Fix printing of PDFs. They should not be cut off.

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/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 97 matching lines @@
       page_numbers.push_back(page_number);
     }
   }
   return page_numbers;
 }
 
 #if defined(OS_LINUX)
 
 PP_Instance g_last_instance_id;
 
-struct PDFFontSubstitution {
-  const char* pdf_name;
-  const char* face;
-  bool bold;
-  bool italic;
-};
-
 PP_BrowserFont_Trusted_Weight WeightToBrowserFontTrustedWeight(int weight) {
   static_assert(PP_BROWSERFONT_TRUSTED_WEIGHT_100 == 0,
                 "PP_BrowserFont_Trusted_Weight min");
   static_assert(PP_BROWSERFONT_TRUSTED_WEIGHT_900 == 8,
                 "PP_BrowserFont_Trusted_Weight max");
   const int kMinimumWeight = 100;
   const int kMaximumWeight = 900;
   int normalized_weight =
       std::min(std::max(weight, kMinimumWeight), kMaximumWeight);
   normalized_weight = (normalized_weight / 100) - 1;
   return static_cast<PP_BrowserFont_Trusted_Weight>(normalized_weight);
 }
 
 // This list is for CPWL_FontMap::GetDefaultFontByCharset().
 // We pretend to have these font natively and let the browser (or underlying
 // fontconfig) to pick the proper font on the system.
 void EnumFonts(struct _FPDF_SYSFONTINFO* sysfontinfo, void* mapper) {
   FPDF_AddInstalledFont(mapper, "Arial", FXFONT_DEFAULT_CHARSET);
 
   const FPDF_CharsetFontMap* font_map = FPDF_GetDefaultTTFMap();
   for (; font_map->charset != -1; ++font_map) {
     FPDF_AddInstalledFont(mapper, font_map->fontname, font_map->charset);
   }
 }
 
-const PDFFontSubstitution PDFFontSubstitutions[] = {
+void* MapFont(struct _FPDF_SYSFONTINFO*, int weight, int italic,
+              int charset, int pitch_family, const char* face, int* exact) {
+  // Do not attempt to map fonts if pepper is not initialized (for privet local
+  // printing).
+  // TODO(noamsml): Real font substitution (http://crbug.com/391978)
+  if (!pp::Module::Get())
+    return NULL;
+
+  pp::BrowserFontDescription description;
+
+  // Pretend the system does not have the Symbol font to force a fallback to
+  // the built in Symbol font in CFX_FontMapper::FindSubstFont().
+  if (strcmp(face, "Symbol") == 0)
+    return NULL;
+
+  if (pitch_family & FXFONT_FF_FIXEDPITCH) {
+    description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE);
+  } else if (pitch_family & FXFONT_FF_ROMAN) {
+    description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_SERIF);
+  }
+
+  static const struct {
+    const char* pdf_name;
+    const char* face;
+    bool bold;
+    bool italic;
+  } kPdfFontSubstitutions[] = {
     {"Courier", "Courier New", false, false},
     {"Courier-Bold", "Courier New", true, false},
     {"Courier-BoldOblique", "Courier New", true, true},
     {"Courier-Oblique", "Courier New", false, true},
     {"Helvetica", "Arial", false, false},
     {"Helvetica-Bold", "Arial", true, false},
     {"Helvetica-BoldOblique", "Arial", true, true},
     {"Helvetica-Oblique", "Arial", false, true},
     {"Times-Roman", "Times New Roman", false, false},
     {"Times-Bold", "Times New Roman", true, false},
@@ skipping 17 matching lines @@
     {"\x82\x6C\x82\x72\x83\x53\x83\x56\x83\x62\x83\x4E",
      "MS Gothic", false, false},
     // MS PMincho in Shift_JIS encoding.
     {"\x82\x6C\x82\x72\x82\x6F\x96\xBE\x92\xA9",
      "MS PMincho", false, false},
     // MS Mincho in Shift_JIS encoding.
     {"\x82\x6C\x82\x72\x96\xBE\x92\xA9",
      "MS Mincho", false, false},
 };
 
-void* MapFont(struct _FPDF_SYSFONTINFO*, int weight, int italic,
-              int charset, int pitch_family, const char* face, int* exact) {
-  // Do not attempt to map fonts if pepper is not initialized (for privet local
-  // printing).
-  // TODO(noamsml): Real font substitution (http://crbug.com/391978)
-  if (!pp::Module::Get())
-    return NULL;
-
-  pp::BrowserFontDescription description;
-
-  // Pretend the system does not have the Symbol font to force a fallback to
-  // the built in Symbol font in CFX_FontMapper::FindSubstFont().
-  if (strcmp(face, "Symbol") == 0)
-    return NULL;
-
-  if (pitch_family & FXFONT_FF_FIXEDPITCH) {
-    description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE);
-  } else if (pitch_family & FXFONT_FF_ROMAN) {
-    description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_SERIF);
-  }
-
   // Map from the standard PDF fonts to TrueType font names.
   size_t i;
-  for (i = 0; i < arraysize(PDFFontSubstitutions); ++i) {
-    if (strcmp(face, PDFFontSubstitutions[i].pdf_name) == 0) {
-      description.set_face(PDFFontSubstitutions[i].face);
-      if (PDFFontSubstitutions[i].bold)
+  for (i = 0; i < arraysize(kPdfFontSubstitutions); ++i) {
+    if (strcmp(face, kPdfFontSubstitutions[i].pdf_name) == 0) {
+      description.set_face(kPdfFontSubstitutions[i].face);
+      if (kPdfFontSubstitutions[i].bold)
         description.set_weight(PP_BROWSERFONT_TRUSTED_WEIGHT_BOLD);
-      if (PDFFontSubstitutions[i].italic)
+      if (kPdfFontSubstitutions[i].italic)
         description.set_italic(true);
       break;
     }
   }
 
-  if (i == arraysize(PDFFontSubstitutions)) {
+  if (i == arraysize(kPdfFontSubstitutions)) {
     // Convert to UTF-8 before calling set_face().
     std::string face_utf8;
     if (base::IsStringUTF8(face)) {
       face_utf8 = face;
     } else {
       std::string encoding;
       if (base::DetectEncoding(face, &encoding)) {
         // ConvertToUtf8AndNormalize() clears |face_utf8| on failure.
         base::ConvertToUtf8AndNormalize(face, encoding, &face_utf8);
       }
@@ skipping 57 matching lines @@
 
 void Unsupported_Handler(UNSUPPORT_INFO*, int type) {
   if (!g_engine_for_unsupported) {
     NOTREACHED();
     return;
   }
 
   g_engine_for_unsupported->UnsupportedFeature(type);
 }
 
-UNSUPPORT_INFO g_unsuppored_info = {
+UNSUPPORT_INFO g_unsupported_info = {
   1,
   Unsupported_Handler
 };
 
 // Set the destination page size and content area in points based on source
 // page rotation and orientation.
 //
 // |rotated| True if source page is rotated 90 degree or 270 degree.
 // |is_src_page_landscape| is true if the source page orientation is landscape.
 // |page_size| has the actual destination page size in points.
@@ skipping 10 matching lines @@
   if (rotate_dst_page) {
     page_size->SetSize(page_size->height(), page_size->width());
     content_rect->SetRect(content_rect->y(), content_rect->x(),
                           content_rect->height(), content_rect->width());
   }
 }
 
 // Calculate the scale factor between |content_rect| and a page of size
 // |src_width| x |src_height|.
 //
-// |scale_to_fit| is true, if we need to calculate the scale factor.
 // |content_rect| specifies the printable area of the destination page, with
 // origin at left-bottom. Values are in points.
 // |src_width| specifies the source page width in points.
 // |src_height| specifies the source page height in points.
 // |rotated| True if source page is rotated 90 degree or 270 degree.
-double CalculateScaleFactor(bool scale_to_fit,
-                            const pp::Rect& content_rect,
-                            double src_width, double src_height, bool rotated) {
-  if (!scale_to_fit || src_width == 0 || src_height == 0)
+double CalculateScaleFactor(const pp::Rect& content_rect,
+                            double src_width,
+                            double src_height,
+                            bool rotated) {
+  if (src_width == 0 || src_height == 0)
     return 1.0;
 
   double actual_source_page_width = rotated ? src_height : src_width;
   double actual_source_page_height = rotated ? src_width : src_height;
   double ratio_x = static_cast<double>(content_rect.width()) /
                    actual_source_page_width;
   double ratio_y = static_cast<double>(content_rect.height()) /
                    actual_source_page_height;
   return std::min(ratio_x, ratio_y);
 }
@@ skipping 13 matching lines @@
 void SetDefaultClipBox(bool rotated, ClipBox* clip_box) {
   const int kDpi = 72;
   const float kPaperWidth = 8.5 * kDpi;
   const float kPaperHeight = 11 * kDpi;
   clip_box->left = 0;
   clip_box->bottom = 0;
   clip_box->right = rotated ? kPaperHeight : kPaperWidth;
   clip_box->top = rotated ? kPaperWidth : kPaperHeight;
 }
 
-// Compute source clip box boundaries based on the crop box / media box of
-// source page and scale factor.
-//
-// |page| Handle to the source page. Returned by FPDF_LoadPage function.
-// |scale_factor| specifies the scale factor that should be applied to source
-// clip box boundaries.
-// |rotated| True if source page is rotated 90 degree or 270 degree.
-// |clip_box| out param to hold the computed source clip box values.
-void CalculateClipBoxBoundary(FPDF_PAGE page, double scale_factor, bool rotated,
-                              ClipBox* clip_box) {
-  ClipBox media_box;
-  if (!FPDFPage_GetMediaBox(page, &media_box.left, &media_box.bottom,
-                            &media_box.right, &media_box.top)) {
-    SetDefaultClipBox(rotated, &media_box);
+// Set the media box and/or crop box as needed.

[raymes, 2015/10/27 05:59:07]

nit: fill 80chars

[Lei Zhang, 2015/10/27 06:52:13]

Done.

+// If both boxes are there, then nothing needs to be done. If one box is
+// missing, then fill it with the value from the other box. If both boxes are
+// missing, then they both get the default value from SetDefaultClipBox(), based
+// on |rotated|.
+void CalculateMediaBoxAndCropBox(bool rotated,
+                                 bool has_media_box,
+                                 bool has_crop_box,
+                                 ClipBox* media_box,
+                                 ClipBox* crop_box) {
+  if (has_media_box) {
+    if (!has_crop_box)
+      *crop_box = *media_box;
+    return;
   }
 
-  ClipBox crop_box;
-  if (!FPDFPage_GetCropBox(page, &crop_box.left, &crop_box.bottom,
-                          &crop_box.right, &crop_box.top)) {
-    SetDefaultClipBox(rotated, &crop_box);
-  }
+  if (!has_crop_box)
+    SetDefaultClipBox(rotated, crop_box);
+  *media_box = *crop_box;

[raymes, 2015/10/27 05:59:07]

This is a little confusing to me. Perhaps we just do the more straightforward
approach?:

if (!has_media_box && !has_crop_box) {
  SetDefaultClipBox(rotated, crop_box);
  SetDefaultClipBox(rotated, media_box);
} else if (has_crop_box && !has_media_box) {
  *media_box = *crop_box;
} else if (has_media_box && !has_crop_box) {
  *crop_box = *media_box;
}

[Lei Zhang, 2015/10/27 06:52:13]

Done.

+}
+
+// Compute source clip box boundaries based on the crop box / media box of
+// source page.
+//
+// |media_box| The PDF's media box.
+// |crop_box| The PDF's crop box.
+ClipBox CalculateClipBoxBoundary(const ClipBox& media_box,
+                                 const ClipBox& crop_box) {
+  ClipBox clip_box;
 
   // Clip |media_box| to the size of |crop_box|, but ignore |crop_box| if it is
   // bigger than |media_box|.
-  clip_box->left =
+  clip_box.left =
       (crop_box.left < media_box.left) ? media_box.left : crop_box.left;
-  clip_box->right =
+  clip_box.right =
       (crop_box.right > media_box.right) ? media_box.right : crop_box.right;
-  clip_box->top = (crop_box.top > media_box.top) ? media_box.top : crop_box.top;
-  clip_box->bottom =
+  clip_box.top = (crop_box.top > media_box.top) ? media_box.top : crop_box.top;
+  clip_box.bottom =
       (crop_box.bottom < media_box.bottom) ? media_box.bottom : crop_box.bottom;
+  return clip_box;
+}
 
-  // Finally, scale |clip_box|.
-  clip_box->left *= scale_factor;
-  clip_box->right *= scale_factor;
-  clip_box->bottom *= scale_factor;
-  clip_box->top *= scale_factor;
+// Scale |box| by |scale_factor|.
+void ScaleClipBox(double scale_factor, ClipBox* box) {
+  box->left *= scale_factor;
+  box->right *= scale_factor;
+  box->bottom *= scale_factor;
+  box->top *= scale_factor;
 }
 
 // Calculate the clip box translation offset for a page that does need to be
 // scaled. All parameters are in points.
 //
 // |content_rect| specifies the printable area of the destination page, with
 // origin at left-bottom.
 // |source_clip_box| specifies the source clip box positions, relative to
 // origin at left-bottom.
 // |offset_x| and |offset_y| will contain the final translation offsets for the
@@ skipping 184 matching lines @@
   config.m_pUserFontPaths = nullptr;
   config.m_pIsolate = v8::Isolate::GetCurrent();
   config.m_v8EmbedderSlot = gin::kEmbedderPDFium;
   FPDF_InitLibraryWithConfig(&config);
 
 #if defined(OS_LINUX)
   // Font loading doesn't work in the renderer sandbox in Linux.
   FPDF_SetSystemFontInfo(&g_font_info);
 #endif
 
-  FSDK_SetUnSpObjProcessHandler(&g_unsuppored_info);
+  FSDK_SetUnSpObjProcessHandler(&g_unsupported_info);
 
   return true;
 }
 
 void ShutdownSDK() {
   FPDF_DestroyLibrary();
 }
 
 PDFEngine* PDFEngine::Create(PDFEngine::Client* client) {
   return new PDFiumEngine(client);
@@ skipping 2779 matching lines @@
                             src_page_width > src_page_height,
                             &page_size,
                             &content_rect);
 
   // Compute the screen page width and height in points.
   const int actual_page_width =
       rotated ? page_size.height() : page_size.width();
   const int actual_page_height =
       rotated ? page_size.width() : page_size.height();
 
-  const double scale_factor = CalculateScaleFactor(fit_to_page, content_rect,
-                                                   src_page_width,
-                                                   src_page_height, rotated);
+  const double scale_factor = fit_to_page ?
+      CalculateScaleFactor(
+          content_rect, src_page_width, src_page_height, rotated) : 1.0;
 
   // Calculate positions for the clip box.
-  ClipBox source_clip_box;
-  CalculateClipBoxBoundary(page, scale_factor, rotated, &source_clip_box);
+  ClipBox media_box;
+  ClipBox crop_box;
+  bool has_media_box = !!FPDFPage_GetMediaBox(page,
+                                              &media_box.left,
+                                              &media_box.bottom,
+                                              &media_box.right,
+                                              &media_box.top);
+  bool has_crop_box = !!FPDFPage_GetCropBox(page,
+                                            &crop_box.left,
+                                            &crop_box.bottom,
+                                            &crop_box.right,
+                                            &crop_box.top);
+  CalculateMediaBoxAndCropBox(
+      rotated, has_media_box, has_crop_box, &media_box, &crop_box);
+  ClipBox source_clip_box = CalculateClipBoxBoundary(media_box, crop_box);
+  ScaleClipBox(scale_factor, &source_clip_box);
 
   // Calculate the translation offset values.
   double offset_x = 0;
   double offset_y = 0;
   if (fit_to_page) {
     CalculateScaledClipBoxOffset(content_rect, source_clip_box, &offset_x,
                                  &offset_y);
   } else {
     CalculateNonScaledClipBoxOffset(content_rect, src_page_rotation,
                                     actual_page_width, actual_page_height,
@@ skipping 665 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