Print Preview: Fix fit to page checkbox.

components/printing/renderer/print_web_view_helper.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 "components/printing/renderer/print_web_view_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
@@ skipping 310 matching lines @@
       frame_has_custom_page_size_style = true;
       break;
     }
   }
   return frame_has_custom_page_size_style;
 }
 #endif  // defined(ENABLE_PRINT_PREVIEW)
 
 // Disable scaling when either:
 // - The PDF specifies disabling scaling.
-// - All the pages in the PDF are the same size, and that size is the same as
-//   the paper size.
+// - All the pages in the PDF are the same size,
+// - |ignore_page_size| is false and the uniform size is the same as the paper
+//   size.

[Larry LA Ca, 2016/09/04 21:09:38]

Editorial cmt only, no impact: description should read
// Disable scaling when either:
// - The PDF specifies disabling scaling,
// - |ignore_page_size| is false
// - All the pages in the PDF are the same size,
// - The uniform size is the same as the paper size.

Keeps the same size logic together, 
there is no && condition between ignore_page_size and uniform size

 bool PDFShouldDisableScalingBasedOnPreset(
     const blink::WebPrintPresetOptions& options,
-    const PrintMsg_Print_Params& params) {
+    const PrintMsg_Print_Params& params,
+    bool ignore_page_size) {
   if (options.isScalingDisabled)
     return true;
 
   if (!options.isPageSizeUniform)
     return false;
 
   int dpi = GetDPI(&params);
   if (!dpi) {
     // Likely |params| is invalid, in which case the return result does not
     // matter. Check for this so ConvertUnit() does not divide by zero.
     return true;
   }
 
+  if (ignore_page_size)

[Larry LA Ca, 2016/09/04 21:09:37]

Editorial cmt only, no impact
The if (ignore_page_size) check should precede the !dpi check.
The !dpi check protects the page_size() call just below.

+    return false;
+
   blink::WebSize page_size(
       ConvertUnit(params.page_size.width(), dpi, kPointsPerInch),
       ConvertUnit(params.page_size.height(), dpi, kPointsPerInch));
   return options.uniformPageSize == page_size;
 }
 
 bool PDFShouldDisableScaling(blink::WebLocalFrame* frame,
                              const blink::WebNode& node,
-                             const PrintMsg_Print_Params& params) {
+                             const PrintMsg_Print_Params& params,
+                             bool ignore_page_size) {
   const bool kDefaultPDFShouldDisableScalingSetting = true;
   blink::WebPrintPresetOptions preset_options;
   if (!frame->getPrintPresetOptionsForPlugin(node, &preset_options))
     return kDefaultPDFShouldDisableScalingSetting;
-  return PDFShouldDisableScalingBasedOnPreset(preset_options, params);
+  return PDFShouldDisableScalingBasedOnPreset(preset_options, params,
+                                              ignore_page_size);
 }
 
 #if defined(ENABLE_BASIC_PRINTING)
 MarginType GetMarginsForPdf(blink::WebLocalFrame* frame,
                             const blink::WebNode& node,
                             const PrintMsg_Print_Params& params) {
-  return PDFShouldDisableScaling(frame, node, params) ?
+  return PDFShouldDisableScaling(frame, node, params, false) ?
       NO_MARGINS : PRINTABLE_AREA_MARGINS;
 }
 #endif
 
 #if defined(ENABLE_PRINT_PREVIEW)
 bool FitToPageEnabled(const base::DictionaryValue& job_settings) {
   bool fit_to_paper_size = false;
   if (!job_settings.GetBoolean(kSettingFitToPageEnabled, &fit_to_paper_size)) {
     NOTREACHED();
   }
@@ skipping 20 matching lines @@
     bool source_is_html,
     const base::DictionaryValue& job_settings,
     const PrintMsg_Print_Params& params) {
   if (params.print_to_pdf)
     return blink::WebPrintScalingOptionSourceSize;
 
   if (!source_is_html) {
     if (!FitToPageEnabled(job_settings))
       return blink::WebPrintScalingOptionNone;
 
-    bool no_plugin_scaling = PDFShouldDisableScaling(frame, node, params);
+    bool no_plugin_scaling = PDFShouldDisableScaling(frame, node, params,
+                                                     true);
     if (params.is_first_request && no_plugin_scaling)
       return blink::WebPrintScalingOptionNone;
   }
   return blink::WebPrintScalingOptionFitToPrintableArea;
 }
 #endif  // defined(ENABLE_PRINT_PREVIEW)
 
 PrintMsg_Print_Params CalculatePrintParamsForCss(
     blink::WebLocalFrame* frame,
     int page_index,
@@ skipping 1160 matching lines @@
   blink::WebLocalFrame* source_frame = print_preview_context_.source_frame();
   const blink::WebNode& source_node = print_preview_context_.source_node();
 
   blink::WebPrintPresetOptions preset_options;
   if (!source_frame->getPrintPresetOptionsForPlugin(source_node,
                                                     &preset_options)) {
     return false;
   }
 
   options->is_scaling_disabled = PDFShouldDisableScalingBasedOnPreset(
-      preset_options, print_pages_params_->params);
+      preset_options, print_pages_params_->params, false);
   options->copies = preset_options.copies;
 
   // TODO(thestig) This should be a straight pass-through, but print preview
   // does not currently support short-edge printing.
   switch (preset_options.duplexMode) {
     case blink::WebSimplex:
       options->duplex = SIMPLEX;
       break;
     case blink::WebLongEdge:
       options->duplex = LONG_EDGE;
@@ skipping 650 matching lines @@
       blink::WebConsoleMessage::LevelWarning, message));
   return false;
 }
 
 void PrintWebViewHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing