[printing] Use uint32_t for a page number and counts

This CL is a follow-up CL of converting
PrintHostMsg_DidGetPrintedPagesCount to mojo [1] and it updates the
type for the page number and counts with uint32_t as it couldn't
have a negative value.

It keeps using int for JNI and dictionary values and uses
'base::checked_cast<int>' to convert uint to int. In order to make
sure that the value is in the range to cast, this change also adds
the maximum limit for the page number and counts and checks the
value before passing it to JNI or dictionary. Given that the previous
type is int, the maximum limit is std::numeric_limits<int>::max().

[1] https://crrev.com/c/2326857

Bug: 1008939
Change-Id: I5c86514be4e7d549f888c9623136078a3b0c88c4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2351580
Reviewed-by: Bo <boliu@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Julie Kim <jkim@igalia.com>
Cr-Commit-Position: refs/heads/master@{#807307}

android_webview/browser/aw_print_manager.cc

@@ -18,14 +18,15 @@
 #include "components/printing/common/print.mojom.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
+#include "printing/print_job_constants.h"
 
 namespace android_webview {
 
 namespace {
 
-int SaveDataToFd(int fd,
-                 int page_count,
-                 scoped_refptr<base::RefCountedSharedMemoryMapping> data) {
+uint32_t SaveDataToFd(int fd,
+                      uint32_t page_count,
+                      scoped_refptr<base::RefCountedSharedMemoryMapping> data) {
   bool result = fd > base::kInvalidFd &&
                 base::IsValueInRangeForNumericType<int>(data->size());
   if (result) {
@@ -128,6 +129,12 @@ void AwPrintManager::OnDidPrintDocument(
     return;
   }
 
+  if (number_pages_ > printing::kMaxPageCount) {
+    web_contents()->Stop();
+    PdfWritingDone(0);
+    return;
+  }
+
   DCHECK(pdf_writing_done_callback_);
   base::PostTaskAndReplyWithResult(
       base::ThreadPool::CreateTaskRunner(
@@ -143,9 +150,10 @@ void AwPrintManager::OnDidPrintDocument(
 void AwPrintManager::OnDidPrintDocumentWritingDone(
     const PdfWritingDoneCallback& callback,
     std::unique_ptr<DelayedFrameDispatchHelper> helper,
-    int page_count) {
+    uint32_t page_count) {
+  DCHECK_LE(page_count, printing::kMaxPageCount);
   if (callback)
-    callback.Run(page_count);
+    callback.Run(base::checked_cast<int>(page_count));
   helper->SendCompleted();
 }
 

android_webview/browser/aw_print_manager.h

@@ -57,7 +57,7 @@ class AwPrintManager : public printing::PrintManager,
   static void OnDidPrintDocumentWritingDone(
       const PdfWritingDoneCallback& callback,
       std::unique_ptr<DelayedFrameDispatchHelper> helper,
-      int page_count);
+      uint32_t page_count);
 
   const std::unique_ptr<printing::PrintSettings> settings_;
 

chrome/browser/apps/platform_apps/app_browsertest.cc

@@ -152,7 +152,7 @@ class ScopedPreviewTestDelegate : printing::PrintPreviewUI::TestDelegate {
   }
 
   // PrintPreviewUI::TestDelegate implementation.
-  void DidGetPreviewPageCount(int page_count) override {
+  void DidGetPreviewPageCount(uint32_t page_count) override {
     total_page_count_ = page_count;
   }
 
@@ -178,8 +178,8 @@ class ScopedPreviewTestDelegate : printing::PrintPreviewUI::TestDelegate {
   gfx::Size dialog_size() { return dialog_size_; }
 
  private:
-  int total_page_count_ = 1;
-  int rendered_page_count_ = 0;
+  uint32_t total_page_count_ = 1;
+  uint32_t rendered_page_count_ = 0;
   base::RunLoop* run_loop_ = nullptr;
   gfx::Size dialog_size_;
 };

chrome/browser/printing/pdf_to_emf_converter.cc

@@ -132,7 +132,8 @@ class PdfConverterImpl : public PdfConverter {
  private:
   class GetPageCallbackData {
    public:
-    GetPageCallbackData(int page_number, PdfConverter::GetPageCallback callback)
+    GetPageCallbackData(uint32_t page_number,
+                        PdfConverter::GetPageCallback callback)
         : page_number_(page_number), callback_(callback) {}
 
     GetPageCallbackData(GetPageCallbackData&& other) {
@@ -145,12 +146,12 @@ class PdfConverterImpl : public PdfConverter {
       return *this;
     }
 
-    int page_number() const { return page_number_; }
+    uint32_t page_number() const { return page_number_; }
 
     PdfConverter::GetPageCallback callback() const { return callback_; }
 
    private:
-    int page_number_;
+    uint32_t page_number_;
 
     PdfConverter::GetPageCallback callback_;
 
@@ -159,7 +160,7 @@ class PdfConverterImpl : public PdfConverter {
 
   void Initialize(scoped_refptr<base::RefCountedMemory> data);
 
-  void GetPage(int page_number,
+  void GetPage(uint32_t page_number,
                PdfConverter::GetPageCallback get_page_callback) override;
 
   void Stop();
@@ -305,7 +306,7 @@ void PdfConverterImpl::OnPageCount(
 }
 
 void PdfConverterImpl::GetPage(
-    int page_number,
+    uint32_t page_number,
     PdfConverter::GetPageCallback get_page_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(pdf_to_emf_converter_.is_bound());

chrome/browser/printing/pdf_to_emf_converter.h

@@ -17,9 +17,9 @@ struct PdfRenderSettings;
 
 class PdfConverter {
  public:
-  using StartCallback = base::OnceCallback<void(int page_count)>;
+  using StartCallback = base::OnceCallback<void(uint32_t page_count)>;
   using GetPageCallback =
-      base::RepeatingCallback<void(int page_number,
+      base::RepeatingCallback<void(uint32_t page_number,
                                    float scale_factor,
                                    std::unique_ptr<MetafilePlayer> file)>;
   virtual ~PdfConverter();
@@ -35,7 +35,8 @@ class PdfConverter {
   // PDF provided in Start() call.
   // Calls |get_page_callback| after conversion. |emf| of callback in not NULL
   // if conversion succeeded.
-  virtual void GetPage(int page_number, GetPageCallback get_page_callback) = 0;
+  virtual void GetPage(uint32_t page_number,
+                       GetPageCallback get_page_callback) = 0;
 };
 
 // Object used by tests to exercise the temporary file creation failure code

chrome/browser/printing/pdf_to_emf_converter_browsertest.cc

@@ -4,8 +4,11 @@
 
 #include "chrome/browser/printing/pdf_to_emf_converter.h"
 
+#include <stdint.h>
 #include <windows.h>
 
+#include <limits>
+
 #include "base/bind.h"
 #include "base/containers/span.h"
 #include "base/files/file_util.h"
@@ -32,17 +35,19 @@ constexpr gfx::Size k200DpiSize = gfx::Size(200, 200);
 
 constexpr size_t kHeaderSize = sizeof(ENHMETAHEADER);
 
+constexpr uint32_t kInvalidPageCount = std::numeric_limits<uint32_t>::max();
+
 void StartCallbackImpl(base::OnceClosure quit_closure,
-                       int* page_count_out,
-                       int page_count_in) {
+                       uint32_t* page_count_out,
+                       uint32_t page_count_in) {
   *page_count_out = page_count_in;
   std::move(quit_closure).Run();
 }
 
 void GetPageCallbackImpl(base::OnceClosure quit_closure,
-                         int* page_number_out,
+                         uint32_t* page_number_out,
                          std::unique_ptr<MetafilePlayer>* file_out,
-                         int page_number_in,
+                         uint32_t page_number_in,
                          float scale_factor,
                          std::unique_ptr<MetafilePlayer> file_in) {
   *page_number_out = page_number_in;
@@ -133,9 +138,9 @@ class PdfToEmfConverterBrowserTest : public InProcessBrowserTest {
   }
 
   bool StartPdfConverter(const PdfRenderSettings& pdf_settings,
-                         int expected_page_count) {
+                         uint32_t expected_page_count) {
     base::RunLoop run_loop;
-    int page_count = -1;
+    uint32_t page_count = kInvalidPageCount;
     pdf_converter_ = PdfConverter::StartPdfConverter(
         test_input_, pdf_settings,
         base::BindOnce(&StartCallbackImpl, run_loop.QuitClosure(),
@@ -144,9 +149,9 @@ class PdfToEmfConverterBrowserTest : public InProcessBrowserTest {
     return pdf_converter_ && (expected_page_count == page_count);
   }
 
-  bool GetPage(int page_number_in) {
+  bool GetPage(uint32_t page_number_in) {
     base::RunLoop run_loop;
-    int page_number = -1;
+    uint32_t page_number = kInvalidPageCount;
     pdf_converter_->GetPage(
         page_number_in,
         base::BindRepeating(&GetPageCallbackImpl, run_loop.QuitClosure(),
@@ -227,12 +232,12 @@ IN_PROC_BROWSER_TEST_F(PdfToEmfConverterBrowserTest, FailureNoTempFile) {
   ScopedSimulateFailureCreatingTempFileForTests fail_creating_temp_file;
 
   base::RunLoop run_loop;
-  int page_count = -1;
+  uint32_t page_count = kInvalidPageCount;
   std::unique_ptr<PdfConverter> pdf_converter = PdfConverter::StartPdfConverter(
       base::MakeRefCounted<base::RefCountedStaticMemory>(), PdfRenderSettings(),
       base::BindOnce(&StartCallbackImpl, run_loop.QuitClosure(), &page_count));
   run_loop.Run();
-  EXPECT_EQ(0, page_count);
+  EXPECT_EQ(0u, page_count);
 }
 
 IN_PROC_BROWSER_TEST_F(PdfToEmfConverterBrowserTest, FailureBadPdf) {
@@ -240,12 +245,12 @@ IN_PROC_BROWSER_TEST_F(PdfToEmfConverterBrowserTest, FailureBadPdf) {
       base::MakeRefCounted<base::RefCountedStaticMemory>("0123456789", 10);
 
   base::RunLoop run_loop;
-  int page_count = -1;
+  uint32_t page_count = kInvalidPageCount;
   std::unique_ptr<PdfConverter> pdf_converter = PdfConverter::StartPdfConverter(
       bad_pdf_data, PdfRenderSettings(),
       base::BindOnce(&StartCallbackImpl, run_loop.QuitClosure(), &page_count));
   run_loop.Run();
-  EXPECT_EQ(0, page_count);
+  EXPECT_EQ(0u, page_count);
 }
 
 IN_PROC_BROWSER_TEST_F(PdfToEmfConverterBrowserTest, EmfBasic) {
@@ -253,11 +258,11 @@ IN_PROC_BROWSER_TEST_F(PdfToEmfConverterBrowserTest, EmfBasic) {
       kLetter200DpiRect, gfx::Point(0, 0), k200DpiSize,
       /*autorotate=*/false,
       /*use_color=*/true, PdfRenderSettings::Mode::NORMAL);
-  constexpr int kNumberOfPages = 3;
+  constexpr uint32_t kNumberOfPages = 3;
 
   ASSERT_TRUE(GetTestInput("pdf_converter_basic.pdf"));
   ASSERT_TRUE(StartPdfConverter(pdf_settings, kNumberOfPages));
-  for (int i = 0; i < kNumberOfPages; ++i) {
+  for (uint32_t i = 0; i < kNumberOfPages; ++i) {
     ASSERT_TRUE(GetPage(i));
     ASSERT_TRUE(GetPageExpectedEmfData(
         GetFileNameForPageNumber("pdf_converter_basic_emf_page_", i)));

chrome/browser/printing/print_browsertest.cc

@@ -84,7 +84,7 @@ class PrintPreviewObserver : PrintPreviewUI::TestDelegate {
 
  private:
   // PrintPreviewUI::TestDelegate:
-  void DidGetPreviewPageCount(int page_count) override {
+  void DidGetPreviewPageCount(uint32_t page_count) override {
     total_page_count_ = page_count;
   }
 
@@ -109,8 +109,8 @@ class PrintPreviewObserver : PrintPreviewUI::TestDelegate {
   }
 
   base::Optional<content::DOMMessageQueue> queue_;
-  int total_page_count_ = 1;
-  int rendered_page_count_ = 0;
+  uint32_t total_page_count_ = 1;
+  uint32_t rendered_page_count_ = 0;
   content::WebContents* preview_dialog_ = nullptr;
   base::RunLoop* run_loop_ = nullptr;
 

chrome/browser/printing/print_job.cc

@@ -85,7 +85,7 @@ PrintJob::~PrintJob() {
 
 void PrintJob::Initialize(std::unique_ptr<PrinterQuery> query,
                           const base::string16& name,
-                          int page_count) {
+                          uint32_t page_count) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!worker_);
   DCHECK(!is_job_pending_);
@@ -98,7 +98,7 @@ void PrintJob::Initialize(std::unique_ptr<PrinterQuery> query,
 #if defined(OS_WIN)
   pdf_page_mapping_ = PageRange::GetPages(settings->ranges());
   if (pdf_page_mapping_.empty()) {
-    for (int i = 0; i < page_count; i++)
+    for (uint32_t i = 0; i < page_count; i++)
       pdf_page_mapping_.push_back(i);
   }
 #endif
@@ -115,12 +115,13 @@ void PrintJob::Initialize(std::unique_ptr<PrinterQuery> query,
 
 #if defined(OS_WIN)
 // static
-std::vector<int> PrintJob::GetFullPageMapping(const std::vector<int>& pages,
-                                              int total_page_count) {
-  std::vector<int> mapping(total_page_count, -1);
-  for (int page_number : pages) {
+std::vector<uint32_t> PrintJob::GetFullPageMapping(
+    const std::vector<uint32_t>& pages,
+    uint32_t total_page_count) {
+  std::vector<uint32_t> mapping(total_page_count, kInvalidPageIndex);
+  for (uint32_t page_number : pages) {
     // Make sure the page is in range.
-    if (page_number >= 0 && page_number < total_page_count)
+    if (page_number < total_page_count)
       mapping[page_number] = page_number;
   }
   return mapping;
@@ -319,13 +320,13 @@ class PrintJob::PdfConversionState {
       converter_.reset();
   }
 
-  void set_page_count(int page_count) { page_count_ = page_count; }
+  void set_page_count(uint32_t page_count) { page_count_ = page_count; }
   const gfx::Size& page_size() const { return page_size_; }
   const gfx::Rect& content_area() const { return content_area_; }
 
  private:
-  int page_count_;
-  int current_page_;
+  uint32_t page_count_;
+  uint32_t current_page_;
   int pages_in_progress_;
   gfx::Size page_size_;
   gfx::Rect content_area_;
@@ -379,7 +380,7 @@ void PrintJob::StartPdfToEmfConversion(
       base::BindOnce(&PrintJob::OnPdfConversionStarted, this));
 }
 
-void PrintJob::OnPdfConversionStarted(int page_count) {
+void PrintJob::OnPdfConversionStarted(uint32_t page_count) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (page_count <= 0) {
@@ -394,13 +395,13 @@ void PrintJob::OnPdfConversionStarted(int page_count) {
       base::BindRepeating(&PrintJob::OnPdfPageConverted, this));
 }
 
-void PrintJob::OnPdfPageConverted(int page_number,
+void PrintJob::OnPdfPageConverted(uint32_t page_number,
                                   float scale_factor,
                                   std::unique_ptr<MetafilePlayer> metafile) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(pdf_conversion_state_);
-  if (!document_ || !metafile || page_number < 0 ||
-      static_cast<size_t>(page_number) >= pdf_page_mapping_.size()) {
+  if (!document_ || !metafile || page_number == kInvalidPageIndex ||
+      page_number >= pdf_page_mapping_.size()) {
     // Be sure to live long enough.
     scoped_refptr<PrintJob> handle(this);
     pdf_conversion_state_.reset();
@@ -410,7 +411,7 @@ void PrintJob::OnPdfPageConverted(int page_number,
 
   // Add the page to the document if it is one of the pages requested by the
   // user. If it is not, ignore it.
-  if (pdf_page_mapping_[page_number] != -1) {
+  if (pdf_page_mapping_[page_number] != kInvalidPageIndex) {
     // Update the rendered document. It will send notifications to the listener.
     document_->SetPage(pdf_page_mapping_[page_number], std::move(metafile),
                        scale_factor, pdf_conversion_state_->page_size(),

chrome/browser/printing/print_job.h

@@ -67,7 +67,7 @@ class PrintJob : public base::RefCountedThreadSafe<PrintJob>,
   // the settings.
   virtual void Initialize(std::unique_ptr<PrinterQuery> query,
                           const base::string16& name,
-                          int page_count);
+                          uint32_t page_count);
 
 #if defined(OS_WIN)
   void StartConversionToNativeFormat(
@@ -188,14 +188,15 @@ class PrintJob : public base::RefCountedThreadSafe<PrintJob>,
       scoped_refptr<base::RefCountedMemory> bytes,
       const gfx::Size& page_size);
 
-  void OnPdfConversionStarted(int page_count);
-  void OnPdfPageConverted(int page_number,
+  void OnPdfConversionStarted(uint32_t page_count);
+  void OnPdfPageConverted(uint32_t page_number,
                           float scale_factor,
                           std::unique_ptr<MetafilePlayer> metafile);
 
   // Helper method to do the work for ResetPageMapping(). Split for unit tests.
-  static std::vector<int> GetFullPageMapping(const std::vector<int>& pages,
-                                             int total_page_count);
+  static std::vector<uint32_t> GetFullPageMapping(
+      const std::vector<uint32_t>& pages,
+      uint32_t total_page_count);
 #endif  // defined(OS_WIN)
 
   content::NotificationRegistrar registrar_;
@@ -218,7 +219,7 @@ class PrintJob : public base::RefCountedThreadSafe<PrintJob>,
 #if defined(OS_WIN)
   class PdfConversionState;
   std::unique_ptr<PdfConversionState> pdf_conversion_state_;
-  std::vector<int> pdf_page_mapping_;
+  std::vector<uint32_t> pdf_page_mapping_;
 #endif  // defined(OS_WIN)
 
 #if defined(OS_CHROMEOS)

chrome/browser/printing/print_job_unittest.cc

@@ -149,28 +149,33 @@ TEST(PrintJobTest, PageRangeMapping) {
   content::BrowserTaskEnvironment task_environment;
 
   int page_count = 4;
-  std::vector<int> input_full = {0, 1, 2, 3};
-  std::vector<int> expected_output_full = {0, 1, 2, 3};
+  std::vector<uint32_t> input_full = {0, 1, 2, 3};
+  std::vector<uint32_t> expected_output_full = {0, 1, 2, 3};
   EXPECT_EQ(expected_output_full,
             PrintJob::GetFullPageMapping(input_full, page_count));
 
-  std::vector<int> input_12 = {1, 2};
-  std::vector<int> expected_output_12 = {-1, 1, 2, -1};
+  std::vector<uint32_t> input_12 = {1, 2};
+  std::vector<uint32_t> expected_output_12 = {kInvalidPageIndex, 1, 2,
+                                              kInvalidPageIndex};
   EXPECT_EQ(expected_output_12,
             PrintJob::GetFullPageMapping(input_12, page_count));
 
-  std::vector<int> input_03 = {0, 3};
-  std::vector<int> expected_output_03 = {0, -1, -1, 3};
+  std::vector<uint32_t> input_03 = {0, 3};
+  std::vector<uint32_t> expected_output_03 = {0, kInvalidPageIndex,
+                                              kInvalidPageIndex, 3};
   EXPECT_EQ(expected_output_03,
             PrintJob::GetFullPageMapping(input_03, page_count));
 
-  std::vector<int> input_0 = {0};
-  std::vector<int> expected_output_0 = {0, -1, -1, -1};
+  std::vector<uint32_t> input_0 = {0};
+  std::vector<uint32_t> expected_output_0 = {
+      0, kInvalidPageIndex, kInvalidPageIndex, kInvalidPageIndex};
   EXPECT_EQ(expected_output_0,
             PrintJob::GetFullPageMapping(input_0, page_count));
 
-  std::vector<int> input_invalid = {4, 100};
-  std::vector<int> expected_output_invalid = {-1, -1, -1, -1};
+  std::vector<uint32_t> input_invalid = {4, 100};
+  std::vector<uint32_t> expected_output_invalid = {
+      kInvalidPageIndex, kInvalidPageIndex, kInvalidPageIndex,
+      kInvalidPageIndex};
   EXPECT_EQ(expected_output_invalid,
             PrintJob::GetFullPageMapping(input_invalid, page_count));
 }

chrome/browser/printing/print_job_worker.cc

@@ -13,6 +13,7 @@
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
@@ -153,7 +154,7 @@ void PrintJobWorker::SetPrintJob(PrintJob* print_job) {
 }
 
 void PrintJobWorker::GetSettings(bool ask_user_for_settings,
-                                 int document_page_count,
+                                 uint32_t document_page_count,
                                  bool has_selection,
                                  mojom::MarginType margin_type,
                                  bool is_scripted,
@@ -263,11 +264,12 @@ void PrintJobWorker::GetSettingsDone(SettingsCallback callback,
   std::move(callback).Run(printing_context_->TakeAndResetSettings(), result);
 }
 
-void PrintJobWorker::GetSettingsWithUI(int document_page_count,
+void PrintJobWorker::GetSettingsWithUI(uint32_t document_page_count,
                                        bool has_selection,
                                        bool is_scripted,
                                        SettingsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_LE(document_page_count, kMaxPageCount);
 
   content::WebContents* web_contents = GetWebContents();
 
@@ -297,7 +299,7 @@ void PrintJobWorker::GetSettingsWithUI(int document_page_count,
     web_contents->ExitFullscreen(true);
 
   printing_context_->AskUserForSettings(
-      document_page_count, has_selection, is_scripted,
+      base::checked_cast<int>(document_page_count), has_selection, is_scripted,
       base::BindOnce(&PrintJobWorker::GetSettingsDone,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
 }
@@ -417,7 +419,7 @@ bool PrintJobWorker::OnNewPageHelperGdi() {
   }
 
   while (true) {
-    scoped_refptr<PrintedPage> page = document_->GetPage(page_number_.ToInt());
+    scoped_refptr<PrintedPage> page = document_->GetPage(page_number_.ToUint());
     if (!page) {
       PostWaitForPage();
       return false;

chrome/browser/printing/print_job_worker.h

@@ -51,7 +51,7 @@ class PrintJobWorker {
   // |is_scripted| should be true for calls coming straight from window.print().
   // |is_modifiable| implies HTML and not other formats like PDF.
   void GetSettings(bool ask_user_for_settings,
-                   int document_page_count,
+                   uint32_t document_page_count,
                    bool has_selection,
                    mojom::MarginType margin_type,
                    bool is_scripted,
@@ -142,7 +142,7 @@ class PrintJobWorker {
   // Asks the user for print settings. Must be called on the UI thread.
   // Required on Mac and Linux. Windows can display UI from non-main threads,
   // but sticks with this for consistency.
-  void GetSettingsWithUI(int document_page_count,
+  void GetSettingsWithUI(uint32_t document_page_count,
                          bool has_selection,
                          bool is_scripted,
                          SettingsCallback callback);

chrome/browser/printing/print_preview_message_handler.cc

@@ -14,6 +14,7 @@
 #include "base/memory/read_only_shared_memory_region.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
+#include "base/numerics/safe_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/printing/pdf_nup_converter_client.h"
 #include "chrome/browser/printing/print_job_manager.h"
@@ -65,8 +66,8 @@ bool ShouldUseCompositor(PrintPreviewUI* print_preview_ui) {
   return IsOopifEnabled() && print_preview_ui->source_is_modifiable();
 }
 
-bool IsValidPageNumber(int page_number, int page_count) {
-  return page_number >= 0 && page_number < page_count;
+bool IsValidPageNumber(uint32_t page_number, uint32_t page_count) {
+  return page_number < page_count;
 }
 
 }  // namespace
@@ -112,12 +113,13 @@ void PrintPreviewMessageHandler::OnRequestPrintPreview(
 void PrintPreviewMessageHandler::OnDidStartPreview(
     const mojom::DidStartPreviewParams& params,
     const mojom::PreviewIds& ids) {
-  if (params.page_count <= 0 || params.pages_to_render.empty()) {
+  if (params.page_count == 0 || params.page_count > kMaxPageCount ||
+      params.pages_to_render.empty()) {
     NOTREACHED();
     return;
   }
 
-  for (int page_number : params.pages_to_render) {
+  for (uint32_t page_number : params.pages_to_render) {
     if (!IsValidPageNumber(page_number, params.page_count)) {
       NOTREACHED();
       return;
@@ -176,10 +178,12 @@ void PrintPreviewMessageHandler::OnDidPreviewPage(
     content::RenderFrameHost* render_frame_host,
     const mojom::DidPreviewPageParams& params,
     const mojom::PreviewIds& ids) {
-  int page_number = params.page_number;
+  uint32_t page_number = params.page_number;
   const mojom::DidPrintContentParams& content = *params.content;
-  if (page_number < FIRST_PAGE_INDEX || !content.metafile_data_region.IsValid())
+  if (page_number == kInvalidPageIndex ||
+      !content.metafile_data_region.IsValid()) {
     return;
+  }
 
   PrintPreviewUI* print_preview_ui = GetPrintPreviewUI(ids.ui_id);
   if (!print_preview_ui)
@@ -285,7 +289,7 @@ void PrintPreviewMessageHandler::OnDidGetDefaultPageLayout(
 
 void PrintPreviewMessageHandler::NotifyUIPreviewPageReady(
     PrintPreviewUI* print_preview_ui,
-    int page_number,
+    uint32_t page_number,
     const mojom::PreviewIds& ids,
     scoped_refptr<base::RefCountedMemory> data_bytes) {
   if (!data_bytes || !data_bytes->size())
@@ -315,7 +319,7 @@ void PrintPreviewMessageHandler::NotifyUIPreviewDocumentReady(
 }
 
 void PrintPreviewMessageHandler::OnCompositePdfPageDone(
-    int page_number,
+    uint32_t page_number,
     int document_cookie,
     const mojom::PreviewIds& ids,
     mojom::PrintCompositor::Status status,
@@ -343,15 +347,17 @@ void PrintPreviewMessageHandler::OnCompositePdfPageDone(
         base::RefCountedSharedMemoryMapping::CreateFromWholeRegion(region));
   } else {
     print_preview_ui->AddPdfPageForNupConversion(std::move(region));
-    int current_page_index =
+    uint32_t current_page_index =
         print_preview_ui->GetPageToNupConvertIndex(page_number);
-    if (current_page_index == -1) {
+    if (current_page_index == kInvalidPageIndex) {
       return;
     }
 
     if (((current_page_index + 1) % pages_per_sheet) == 0 ||
         print_preview_ui->LastPageComposited(page_number)) {
-      int new_page_number = current_page_index / pages_per_sheet;
+      uint32_t new_page_number =
+          base::checked_cast<uint32_t>(current_page_index / pages_per_sheet);
+      DCHECK_NE(new_page_number, kInvalidPageIndex);
       std::vector<base::ReadOnlySharedMemoryRegion> pdf_page_regions =
           print_preview_ui->TakePagesForNupConvert();
 
@@ -376,7 +382,7 @@ void PrintPreviewMessageHandler::OnCompositePdfPageDone(
 }
 
 void PrintPreviewMessageHandler::OnNupPdfConvertDone(
-    int page_number,
+    uint32_t page_number,
     const mojom::PreviewIds& ids,
     mojom::PdfNupConverter::Status status,
     base::ReadOnlySharedMemoryRegion region) {

chrome/browser/printing/print_preview_message_handler.h

@@ -81,7 +81,7 @@ class PrintPreviewMessageHandler
 
   void NotifyUIPreviewPageReady(
       PrintPreviewUI* print_preview_ui,
-      int page_number,
+      uint32_t page_number,
       const mojom::PreviewIds& ids,
       scoped_refptr<base::RefCountedMemory> data_bytes);
   void NotifyUIPreviewDocumentReady(
@@ -90,7 +90,7 @@ class PrintPreviewMessageHandler
       scoped_refptr<base::RefCountedMemory> data_bytes);
 
   // Callbacks for print compositor client.
-  void OnCompositePdfPageDone(int page_number,
+  void OnCompositePdfPageDone(uint32_t page_number,
                               int document_cookie,
                               const mojom::PreviewIds& ids,
                               mojom::PrintCompositor::Status status,
@@ -102,7 +102,7 @@ class PrintPreviewMessageHandler
   void OnPrepareForDocumentToPdfDone(const mojom::PreviewIds& ids,
                                      mojom::PrintCompositor::Status status);
 
-  void OnNupPdfConvertDone(int page_number,
+  void OnNupPdfConvertDone(uint32_t page_number,
                            const mojom::PreviewIds& ids,
                            mojom::PdfNupConverter::Status status,
                            base::ReadOnlySharedMemoryRegion region);

chrome/browser/printing/print_view_manager_base.cc

@@ -13,6 +13,7 @@
 #include "base/location.h"
 #include "base/memory/read_only_shared_memory_region.h"
 #include "base/memory/ref_counted_memory.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
@@ -187,7 +188,7 @@ void PrintViewManagerBase::PrintDocument(
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
 void PrintViewManagerBase::OnPrintSettingsDone(
     scoped_refptr<base::RefCountedMemory> print_data,
-    int page_count,
+    uint32_t page_count,
     PrinterHandler::PrintCallback callback,
     std::unique_ptr<printing::PrinterQuery> printer_query) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ -226,7 +227,7 @@ void PrintViewManagerBase::OnPrintSettingsDone(
 
 void PrintViewManagerBase::StartLocalPrintJob(
     scoped_refptr<base::RefCountedMemory> print_data,
-    int page_count,
+    uint32_t page_count,
     int cookie,
     PrinterHandler::PrintCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ -274,7 +275,7 @@ base::string16 PrintViewManagerBase::RenderSourceName() {
 }
 
 void PrintViewManagerBase::DidGetPrintedPagesCount(int32_t cookie,
-                                                   int32_t number_pages) {
+                                                   uint32_t number_pages) {
   PrintManager::DidGetPrintedPagesCount(cookie, number_pages);
   OpportunisticallyCreatePrintJob(cookie);
 }
@@ -478,7 +479,8 @@ void PrintViewManagerBase::OnNotifyPrintJobEvent(
     case JobEventDetails::DOC_DONE: {
       // Don't care about the actual printing process, except on Android.
 #if defined(OS_ANDROID)
-      PdfWritingDone(number_pages_);
+      DCHECK_LE(number_pages_, kMaxPageCount);
+      PdfWritingDone(base::checked_cast<int>(number_pages_));
 #endif
       break;
     }

chrome/browser/printing/print_view_manager_base.h

@@ -76,7 +76,7 @@ class PrintViewManagerBase : public content::NotificationObserver,
   }
 
   // mojom::PrintManagerHost:
-  void DidGetPrintedPagesCount(int32_t cookie, int32_t number_pages) override;
+  void DidGetPrintedPagesCount(int32_t cookie, uint32_t number_pages) override;
 #if BUILDFLAG(ENABLE_TAGGED_PDF)
   void SetAccessibilityTree(
       int32_t cookie,
@@ -147,12 +147,12 @@ class PrintViewManagerBase : public content::NotificationObserver,
 // Helpers for PrintForPrintPreview();
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   void OnPrintSettingsDone(scoped_refptr<base::RefCountedMemory> print_data,
-                           int page_count,
+                           uint32_t page_count,
                            PrinterHandler::PrintCallback callback,
                            std::unique_ptr<PrinterQuery> printer_query);
 
   void StartLocalPrintJob(scoped_refptr<base::RefCountedMemory> print_data,
-                          int page_count,
+                          uint32_t page_count,
                           int cookie,
                           PrinterHandler::PrintCallback callback);
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)

chrome/browser/printing/printer_query.cc

@@ -87,7 +87,7 @@ int PrinterQuery::cookie() const {
 }
 
 void PrinterQuery::GetSettings(GetSettingsAskParam ask_user_for_settings,
-                               int expected_page_count,
+                               uint32_t expected_page_count,
                                bool has_selection,
                                mojom::MarginType margin_type,
                                bool is_scripted,

chrome/browser/printing/printer_query.h

@@ -51,7 +51,7 @@ class PrinterQuery {
   // |ask_for_user_settings| is DEFAULTS.
   // Caller has to ensure that |this| is alive until |callback| is run.
   void GetSettings(GetSettingsAskParam ask_user_for_settings,
-                   int expected_page_count,
+                   uint32_t expected_page_count,
                    bool has_selection,
                    mojom::MarginType margin_type,
                    bool is_scripted,

chrome/browser/printing/test_print_job.cc

@@ -18,7 +18,7 @@ namespace printing {
 
 void TestPrintJob::Initialize(std::unique_ptr<PrinterQuery> query,
                               const base::string16& name,
-                              int page_count) {
+                              uint32_t page_count) {
   // Since we do not actually print in these tests, just let this get destroyed
   // when this function exits.
   std::unique_ptr<PrintJobWorker> worker = query->DetachWorker();

chrome/browser/printing/test_print_job.h

@@ -39,7 +39,7 @@ class TestPrintJob : public PrintJob {
   // All remaining functions are PrintJob implementation.
   void Initialize(std::unique_ptr<PrinterQuery> query,
                   const base::string16& name,
-                  int page_count) override;
+                  uint32_t page_count) override;
 
   // Sets |job_pending_| to true.
   void StartPrinting() override;

chrome/browser/ui/webui/print_preview/print_preview_ui.cc

@@ -18,6 +18,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram_functions.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ -611,19 +612,19 @@ void PrintPreviewUI::SetInitiatorTitle(
   initiator_title_ = job_title;
 }
 
-bool PrintPreviewUI::LastPageComposited(int page_number) const {
+bool PrintPreviewUI::LastPageComposited(uint32_t page_number) const {
   if (pages_to_render_.empty())
     return false;
 
   return page_number == pages_to_render_.back();
 }
 
-int PrintPreviewUI::GetPageToNupConvertIndex(int page_number) const {
+uint32_t PrintPreviewUI::GetPageToNupConvertIndex(uint32_t page_number) const {
   for (size_t index = 0; index < pages_to_render_.size(); ++index) {
     if (page_number == pages_to_render_[index])
       return index;
   }
-  return -1;
+  return kInvalidPageIndex;
 }
 
 std::vector<base::ReadOnlySharedMemoryRegion>
@@ -701,7 +702,8 @@ void PrintPreviewUI::OnPrintPreviewRequest(int request_id) {
 void PrintPreviewUI::OnDidStartPreview(
     const mojom::DidStartPreviewParams& params,
     int request_id) {
-  DCHECK_GT(params.page_count, 0);
+  DCHECK_GT(params.page_count, 0u);
+  DCHECK_LE(params.page_count, kMaxPageCount);
   DCHECK(!params.pages_to_render.empty());
 
   pages_to_render_ = params.pages_to_render;
@@ -712,8 +714,8 @@ void PrintPreviewUI::OnDidStartPreview(
 
   if (g_test_delegate)
     g_test_delegate->DidGetPreviewPageCount(params.page_count);
-  handler_->SendPageCountReady(params.page_count, params.fit_to_page_scaling,
-                               request_id);
+  handler_->SendPageCountReady(base::checked_cast<int>(params.page_count),
+                               params.fit_to_page_scaling, request_id);
 }
 
 void PrintPreviewUI::OnDidGetDefaultPageLayout(
@@ -745,7 +747,7 @@ void PrintPreviewUI::OnDidGetDefaultPageLayout(
   handler_->SendPageLayoutReady(layout, has_custom_page_size_style, request_id);
 }
 
-bool PrintPreviewUI::OnPendingPreviewPage(int page_number) {
+bool PrintPreviewUI::OnPendingPreviewPage(uint32_t page_number) {
   if (pages_to_render_index_ >= pages_to_render_.size())
     return false;
 
@@ -755,16 +757,18 @@ bool PrintPreviewUI::OnPendingPreviewPage(int page_number) {
 }
 
 void PrintPreviewUI::OnDidPreviewPage(
-    int page_number,
+    uint32_t page_number,
     scoped_refptr<base::RefCountedMemory> data,
     int preview_request_id) {
-  DCHECK_GE(page_number, 0);
+  DCHECK_NE(page_number, kInvalidPageIndex);
 
-  SetPrintPreviewDataForIndex(page_number, std::move(data));
+  SetPrintPreviewDataForIndex(base::checked_cast<int>(page_number),
+                              std::move(data));
 
   if (g_test_delegate)
     g_test_delegate->DidRenderPreviewPage(web_ui()->GetWebContents());
-  handler_->SendPagePreviewReady(page_number, *id_, preview_request_id);
+  handler_->SendPagePreviewReady(base::checked_cast<int>(page_number), *id_,
+                                 preview_request_id);
 }
 
 void PrintPreviewUI::OnPreviewDataIsAvailable(

chrome/browser/ui/webui/print_preview/print_preview_ui.h

@@ -90,11 +90,11 @@ class PrintPreviewUI : public ConstrainedWebDialogUI,
 
   // Returns true if |page_number| is the last page in |pages_to_render_|.
   // |page_number| is a 0-based number.
-  bool LastPageComposited(int page_number) const;
+  bool LastPageComposited(uint32_t page_number) const;
 
   // Get the 0-based index of the |page_number| in |pages_to_render_|.
   // Same as above, |page_number| is a 0-based number.
-  int GetPageToNupConvertIndex(int page_number) const;
+  uint32_t GetPageToNupConvertIndex(uint32_t page_number) const;
 
   std::vector<base::ReadOnlySharedMemoryRegion> TakePagesForNupConvert();
 
@@ -153,11 +153,11 @@ class PrintPreviewUI : public ConstrainedWebDialogUI,
   // Notifies the Web UI that the 0-based page |page_number| rendering is being
   // processed and an OnPendingPreviewPage() call is imminent. Returns whether
   // |page_number| is the expected page.
-  bool OnPendingPreviewPage(int page_number);
+  bool OnPendingPreviewPage(uint32_t page_number);
 
   // Notifies the Web UI that the 0-based page |page_number| has been rendered.
   // |preview_request_id| indicates which request resulted in this response.
-  void OnDidPreviewPage(int page_number,
+  void OnDidPreviewPage(uint32_t page_number,
                         scoped_refptr<base::RefCountedMemory> data,
                         int preview_request_id);
 
@@ -190,7 +190,7 @@ class PrintPreviewUI : public ConstrainedWebDialogUI,
   // Allows tests to wait until the print preview dialog is loaded.
   class TestDelegate {
    public:
-    virtual void DidGetPreviewPageCount(int page_count) = 0;
+    virtual void DidGetPreviewPageCount(uint32_t page_count) = 0;
     virtual void DidRenderPreviewPage(content::WebContents* preview_dialog) = 0;
 
    protected:
@@ -279,7 +279,7 @@ class PrintPreviewUI : public ConstrainedWebDialogUI,
   base::string16 initiator_title_;
 
   // The list of 0-based page numbers that will be rendered.
-  std::vector<int> pages_to_render_;
+  std::vector<uint32_t> pages_to_render_;
 
   // The list of pages to be converted.
   std::vector<base::ReadOnlySharedMemoryRegion> pages_for_nup_convert_;

components/printing/browser/print_manager.cc

@@ -103,9 +103,9 @@ void PrintManager::RenderFrameDeleted(
 }
 
 void PrintManager::DidGetPrintedPagesCount(int32_t cookie,
-                                           int32_t number_pages) {
+                                           uint32_t number_pages) {
   DCHECK_GT(cookie, 0);
-  DCHECK_GT(number_pages, 0);
+  DCHECK_GT(number_pages, 0u);
   number_pages_ = number_pages;
 }
 

components/printing/browser/print_manager.h

@@ -45,7 +45,7 @@ class PrintManager : public content::WebContentsObserver,
 #endif
 
   // printing::mojom::PrintManagerHost:
-  void DidGetPrintedPagesCount(int32_t cookie, int32_t number_pages) override;
+  void DidGetPrintedPagesCount(int32_t cookie, uint32_t number_pages) override;
   void DidGetDocumentCookie(int32_t cookie) override;
 #if BUILDFLAG(ENABLE_TAGGED_PDF)
   void SetAccessibilityTree(
@@ -114,7 +114,7 @@ class PrintManager : public content::WebContentsObserver,
                                const mojom::ScriptedPrintParams& params,
                                IPC::Message* reply_msg) = 0;
 
-  int number_pages_ = 0;  // Number of pages to print in the print job.
+  uint32_t number_pages_ = 0;  // Number of pages to print in the print job.
   int cookie_ = 0;        // The current document cookie.
   // Holds WebContents associated mojo receivers.
   content::WebContentsFrameReceiverSet<printing::mojom::PrintManagerHost>

components/printing/common/print.mojom

@@ -58,9 +58,9 @@ struct DidPrintContentParams {
 struct DidStartPreviewParams {
   // Total page count for the rendered preview. (Not the number of pages the
   // user selected to print.)
-  int32 page_count;
+  uint32 page_count;
   // The list of 0-based page numbers that will be rendered.
-  array<int32> pages_to_render;
+  array<uint32> pages_to_render;
   // number of pages per sheet and should be greater or equal to 1.
   int32 pages_per_sheet;
   // Physical size of the page, including non-printable margins.
@@ -157,7 +157,7 @@ struct PrintPagesParams {
   // value for all the document.
   PrintParams params;
   // If empty, this means a request to render all the printed pages.
-  array<int32> pages;
+  array<uint32> pages;
 };
 
 // Parameters to describe a rendered page.
@@ -179,7 +179,7 @@ struct DidPrintDocumentParams {
 // Parameters to get a print setting from a user before printing.
 struct ScriptedPrintParams {
   int32 cookie;
-  int32 expected_pages_count;
+  uint32 expected_pages_count;
   bool has_selection;
   bool is_scripted;
   bool is_modifiable;
@@ -278,7 +278,7 @@ interface PrintRenderFrame {
 interface PrintManagerHost {
   // Tells the browser that the renderer is done calculating the number of
   // rendered pages according to the specified settings.
-  DidGetPrintedPagesCount(int32 cookie, int32 number_pages);
+  DidGetPrintedPagesCount(int32 cookie, uint32 number_pages);
 
   // Sends the document cookie of the current printer query to the browser.
   DidGetDocumentCookie(int32 cookie);

components/printing/renderer/print_render_frame_helper.cc

@@ -20,6 +20,7 @@
 #include "base/logging.h"
 #include "base/memory/shared_memory_mapping.h"
 #include "base/metrics/histogram_functions.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ -159,7 +160,7 @@ mojom::PageOrientation FromBlinkPageOrientation(
 }
 
 mojom::PrintParamsPtr GetCssPrintParams(blink::WebLocalFrame* frame,
-                                        int page_index,
+                                        uint32_t page_index,
                                         const mojom::PrintParams& page_params) {
   mojom::PrintParamsPtr page_css_params = page_params.Clone();
   int dpi = GetDPI(page_params);
@@ -372,11 +373,11 @@ bool IsPrintToPdfRequested(const base::DictionaryValue& job_settings) {
 }
 
 bool PrintingFrameHasPageSizeStyle(blink::WebLocalFrame* frame,
-                                   int total_page_count) {
+                                   uint32_t total_page_count) {
   if (!frame)
     return false;
   bool frame_has_custom_page_size_style = false;
-  for (int i = 0; i < total_page_count; ++i) {
+  for (uint32_t i = 0; i < total_page_count; ++i) {
     if (frame->GetPageSizeType(i) != blink::PageSizeType::kAuto) {
       // TODO(crbug.com/1016235): We should propagate the page size type all the
       // way to the UI. See the crbug issue for details.
@@ -507,7 +508,7 @@ gfx::Size ScaleAndRoundSize(gfx::Size original, double scaling) {
 
 mojom::PrintParamsPtr CalculatePrintParamsForCss(
     blink::WebLocalFrame* frame,
-    int page_index,
+    uint32_t page_index,
     const mojom::PrintParams& page_params,
     bool ignore_css_margins,
     bool fit_to_page,
@@ -650,12 +651,16 @@ double PrintRenderFrameHelper::GetScaleFactor(double input_scale_factor,
 // static - Not anonymous so that platform implementations can use it.
 void PrintRenderFrameHelper::PrintHeaderAndFooter(
     cc::PaintCanvas* canvas,
-    int page_number,
-    int total_pages,
+    uint32_t page_number,
+    uint32_t total_pages,
     const blink::WebLocalFrame& source_frame,
     float webkit_scale_factor,
     const mojom::PageSizeMargins& page_layout,
     const mojom::PrintParams& params) {
+  DCHECK_LE(total_pages, kMaxPageCount);
+  // |page_number| is 1-based here, so it could be equal to kMaxPageCount.
+  DCHECK_LE(page_number, kMaxPageCount);
+
   cc::PaintCanvasAutoRestore auto_restore(canvas, true);
   canvas->scale(1 / webkit_scale_factor, 1 / webkit_scale_factor);
 
@@ -719,8 +724,8 @@ void PrintRenderFrameHelper::PrintHeaderAndFooter(
   options->SetDoubleKey("bottomMargin", page_layout.margin_bottom);
   options->SetDoubleKey("leftMargin", page_layout.margin_left);
   options->SetDoubleKey("rightMargin", page_layout.margin_right);
-  options->SetIntKey("pageNumber", page_number);
-  options->SetIntKey("totalPages", total_pages);
+  options->SetIntKey("pageNumber", base::checked_cast<int>(page_number));
+  options->SetIntKey("totalPages", base::checked_cast<int>(total_pages));
   options->SetStringKey("url", params.url);
   base::string16 title = source_frame.GetDocument().Title().Utf16();
   options->SetStringKey("title", title.empty() ? params.title : title);
@@ -742,7 +747,7 @@ void PrintRenderFrameHelper::PrintHeaderAndFooter(
 
 // static - Not anonymous so that platform implementations can use it.
 float PrintRenderFrameHelper::RenderPageContent(blink::WebLocalFrame* frame,
-                                                int page_number,
+                                                uint32_t page_number,
                                                 const gfx::Rect& canvas_area,
                                                 const gfx::Rect& content_area,
                                                 double scale_factor,
@@ -783,7 +788,7 @@ class PrepareFrameAndViewForPrint : public blink::WebViewClient,
 
   const blink::WebNode& node() const { return node_to_print_; }
 
-  int GetExpectedPageCount() const { return expected_pages_count_; }
+  uint32_t GetExpectedPageCount() const { return expected_pages_count_; }
 
   void FinishPrinting();
 
@@ -822,7 +827,7 @@ class PrepareFrameAndViewForPrint : public blink::WebViewClient,
   blink::WebPrintParams web_print_params_;
   gfx::Size prev_view_size_;
   gfx::Size prev_scroll_offset_;
-  int expected_pages_count_ = 0;
+  uint32_t expected_pages_count_ = 0;
   base::OnceClosure on_ready_;
   const bool should_print_backgrounds_;
   const bool should_print_selection_only_;
@@ -1523,7 +1528,7 @@ PrintRenderFrameHelper::CreatePreviewDocument() {
   }
 
   const mojom::PrintParams& print_params = *print_pages_params_->params;
-  const std::vector<int>& pages = print_pages_params_->pages;
+  const std::vector<uint32_t>& pages = print_pages_params_->pages;
 
   bool require_document_metafile =
       print_renderer_ ||
@@ -1594,8 +1599,8 @@ PrintRenderFrameHelper::CreatePreviewDocument() {
   }
 
   while (!print_preview_context_.IsFinalPageRendered()) {
-    int page_number = print_preview_context_.GetNextPageNumber();
-    DCHECK_GE(page_number, 0);
+    uint32_t page_number = print_preview_context_.GetNextPageNumber();
+    DCHECK_NE(page_number, kInvalidPageIndex);
 
     blink::WebLocalFrame* frame = print_preview_context_.source_frame();
     if (frame) {
@@ -1632,7 +1637,7 @@ PrintRenderFrameHelper::CreatePreviewDocument() {
   return CREATE_SUCCESS;
 }
 
-bool PrintRenderFrameHelper::RenderPreviewPage(int page_number) {
+bool PrintRenderFrameHelper::RenderPreviewPage(uint32_t page_number) {
   TRACE_EVENT1("print", "PrintRenderFrameHelper::RenderPreviewPage",
                "page_number", page_number);
 
@@ -1856,14 +1861,14 @@ void PrintRenderFrameHelper::Print(
 
   FrameReference frame_ref(frame);
 
-  int expected_page_count = 0;
+  uint32_t expected_page_count = 0;
   if (!CalculateNumberOfPages(frame, node, &expected_page_count)) {
     DidFinishPrinting(FAIL_PRINT_INIT);
     return;  // Failed to init print page settings.
   }
 
   // Some full screen plugins can say they don't want to print.
-  if (!expected_page_count) {
+  if (!expected_page_count || expected_page_count > kMaxPageCount) {
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
@@ -1971,9 +1976,10 @@ void PrintRenderFrameHelper::PrintPages() {
 
   prep_frame_view_->StartPrinting();
 
-  int page_count = prep_frame_view_->GetExpectedPageCount();
-  if (!page_count) {
-    LOG(ERROR) << "Can't print 0 pages.";
+  uint32_t page_count = prep_frame_view_->GetExpectedPageCount();
+  if (!page_count || page_count > kMaxPageCount) {
+    LOG(ERROR) << "Can't print 0 pages and the page count couldn't be greater "
+                  "than kMaxPageCount.";
     return DidFinishPrinting(FAIL_PRINT);
   }
 
@@ -2001,12 +2007,12 @@ void PrintRenderFrameHelper::PrintPages() {
 }
 
 bool PrintRenderFrameHelper::PrintPagesNative(blink::WebLocalFrame* frame,
-                                              int page_count,
+                                              uint32_t page_count,
                                               bool is_pdf) {
   const mojom::PrintPagesParams& params = *print_pages_params_;
   const mojom::PrintParams& print_params = *params.params;
 
-  std::vector<int> printed_pages = GetPrintedPages(params, page_count);
+  std::vector<uint32_t> printed_pages = GetPrintedPages(params, page_count);
   if (printed_pages.empty())
     return false;
 
@@ -2076,7 +2082,7 @@ void PrintRenderFrameHelper::FinishFramePrinting() {
 // static - Not anonymous so that platform implementations can use it.
 void PrintRenderFrameHelper::ComputePageLayoutInPointsForCss(
     blink::WebLocalFrame* frame,
-    int page_index,
+    uint32_t page_index,
     const mojom::PrintParams& page_params,
     bool ignore_css_margins,
     double* scale_factor,
@@ -2090,17 +2096,17 @@ void PrintRenderFrameHelper::ComputePageLayoutInPointsForCss(
 }
 
 // static - Not anonymous so that platform implementations can use it.
-std::vector<int> PrintRenderFrameHelper::GetPrintedPages(
+std::vector<uint32_t> PrintRenderFrameHelper::GetPrintedPages(
     const mojom::PrintPagesParams& params,
-    int page_count) {
-  std::vector<int> printed_pages;
+    uint32_t page_count) {
+  std::vector<uint32_t> printed_pages;
   if (params.pages.empty()) {
-    for (int i = 0; i < page_count; ++i) {
+    for (uint32_t i = 0; i < page_count; ++i) {
       printed_pages.push_back(i);
     }
   } else {
-    for (int page : params.pages) {
-      if (page >= 0 && page < page_count) {
+    for (uint32_t page : params.pages) {
+      if (page != kInvalidPageIndex && page < page_count) {
         printed_pages.push_back(page);
       }
     }
@@ -2151,7 +2157,7 @@ bool PrintRenderFrameHelper::InitPrintSettings(bool fit_to_paper_size) {
 
 bool PrintRenderFrameHelper::CalculateNumberOfPages(blink::WebLocalFrame* frame,
                                                     const blink::WebNode& node,
-                                                    int* number_of_pages) {
+                                                    uint32_t* number_of_pages) {
   DCHECK(frame);
   bool fit_to_paper_size = !IsPrintingNodeOrPdfFrame(frame, node);
   if (!InitPrintSettings(fit_to_paper_size)) {
@@ -2261,7 +2267,7 @@ bool PrintRenderFrameHelper::UpdatePrintSettings(
 void PrintRenderFrameHelper::GetPrintSettingsFromUser(
     blink::WebLocalFrame* frame,
     const blink::WebNode& node,
-    int expected_pages_count,
+    uint32_t expected_pages_count,
     PrintRequestType print_request_type,
     mojom::PrintPagesParams* print_settings) {
   bool is_scripted = print_request_type == PrintRequestType::kScripted;
@@ -2310,8 +2316,8 @@ bool PrintRenderFrameHelper::RenderPagesForPrint(blink::WebLocalFrame* frame,
 
 #if !defined(OS_APPLE)
 void PrintRenderFrameHelper::PrintPageInternal(const mojom::PrintParams& params,
-                                               int page_number,
-                                               int page_count,
+                                               uint32_t page_number,
+                                               uint32_t page_count,
                                                double scale_factor,
                                                blink::WebLocalFrame* frame,
                                                MetafileSkia* metafile,
@@ -2507,9 +2513,9 @@ bool PrintRenderFrameHelper::CheckForCancel() {
 }
 
 bool PrintRenderFrameHelper::PreviewPageRendered(
-    int page_number,
+    uint32_t page_number,
     std::unique_ptr<MetafileSkia> metafile) {
-  DCHECK_GE(page_number, FIRST_PAGE_INDEX);
+  DCHECK_NE(page_number, kInvalidPageIndex);
   DCHECK(metafile);
   DCHECK(print_preview_context_.IsModifiable());
 
@@ -2626,7 +2632,7 @@ void PrintRenderFrameHelper::PrintPreviewContext::OnPrintPreview() {
 
 bool PrintRenderFrameHelper::PrintPreviewContext::CreatePreviewDocument(
     std::unique_ptr<PrepareFrameAndViewForPrint> prepared_frame,
-    const std::vector<int>& pages,
+    const std::vector<uint32_t>& pages,
     mojom::SkiaDocumentType doc_type,
     int document_cookie,
     bool require_document_metafile) {
@@ -2638,8 +2644,9 @@ bool PrintRenderFrameHelper::PrintPreviewContext::CreatePreviewDocument(
   prep_frame_view_->StartPrinting();
 
   total_page_count_ = prep_frame_view_->GetExpectedPageCount();
-  if (total_page_count_ == 0) {
-    LOG(ERROR) << "CreatePreviewDocument got 0 page count";
+  if (total_page_count_ == 0 || total_page_count_ > kMaxPageCount) {
+    LOG(ERROR) << "CreatePreviewDocument got 0 page count or it's greater than "
+                  "kMaxPageCount.";
     set_error(PREVIEW_ERROR_ZERO_PAGES);
     return false;
   }
@@ -2665,7 +2672,7 @@ bool PrintRenderFrameHelper::PrintPreviewContext::CreatePreviewDocument(
   if (pages_to_render_.empty()) {
     // Render all pages.
     pages_to_render_.reserve(total_page_count_);
-    for (int i = 0; i < total_page_count_; ++i)
+    for (uint32_t i = 0; i < total_page_count_; ++i)
       pages_to_render_.push_back(i);
   }
   print_ready_metafile_page_count_ = pages_to_render_.size();
@@ -2743,10 +2750,10 @@ void PrintRenderFrameHelper::PrintPreviewContext::Failed(bool report_error) {
   ClearContext();
 }
 
-int PrintRenderFrameHelper::PrintPreviewContext::GetNextPageNumber() {
+uint32_t PrintRenderFrameHelper::PrintPreviewContext::GetNextPageNumber() {
   DCHECK_EQ(RENDERING, state_);
   if (IsFinalPageRendered())
-    return -1;
+    return kInvalidPageIndex;
   return pages_to_render_[current_page_index_++];
 }
 
@@ -2822,12 +2829,12 @@ PrintRenderFrameHelper::PrintPreviewContext::prepared_node() const {
   return prep_frame_view_->node();
 }
 
-int PrintRenderFrameHelper::PrintPreviewContext::total_page_count() const {
+uint32_t PrintRenderFrameHelper::PrintPreviewContext::total_page_count() const {
   DCHECK(state_ != UNINITIALIZED);
   return total_page_count_;
 }
 
-const std::vector<int>&
+const std::vector<uint32_t>&
 PrintRenderFrameHelper::PrintPreviewContext::pages_to_render() const {
   DCHECK_EQ(RENDERING, state_);
   return pages_to_render_;

components/printing/renderer/print_render_frame_helper.h

@@ -270,7 +270,7 @@ class PrintRenderFrameHelper
 
   // Renders a print preview page. |page_number| is 0-based.
   // Returns true if print preview should continue, false on failure.
-  bool RenderPreviewPage(int page_number);
+  bool RenderPreviewPage(uint32_t page_number);
 
   // Finalize the print ready preview document.
   bool FinalizePrintReadyDocument();
@@ -313,7 +313,7 @@ class PrintRenderFrameHelper
   // Calculate number of pages in source document.
   bool CalculateNumberOfPages(blink::WebLocalFrame* frame,
                               const blink::WebNode& node,
-                              int* number_of_pages);
+                              uint32_t* number_of_pages);
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   // Set options for print preset from source PDF document.
@@ -331,7 +331,7 @@ class PrintRenderFrameHelper
   // WARNING: |this| may be gone after this method returns.
   void GetPrintSettingsFromUser(blink::WebLocalFrame* frame,
                                 const blink::WebNode& node,
-                                int expected_pages_count,
+                                uint32_t expected_pages_count,
                                 PrintRequestType print_request_type,
                                 mojom::PrintPagesParams* print_settings);
 
@@ -340,7 +340,7 @@ class PrintRenderFrameHelper
   void OnFramePreparedForPrintPages();
   void PrintPages();
   bool PrintPagesNative(blink::WebLocalFrame* frame,
-                        int page_count,
+                        uint32_t page_count,
                         bool is_pdf);
   void FinishFramePrinting();
   // Render the frame for printing.
@@ -349,8 +349,8 @@ class PrintRenderFrameHelper
 
   // Platform-specific helper function for rendering page(s) to |metafile|.
   void PrintPageInternal(const mojom::PrintParams& params,
-                         int page_number,
-                         int page_count,
+                         uint32_t page_number,
+                         uint32_t page_count,
                          double scale_factor,
                          blink::WebLocalFrame* frame,
                          MetafileSkia* metafile,
@@ -362,7 +362,7 @@ class PrintRenderFrameHelper
   // When method is called, canvas should be setup to draw to |canvas_area|
   // with |scale_factor|.
   static float RenderPageContent(blink::WebLocalFrame* frame,
-                                 int page_number,
+                                 uint32_t page_number,
                                  const gfx::Rect& canvas_area,
                                  const gfx::Rect& content_area,
                                  double scale_factor,
@@ -379,7 +379,7 @@ class PrintRenderFrameHelper
   // Helper method to get page layout in points and fit to page if needed.
   static void ComputePageLayoutInPointsForCss(
       blink::WebLocalFrame* frame,
-      int page_index,
+      uint32_t page_index,
       const mojom::PrintParams& default_params,
       bool ignore_css_margins,
       double* scale_factor,
@@ -387,15 +387,16 @@ class PrintRenderFrameHelper
 
   // Return an array of pages to print given the print |params| and an expected
   // |page_count|. Page numbers are zero-based.
-  static std::vector<int> GetPrintedPages(const mojom::PrintPagesParams& params,
-                                          int page_count);
+  static std::vector<uint32_t> GetPrintedPages(
+      const mojom::PrintPagesParams& params,
+      uint32_t page_count);
 
   // Given the |device| and |canvas| to draw on, prints the appropriate headers
   // and footers using strings from |header_footer_info| on to the canvas.
   static void PrintHeaderAndFooter(
       cc::PaintCanvas* canvas,
-      int page_number,
-      int total_pages,
+      uint32_t page_number,
+      uint32_t total_pages,
       const blink::WebLocalFrame& source_frame,
       float webkit_scale_factor,
       const mojom::PageSizeMargins& page_layout_in_points,
@@ -426,7 +427,7 @@ class PrintRenderFrameHelper
   // |page_number| is 0-based.
   // |metafile| is the rendered page and should be valid.
   // Returns true if print preview should continue, false on failure.
-  bool PreviewPageRendered(int page_number,
+  bool PreviewPageRendered(uint32_t page_number,
                            std::unique_ptr<MetafileSkia> metafile);
 
   // Called when the connection with the |preview_ui_| goes away.
@@ -499,7 +500,7 @@ class PrintRenderFrameHelper
     // Create the print preview document. |pages| is empty to print all pages.
     bool CreatePreviewDocument(
         std::unique_ptr<PrepareFrameAndViewForPrint> prepared_frame,
-        const std::vector<int>& pages,
+        const std::vector<uint32_t>& pages,
         mojom::SkiaDocumentType doc_type,
         int document_cookie,
         bool require_document_metafile);
@@ -525,7 +526,7 @@ class PrintRenderFrameHelper
     void Failed(bool report_error);
 
     // Helper functions
-    int GetNextPageNumber();
+    uint32_t GetNextPageNumber();
     bool IsRendering() const;
     bool IsForArc() const;
     bool IsPlugin() const;
@@ -552,8 +553,8 @@ class PrintRenderFrameHelper
     // generated from it, e.g. copy of selected block.
     const blink::WebNode& prepared_node() const;
 
-    int total_page_count() const;
-    const std::vector<int>& pages_to_render() const;
+    uint32_t total_page_count() const;
+    const std::vector<uint32_t>& pages_to_render() const;
     size_t pages_rendered_count() const;
     MetafileSkia* metafile();
     ContentProxySet* typeface_content_info();
@@ -589,13 +590,13 @@ class PrintRenderFrameHelper
     std::unique_ptr<MetafileSkia> metafile_;
 
     // Total page count in the renderer.
-    int total_page_count_ = 0;
+    uint32_t total_page_count_ = 0;
 
     // The current page to render.
     int current_page_index_ = 0;
 
     // List of page indices that need to be rendered.
-    std::vector<int> pages_to_render_;
+    std::vector<uint32_t> pages_to_render_;
 
     // True, if the document source is a plugin.
     bool is_plugin_ = false;

components/printing/renderer/print_render_frame_helper_mac.mm

@@ -21,8 +21,8 @@
 namespace printing {
 
 void PrintRenderFrameHelper::PrintPageInternal(const mojom::PrintParams& params,
-                                               int page_number,
-                                               int page_count,
+                                               uint32_t page_number,
+                                               uint32_t page_count,
                                                double scale_factor,
                                                blink::WebLocalFrame* frame,
                                                MetafileSkia* metafile,

components/printing/test/mock_printer.cc

@@ -75,8 +75,8 @@ MockPrinter::MockPrinter()
       document_cookie_(-1),
       current_document_cookie_(0),
       printer_status_(PRINTER_READY),
-      number_pages_(0),
-      page_number_(0),
+      number_pages_(0u),
+      page_number_(0u),
       is_first_request_(true),
       print_to_pdf_(false),
       preview_request_id_(0),
@@ -146,7 +146,7 @@ void MockPrinter::UseInvalidContentSize() {
 }
 
 void MockPrinter::ScriptedPrint(int cookie,
-                                int expected_pages_count,
+                                uint32_t expected_pages_count,
                                 bool has_selection,
                                 printing::mojom::PrintPagesParams* settings) {
   // Verify the input parameters.
@@ -174,7 +174,7 @@ void MockPrinter::ScriptedPrint(int cookie,
 
 void MockPrinter::UpdateSettings(int cookie,
                                  printing::mojom::PrintPagesParams* params,
-                                 const std::vector<int>& pages,
+                                 const std::vector<uint32_t>& pages,
                                  int margins_type,
                                  const gfx::Size& page_size,
                                  int scale_factor) {
@@ -190,17 +190,17 @@ void MockPrinter::UpdateSettings(int cookie,
   printer_status_ = PRINTER_PRINTING;
 }
 
-void MockPrinter::SetPrintedPagesCount(int cookie, int number_pages) {
+void MockPrinter::SetPrintedPagesCount(int cookie, uint32_t number_pages) {
   // Verify the input parameter and update the printer status so that the
   // RenderViewTest class can verify the this function finishes without errors.
   EXPECT_EQ(document_cookie_, cookie);
   EXPECT_EQ(PRINTER_PRINTING, printer_status_);
-  EXPECT_EQ(0, number_pages_);
-  EXPECT_EQ(0, page_number_);
+  EXPECT_EQ(0u, number_pages_);
+  EXPECT_EQ(0u, page_number_);
 
   // Initialize the job status.
   number_pages_ = number_pages;
-  page_number_ = 0;
+  page_number_ = 0u;
   pages_.clear();
 }
 

components/printing/test/mock_printer.h

@@ -77,16 +77,16 @@ class MockPrinter {
   // Functions that handles IPC events.
   void GetDefaultPrintSettings(printing::mojom::PrintParams* params);
   void ScriptedPrint(int cookie,
-                     int expected_pages_count,
+                     uint32_t expected_pages_count,
                      bool has_selection,
                      printing::mojom::PrintPagesParams* settings);
   void UpdateSettings(int cookie,
                       printing::mojom::PrintPagesParams* params,
-                      const std::vector<int>& page_range_array,
+                      const std::vector<uint32_t>& page_range_array,
                       int margins_type,
                       const gfx::Size& page_size,
                       int scale_factor);
-  void SetPrintedPagesCount(int cookie, int number_pages);
+  void SetPrintedPagesCount(int cookie, uint32_t number_pages);
   void PrintPage(const printing::mojom::DidPrintDocumentParams& params);
 
   // Functions that retrieve the output pages.
@@ -136,8 +136,8 @@ class MockPrinter {
   Status printer_status_;
 
   // The output of a printing job.
-  int number_pages_;
-  int page_number_;
+  uint32_t number_pages_;
+  uint32_t page_number_;
 
   // Used only in the preview sequence.
   bool is_first_request_;

components/printing/test/print_mock_render_thread.cc

@@ -109,8 +109,8 @@ void PrintMockRenderThread::OnDidStartPreview(
 void PrintMockRenderThread::OnDidPreviewPage(
     const printing::mojom::DidPreviewPageParams& params,
     const printing::mojom::PreviewIds& ids) {
-  int page_number = params.page_number;
-  DCHECK_GE(page_number, printing::FIRST_PAGE_INDEX);
+  uint32_t page_number = params.page_number;
+  DCHECK_NE(page_number, printing::kInvalidPageIndex);
   print_preview_pages_remaining_--;
   print_preview_pages_.emplace_back(
       params.page_number, params.content->metafile_data_region.GetSize());
@@ -202,7 +202,7 @@ void PrintMockRenderThread::OnUpdatePrintSettings(
       job_settings.FindIntKey(printing::kSettingScaleFactor);
   int scale_factor = setting_scale_factor.value_or(100);
 
-  std::vector<int> pages(printing::PageRange::GetPages(new_ranges));
+  std::vector<uint32_t> pages(printing::PageRange::GetPages(new_ranges));
   printer_->UpdateSettings(document_cookie, &params, pages,
                            margins_type.value(), page_size, scale_factor);
   base::Optional<bool> selection_only =
@@ -224,15 +224,16 @@ void PrintMockRenderThread::set_print_dialog_user_response(bool response) {
   print_dialog_user_response_ = response;
 }
 
-void PrintMockRenderThread::set_print_preview_cancel_page_number(int page) {
+void PrintMockRenderThread::set_print_preview_cancel_page_number(
+    uint32_t page) {
   print_preview_cancel_page_number_ = page;
 }
 
-int PrintMockRenderThread::print_preview_pages_remaining() const {
+uint32_t PrintMockRenderThread::print_preview_pages_remaining() const {
   return print_preview_pages_remaining_;
 }
 
-const std::vector<std::pair<int, uint32_t>>&
+const std::vector<std::pair<uint32_t, uint32_t>>&
 PrintMockRenderThread::print_preview_pages() const {
   return print_preview_pages_;
 }

components/printing/test/print_mock_render_thread.h

@@ -18,6 +18,7 @@
 #include "components/printing/common/print.mojom-forward.h"
 #include "content/public/test/mock_render_thread.h"
 #include "printing/buildflags/buildflags.h"
+#include "printing/print_job_constants.h"
 
 namespace base {
 class DictionaryValue;
@@ -51,13 +52,13 @@ class PrintMockRenderThread : public content::MockRenderThread {
   void set_print_dialog_user_response(bool response);
 
   // Cancel print preview when print preview has |page| remaining pages.
-  void set_print_preview_cancel_page_number(int page);
+  void set_print_preview_cancel_page_number(uint32_t page);
 
   // Get the number of pages to generate for print preview.
-  int print_preview_pages_remaining() const;
+  uint32_t print_preview_pages_remaining() const;
 
   // Get a vector of print preview pages.
-  const std::vector<std::pair<int, uint32_t>>& print_preview_pages() const;
+  const std::vector<std::pair<uint32_t, uint32_t>>& print_preview_pages() const;
 #endif
 
   MockPrinter* GetPrinter() { return printer_.get(); }
@@ -97,13 +98,13 @@ class PrintMockRenderThread : public content::MockRenderThread {
 
   // Simulates cancelling print preview if |print_preview_pages_remaining_|
   // equals this.
-  int print_preview_cancel_page_number_ = -1;
+  uint32_t print_preview_cancel_page_number_ = printing::kInvalidPageIndex;
 
   // Number of pages to generate for print preview.
-  int print_preview_pages_remaining_ = 0;
+  uint32_t print_preview_pages_remaining_ = 0;
 
   // Vector of <page_number, content_data_size> that were previewed.
-  std::vector<std::pair<int, uint32_t>> print_preview_pages_;
+  std::vector<std::pair<uint32_t, uint32_t>> print_preview_pages_;
 #endif
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;

components/printing/test/print_render_frame_helper_browsertest.cc

@@ -223,7 +223,7 @@ class TestPrintManagerHost
 
   // mojom::PrintManagerInterceptorForTesting
   mojom::PrintManagerHost* GetForwardingInterface() override { return nullptr; }
-  void DidGetPrintedPagesCount(int32_t cookie, int32_t number_pages) override {
+  void DidGetPrintedPagesCount(int32_t cookie, uint32_t number_pages) override {
     if (number_pages_ > 0)
       EXPECT_EQ(number_pages, number_pages_);
     printer_->SetPrintedPagesCount(cookie, number_pages);
@@ -231,7 +231,7 @@ class TestPrintManagerHost
   void DidGetDocumentCookie(int32_t cookie) override {}
   void DidShowPrintDialog() override {}
 
-  void SetExpectedPagesCount(int32_t number_pages) {
+  void SetExpectedPagesCount(uint32_t number_pages) {
     number_pages_ = number_pages;
   }
 
@@ -249,7 +249,7 @@ class TestPrintManagerHost
         std::move(handle)));
   }
 
-  int32_t number_pages_ = -1;
+  uint32_t number_pages_ = 0;
   MockPrinter* printer_;
   mojo::AssociatedReceiver<mojom::PrintManagerHost> receiver_{this};
 };
@@ -309,7 +309,7 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
   // The renderer should be done calculating the number of rendered pages
   // according to the specified settings defined in the mock render thread.
   // Verify the page count is correct.
-  void VerifyPreviewPageCount(int expected_count) {
+  void VerifyPreviewPageCount(uint32_t expected_count) {
     const IPC::Message* preview_started_message =
         render_thread_->sink().GetUniqueMessageMatching(
             PrintHostMsg_DidStartPreview::ID);
@@ -790,7 +790,7 @@ class MAYBE_PrintRenderFrameHelperPreviewTest
   }
 
   // |page_number| is 0-based.
-  void VerifyDidPreviewPage(bool expect_generated, int page_number) {
+  void VerifyDidPreviewPage(bool expect_generated, uint32_t page_number) {
     bool msg_found = false;
     uint32_t data_size = 0;
     for (const auto& preview : print_render_thread()->print_preview_pages()) {
@@ -870,7 +870,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, OnPrintPreview) {
   CreatePrintSettingsDictionary(&dict);
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
   VerifyDefaultPageLayout(540, 720, 36, 36, 36, 36, false);
@@ -903,7 +903,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
   dict.SetInteger(kSettingPrinterType, static_cast<int>(PrinterType::kLocal));
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDefaultPageLayout(519, 432, 216, 144, 21, 72, false);
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
@@ -929,7 +929,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
                   static_cast<int>(mojom::MarginType::kNoMargins));
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDefaultPageLayout(612, 792, 0, 0, 0, 0, true);
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
@@ -954,7 +954,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
                   static_cast<int>(mojom::MarginType::kPrintableAreaMargins));
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   // Since PRINT_TO_PDF is selected, pdf page size is equal to print media page
   // size.
   VerifyDefaultPageLayout(252, 252, 18, 18, 18, 18, true);
@@ -1080,7 +1080,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
   dict.SetInteger(kSettingPrinterType, static_cast<int>(PrinterType::kLocal));
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDidPreviewPage(true, 0);
   VerifyDidPreviewPage(true, 1);
   VerifyPreviewPageCount(2);
@@ -1115,7 +1115,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
   CreatePrintSettingsDictionary(&dict);
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   // Since PRINT_TO_PDF is selected, pdf page size is equal to print media page
   // size.
   VerifyDefaultPageLayout(915, 648, 216, 144, 21, 72, true);
@@ -1140,7 +1140,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, PrintPreviewCenterToFitPage) {
   dict.SetInteger(kSettingPrinterType, static_cast<int>(PrinterType::kLocal));
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDefaultPageLayout(216, 216, 288, 288, 198, 198, true);
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
@@ -1174,7 +1174,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, PrintPreviewShrinkToFitPage) {
   dict.SetInteger(kSettingPrinterType, static_cast<int>(PrinterType::kLocal));
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDefaultPageLayout(571, 652, 69, 71, 20, 21, true);
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
@@ -1200,7 +1200,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
                   static_cast<int>(mojom::MarginType::kNoMargins));
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDefaultPageLayout(792, 612, 0, 0, 0, 0, true);
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
@@ -1225,7 +1225,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
                   static_cast<int>(mojom::MarginType::kCustomMargins));
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDefaultPageLayout(748, 568, 21, 23, 21, 23, true);
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
@@ -1246,7 +1246,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, PrintPreviewForMultiplePages) {
 
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDidPreviewPage(true, 0);
   VerifyDidPreviewPage(true, 1);
   VerifyDidPreviewPage(true, 2);
@@ -1283,7 +1283,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, PrintPreviewForSelectedPages) {
   // generated, the print_preview_pages_remaining() result is 1.
   // TODO(thestig): Fix this on the browser side to accept the number of actual
   // pages generated instead, or to take both page counts.
-  EXPECT_EQ(1, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(1u, print_render_thread()->print_preview_pages_remaining());
   VerifyDidPreviewPage(false, 0);
   VerifyDidPreviewPage(true, 1);
   VerifyDidPreviewPage(true, 2);
@@ -1310,7 +1310,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, PrintPreviewForSelectedText) {
 
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
   VerifyPrintPreviewCancelled(false);
@@ -1335,7 +1335,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, PrintPreviewForSelectedText2) {
 
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(2);
   VerifyPrintPreviewCancelled(false);
@@ -1350,7 +1350,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, PrintPreviewForSelectedText2) {
 TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, PrintPreviewCancel) {
   LoadHTML(kLongPageHTML);
 
-  const int kCancelPage = 3;
+  const uint32_t kCancelPage = 3;
   print_render_thread()->set_print_preview_cancel_page_number(kCancelPage);
   // Fill in some dummy values.
   base::DictionaryValue dict;
@@ -1383,7 +1383,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
 
   // We should have received invalid printer settings from |printer_|.
   VerifyPrintPreviewInvalidPrinterSettings(true);
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
 
   // It should receive the invalid printer settings message only.
   VerifyPrintPreviewFailed(false);
@@ -1405,7 +1405,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
   OnPrintPreview(dict);
 
   VerifyPrintPreviewInvalidPrinterSettings(true);
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
 
   // It should receive the invalid printer settings message only.
   VerifyPrintPreviewFailed(false);
@@ -1427,7 +1427,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest,
   OnPrintPreview(dict);
 
   VerifyPrintPreviewInvalidPrinterSettings(true);
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
 
   // It should receive the invalid printer settings message only.
   VerifyPrintPreviewFailed(false);
@@ -1444,7 +1444,7 @@ TEST_F(MAYBE_PrintRenderFrameHelperPreviewTest, BasicBeforePrintAfterPrint) {
   CreatePrintSettingsDictionary(&dict);
   OnPrintPreview(dict);
 
-  EXPECT_EQ(0, print_render_thread()->print_preview_pages_remaining());
+  EXPECT_EQ(0u, print_render_thread()->print_preview_pages_remaining());
   VerifyDidPreviewPage(true, 0);
   VerifyPreviewPageCount(1);
   VerifyDefaultPageLayout(540, 720, 36, 36, 36, 36, false);

content/renderer/gpu_benchmarking_extension.cc

@@ -469,8 +469,8 @@ static void PrintDocument(blink::WebLocalFrame* frame, SkDocument* doc) {
   const int kContentHeight = 735;    // 10.21 inch
   blink::WebPrintParams params(blink::WebSize(kContentWidth, kContentHeight));
   params.printer_dpi = 300;
-  int page_count = frame->PrintBegin(params);
-  for (int i = 0; i < page_count; ++i) {
+  uint32_t page_count = frame->PrintBegin(params);
+  for (uint32_t i = 0; i < page_count; ++i) {
     SkCanvas* sk_canvas = doc->beginPage(kPageWidth, kPageHeight);
     cc::SkiaPaintCanvas canvas(sk_canvas);
     cc::PaintCanvasAutoRestore auto_restore(&canvas, true);

content/web_test/renderer/pixel_dump.cc

@@ -46,7 +46,7 @@ SkBitmap PrintFrameToBitmap(blink::WebLocalFrame* web_frame) {
 
   blink::WebSize page_size_in_pixels = frame_widget->Size();
 
-  int page_count = web_frame->PrintBegin(page_size_in_pixels);
+  uint32_t page_count = web_frame->PrintBegin(page_size_in_pixels);
   blink::WebSize spool_size =
       web_frame->SpoolSizeInPixelsForTesting(page_size_in_pixels, page_count);
 

headless/lib/browser/headless_print_manager.cc

@@ -72,15 +72,15 @@ std::string HeadlessPrintManager::PrintResultToString(PrintResult result) {
 HeadlessPrintManager::PageRangeStatus
 HeadlessPrintManager::PageRangeTextToPages(base::StringPiece page_range_text,
                                            bool ignore_invalid_page_ranges,
-                                           int pages_count,
-                                           std::vector<int>* pages) {
+                                           uint32_t pages_count,
+                                           std::vector<uint32_t>* pages) {
   printing::PageRanges page_ranges;
   for (const auto& range_string :
        base::SplitStringPiece(page_range_text, ",", base::TRIM_WHITESPACE,
                               base::SPLIT_WANT_NONEMPTY)) {
     printing::PageRange range;
     if (range_string.find("-") == base::StringPiece::npos) {
-      if (!base::StringToInt(range_string, &range.from))
+      if (!base::StringToUint(range_string, &range.from))
         return SYNTAX_ERROR;
       range.to = range.from;
     } else if (range_string == "-") {
@@ -88,18 +88,18 @@ HeadlessPrintManager::PageRangeTextToPages(base::StringPiece page_range_text,
       range.to = pages_count;
     } else if (base::StartsWith(range_string, "-")) {
       range.from = 1;
-      if (!base::StringToInt(range_string.substr(1), &range.to))
+      if (!base::StringToUint(range_string.substr(1), &range.to))
         return SYNTAX_ERROR;
     } else if (base::EndsWith(range_string, "-")) {
       range.to = pages_count;
-      if (!base::StringToInt(range_string.substr(0, range_string.length() - 1),
-                             &range.from))
+      if (!base::StringToUint(range_string.substr(0, range_string.length() - 1),
+                              &range.from))
         return SYNTAX_ERROR;
     } else {
       auto tokens = base::SplitStringPiece(
           range_string, "-", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-      if (tokens.size() != 2 || !base::StringToInt(tokens[0], &range.from) ||
-          !base::StringToInt(tokens[1], &range.to))
+      if (tokens.size() != 2 || !base::StringToUint(tokens[0], &range.from) ||
+          !base::StringToUint(tokens[1], &range.to))
         return SYNTAX_ERROR;
     }
 

headless/lib/browser/headless_print_manager.h

@@ -77,8 +77,8 @@ class HeadlessPrintManager
   HEADLESS_EXPORT static PageRangeStatus PageRangeTextToPages(
       base::StringPiece page_range_text,
       bool ignore_invalid_page_ranges,
-      int pages_count,
-      std::vector<int>* pages);
+      uint32_t pages_count,
+      std::vector<uint32_t>* pages);
 
   // Prints the current document immediately. Since the rendering is
   // asynchronous, the actual printing will not be completed on the return of

headless/lib/browser/headless_printing_unittest.cc

@@ -15,8 +15,8 @@ namespace headless {
 
 TEST(PageRangeTextToPagesTest, General) {
   using PM = HeadlessPrintManager;
-  std::vector<int> pages;
-  std::vector<int> expected_pages;
+  std::vector<uint32_t> pages;
+  std::vector<uint32_t> expected_pages;
 
   // "-" is full range of pages.
   PM::PageRangeStatus status = PM::PageRangeTextToPages("-", false, 10, &pages);

printing/page_number.cc

@@ -13,14 +13,15 @@
 
 namespace printing {
 
-PageNumber::PageNumber(const PrintSettings& settings, int document_page_count) {
+PageNumber::PageNumber(const PrintSettings& settings,
+                       uint32_t document_page_count) {
   Init(settings, document_page_count);
 }
 
 PageNumber::PageNumber()
     : ranges_(nullptr),
-      page_number_(-1),
-      page_range_index_(-1),
+      page_number_(kInvalidPageIndex),
+      page_range_index_(kInvalidPageIndex),
       document_page_count_(0) {}
 
 void PageNumber::operator=(const PageNumber& other) {
@@ -30,7 +31,8 @@ void PageNumber::operator=(const PageNumber& other) {
   document_page_count_ = other.document_page_count_;
 }
 
-void PageNumber::Init(const PrintSettings& settings, int document_page_count) {
+void PageNumber::Init(const PrintSettings& settings,
+                      uint32_t document_page_count) {
   DCHECK(document_page_count);
   ranges_ = settings.ranges().empty() ? NULL : &settings.ranges();
   document_page_count_ = document_page_count;
@@ -41,16 +43,16 @@ void PageNumber::Init(const PrintSettings& settings, int document_page_count) {
     if (document_page_count) {
       page_number_ = 0;
     } else {
-      page_number_ = -1;
+      page_number_ = kInvalidPageIndex;
     }
-    page_range_index_ = -1;
+    page_range_index_ = kInvalidPageIndex;
   }
 }
 
 int PageNumber::operator++() {
   if (!ranges_) {
     // Switch to next page.
-    if (++page_number_ == document_page_count_) {
+    if (++page_number_ >= document_page_count_) {
       // Finished.
       *this = npos();
     }
@@ -61,7 +63,7 @@ int PageNumber::operator++() {
     if (page_number_ > (*ranges_)[page_range_index_].to) {
       DCHECK(ranges_->size() <=
              static_cast<size_t>(std::numeric_limits<int>::max()));
-      if (++page_range_index_ == static_cast<int>(ranges_->size())) {
+      if (++page_range_index_ == ranges_->size()) {
         // Finished.
         *this = npos();
       } else {
@@ -69,7 +71,7 @@ int PageNumber::operator++() {
       }
     }
   }
-  return ToInt();
+  return ToUint();
 }
 
 bool PageNumber::operator==(const PageNumber& other) const {

printing/page_number.h

@@ -18,7 +18,7 @@ class PrintSettings;
 class PRINTING_EXPORT PageNumber {
  public:
   // Initializes the page to the first page in the settings's range or 0.
-  PageNumber(const PrintSettings& settings, int document_page_count);
+  PageNumber(const PrintSettings& settings, uint32_t document_page_count);
 
   PageNumber();
 
@@ -26,10 +26,10 @@ class PRINTING_EXPORT PageNumber {
 
   // Initializes the page to the first page in the setting's range or 0. It
   // initialize to npos if the range is empty and document_page_count is 0.
-  void Init(const PrintSettings& settings, int document_page_count);
+  void Init(const PrintSettings& settings, uint32_t document_page_count);
 
   // Converts to a page numbers.
-  int ToInt() const { return page_number_; }
+  uint32_t ToUint() const { return page_number_; }
 
   // Calculates the next page in the serie.
   int operator++();
@@ -46,15 +46,15 @@ class PRINTING_EXPORT PageNumber {
   // The page range to follow.
   const PageRanges* ranges_;
 
-  // The next page to be printed. -1 when not printing.
-  int page_number_;
+  // The next page to be printed. |kInvalidPageIndex| when not printing.
+  uint32_t page_number_;
 
-  // The next page to be printed. -1 when not used. Valid only if
-  // document()->settings().range.empty() is false.
-  int page_range_index_;
+  // The next page to be printed. |kInvalidPageIndex| when not used. Valid only
+  // if document()->settings().range.empty() is false.
+  uint32_t page_range_index_;
 
   // Number of expected pages in the document. Used when ranges_ is NULL.
-  int document_page_count_;
+  uint32_t document_page_count_;
 };
 
 // Debug output support.
@@ -62,7 +62,7 @@ template <class E, class T>
 inline typename std::basic_ostream<E, T>& operator<<(
     typename std::basic_ostream<E, T>& ss,
     const PageNumber& page) {
-  return ss << page.ToInt();
+  return ss << page.ToUint();
 }
 
 }  // namespace printing

printing/page_number_unittest.cc

@@ -11,18 +11,18 @@ TEST(PageNumberTest, Count) {
   printing::PageNumber page;
   EXPECT_EQ(printing::PageNumber::npos(), page);
   page.Init(settings, 3);
-  EXPECT_EQ(0, page.ToInt());
+  EXPECT_EQ(0u, page.ToUint());
   EXPECT_NE(printing::PageNumber::npos(), page);
   ++page;
-  EXPECT_EQ(1, page.ToInt());
+  EXPECT_EQ(1u, page.ToUint());
   EXPECT_NE(printing::PageNumber::npos(), page);
 
   printing::PageNumber page_copy(page);
-  EXPECT_EQ(1, page_copy.ToInt());
-  EXPECT_EQ(1, page.ToInt());
+  EXPECT_EQ(1u, page_copy.ToUint());
+  EXPECT_EQ(1u, page.ToUint());
   ++page;
-  EXPECT_EQ(1, page_copy.ToInt());
-  EXPECT_EQ(2, page.ToInt());
+  EXPECT_EQ(1u, page_copy.ToUint());
+  EXPECT_EQ(2u, page.ToUint());
   ++page;
   EXPECT_EQ(printing::PageNumber::npos(), page);
   ++page;

printing/page_range.cc

@@ -11,19 +11,19 @@
 namespace printing {
 
 // static
-std::vector<int> PageRange::GetPages(const PageRanges& ranges) {
+std::vector<uint32_t> PageRange::GetPages(const PageRanges& ranges) {
   // TODO(vitalybuka): crbug.com/95548 Remove this method as part fix.
-  std::set<int> pages;
+  std::set<uint32_t> pages;
   for (const PageRange& range : ranges) {
     // Ranges are inclusive.
-    for (int i = range.from; i <= range.to; ++i) {
+    for (uint32_t i = range.from; i <= range.to; ++i) {
       static constexpr size_t kMaxNumberOfPages = 100000;
       pages.insert(i);
       if (pages.size() >= kMaxNumberOfPages)
-        return std::vector<int>(pages.begin(), pages.end());
+        return std::vector<uint32_t>(pages.begin(), pages.end());
     }
   }
-  return std::vector<int>(pages.begin(), pages.end());
+  return std::vector<uint32_t>(pages.begin(), pages.end());
 }
 
 }  // namespace printing

printing/page_range.h

@@ -17,15 +17,15 @@ using PageRanges = std::vector<PageRange>;
 
 // Print range is inclusive. To select one page, set from == to.
 struct PRINTING_EXPORT PageRange {
-  int from;
-  int to;
+  uint32_t from;
+  uint32_t to;
 
   bool operator==(const PageRange& rhs) const {
     return from == rhs.from && to == rhs.to;
   }
 
   // Retrieves the sorted list of unique pages in the page ranges.
-  static std::vector<int> GetPages(const PageRanges& ranges);
+  static std::vector<uint32_t> GetPages(const PageRanges& ranges);
 };
 
 }  // namespace printing

printing/page_range_unittest.cc

@@ -17,21 +17,21 @@ TEST(PageRangeTest, RangeMerge) {
   range.from = 2;
   range.to = 5;
   ranges.push_back(range);
-  std::vector<int> pages(printing::PageRange::GetPages(ranges));
+  std::vector<uint32_t> pages(printing::PageRange::GetPages(ranges));
   ASSERT_EQ(8U, pages.size());
-  EXPECT_EQ(1, pages[0]);
-  EXPECT_EQ(2, pages[1]);
-  EXPECT_EQ(3, pages[2]);
-  EXPECT_EQ(4, pages[3]);
-  EXPECT_EQ(5, pages[4]);
-  EXPECT_EQ(10, pages[5]);
-  EXPECT_EQ(11, pages[6]);
-  EXPECT_EQ(12, pages[7]);
+  EXPECT_EQ(1u, pages[0]);
+  EXPECT_EQ(2u, pages[1]);
+  EXPECT_EQ(3u, pages[2]);
+  EXPECT_EQ(4u, pages[3]);
+  EXPECT_EQ(5u, pages[4]);
+  EXPECT_EQ(10u, pages[5]);
+  EXPECT_EQ(11u, pages[6]);
+  EXPECT_EQ(12u, pages[7]);
 }
 
 TEST(PageRangeTest, Empty) {
   printing::PageRanges ranges;
-  std::vector<int> pages(printing::PageRange::GetPages(ranges));
+  std::vector<uint32_t> pages(printing::PageRange::GetPages(ranges));
   EXPECT_TRUE(pages.empty());
 }
 
@@ -41,6 +41,6 @@ TEST(PageRangeTest, Huge) {
   range.from = 1;
   range.to = 2000000000;
   ranges.push_back(range);
-  std::vector<int> pages(printing::PageRange::GetPages(ranges));
+  std::vector<uint32_t> pages(printing::PageRange::GetPages(ranges));
   EXPECT_FALSE(pages.empty());
 }

printing/print_job_constants.cc

@@ -4,6 +4,8 @@
 
 #include "printing/print_job_constants.h"
 
+#include <limits>
+
 namespace printing {
 
 // True if this is the first preview request.
@@ -209,6 +211,9 @@ const int COMPLETE_PREVIEW_DOCUMENT_INDEX = -1;
 // Whether to show PDF in view provided by OS. Implemented for MacOS only.
 const char kSettingOpenPDFInPreview[] = "OpenPDFInPreview";
 
+const uint32_t kInvalidPageIndex = std::numeric_limits<int>::max();
+const uint32_t kMaxPageCount = std::numeric_limits<int>::max();
+
 #if defined(USE_CUPS)
 const char kBlack[] = "Black";
 const char kCMYK[] = "CMYK";

printing/print_job_constants.h

@@ -5,6 +5,8 @@
 #ifndef PRINTING_PRINT_JOB_CONSTANTS_H_
 #define PRINTING_PRINT_JOB_CONSTANTS_H_
 
+#include <stdint.h>
+
 #include "printing/printing_export.h"
 
 namespace printing {
@@ -80,6 +82,9 @@ PRINTING_EXPORT extern const int FIRST_PAGE_INDEX;
 PRINTING_EXPORT extern const int COMPLETE_PREVIEW_DOCUMENT_INDEX;
 PRINTING_EXPORT extern const char kSettingOpenPDFInPreview[];
 
+PRINTING_EXPORT extern const uint32_t kInvalidPageIndex;
+PRINTING_EXPORT extern const uint32_t kMaxPageCount;
+
 #if defined(USE_CUPS)
 // Printer color models
 PRINTING_EXPORT extern const char kBlack[];

printing/printed_document.cc

@@ -126,7 +126,7 @@ void PrintedDocument::SetConvertingPdf() {
   mutable_.converting_pdf_ = true;
 }
 
-void PrintedDocument::SetPage(int page_number,
+void PrintedDocument::SetPage(uint32_t page_number,
                               std::unique_ptr<MetafilePlayer> metafile,
                               float shrink,
                               const gfx::Size& page_size,
@@ -148,7 +148,7 @@ void PrintedDocument::SetPage(int page_number,
   }
 }
 
-scoped_refptr<PrintedPage> PrintedDocument::GetPage(int page_number) {
+scoped_refptr<PrintedPage> PrintedDocument::GetPage(uint32_t page_number) {
   scoped_refptr<PrintedPage> page;
   {
     base::AutoLock lock(lock_);
@@ -198,7 +198,7 @@ bool PrintedDocument::IsComplete() const {
     return false;
 
   for (; page != PageNumber::npos(); ++page) {
-    PrintedPages::const_iterator it = mutable_.pages_.find(page.ToInt());
+    PrintedPages::const_iterator it = mutable_.pages_.find(page.ToUint());
     if (it == mutable_.pages_.end() || !it->second.get() ||
         !it->second->metafile()) {
       return false;
@@ -210,25 +210,25 @@ bool PrintedDocument::IsComplete() const {
 #endif
 }
 
-void PrintedDocument::set_page_count(int max_page) {
+void PrintedDocument::set_page_count(uint32_t max_page) {
   base::AutoLock lock(lock_);
-  DCHECK_EQ(0, mutable_.page_count_);
+  DCHECK_EQ(0u, mutable_.page_count_);
   mutable_.page_count_ = max_page;
   if (immutable_.settings_->ranges().empty()) {
     mutable_.expected_page_count_ = max_page;
   } else {
     // If there is a range, don't bother since expected_page_count_ is already
     // initialized.
-    DCHECK_NE(mutable_.expected_page_count_, 0);
+    DCHECK_NE(mutable_.expected_page_count_, 0u);
   }
 }
 
-int PrintedDocument::page_count() const {
+uint32_t PrintedDocument::page_count() const {
   base::AutoLock lock(lock_);
   return mutable_.page_count_;
 }
 
-int PrintedDocument::expected_page_count() const {
+uint32_t PrintedDocument::expected_page_count() const {
   base::AutoLock lock(lock_);
   return mutable_.expected_page_count_;
 }

printing/printed_document.h

@@ -51,7 +51,7 @@ class PRINTING_EXPORT PrintedDocument
   void SetConvertingPdf();
 
   // Sets a page's data. 0-based. Note: locks for a short amount of time.
-  void SetPage(int page_number,
+  void SetPage(uint32_t page_number,
                std::unique_ptr<MetafilePlayer> metafile,
                float shrink,
                const gfx::Size& page_size,
@@ -60,7 +60,7 @@ class PRINTING_EXPORT PrintedDocument
   // Retrieves a page. If the page is not available right now, it
   // requests to have this page be rendered and returns NULL.
   // Note: locks for a short amount of time.
-  scoped_refptr<PrintedPage> GetPage(int page_number);
+  scoped_refptr<PrintedPage> GetPage(uint32_t page_number);
 
   // Drop the specified page's reference for the particular page number.
   // Note: locks for a short amount of time.
@@ -94,17 +94,17 @@ class PRINTING_EXPORT PrintedDocument
   // Sets the number of pages in the document to be rendered. Can only be set
   // once.
   // Note: locks for a short amount of time.
-  void set_page_count(int max_page);
+  void set_page_count(uint32_t max_page);
 
   // Number of pages in the document.
   // Note: locks for a short amount of time.
-  int page_count() const;
+  uint32_t page_count() const;
 
   // Returns the number of expected pages to be rendered. It is a non-linear
   // series if settings().ranges is not empty. It is the same value as
   // document_page_count() otherwise.
   // Note: locks for a short amount of time.
-  int expected_page_count() const;
+  uint32_t expected_page_count() const;
 
   // Getters. All these items are immutable hence thread-safe.
   const PrintSettings& settings() const { return *immutable_.settings_; }
@@ -144,7 +144,7 @@ class PRINTING_EXPORT PrintedDocument
   ~PrintedDocument();
 
   // Array of data for each print previewed page.
-  using PrintedPages = std::map<int, scoped_refptr<PrintedPage>>;
+  using PrintedPages = std::map<uint32_t, scoped_refptr<PrintedPage>>;
 
   // Contains all the mutable stuff. All this stuff MUST be accessed with the
   // lock held.
@@ -154,10 +154,10 @@ class PRINTING_EXPORT PrintedDocument
 
     // Number of expected pages to be rendered.
     // Warning: Lock must be held when accessing this member.
-    int expected_page_count_ = 0;
+    uint32_t expected_page_count_ = 0;
 
     // The total number of pages in the document.
-    int page_count_ = 0;
+    uint32_t page_count_ = 0;
 
     std::unique_ptr<MetafilePlayer> metafile_;
 

printing/printed_page_win.cc

@@ -8,7 +8,7 @@
 
 namespace printing {
 
-PrintedPage::PrintedPage(int page_number,
+PrintedPage::PrintedPage(uint32_t page_number,
                          std::unique_ptr<MetafilePlayer> metafile,
                          const gfx::Size& page_size,
                          const gfx::Rect& page_content_rect)

printing/printed_page_win.h

@@ -23,7 +23,7 @@ namespace printing {
 class PRINTING_EXPORT PrintedPage
     : public base::RefCountedThreadSafe<PrintedPage> {
  public:
-  PrintedPage(int page_number,
+  PrintedPage(uint32_t page_number,
               std::unique_ptr<MetafilePlayer> metafile,
               const gfx::Size& page_size,
               const gfx::Rect& page_content_rect);
@@ -31,7 +31,7 @@ class PRINTING_EXPORT PrintedPage
   PrintedPage& operator=(const PrintedPage&) = delete;
 
   // Getters
-  int page_number() const { return page_number_; }
+  uint32_t page_number() const { return page_number_; }
   const MetafilePlayer* metafile() const;
   const gfx::Size& page_size() const { return page_size_; }
   const gfx::Rect& page_content_rect() const { return page_content_rect_; }
@@ -46,7 +46,7 @@ class PRINTING_EXPORT PrintedPage
   ~PrintedPage();
 
   // Page number inside the printed document.
-  const int page_number_;
+  const uint32_t page_number_;
 
   // Actual paint data.
   const std::unique_ptr<MetafilePlayer> metafile_;

third_party/blink/public/web/web_local_frame.h

@@ -299,13 +299,14 @@ class WebLocalFrame : public WebFrame {
   // CSS3 Paged Media ----------------------------------------------------
 
   // Returns the type of @page size styling for the given page.
-  virtual PageSizeType GetPageSizeType(int page_index) = 0;
+  virtual PageSizeType GetPageSizeType(uint32_t page_index) = 0;
 
   // Gets the description for the specified page. This includes preferred page
   // size and margins in pixels, assuming 96 pixels per inch. The size and
   // margins must be initialized to the default values that are used if auto is
   // specified.
-  virtual void GetPageDescription(int page_index, WebPrintPageDescription*) = 0;
+  virtual void GetPageDescription(uint32_t page_index,
+                                  WebPrintPageDescription*) = 0;
 
   // Scripting --------------------------------------------------------------
 
@@ -671,18 +672,18 @@ class WebLocalFrame : public WebFrame {
   // node is printed (for now only plugins are supported), instead of the entire
   // frame.
   // Returns the number of pages that can be printed at the given page size.
-  virtual int PrintBegin(const WebPrintParams&,
-                         const WebNode& constrain_to_node = WebNode()) = 0;
+  virtual uint32_t PrintBegin(const WebPrintParams&,
+                              const WebNode& constrain_to_node = WebNode()) = 0;
 
   // Returns the page shrinking factor calculated by webkit (usually
   // between 1/1.33 and 1/2). Returns 0 if the page number is invalid or
   // not in printing mode.
-  virtual float GetPrintPageShrink(int page) = 0;
+  virtual float GetPrintPageShrink(uint32_t page) = 0;
 
   // Prints one page, and returns the calculated page shrinking factor
   // (usually between 1/1.33 and 1/2).  Returns 0 if the page number is
   // invalid or not in printing mode.
-  virtual float PrintPage(int page_to_print, cc::PaintCanvas*) = 0;
+  virtual float PrintPage(uint32_t page_to_print, cc::PaintCanvas*) = 0;
 
   // Reformats the WebFrame for screen display.
   virtual void PrintEnd() = 0;
@@ -757,7 +758,7 @@ class WebLocalFrame : public WebFrame {
   // page-orientation.
   virtual WebSize SpoolSizeInPixelsForTesting(
       const WebSize& page_size_in_pixels,
-      int page_count) = 0;
+      uint32_t page_count) = 0;
 
   // Prints the frame into the canvas, with page boundaries drawn as one pixel
   // wide blue lines. This method exists to support web tests.

third_party/blink/renderer/core/css/page_rule_collector.cc

@@ -44,7 +44,7 @@ static inline bool ComparePageRules(const StyleRulePage* r1,
 }
 
 bool PageRuleCollector::IsLeftPage(const ComputedStyle* root_element_style,
-                                   int page_index) const {
+                                   uint32_t page_index) const {
   bool is_first_page_left = false;
   DCHECK(root_element_style);
   if (!root_element_style->IsLeftToRightDirection())
@@ -53,14 +53,14 @@ bool PageRuleCollector::IsLeftPage(const ComputedStyle* root_element_style,
   return (page_index + (is_first_page_left ? 1 : 0)) % 2;
 }
 
-bool PageRuleCollector::IsFirstPage(int page_index) const {
+bool PageRuleCollector::IsFirstPage(uint32_t page_index) const {
   // FIXME: In case of forced left/right page, page at index 1 (not 0) can be
   // the first page.
   return (!page_index);
 }
 
 PageRuleCollector::PageRuleCollector(const ComputedStyle* root_element_style,
-                                     int page_index,
+                                     uint32_t page_index,
                                      const AtomicString& page_name,
                                      MatchResult& match_result)
     : is_left_page_(IsLeftPage(root_element_style, page_index)),

third_party/blink/renderer/core/css/page_rule_collector.h

@@ -35,7 +35,7 @@ class PageRuleCollector {
 
  public:
   PageRuleCollector(const ComputedStyle* root_element_style,
-                    int page_index,
+                    uint32_t page_index,
                     const AtomicString& page_name,
                     MatchResult&);
 
@@ -44,12 +44,12 @@ class PageRuleCollector {
 
  private:
   bool IsLeftPage(const ComputedStyle* root_element_style,
-                  int page_index) const;
+                  uint32_t page_index) const;
   bool IsRightPage(const ComputedStyle* root_element_style,
-                   int page_index) const {
+                   uint32_t page_index) const {
     return !IsLeftPage(root_element_style, page_index);
   }
-  bool IsFirstPage(int page_index) const;
+  bool IsFirstPage(uint32_t page_index) const;
 
   void MatchPageRulesForList(HeapVector<Member<StyleRulePage>>& matched_rules,
                              const HeapVector<Member<StyleRulePage>>& rules);

third_party/blink/renderer/core/css/resolver/style_resolver.cc

@@ -1172,7 +1172,7 @@ scoped_refptr<ComputedStyle> StyleResolver::PseudoStyleForElement(
 }
 
 scoped_refptr<const ComputedStyle> StyleResolver::StyleForPage(
-    int page_index,
+    uint32_t page_index,
     const AtomicString& page_name) {
   scoped_refptr<const ComputedStyle> initial_style =
       InitialStyleForElement(GetDocument());

third_party/blink/renderer/core/css/resolver/style_resolver.h

@@ -87,7 +87,7 @@ class CORE_EXPORT StyleResolver final : public GarbageCollected<StyleResolver> {
       const ComputedStyle* layout_parent_style);
 
   scoped_refptr<const ComputedStyle> StyleForPage(
-      int page_index,
+      uint32_t page_index,
       const AtomicString& page_name);
   scoped_refptr<const ComputedStyle> StyleForText(Text*);
   scoped_refptr<ComputedStyle> StyleForViewport();

third_party/blink/renderer/core/dom/document.cc

@@ -2864,7 +2864,7 @@ void Document::ClearFocusedElementTimerFired(TimerBase*) {
     focused_element_->blur();
 }
 
-scoped_refptr<const ComputedStyle> Document::StyleForPage(int page_index) {
+scoped_refptr<const ComputedStyle> Document::StyleForPage(uint32_t page_index) {
   UpdateDistributionForUnknownReasons();
 
   AtomicString page_name;
@@ -2910,12 +2910,12 @@ void Document::EnsurePaintLocationDataValidForNode(
   }
 }
 
-bool Document::IsPageBoxVisible(int page_index) {
+bool Document::IsPageBoxVisible(uint32_t page_index) {
   return StyleForPage(page_index)->Visibility() !=
          EVisibility::kHidden;  // display property doesn't apply to @page.
 }
 
-void Document::GetPageDescription(int page_index,
+void Document::GetPageDescription(uint32_t page_index,
                                   WebPrintPageDescription* description) {
   scoped_refptr<const ComputedStyle> style = StyleForPage(page_index);
 

third_party/blink/renderer/core/dom/document.h

@@ -597,7 +597,7 @@ class CORE_EXPORT Document : public ContainerNode,
   void IncLayoutBlockCounter() { ++layout_blocks_counter_; }
   void IncLayoutBlockCounterNG() { ++layout_blocks_counter_ng_; }
 
-  scoped_refptr<const ComputedStyle> StyleForPage(int page_index);
+  scoped_refptr<const ComputedStyle> StyleForPage(uint32_t page_index);
 
   // Ensures that location-based data will be valid for a given node.
   //
@@ -611,13 +611,13 @@ class CORE_EXPORT Document : public ContainerNode,
                                            DocumentUpdateReason reason);
 
   // Returns true if page box (margin boxes and page borders) is visible.
-  bool IsPageBoxVisible(int page_index);
+  bool IsPageBoxVisible(uint32_t page_index);
 
   // Gets the description for the specified page. This includes preferred page
   // size and margins in pixels, assuming 96 pixels per inch. The size and
   // margins must be initialized to the default values that are used if auto is
   // specified.
-  void GetPageDescription(int page_index, WebPrintPageDescription*);
+  void GetPageDescription(uint32_t page_index, WebPrintPageDescription*);
 
   ResourceFetcher* Fetcher() const { return fetcher_.Get(); }
 

third_party/blink/renderer/core/exported/web_frame_test.cc

@@ -8743,8 +8743,8 @@ TEST_F(WebFrameTest, PrintingBasic)
   print_params.print_content_area.width = 500;
   print_params.print_content_area.height = 500;
 
-  int page_count = frame->PrintBegin(print_params);
-  EXPECT_EQ(1, page_count);
+  uint32_t page_count = frame->PrintBegin(print_params);
+  EXPECT_EQ(1u, page_count);
   frame->PrintEnd();
 }
 
@@ -13038,7 +13038,7 @@ static void TestFramePrinting(WebLocalFrameImpl* frame) {
   WebSize page_size(500, 500);
   print_params.print_content_area.width = page_size.width;
   print_params.print_content_area.height = page_size.height;
-  EXPECT_EQ(1, frame->PrintBegin(print_params, WebNode()));
+  EXPECT_EQ(1u, frame->PrintBegin(print_params, WebNode()));
   PaintRecorder recorder;
   frame->PrintPagesForTesting(recorder.beginRecording(IntRect()), page_size,
                               page_size);
@@ -13117,7 +13117,7 @@ TEST_F(WebFrameTest, FirstLetterHasDOMNodeIdWhenPrinting) {
   print_params.print_content_area.width = page_size.width;
   print_params.print_content_area.height = page_size.height;
   WebLocalFrameImpl* frame = web_view_helper.LocalMainFrame();
-  EXPECT_EQ(1, frame->PrintBegin(print_params, WebNode()));
+  EXPECT_EQ(1u, frame->PrintBegin(print_params, WebNode()));
   PaintRecorder recorder;
   frame->PrintPagesForTesting(recorder.beginRecording(IntRect()), page_size,
                               page_size);
@@ -13365,7 +13365,7 @@ TEST_F(WebFrameSimTest, PageOrientation) {
   WebPrintParams print_params;
   print_params.print_content_area.width = page_size.width;
   print_params.print_content_area.height = page_size.height;
-  EXPECT_EQ(4, frame->PrintBegin(print_params, WebNode()));
+  EXPECT_EQ(4u, frame->PrintBegin(print_params, WebNode()));
 
   WebPrintPageDescription description;
 

third_party/blink/renderer/core/frame/web_local_frame_impl.cc

@@ -292,7 +292,7 @@ class ChromePrintContext : public PrintContext {
     PrintContext::BeginPrintMode(printed_page_width_, height);
   }
 
-  virtual float GetPageShrink(int page_number) const {
+  virtual float GetPageShrink(uint32_t page_number) const {
     IntRect page_rect = page_rects_[page_number];
     return printed_page_width_ / page_rect.Width();
   }
@@ -488,7 +488,7 @@ class ChromePluginPrintContext final : public ChromePrintContext {
 
   void EndPrintMode() override { plugin_->PrintEnd(); }
 
-  float GetPageShrink(int page_number) const override {
+  float GetPageShrink(uint32_t page_number) const override {
     // We don't shrink the page (maybe we should ask the widget ??)
     return 1.0;
   }
@@ -1626,8 +1626,8 @@ WebPlugin* WebLocalFrameImpl::GetPluginToPrint(
   return plugin_container ? plugin_container->Plugin() : nullptr;
 }
 
-int WebLocalFrameImpl::PrintBegin(const WebPrintParams& print_params,
-                                  const WebNode& constrain_to_node) {
+uint32_t WebLocalFrameImpl::PrintBegin(const WebPrintParams& print_params,
+                                       const WebNode& constrain_to_node) {
   WebPluginContainerImpl* plugin_container =
       GetPluginToPrintHelper(constrain_to_node);
   if (plugin_container && plugin_container->SupportsPaginatedPrint()) {
@@ -1643,18 +1643,16 @@ int WebLocalFrameImpl::PrintBegin(const WebPrintParams& print_params,
   print_context_->BeginPrintMode(size.Width(), size.Height());
   print_context_->ComputePageRects(size);
 
-  return static_cast<int>(print_context_->PageCount());
+  return print_context_->PageCount();
 }
 
-float WebLocalFrameImpl::GetPrintPageShrink(int page) {
+float WebLocalFrameImpl::GetPrintPageShrink(uint32_t page) {
   DCHECK(print_context_);
-  DCHECK_GE(page, 0);
   return print_context_->GetPageShrink(page);
 }
 
-float WebLocalFrameImpl::PrintPage(int page, cc::PaintCanvas* canvas) {
+float WebLocalFrameImpl::PrintPage(uint32_t page, cc::PaintCanvas* canvas) {
   DCHECK(print_context_);
-  DCHECK_GE(page, 0);
   DCHECK(GetFrame());
   DCHECK(GetFrame()->GetDocument());
 
@@ -1697,22 +1695,22 @@ bool WebLocalFrameImpl::CapturePaintPreview(const WebRect& bounds,
   return success;
 }
 
-PageSizeType WebLocalFrameImpl::GetPageSizeType(int page_index) {
+PageSizeType WebLocalFrameImpl::GetPageSizeType(uint32_t page_index) {
   return GetFrame()->GetDocument()->StyleForPage(page_index)->GetPageSizeType();
 }
 
 void WebLocalFrameImpl::GetPageDescription(
-    int page_index,
+    uint32_t page_index,
     WebPrintPageDescription* description) {
   GetFrame()->GetDocument()->GetPageDescription(page_index, description);
 }
 
 WebSize WebLocalFrameImpl::SpoolSizeInPixelsForTesting(
     const WebSize& page_size_in_pixels,
-    int page_count) {
+    uint32_t page_count) {
   int spool_width = page_size_in_pixels.width;
   int spool_height = 0;
-  for (int page_index = 0; page_index < page_count; page_index++) {
+  for (uint32_t page_index = 0; page_index < page_count; page_index++) {
     // Make room for the 1px tall page separator.
     if (page_index)
       spool_height++;

third_party/blink/renderer/core/frame/web_local_frame_impl.h

@@ -143,8 +143,9 @@ class CORE_EXPORT WebLocalFrameImpl final
                          bool had_redirect,
                          const WebSourceLocation&) override;
   void SendOrientationChangeEvent() override;
-  PageSizeType GetPageSizeType(int page_index) override;
-  void GetPageDescription(int page_index, WebPrintPageDescription*) override;
+  PageSizeType GetPageSizeType(uint32_t page_index) override;
+  void GetPageDescription(uint32_t page_index,
+                          WebPrintPageDescription*) override;
   void ExecuteScript(const WebScriptSource&) override;
   void ExecuteScriptInIsolatedWorld(int32_t world_id,
                                     const WebScriptSource&) override;
@@ -279,10 +280,10 @@ class CORE_EXPORT WebLocalFrameImpl final
   void DispatchBeforePrintEvent(
       base::WeakPtr<WebPrintClient> print_client) override;
   WebPlugin* GetPluginToPrint(const WebNode& constrain_to_node) override;
-  int PrintBegin(const WebPrintParams&,
-                 const WebNode& constrain_to_node) override;
-  float GetPrintPageShrink(int page) override;
-  float PrintPage(int page_to_print, cc::PaintCanvas*) override;
+  uint32_t PrintBegin(const WebPrintParams&,
+                      const WebNode& constrain_to_node) override;
+  float GetPrintPageShrink(uint32_t page) override;
+  float PrintPage(uint32_t page_to_print, cc::PaintCanvas*) override;
   void PrintEnd() override;
   void DispatchAfterPrintEvent() override;
   bool GetPrintPresetOptionsForPlugin(const WebNode&,
@@ -295,7 +296,7 @@ class CORE_EXPORT WebLocalFrameImpl final
   bool IsAdSubframe() const override;
   void SetIsAdSubframe(blink::mojom::AdFrameType ad_frame_type) override;
   WebSize SpoolSizeInPixelsForTesting(const WebSize& page_size_in_pixels,
-                                      int page_count) override;
+                                      uint32_t page_count) override;
   void PrintPagesForTesting(cc::PaintCanvas*,
                             const WebSize& page_size_in_pixels,
                             const WebSize& spool_size_in_pixels) override;

third_party/blink/renderer/core/page/print_context.cc

@@ -245,7 +245,7 @@ void PrintContext::OutputLinkedDestinations(GraphicsContext& context,
 // static
 String PrintContext::PageProperty(LocalFrame* frame,
                                   const char* property_name,
-                                  int page_number) {
+                                  uint32_t page_number) {
   Document* document = frame->GetDocument();
   ScopedPrintContext print_context(frame);
   // Any non-zero size is OK here. We don't care about actual layout. We just
@@ -274,12 +274,12 @@ String PrintContext::PageProperty(LocalFrame* frame,
   return String("pageProperty() unimplemented for: ") + property_name;
 }
 
-bool PrintContext::IsPageBoxVisible(LocalFrame* frame, int page_number) {
+bool PrintContext::IsPageBoxVisible(LocalFrame* frame, uint32_t page_number) {
   return frame->GetDocument()->IsPageBoxVisible(page_number);
 }
 
 String PrintContext::PageSizeAndMarginsInPixels(LocalFrame* frame,
-                                                int page_number,
+                                                uint32_t page_number,
                                                 int width,
                                                 int height,
                                                 int margin_top,

third_party/blink/renderer/core/page/print_context.h

@@ -91,10 +91,10 @@ class CORE_EXPORT PrintContext : public GarbageCollected<PrintContext> {
                                   const FloatSize& page_size_in_pixels);
   static String PageProperty(LocalFrame*,
                              const char* property_name,
-                             int page_number);
-  static bool IsPageBoxVisible(LocalFrame*, int page_number);
+                             uint32_t page_number);
+  static bool IsPageBoxVisible(LocalFrame*, uint32_t page_number);
   static String PageSizeAndMarginsInPixels(LocalFrame*,
-                                           int page_number,
+                                           uint32_t page_number,
                                            int width,
                                            int height,
                                            int margin_top,

third_party/blink/renderer/core/testing/internals.cc

@@ -2320,7 +2320,7 @@ int Internals::numberOfPages(float page_width,
 }
 
 String Internals::pageProperty(String property_name,
-                               int page_number,
+                               unsigned page_number,
                                ExceptionState& exception_state) const {
   if (!GetFrame()) {
     exception_state.ThrowDOMException(DOMExceptionCode::kInvalidAccessError,
@@ -2333,7 +2333,7 @@ String Internals::pageProperty(String property_name,
 }
 
 String Internals::pageSizeAndMarginsInPixels(
-    int page_number,
+    unsigned page_number,
     int width,
     int height,
     int margin_top,

third_party/blink/renderer/core/testing/internals.h

@@ -380,9 +380,11 @@ class Internals final : public ScriptWrappable {
   int numberOfPages(float page_width_in_pixels,
                     float page_height_in_pixels,
                     ExceptionState&);
-  String pageProperty(String, int, ExceptionState& = ASSERT_NO_EXCEPTION) const;
+  String pageProperty(String,
+                      unsigned,
+                      ExceptionState& = ASSERT_NO_EXCEPTION) const;
   String pageSizeAndMarginsInPixels(
-      int,
+      unsigned,
       int,
       int,
       int,

third_party/blink/renderer/core/testing/internals.idl

@@ -218,8 +218,8 @@
     sequence<DOMString> shortcutIconURLs(Document document);
     sequence<DOMString> allIconURLs(Document document);
     [RaisesException] long numberOfPages(optional double pageWidthInPixels = 800, optional double pageHeightInPixels = 600);
-    [RaisesException] DOMString pageProperty(DOMString propertyName, long pageNumber);
-    [RaisesException] DOMString pageSizeAndMarginsInPixels(long pageIndex, long width, long height, long marginTop, long marginRight, long marginBottom, long marginLeft);
+    [RaisesException] DOMString pageProperty(DOMString propertyName, unsigned long pageNumber);
+    [RaisesException] DOMString pageSizeAndMarginsInPixels(unsigned long pageIndex, long width, long height, long marginTop, long marginRight, long marginBottom, long marginLeft);
 
     [RaisesException] float pageScaleFactor();
     [RaisesException] void setPageScaleFactor(float scaleFactor);