Revert of Combine PDF plugin into the Chromium binary.

chrome/browser/printing/print_preview_pdf_generated_browsertest.cc

 // Copyright 2014 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 <algorithm>
 #include <fstream>
 #include <iostream>
 #include <iterator>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
+#include "base/scoped_native_library.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/printing/print_preview_dialog_controller.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/printing/common/print_messages.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "content/public/test/browser_test_utils.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/filename_util.h"
-#include "pdf/pdf.h"
 #include "printing/pdf_render_settings.h"
 #include "printing/units.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/rect.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include <fcntl.h>
 #include <io.h>
 #endif
@@ skipping 264 matching lines @@
     chrome::Print(browser());
     loop.Run();
 
     // Need to check whether the save was successful. Ending the loop only
     // means the save was attempted.
     base::File pdf_file(
         pdf_file_save_path_, base::File::FLAG_OPEN | base::File::FLAG_READ);
     ASSERT_TRUE(pdf_file.IsValid());
   }
 
+  // Initializes function pointers from the PDF library. Called once when the
+  // test starts. The library is closed when the browser test ends.
+  void InitPdfFunctions() {
+    base::FilePath pdf_module_path;
+
+    ASSERT_TRUE(PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_module_path));
+    ASSERT_TRUE(base::PathExists(pdf_module_path));
+    pdf_lib_.Reset(base::LoadNativeLibrary(pdf_module_path, NULL));
+
+    ASSERT_TRUE(pdf_lib_.is_valid());
+    pdf_to_bitmap_func_ =
+        reinterpret_cast<PDFPageToBitmapProc>(
+            pdf_lib_.GetFunctionPointer("RenderPDFPageToBitmap"));
+
+    pdf_doc_info_func_ =
+        reinterpret_cast<GetPDFDocInfoProc>(
+            pdf_lib_.GetFunctionPointer("GetPDFDocInfo"));
+
+    pdf_page_size_func_ =
+        reinterpret_cast<GetPDFPageSizeByIndexProc>(
+            pdf_lib_.GetFunctionPointer("GetPDFPageSizeByIndex"));
+
+    ASSERT_TRUE(pdf_to_bitmap_func_);
+    ASSERT_TRUE(pdf_doc_info_func_);
+    ASSERT_TRUE(pdf_page_size_func_);
+  }
+
   // Converts the PDF to a PNG file so that the layout test can do an image
   // diff on this image and a reference image.
   void PdfToPng() {
     int num_pages;
     double max_width_in_points = 0;
     std::vector<uint8_t> bitmap_data;
     double total_height_in_pixels = 0;
     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));
+    ASSERT_TRUE(pdf_doc_info_func_(pdf_data.data(),
+                                   pdf_data.size(),
+                                   &num_pages,
+                                   &max_width_in_points));
 
     ASSERT_GT(num_pages, 0);
     double max_width_in_pixels =
         ConvertUnitDouble(max_width_in_points, kPointsPerInch, kDpi);
 
     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));
+      ASSERT_TRUE(pdf_page_size_func_(pdf_data.data(),
+                                      pdf_data.size(),
+                                      i,
+                                      &width_in_points,
+                                      &height_in_points));
 
       double width_in_pixels = ConvertUnitDouble(
           width_in_points, kPointsPerInch, kDpi);
       double height_in_pixels = ConvertUnitDouble(
           height_in_points, kPointsPerInch, kDpi);
 
       // The image will be rotated if |width_in_pixels| is greater than
       // |height_in_pixels|. This is because the page will be rotated to fit
       // within a piece of paper. Therefore, |width_in_pixels| and
       // |height_in_pixels| have to be swapped or else they won't reflect the
       // dimensions of the rotated page.
       if (width_in_pixels > height_in_pixels)
         std::swap(width_in_pixels, height_in_pixels);
 
       total_height_in_pixels += height_in_pixels;
       gfx::Rect rect(width_in_pixels, height_in_pixels);
       PdfRenderSettings settings(rect, kDpi, true);
 
       int int_max = std::numeric_limits<int>::max();
       if (settings.area().width() > int_max / kColorChannels ||
           settings.area().height() > int_max / (kColorChannels *
               settings.area().width())) {
         FAIL() << "The dimensions of the image are too large."
                << "Decrease the DPI or the dimensions of the image.";
       }
 
       std::vector<uint8_t> page_bitmap_data(
           kColorChannels * 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(),
-          true));
+      ASSERT_TRUE(pdf_to_bitmap_func_(pdf_data.data(),
+                                      pdf_data.size(),
+                                      i,
+                                      page_bitmap_data.data(),
+                                      settings.area().size().width(),
+                                      settings.area().size().height(),
+                                      settings.dpi(),
+                                      settings.dpi(),
+                                      true));
       FillPng(&page_bitmap_data,
               width_in_pixels,
               max_width_in_pixels,
               settings.area().size().height());
       bitmap_data.insert(bitmap_data.end(),
                          page_bitmap_data.begin(),
                          page_bitmap_data.end());
     }
 
     CreatePng(bitmap_data, max_width_in_pixels, total_height_in_pixels);
@@ skipping 138 matching lines @@
                                       png_rect.size(),
                                       png_rect.size().width() * kColorChannels,
                                       false,
                                       comments,
                                       &png_output_));
   }
 
   scoped_ptr<PrintPreviewObserver> print_preview_observer_;
   base::FilePath pdf_file_save_path_;
 
+  // These typedefs are function pointers to pdflib functions that give
+  // information about the PDF as a whole and about specific pages.
+
+  // Converts the PDF to a bitmap.
+  typedef bool (*PDFPageToBitmapProc)(const void* pdf_buffer,
+                                      int pdf_buffer_size,
+                                      int page_number,
+                                      void* bitmap_buffer,
+                                      int bitmap_width,
+                                      int bitmap_height,
+                                      int dpi_x,
+                                      int dpi_y,
+                                      bool autorotate);
+
+  // Gets the page count and maximum page width of the PDF in points.
+  typedef bool (*GetPDFDocInfoProc)(const void* pdf_buffer,
+                                    int buffer_size,
+                                    int* pages_count,
+                                    double* max_page_width);
+
+  // Gets the dimensions of a specific page within a PDF.
+  typedef bool (*GetPDFPageSizeByIndexProc)(const void* pdf_buffer,
+                                            int buffer_size,
+                                            int index,
+                                            double* width,
+                                            double* height);
+
+  // Instantiations of the function pointers described above.
+  PDFPageToBitmapProc pdf_to_bitmap_func_;
+  GetPDFDocInfoProc pdf_doc_info_func_;
+  GetPDFPageSizeByIndexProc pdf_page_size_func_;
+
+  // Used to open up the pdf plugin, which contains the functions above.
+  base::ScopedNativeLibrary pdf_lib_;
+
   // Vector for storing the PNG to be sent to the layout test framework.
   // TODO(ivandavid): Eventually change this to uint32_t and make everything
   // work with that. It might be a bit tricky to fix everything to work with
   // uint32_t, but not too tricky.
   std::vector<unsigned char> png_output_;
 
   // Image hash of the bitmap that is turned into a PNG. The hash is put into
   // the PNG as a comment, as it is needed by the layout test framework.
   base::MD5Digest hash_;
 
@@ skipping 14 matching lines @@
   // - Print webpage to a pdf
   // - Convert pdf to a png
   // - Send png to layout test framework, where it doesn an image diff
   //   on the image sent by this test and a reference image.
   //
   // Throughout this code, there will be |std::cout| statements. The layout test
   // framework uses stdout to get data from the browser test and uses stdin
   // to send data to the browser test. Writing "EOF\n" to |std::cout| indicates
   // that whatever block of data that the test was expecting has been completely
   // sent. Sometimes EOF is printed to stderr because the test will expect it
-  // from stderr in addition to stdout for certain blocks of data.=
+  // from stderr in addition to stdout for certain blocks of data.
+  InitPdfFunctions();
   SetupStdinAndSavePath();
 
   while (true) {
     std::string input;
     while (input.empty()) {
       std::getline(std::cin, input);
       if (std::cin.eof())
         std::cin.clear();
     }
 
@@ skipping 37 matching lines @@
     // waiting for this message and start waiting for the image data.
     std::cout << "#EOF\n";
     std::cout.flush();
 
     SendPng();
     Reset();
   }
 }
 
 }  // namespace printing