Remove some duplicate code / constants in pdf/.

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 "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 15 matching lines @@
 #include "ppapi/c/private/ppb_pdf.h"
 #include "ppapi/cpp/dev/memory_dev.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/private/pdf.h"
 #include "ppapi/cpp/trusted/browser_font_trusted.h"
 #include "ppapi/cpp/url_response_info.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/var_dictionary.h"
+#include "printing/units.h"
 #include "third_party/pdfium/fpdfsdk/include/fpdf_ext.h"
 #include "third_party/pdfium/fpdfsdk/include/fpdf_flatten.h"
 #include "third_party/pdfium/fpdfsdk/include/fpdf_searchex.h"
 #include "third_party/pdfium/fpdfsdk/include/fpdf_sysfontinfo.h"
 #include "third_party/pdfium/fpdfsdk/include/fpdf_transformpage.h"
 #include "third_party/pdfium/fpdfsdk/include/fpdfedit.h"
 #include "third_party/pdfium/fpdfsdk/include/fpdfppo.h"
 #include "third_party/pdfium/fpdfsdk/include/fpdfsave.h"
 #include "third_party/pdfium/fpdfsdk/include/pdfwindow/PDFWindow.h"
 #include "third_party/pdfium/fpdfsdk/include/pdfwindow/PWL_FontMap.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
+using printing::ConvertUnit;
+using printing::ConvertUnitDouble;
+using printing::kPointsPerInch;
+using printing::kPixelsPerInch;
+
 namespace chrome_pdf {
 
 namespace {
 
 #define kPageShadowTop    3
 #define kPageShadowBottom 7
 #define kPageShadowLeft   5
 #define kPageShadowRight  5
 
 #define kPageSeparatorThickness 4
@@ skipping 25 matching lines @@
 // than the above to keep things smooth if the user is scrolling quickly. We
 // try painting a little because with accelerated compositing, we get flushes
 // only every 16 ms. If we were to wait until the next flush to paint the rest
 // of the pdf, we would never get to draw the pdf and would only draw the
 // scrollbars. This value is picked to give enough time for gpu related code to
 // do its thing and still fit within the timelimit for 60Hz. For the
 // non-composited case, this doesn't make things worse since we're still
 // painting the scrollbars > 60 Hz.
 #define kMaxInitialProgressivePaintTimeMs 10
 
-// Copied from printing/units.cc because we don't want to depend on printing
-// since it brings in libpng which causes duplicate symbols with PDFium.
-const int kPointsPerInch = 72;
-const int kPixelsPerInch = 96;
-
 struct ClipBox {
   float left;
   float right;
   float top;
   float bottom;
 };
 
-int ConvertUnit(int value, int old_unit, int new_unit) {
-  // With integer arithmetic, to divide a value with correct rounding, you need
-  // to add half of the divisor value to the dividend value. You need to do the
-  // reverse with negative number.
-  if (value >= 0) {
-    return ((value * new_unit) + (old_unit / 2)) / old_unit;
-  } else {
-    return ((value * new_unit) - (old_unit / 2)) / old_unit;
-  }
-}
-
 std::vector<uint32_t> GetPageNumbersFromPrintPageNumberRange(
     const PP_PrintPageNumberRange_Dev* page_ranges,
     uint32_t page_range_count) {
   std::vector<uint32_t> page_numbers;
   for (uint32_t index = 0; index < page_range_count; ++index) {
     for (uint32_t page_number = page_ranges[index].first_page_number;
          page_number <= page_ranges[index].last_page_number; ++page_number) {
       page_numbers.push_back(page_number);
     }
   }
@@ skipping 1265 matching lines @@
   pp::Rect page_rect = page_to_print->rect();
   FPDF_RenderPageBitmap(bitmap,
                         page_to_print->GetPrintPage(),
                         page_rect.x(),
                         page_rect.y(),
                         page_rect.width(),
                         page_rect.height(),
                         print_settings.orientation,
                         FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
 
-  double ratio_x = (static_cast<double>(bitmap_size.width()) * kPointsPerInch) /
-                   print_settings.dpi;
-  double ratio_y =
-      (static_cast<double>(bitmap_size.height()) * kPointsPerInch) /
-      print_settings.dpi;
+  double ratio_x = ConvertUnitDouble(bitmap_size.width(),
+                                     print_settings.dpi,
+                                     kPointsPerInch);
+  double ratio_y = ConvertUnitDouble(bitmap_size.height(),
+                                     print_settings.dpi,
+                                     kPointsPerInch);
 
   // Add the bitmap to an image object and add the image object to the output
   // page.
   FPDF_PAGEOBJECT temp_img = FPDFPageObj_NewImgeObj(temp_doc);
   FPDFImageObj_SetBitmap(&temp_page, 1, temp_img, bitmap);
   FPDFImageObj_SetMatrix(temp_img, ratio_x, 0, 0, ratio_y, 0, 0);
   FPDFPage_InsertObject(temp_page, temp_img);
   FPDFPage_GenerateContent(temp_page);
   FPDF_ClosePage(temp_page);
 
@@ skipping 27 matching lines @@
       GetPageNumbersFromPrintPageNumberRange(page_ranges, page_range_count);
   for (size_t i = 0; i < page_numbers.size(); ++i) {
     uint32_t page_number = page_numbers[i];
     FPDF_PAGE pdf_page = FPDF_LoadPage(doc_, page_number);
     double source_page_width = FPDF_GetPageWidth(pdf_page);
     double source_page_height = FPDF_GetPageHeight(pdf_page);
     source_page_sizes.push_back(std::make_pair(source_page_width,
                                                source_page_height));
 
     int width_in_pixels = ConvertUnit(source_page_width,
-                                      static_cast<int>(kPointsPerInch),
+                                      kPointsPerInch,
                                       print_settings.dpi);
     int height_in_pixels = ConvertUnit(source_page_height,
-                                       static_cast<int>(kPointsPerInch),
+                                       kPointsPerInch,
                                        print_settings.dpi);
 
     pp::Rect rect(width_in_pixels, height_in_pixels);
     pages_to_print.push_back(PDFiumPage(this, page_number, rect, true));
     FPDF_ClosePage(pdf_page);
   }
 
 #if defined(OS_LINUX)
   g_last_instance_id = client_->GetPluginInstance()->pp_instance();
 #endif
@@ skipping 1032 matching lines @@
     page_rects.push_back(rect);
 
     document_size_.Enlarge(0, page_size.height());
   }
 
   // Create blank pages.
   for (int i = 1; i < num_pages; ++i) {
     pp::Rect page_rect(page_rects[i]);
     page_rect.Inset(kPageShadowLeft, kPageShadowTop,
                     kPageShadowRight, kPageShadowBottom);
-    double width_in_points =
-        page_rect.width() * kPointsPerInch / kPixelsPerInch;
-    double height_in_points =
-        page_rect.height() * kPointsPerInch / kPixelsPerInch;
+    double width_in_points = ConvertUnitDouble(page_rect.width(),
+                                               kPixelsPerInch,
+                                               kPointsPerInch);
+    double height_in_points = ConvertUnitDouble(page_rect.height(),
+                                                kPixelsPerInch,
+                                                kPointsPerInch);
     FPDFPage_New(doc_, i, width_in_points, height_in_points);
     pages_.push_back(new PDFiumPage(this, i, page_rect, true));
   }
 
   CalculateVisiblePages();
   if (document_size_ != old_document_size)
     client_->DocumentSizeUpdated(document_size_);
 }
 
 void PDFiumEngine::LoadDocument() {
@@ skipping 263 matching lines @@
 
 pp::Size PDFiumEngine::GetPageSize(int index) {
   pp::Size size;
   double width_in_points = 0;
   double height_in_points = 0;
   int rv = FPDF_GetPageSizeByIndex(
       doc_, index, &width_in_points, &height_in_points);
 
   if (rv) {
     int width_in_pixels = static_cast<int>(
-        width_in_points * kPixelsPerInch / kPointsPerInch);
+        ConvertUnitDouble(width_in_points, kPointsPerInch, kPixelsPerInch));
     int height_in_pixels = static_cast<int>(
-        height_in_points * kPixelsPerInch / kPointsPerInch);
+        ConvertUnitDouble(height_in_points, kPointsPerInch, kPixelsPerInch));
     if (current_rotation_ % 2 == 1)
       std::swap(width_in_pixels, height_in_pixels);
     size = pp::Size(width_in_pixels, height_in_pixels);
   }
   return size;
 }
 
 int PDFiumEngine::StartPaint(int page_index, const pp::Rect& dirty) {
   // For the first time we hit paint, do nothing and just record the paint for
   // the next callback.  This keeps the UI responsive in case the user is doing
@@ skipping 964 matching lines @@
 
 PDFEngineExports* PDFEngineExports::Create() {
   return new PDFiumEngineExports;
 }
 
 namespace {
 
 int CalculatePosition(FPDF_PAGE page,
                       const PDFiumEngineExports::RenderingSettings& settings,
                       pp::Rect* dest) {
-  int page_width = static_cast<int>(
-      FPDF_GetPageWidth(page) * settings.dpi_x / kPointsPerInch);
-  int page_height = static_cast<int>(
-      FPDF_GetPageHeight(page) * settings.dpi_y / kPointsPerInch);
+  int page_width = static_cast<int>(ConvertUnitDouble(FPDF_GetPageWidth(page),
+                                                      kPointsPerInch,
+                                                      settings.dpi_x));
+  int page_height = static_cast<int>(ConvertUnitDouble(FPDF_GetPageHeight(page),
+                                                       kPointsPerInch,
+                                                       settings.dpi_y));
 
   // Start by assuming that we will draw exactly to the bounds rect
   // specified.
   *dest = settings.bounds;
 
   int rotate = 0;  // normal orientation.
 
   // Auto-rotate landscape pages to print correctly.
   if (settings.autorotate &&
       (dest->width() > dest->height()) != (page_width > page_height)) {
@@ skipping 202 matching lines @@
     double* height) {
   FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf