Printing: Load the source PDF only once.

pdf/pdfium/pdfium_engine.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "pdf/pdfium/pdfium_engine.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 3983 matching lines @@
       autorotate(autorotate) {}
 
 PDFEngineExports::RenderingSettings::RenderingSettings(
     const RenderingSettings& that) = default;
 
 PDFEngineExports* PDFEngineExports::Get() {
   return g_pdf_engine_exports.Pointer();
 }
 
 #if defined(OS_WIN)
-bool PDFiumEngineExports::RenderPDFPageToDC(const void* pdf_buffer,
-                                            int buffer_size,
+bool PDFiumEngineExports::RenderPDFPageToDC(void* pdf_handle,
                                             int page_number,
                                             const RenderingSettings& settings,
                                             HDC dc) {
-  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, nullptr);
+  FPDF_DOCUMENT doc = pdf_handle;
   if (!doc)
     return false;
   FPDF_PAGE page = FPDF_LoadPage(doc, page_number);
-  if (!page) {
-    FPDF_CloseDocument(doc);
+  if (!page)
     return false;
-  }
+
   RenderingSettings new_settings = settings;
   // calculate the page size
   if (new_settings.dpi_x == -1)
     new_settings.dpi_x = GetDeviceCaps(dc, LOGPIXELSX);
   if (new_settings.dpi_y == -1)
     new_settings.dpi_y = GetDeviceCaps(dc, LOGPIXELSY);
 
   pp::Rect dest;
   int rotate = CalculatePosition(page, new_settings, &dest);
 
@@ skipping 33 matching lines @@
     StretchDIBits(dc, dest.x(), dest.y(), dest.width(), dest.height(),
                   0, 0, dest.width(), dest.height(),
                   FPDFBitmap_GetBuffer(bitmap), &bmi, DIB_RGB_COLORS, SRCCOPY);
     FPDFBitmap_Destroy(bitmap);
   } else {
     FPDF_RenderPage(dc, page, dest.x(), dest.y(), dest.width(), dest.height(),
                     rotate, FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
   }
   RestoreDC(dc, save_state);
   FPDF_ClosePage(page);
-  FPDF_CloseDocument(doc);
   return true;
 }
 
 void PDFiumEngineExports::SetPDFEnsureTypefaceCharactersAccessible(
     PDFEnsureTypefaceCharactersAccessible func) {
   FPDF_SetTypefaceAccessibleFunc(
       reinterpret_cast<PDFiumEnsureTypefaceCharactersAccessible>(func));
 }
 
 void PDFiumEngineExports::SetPDFUseGDIPrinting(bool enable) {
   FPDF_SetPrintTextWithGDI(enable);
 }
 #endif  // defined(OS_WIN)
 
 bool PDFiumEngineExports::RenderPDFPageToBitmap(
-    const void* pdf_buffer,
-    int pdf_buffer_size,
+    void* pdf_handle,
     int page_number,
     const RenderingSettings& settings,
     void* bitmap_buffer) {
-  FPDF_DOCUMENT doc =
-      FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
+  FPDF_DOCUMENT doc = pdf_handle;
   if (!doc)
     return false;
   FPDF_PAGE page = FPDF_LoadPage(doc, page_number);
-  if (!page) {
-    FPDF_CloseDocument(doc);
+  if (!page)
     return false;
-  }
 
   pp::Rect dest;
   int rotate = CalculatePosition(page, settings, &dest);
 
   FPDF_BITMAP bitmap =
       FPDFBitmap_CreateEx(settings.bounds.width(), settings.bounds.height(),
                           FPDFBitmap_BGRA, bitmap_buffer,
                           settings.bounds.width() * 4);
   // Clear the bitmap
   FPDFBitmap_FillRect(bitmap, 0, 0, settings.bounds.width(),
                       settings.bounds.height(), 0xFFFFFFFF);
   // Shift top-left corner of bounds to (0, 0) if it's not there.
   dest.set_point(dest.point() - settings.bounds.point());
   FPDF_RenderPageBitmap(
       bitmap, page, dest.x(), dest.y(), dest.width(), dest.height(), rotate,
       FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
   FPDFBitmap_Destroy(bitmap);
   FPDF_ClosePage(page);
-  FPDF_CloseDocument(doc);
   return true;
 }
 
 bool PDFiumEngineExports::GetPDFDocInfo(const void* pdf_buffer,
                                         int buffer_size,
                                         int* page_count,
-                                        double* max_page_width) {
+                                        double* max_page_width,
+                                        void** pdf_handle) {
   FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, nullptr);
   if (!doc)
     return false;
+
   int page_count_local = FPDF_GetPageCount(doc);
-  if (page_count) {
+  if (page_count)
     *page_count = page_count_local;
-  }
+
   if (max_page_width) {
     *max_page_width = 0;
     for (int page_number = 0; page_number < page_count_local; page_number++) {
       double page_width = 0;
       double page_height = 0;
       FPDF_GetPageSizeByIndex(doc, page_number, &page_width, &page_height);
-      if (page_width > *max_page_width) {
-        *max_page_width = page_width;
-      }
+      *max_page_width = std::max(*max_page_width, page_width);
     }
   }
-  FPDF_CloseDocument(doc);
+
+  if (pdf_handle)
+    *pdf_handle = doc;  // Caller takes ownership.
+  else
+    FPDF_CloseDocument(pdf_handle);
   return true;
 }
 
-bool PDFiumEngineExports::GetPDFPageSizeByIndex(
-    const void* pdf_buffer,
-    int pdf_buffer_size,
-    int page_number,
-    double* width,
-    double* height) {
-  FPDF_DOCUMENT doc =
-      FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
-  if (!doc)
-    return false;
-  bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
-  FPDF_CloseDocument(doc);
-  return success;
+void PDFiumEngineExports::ReleasePDFHandle(void* pdf_handle) {
+  FPDF_CloseDocument(pdf_handle);
+}
+
+bool PDFiumEngineExports::GetPDFPageSizeByIndex(void* pdf_handle,
+                                                int page_number,
+                                                double* width,
+                                                double* height) {
+  FPDF_DOCUMENT doc = pdf_handle;
+  return doc && FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
 }
 
 }  // namespace chrome_pdf