Convert functions in pdf/pdf.h to take base::span for inputs.

Change-Id: Ic9aae2a702866818c2b06aaae5710813b6335bfa
Reviewed-on: https://chromium-review.googlesource.com/1135942Reviewed-by: Jianzhou Feng <jzfeng@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
Cr-Commit-Position: refs/heads/master@{#577409}

chrome/browser/printing/print_preview_pdf_generated_browsertest.cc

@@ -16,6 +16,7 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/containers/span.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ -341,8 +342,10 @@ class PrintPreviewPdfGeneratedBrowserTest : public InProcessBrowserTest {
     std::string pdf_data;
 
     ASSERT_TRUE(base::ReadFileToString(pdf_file_save_path_, &pdf_data));
-    ASSERT_TRUE(chrome_pdf::GetPDFDocInfo(pdf_data.data(), pdf_data.size(),
-                                          &num_pages, &max_width_in_points));
+
+    auto pdf_span = base::as_bytes(base::make_span(pdf_data));
+    ASSERT_TRUE(
+        chrome_pdf::GetPDFDocInfo(pdf_span, &num_pages, &max_width_in_points));
 
     ASSERT_GT(num_pages, 0);
     double max_width_in_pixels =
@@ -351,8 +354,7 @@ class PrintPreviewPdfGeneratedBrowserTest : public InProcessBrowserTest {
     for (int i = 0; i < num_pages; ++i) {
       double width_in_points, height_in_points;
       ASSERT_TRUE(chrome_pdf::GetPDFPageSizeByIndex(
-          pdf_data.data(), pdf_data.size(), i, &width_in_points,
-          &height_in_points));
+          pdf_span, i, &width_in_points, &height_in_points));
 
       double width_in_pixels = ConvertUnitDouble(
           width_in_points, kPointsPerInch, kDpi);
@@ -386,10 +388,9 @@ class PrintPreviewPdfGeneratedBrowserTest : public InProcessBrowserTest {
                                             settings.area.size().GetArea());
 
       ASSERT_TRUE(chrome_pdf::RenderPDFPageToBitmap(
-          pdf_data.data(), pdf_data.size(), i, page_bitmap_data.data(),
-          settings.area.size().width(), settings.area.size().height(),
-          settings.dpi.width(), settings.dpi.height(), settings.autorotate,
-          settings.use_color));
+          pdf_span, i, page_bitmap_data.data(), settings.area.size().width(),
+          settings.area.size().height(), settings.dpi.width(),
+          settings.dpi.height(), settings.autorotate, settings.use_color));
       FillPng(&page_bitmap_data, width_in_pixels, max_width_in_pixels,
               settings.area.size().height());
       bitmap_data.insert(bitmap_data.end(),

chrome/services/printing/pdf_to_emf_converter.cc

@@ -8,6 +8,7 @@
 #include <limits>
 #include <utility>
 
+#include "base/containers/span.h"
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "components/services/pdf_compositor/public/cpp/pdf_service_mojo_utils.h"
@@ -111,7 +112,9 @@ void PdfToEmfConverter::LoadPdf(base::ReadOnlySharedMemoryRegion pdf_region) {
     return;
 
   int page_count = 0;
-  chrome_pdf::GetPDFDocInfo(pdf_mapping_.memory(), size, &page_count, nullptr);
+  auto pdf_span = base::make_span(
+      reinterpret_cast<const uint8_t*>(pdf_mapping_.memory()), size);
+  chrome_pdf::GetPDFDocInfo(pdf_span, &page_count, nullptr);
   total_page_count_ = page_count;
 }
 
@@ -149,10 +152,12 @@ base::ReadOnlySharedMemoryRegion PdfToEmfConverter::RenderPdfPageToMetafile(
   int offset_y = postscript ? pdf_render_settings_.offsets.y() : 0;
 
   base::ReadOnlySharedMemoryRegion invalid_emf_region;
+  auto pdf_span =
+      base::make_span(reinterpret_cast<const uint8_t*>(pdf_mapping_.memory()),
+                      pdf_mapping_.size());
   if (!chrome_pdf::RenderPDFPageToDC(
-          pdf_mapping_.memory(), pdf_mapping_.size(), page_number,
-          metafile.context(), pdf_render_settings_.dpi.width(),
-          pdf_render_settings_.dpi.height(),
+          pdf_span, page_number, metafile.context(),
+          pdf_render_settings_.dpi.width(), pdf_render_settings_.dpi.height(),
           pdf_render_settings_.area.x() - offset_x,
           pdf_render_settings_.area.y() - offset_y,
           pdf_render_settings_.area.width(), pdf_render_settings_.area.height(),

chrome/services/printing/pdf_to_pwg_raster_converter.cc

@@ -8,6 +8,7 @@
 #include <string>
 #include <utility>
 
+#include "base/containers/span.h"
 #include "components/pwg_encoder/bitmap_image.h"
 #include "components/pwg_encoder/pwg_encoder.h"
 #include "components/services/pdf_compositor/public/cpp/pdf_service_mojo_utils.h"
@@ -29,13 +30,16 @@ base::ReadOnlySharedMemoryRegion RenderPdfPagesToPwgRaster(
   if (!pdf_mapping.IsValid())
     return invalid_pwg_region;
 
+  auto pdf_data =
+      base::make_span(reinterpret_cast<const uint8_t*>(pdf_mapping.memory()),
+                      pdf_mapping.size());
+
   // Get the page count and reserve 64 KB per page in |pwg_data| below.
   static constexpr size_t kEstimatedSizePerPage = 64 * 1024;
   static constexpr size_t kMaxPageCount =
       std::numeric_limits<size_t>::max() / kEstimatedSizePerPage;
   int total_page_count = 0;
-  if (!chrome_pdf::GetPDFDocInfo(pdf_mapping.memory(), pdf_mapping.size(),
-                                 &total_page_count, nullptr) ||
+  if (!chrome_pdf::GetPDFDocInfo(pdf_data, &total_page_count, nullptr) ||
       total_page_count <= 0 ||
       static_cast<size_t>(total_page_count) >= kMaxPageCount) {
     return invalid_pwg_region;
@@ -53,10 +57,9 @@ base::ReadOnlySharedMemoryRegion RenderPdfPagesToPwgRaster(
       page_number = total_page_count - 1 - page_number;
 
     if (!chrome_pdf::RenderPDFPageToBitmap(
-            pdf_mapping.memory(), pdf_mapping.size(), page_number,
-            image.pixel_data(), image.size().width(), image.size().height(),
-            settings.dpi.width(), settings.dpi.height(), settings.autorotate,
-            settings.use_color)) {
+            pdf_data, page_number, image.pixel_data(), image.size().width(),
+            image.size().height(), settings.dpi.width(), settings.dpi.height(),
+            settings.autorotate, settings.use_color)) {
       return invalid_pwg_region;
     }
 

headless/lib/headless_web_contents_browsertest.cc

@@ -313,17 +313,16 @@ class HeadlessWebContentsPDFTest : public HeadlessAsyncDevTooledBrowserTest {
     std::string pdf_data;
     EXPECT_TRUE(base::Base64Decode(base64, &pdf_data));
 
+    auto pdf_span = base::as_bytes(base::make_span(pdf_data));
     int num_pages;
-    EXPECT_TRUE(chrome_pdf::GetPDFDocInfo(pdf_data.data(), pdf_data.size(),
-                                          &num_pages, nullptr));
+    EXPECT_TRUE(chrome_pdf::GetPDFDocInfo(pdf_span, &num_pages, nullptr));
     EXPECT_EQ(std::ceil(kDocHeight / kPaperHeight), num_pages);
 
     for (int i = 0; i < num_pages; i++) {
       double width_in_points;
       double height_in_points;
       EXPECT_TRUE(chrome_pdf::GetPDFPageSizeByIndex(
-          pdf_data.data(), pdf_data.size(), i, &width_in_points,
-          &height_in_points));
+          pdf_span, i, &width_in_points, &height_in_points));
       EXPECT_EQ(static_cast<int>(width_in_points),
                 static_cast<int>(kPaperWidth * printing::kPointsPerInch));
       EXPECT_EQ(static_cast<int>(height_in_points),
@@ -336,10 +335,9 @@ class HeadlessWebContentsPDFTest : public HeadlessAsyncDevTooledBrowserTest {
       std::vector<uint8_t> page_bitmap_data(kColorChannels *
                                             settings.area.size().GetArea());
       EXPECT_TRUE(chrome_pdf::RenderPDFPageToBitmap(
-          pdf_data.data(), pdf_data.size(), i, page_bitmap_data.data(),
-          settings.area.size().width(), settings.area.size().height(),
-          settings.dpi.width(), settings.dpi.height(), settings.autorotate,
-          settings.use_color));
+          pdf_span, i, page_bitmap_data.data(), settings.area.size().width(),
+          settings.area.size().height(), settings.dpi.width(),
+          settings.dpi.height(), settings.autorotate, settings.use_color));
       EXPECT_EQ(0x56, page_bitmap_data[0]);  // B
       EXPECT_EQ(0x34, page_bitmap_data[1]);  // G
       EXPECT_EQ(0x12, page_bitmap_data[2]);  // R

pdf/pdf.cc

@@ -8,10 +8,6 @@
 
 #include <utility>
 
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
 #include "base/logging.h"
 #include "base/macros.h"
 #include "pdf/out_of_process_instance.h"
@@ -51,8 +47,7 @@ class ScopedSdkInitializer {
 }  // namespace
 
 #if defined(OS_WIN)
-bool RenderPDFPageToDC(const void* pdf_buffer,
-                       int buffer_size,
+bool RenderPDFPageToDC(base::span<const uint8_t> pdf_buffer,
                        int page_number,
                        HDC dc,
                        int dpi_x,
@@ -77,8 +72,8 @@ bool RenderPDFPageToDC(const void* pdf_buffer,
       pp::Rect(bounds_origin_x, bounds_origin_y, bounds_width, bounds_height),
       fit_to_bounds, stretch_to_bounds, keep_aspect_ratio, center_in_bounds,
       autorotate, use_color);
-  return engine_exports->RenderPDFPageToDC(pdf_buffer, buffer_size, page_number,
-                                           settings, dc);
+  return engine_exports->RenderPDFPageToDC(pdf_buffer, page_number, settings,
+                                           dc);
 }
 
 void SetPDFEnsureTypefaceCharactersAccessible(
@@ -95,8 +90,7 @@ void SetPDFUsePrintMode(int mode) {
 }
 #endif  // defined(OS_WIN)
 
-bool GetPDFDocInfo(const void* pdf_buffer,
-                   int buffer_size,
+bool GetPDFDocInfo(base::span<const uint8_t> pdf_buffer,
                    int* page_count,
                    double* max_page_width) {
   ScopedSdkInitializer scoped_sdk_initializer;
@@ -104,12 +98,10 @@ bool GetPDFDocInfo(const void* pdf_buffer,
     return false;
 
   PDFEngineExports* engine_exports = PDFEngineExports::Get();
-  return engine_exports->GetPDFDocInfo(pdf_buffer, buffer_size, page_count,
-                                       max_page_width);
+  return engine_exports->GetPDFDocInfo(pdf_buffer, page_count, max_page_width);
 }
 
-bool GetPDFPageSizeByIndex(const void* pdf_buffer,
-                           int pdf_buffer_size,
+bool GetPDFPageSizeByIndex(base::span<const uint8_t> pdf_buffer,
                            int page_number,
                            double* width,
                            double* height) {
@@ -119,12 +111,11 @@ bool GetPDFPageSizeByIndex(const void* pdf_buffer,
 
   chrome_pdf::PDFEngineExports* engine_exports =
       chrome_pdf::PDFEngineExports::Get();
-  return engine_exports->GetPDFPageSizeByIndex(pdf_buffer, pdf_buffer_size,
-                                               page_number, width, height);
+  return engine_exports->GetPDFPageSizeByIndex(pdf_buffer, page_number, width,
+                                               height);
 }
 
-bool RenderPDFPageToBitmap(const void* pdf_buffer,
-                           int pdf_buffer_size,
+bool RenderPDFPageToBitmap(base::span<const uint8_t> pdf_buffer,
                            int page_number,
                            void* bitmap_buffer,
                            int bitmap_width,
@@ -141,8 +132,8 @@ bool RenderPDFPageToBitmap(const void* pdf_buffer,
   PDFEngineExports::RenderingSettings settings(
       dpi_x, dpi_y, pp::Rect(bitmap_width, bitmap_height), true, false, true,
       true, autorotate, use_color);
-  return engine_exports->RenderPDFPageToBitmap(
-      pdf_buffer, pdf_buffer_size, page_number, settings, bitmap_buffer);
+  return engine_exports->RenderPDFPageToBitmap(pdf_buffer, page_number,
+                                               settings, bitmap_buffer);
 }
 
 bool ConvertPdfPagesToNupPdf(

pdf/pdf.h

@@ -33,7 +33,6 @@ enum PrintingMode {
 
 // |pdf_buffer| is the buffer that contains the entire PDF document to be
 //     rendered.
-// |buffer_size| is the size of |pdf_buffer| in bytes.
 // |page_number| is the 0-based index of the page to be rendered.
 // |dc| is the device context to render into.
 // |dpi_x| and |dpi_y| is the resolution.
@@ -58,8 +57,7 @@ enum PrintingMode {
 //     the output bound.
 // |use_color| specifies color or grayscale.
 // Returns false if the document or the page number are not valid.
-bool RenderPDFPageToDC(const void* pdf_buffer,
-                       int buffer_size,
+bool RenderPDFPageToDC(base::span<const uint8_t> pdf_buffer,
                        int page_number,
                        HDC dc,
                        int dpi_x,
@@ -85,22 +83,19 @@ void SetPDFUsePrintMode(int mode);
 
 // |page_count| and |max_page_width| are optional and can be NULL.
 // Returns false if the document is not valid.
-bool GetPDFDocInfo(const void* pdf_buffer,
-                   int buffer_size,
+bool GetPDFDocInfo(base::span<const uint8_t> pdf_buffer,
                    int* page_count,
                    double* max_page_width);
 
 // Gets the dimensions of a specific page in a document.
 // |pdf_buffer| is the buffer that contains the entire PDF document to be
 //     rendered.
-// |pdf_buffer_size| is the size of |pdf_buffer| in bytes.
 // |page_number| is the page number that the function will get the dimensions
 //     of.
 // |width| is the output for the width of the page in points.
 // |height| is the output for the height of the page in points.
 // Returns false if the document or the page number are not valid.
-bool GetPDFPageSizeByIndex(const void* pdf_buffer,
-                           int pdf_buffer_size,
+bool GetPDFPageSizeByIndex(base::span<const uint8_t> pdf_buffer,
                            int page_number,
                            double* width,
                            double* height);
@@ -108,7 +103,6 @@ bool GetPDFPageSizeByIndex(const void* pdf_buffer,
 // Renders PDF page into 4-byte per pixel BGRA color bitmap.
 // |pdf_buffer| is the buffer that contains the entire PDF document to be
 //     rendered.
-// |pdf_buffer_size| is the size of |pdf_buffer| in bytes.
 // |page_number| is the 0-based index of the page to be rendered.
 // |bitmap_buffer| is the output buffer for bitmap.
 // |bitmap_width| is the width of the output bitmap.
@@ -118,8 +112,7 @@ bool GetPDFPageSizeByIndex(const void* pdf_buffer,
 //     the output bound.
 // |use_color| specifies color or grayscale.
 // Returns false if the document or the page number are not valid.
-bool RenderPDFPageToBitmap(const void* pdf_buffer,
-                           int pdf_buffer_size,
+bool RenderPDFPageToBitmap(base::span<const uint8_t> pdf_buffer,
                            int page_number,
                            void* bitmap_buffer,
                            int bitmap_width,

pdf/pdf_engine.h

@@ -7,12 +7,6 @@
 
 #include <stdint.h>
 
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
 #include <memory>
 #include <set>
 #include <string>
@@ -22,6 +16,7 @@
 #include "base/optional.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "ppapi/c/dev/pp_cursor_type_dev.h"
 #include "ppapi/c/dev/ppp_printing_dev.h"
 #include "ppapi/c/ppb_input_event.h"
@@ -34,6 +29,10 @@
 #include "ui/base/window_open_disposition.h"
 #include "ui/gfx/geometry/point_f.h"
 
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
 #if defined(OS_WIN)
 typedef void (*PDFEnsureTypefaceCharactersAccessible)(const LOGFONT* font,
                                                       const wchar_t* text,
@@ -445,8 +444,7 @@ class PDFEngineExports {
 
 #if defined(OS_WIN)
   // See the definition of RenderPDFPageToDC in pdf.cc for details.
-  virtual bool RenderPDFPageToDC(const void* pdf_buffer,
-                                 int buffer_size,
+  virtual bool RenderPDFPageToDC(base::span<const uint8_t> pdf_buffer,
                                  int page_number,
                                  const RenderingSettings& settings,
                                  HDC dc) = 0;
@@ -459,8 +457,7 @@ class PDFEngineExports {
 #endif  // defined(OS_WIN)
 
   // See the definition of RenderPDFPageToBitmap in pdf.cc for details.
-  virtual bool RenderPDFPageToBitmap(const void* pdf_buffer,
-                                     int pdf_buffer_size,
+  virtual bool RenderPDFPageToBitmap(base::span<const uint8_t> pdf_buffer,
                                      int page_number,
                                      const RenderingSettings& settings,
                                      void* bitmap_buffer) = 0;
@@ -483,14 +480,12 @@ class PDFEngineExports {
       void** dest_pdf_buffer,
       size_t* dest_pdf_buffer_size) = 0;
 
-  virtual bool GetPDFDocInfo(const void* pdf_buffer,
-                             int buffer_size,
+  virtual bool GetPDFDocInfo(base::span<const uint8_t> pdf_buffer,
                              int* page_count,
                              double* max_page_width) = 0;
 
   // See the definition of GetPDFPageSizeByIndex in pdf.cc for details.
-  virtual bool GetPDFPageSizeByIndex(const void* pdf_buffer,
-                                     int pdf_buffer_size,
+  virtual bool GetPDFPageSizeByIndex(base::span<const uint8_t> pdf_buffer,
                                      int page_number,
                                      double* width,
                                      double* height) = 0;

pdf/pdfium/pdfium_engine_exports.cc

@@ -95,12 +95,10 @@ int CalculatePosition(FPDF_PAGE page,
 }
 
 ScopedFPDFDocument LoadPdfData(base::span<const uint8_t> pdf_buffer) {
-  ScopedFPDFDocument doc;
-  if (base::IsValueInRangeForNumericType<int>(pdf_buffer.size())) {
-    doc.reset(
-        FPDF_LoadMemDocument(pdf_buffer.data(), pdf_buffer.size(), nullptr));
-  }
-  return doc;
+  if (!base::IsValueInRangeForNumericType<int>(pdf_buffer.size()))
+    return nullptr;
+  return ScopedFPDFDocument(
+      FPDF_LoadMemDocument(pdf_buffer.data(), pdf_buffer.size(), nullptr));
 }
 
 ScopedFPDFDocument CreatePdfDoc(
@@ -188,13 +186,12 @@ PDFiumEngineExports::PDFiumEngineExports() {}
 PDFiumEngineExports::~PDFiumEngineExports() {}
 
 #if defined(OS_WIN)
-bool PDFiumEngineExports::RenderPDFPageToDC(const void* pdf_buffer,
-                                            int buffer_size,
-                                            int page_number,
-                                            const RenderingSettings& settings,
-                                            HDC dc) {
-  ScopedFPDFDocument doc(
-      FPDF_LoadMemDocument(pdf_buffer, buffer_size, nullptr));
+bool PDFiumEngineExports::RenderPDFPageToDC(
+    base::span<const uint8_t> pdf_buffer,
+    int page_number,
+    const RenderingSettings& settings,
+    HDC dc) {
+  ScopedFPDFDocument doc = LoadPdfData(pdf_buffer);
   if (!doc)
     return false;
   ScopedFPDFPage page(FPDF_LoadPage(doc.get(), page_number));
@@ -276,13 +273,11 @@ void PDFiumEngineExports::SetPDFUsePrintMode(int mode) {
 #endif  // defined(OS_WIN)
 
 bool PDFiumEngineExports::RenderPDFPageToBitmap(
-    const void* pdf_buffer,
-    int pdf_buffer_size,
+    base::span<const uint8_t> pdf_buffer,
     int page_number,
     const RenderingSettings& settings,
     void* bitmap_buffer) {
-  ScopedFPDFDocument doc(
-      FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr));
+  ScopedFPDFDocument doc = LoadPdfData(pdf_buffer);
   if (!doc)
     return false;
   ScopedFPDFPage page(FPDF_LoadPage(doc.get(), page_number));
@@ -342,12 +337,10 @@ bool PDFiumEngineExports::ConvertPdfDocumentToNupPdf(
                               dest_pdf_buffer_size);
 }
 
-bool PDFiumEngineExports::GetPDFDocInfo(const void* pdf_buffer,
-                                        int buffer_size,
+bool PDFiumEngineExports::GetPDFDocInfo(base::span<const uint8_t> pdf_buffer,
                                         int* page_count,
                                         double* max_page_width) {
-  ScopedFPDFDocument doc(
-      FPDF_LoadMemDocument(pdf_buffer, buffer_size, nullptr));
+  ScopedFPDFDocument doc = LoadPdfData(pdf_buffer);
   if (!doc)
     return false;
 
@@ -373,13 +366,12 @@ bool PDFiumEngineExports::GetPDFDocInfo(const void* pdf_buffer,
   return true;
 }
 
-bool PDFiumEngineExports::GetPDFPageSizeByIndex(const void* pdf_buffer,
-                                                int pdf_buffer_size,
-                                                int page_number,
-                                                double* width,
-                                                double* height) {
-  ScopedFPDFDocument doc(
-      FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr));
+bool PDFiumEngineExports::GetPDFPageSizeByIndex(
+    base::span<const uint8_t> pdf_buffer,
+    int page_number,
+    double* width,
+    double* height) {
+  ScopedFPDFDocument doc = LoadPdfData(pdf_buffer);
   if (!doc)
     return false;
   return FPDF_GetPageSizeByIndex(doc.get(), page_number, width, height) != 0;

pdf/pdfium/pdfium_engine_exports.h

@@ -21,8 +21,7 @@ class PDFiumEngineExports : public PDFEngineExports {
 
 // PDFEngineExports:
 #if defined(OS_WIN)
-  bool RenderPDFPageToDC(const void* pdf_buffer,
-                         int buffer_size,
+  bool RenderPDFPageToDC(base::span<const uint8_t> pdf_buffer,
                          int page_number,
                          const RenderingSettings& settings,
                          HDC dc) override;
@@ -32,8 +31,7 @@ class PDFiumEngineExports : public PDFEngineExports {
   void SetPDFUseGDIPrinting(bool enable) override;
   void SetPDFUsePrintMode(int mode) override;
 #endif  // defined(OS_WIN)
-  bool RenderPDFPageToBitmap(const void* pdf_buffer,
-                             int pdf_buffer_size,
+  bool RenderPDFPageToBitmap(base::span<const uint8_t> pdf_buffer,
                              int page_number,
                              const RenderingSettings& settings,
                              void* bitmap_buffer) override;
@@ -50,12 +48,10 @@ class PDFiumEngineExports : public PDFEngineExports {
                                   size_t page_size_height,
                                   void** dest_pdf_buffer,
                                   size_t* dest_pdf_buffer_size) override;
-  bool GetPDFDocInfo(const void* pdf_buffer,
-                     int buffer_size,
+  bool GetPDFDocInfo(base::span<const uint8_t> pdf_buffer,
                      int* page_count,
                      double* max_page_width) override;
-  bool GetPDFPageSizeByIndex(const void* pdf_buffer,
-                             int pdf_buffer_size,
+  bool GetPDFPageSizeByIndex(base::span<const uint8_t> pdf_buffer,
                              int page_number,
                              double* width,
                              double* height) override;

pdf/pdfium/pdfium_engine_exports_unittest.cc

@@ -61,15 +61,12 @@ TEST_F(PDFiumEngineExportsTest, GetPDFDocInfo) {
   std::string pdf_data;
   ASSERT_TRUE(base::ReadFileToString(pdf_path, &pdf_data));
 
-  EXPECT_FALSE(GetPDFDocInfo(nullptr, 0, nullptr, nullptr));
-
-  ASSERT_TRUE(
-      GetPDFDocInfo(pdf_data.data(), pdf_data.size(), nullptr, nullptr));
+  auto pdf_span = base::as_bytes(base::make_span(pdf_data));
+  ASSERT_TRUE(GetPDFDocInfo(pdf_span, nullptr, nullptr));
 
   int page_count;
   double max_page_width;
-  ASSERT_TRUE(GetPDFDocInfo(pdf_data.data(), pdf_data.size(), &page_count,
-                            &max_page_width));
+  ASSERT_TRUE(GetPDFDocInfo(pdf_span, &page_count, &max_page_width));
   EXPECT_EQ(2, page_count);
   EXPECT_DOUBLE_EQ(200.0, max_page_width);
 }
@@ -82,17 +79,16 @@ TEST_F(PDFiumEngineExportsTest, GetPDFPageSizeByIndex) {
   std::string pdf_data;
   ASSERT_TRUE(base::ReadFileToString(pdf_path, &pdf_data));
 
-  EXPECT_FALSE(GetPDFPageSizeByIndex(nullptr, 0, 0, nullptr, nullptr));
+  auto pdf_span = base::as_bytes(base::make_span(pdf_data));
+  EXPECT_FALSE(GetPDFPageSizeByIndex(pdf_span, 0, nullptr, nullptr));
 
   int page_count;
-  ASSERT_TRUE(
-      GetPDFDocInfo(pdf_data.data(), pdf_data.size(), &page_count, nullptr));
+  ASSERT_TRUE(GetPDFDocInfo(pdf_span, &page_count, nullptr));
   ASSERT_EQ(2, page_count);
   for (int page_number = 0; page_number < page_count; ++page_number) {
     double width;
     double height;
-    ASSERT_TRUE(GetPDFPageSizeByIndex(pdf_data.data(), pdf_data.size(),
-                                      page_number, &width, &height));
+    ASSERT_TRUE(GetPDFPageSizeByIndex(pdf_span, page_number, &width, &height));
     EXPECT_DOUBLE_EQ(200.0, width);
     EXPECT_DOUBLE_EQ(200.0, height);
   }
@@ -118,15 +114,16 @@ TEST_F(PDFiumEngineExportsTest, ConvertPdfPagesToNupPdf) {
       pdf_buffers, 2, 512, 792, &output_pdf_buffer, &output_pdf_buffer_size));
   ASSERT_GT(output_pdf_buffer_size, 0U);
   ASSERT_NE(output_pdf_buffer, nullptr);
+
+  base::span<const uint8_t> output_pdf_span = base::make_span(
+      reinterpret_cast<uint8_t*>(output_pdf_buffer), output_pdf_buffer_size);
   int page_count;
-  ASSERT_TRUE(GetPDFDocInfo(output_pdf_buffer, output_pdf_buffer_size,
-                            &page_count, nullptr));
+  ASSERT_TRUE(GetPDFDocInfo(output_pdf_span, &page_count, nullptr));
   ASSERT_EQ(1, page_count);
 
   double width;
   double height;
-  ASSERT_TRUE(GetPDFPageSizeByIndex(output_pdf_buffer, output_pdf_buffer_size,
-                                    0, &width, &height));
+  ASSERT_TRUE(GetPDFPageSizeByIndex(output_pdf_span, 0, &width, &height));
   EXPECT_DOUBLE_EQ(792.0, width);
   EXPECT_DOUBLE_EQ(512.0, height);
 
@@ -152,15 +149,17 @@ TEST_F(PDFiumEngineExportsTest, ConvertPdfDocumentToNupPdf) {
       pdf_buffer, 4, 512, 792, &output_pdf_buffer, &output_pdf_buffer_size));
   ASSERT_GT(output_pdf_buffer_size, 0U);
   ASSERT_NE(output_pdf_buffer, nullptr);
+
+  base::span<const uint8_t> output_pdf_span = base::make_span(
+      reinterpret_cast<uint8_t*>(output_pdf_buffer), output_pdf_buffer_size);
   int page_count;
-  ASSERT_TRUE(GetPDFDocInfo(output_pdf_buffer, output_pdf_buffer_size,
-                            &page_count, nullptr));
+  ASSERT_TRUE(GetPDFDocInfo(output_pdf_span, &page_count, nullptr));
   ASSERT_EQ(2, page_count);
   for (int page_number = 0; page_number < page_count; ++page_number) {
     double width;
     double height;
-    ASSERT_TRUE(GetPDFPageSizeByIndex(output_pdf_buffer, output_pdf_buffer_size,
-                                      page_number, &width, &height));
+    ASSERT_TRUE(
+        GetPDFPageSizeByIndex(output_pdf_span, page_number, &width, &height));
     EXPECT_DOUBLE_EQ(512.0, width);
     EXPECT_DOUBLE_EQ(792.0, height);
   }