Printing: PDFs should only be fit to page if there is a size mismatch.

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 <string>
 
 #include "base/auto_reset.h"
 #include "base/json/json_writer.h"
@@ skipping 17 matching lines @@
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPlugin.h"
 #include "third_party/WebKit/public/web/WebPluginDocument.h"
 #include "third_party/WebKit/public/web/WebPrintParams.h"
 #include "third_party/WebKit/public/web/WebPrintPresetOptions.h"
-#include "third_party/WebKit/public/web/WebPrintScalingOption.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSettings.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebViewClient.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::WebPreferences;
 
 namespace printing {
@@ skipping 256 matching lines @@
   bool frame_has_custom_page_size_style = false;
   for (int i = 0; i < total_page_count; ++i) {
     if (frame->hasCustomPageSizeStyle(i)) {
       frame_has_custom_page_size_style = true;
       break;
     }
   }
   return frame_has_custom_page_size_style;
 }
 
-MarginType GetMarginsForPdf(blink::WebFrame* frame,
-                            const blink::WebNode& node) {
-  if (frame->isPrintScalingDisabledForPlugin(node))
-    return NO_MARGINS;
-  else
-    return PRINTABLE_AREA_MARGINS;
+// 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.
+bool PDFShouldDisableScalingBasedOnPreset(
+    const blink::WebPrintPresetOptions& options,
+    const PrintMsg_Print_Params& params) {
+  if (options.isScalingDisabled)
+    return true;
+
+  if (!options.isPageSizeUniform)
+    return false;
+
+  int dpi = GetDPI(&params);
+  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 bool kDefaultPDFShouldDisableScalingSetting = true;
+  blink::WebPrintPresetOptions preset_options;
+  if (!frame->getPrintPresetOptionsForPlugin(node, &preset_options))
+    return kDefaultPDFShouldDisableScalingSetting;
+  return PDFShouldDisableScalingBasedOnPreset(preset_options, params);
+}
+
+MarginType GetMarginsForPdf(blink::WebLocalFrame* frame,
+                            const blink::WebNode& node,
+                            const PrintMsg_Print_Params& params) {
+  return PDFShouldDisableScaling(frame, node, params) ?
+      NO_MARGINS : PRINTABLE_AREA_MARGINS;
 }
 
 bool FitToPageEnabled(const base::DictionaryValue& job_settings) {
   bool fit_to_paper_size = false;
   if (!job_settings.GetBoolean(kSettingFitToPageEnabled, &fit_to_paper_size)) {
     NOTREACHED();
   }
   return fit_to_paper_size;
 }
 
 // Returns the print scaling option to retain/scale/crop the source page size
 // to fit the printable area of the paper.
 //
 // We retain the source page size when the current destination printer is
 // SAVE_AS_PDF.
 //
 // We crop the source page size to fit the printable area or we print only the
 // left top page contents when
 // (1) Source is PDF and the user has requested not to fit to printable area
 // via |job_settings|.
 // (2) Source is PDF. This is the first preview request and print scaling
 // option is disabled for initiator renderer plugin.
 //
 // In all other cases, we scale the source page to fit the printable area.
 blink::WebPrintScalingOption GetPrintScalingOption(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebNode& node,
     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 = frame->isPrintScalingDisabledForPlugin(node);
-
+    bool no_plugin_scaling = PDFShouldDisableScaling(frame, node, params);
     if (params.is_first_request && no_plugin_scaling)
       return blink::WebPrintScalingOptionNone;
   }
   return blink::WebPrintScalingOptionFitToPrintableArea;
 }
 
 PrintMsg_Print_Params CalculatePrintParamsForCss(
     blink::WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& page_params,
@@ skipping 640 matching lines @@
     }
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   // Set the options from document if we are previewing a pdf and send a
   // message to browser.
   if (print_pages_params_->params.is_first_request &&
       !print_preview_context_.IsModifiable()) {
     PrintHostMsg_SetOptionsFromDocument_Params options;
-    SetOptionsFromPdfDocument(&options);
-    Send(new PrintHostMsg_SetOptionsFromDocument(routing_id(), options));
+    if (SetOptionsFromPdfDocument(&options))
+      Send(new PrintHostMsg_SetOptionsFromDocument(routing_id(), options));
   }
 
   is_print_ready_metafile_sent_ = false;
 
   // PDF printer device supports alpha blending.
   print_pages_params_->params.supports_alpha_blend = true;
 
   bool generate_draft_pages = false;
   if (!settings.GetBoolean(kSettingGenerateDraftData, &generate_draft_pages)) {
     NOTREACHED();
@@ skipping 404 matching lines @@
   }
 
   const PrintMsg_Print_Params& params = print_pages_params_->params;
   PrepareFrameAndViewForPrint prepare(params, frame, node, ignore_css_margins_);
   prepare.StartPrinting();
 
   *number_of_pages = prepare.GetExpectedPageCount();
   return true;
 }
 
-void PrintWebViewHelper::SetOptionsFromPdfDocument(
+bool PrintWebViewHelper::SetOptionsFromPdfDocument(
     PrintHostMsg_SetOptionsFromDocument_Params* options) {
   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;
+    return false;
   }
 
-  options->is_scaling_disabled = preset_options.isScalingDisabled;
+  options->is_scaling_disabled = PDFShouldDisableScalingBasedOnPreset(
+      preset_options, print_pages_params_->params);
   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;
       break;
     default:
       options->duplex = UNKNOWN_DUPLEX_MODE;
       break;
   }
+  return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
     blink::WebLocalFrame* frame,
     const blink::WebNode& node,
     const base::DictionaryValue& passed_job_settings) {
   const base::DictionaryValue* job_settings = &passed_job_settings;
   base::DictionaryValue modified_job_settings;
   if (job_settings->empty()) {
     if (!print_for_preview_)
@@ skipping 60 matching lines @@
       print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
     else
       Send(new PrintHostMsg_ShowInvalidPrinterSettingsError(routing_id()));
 
     return false;
   }
 
   return true;
 }
 
-bool PrintWebViewHelper::GetPrintSettingsFromUser(blink::WebFrame* frame,
+bool PrintWebViewHelper::GetPrintSettingsFromUser(blink::WebLocalFrame* frame,
                                                   const blink::WebNode& node,
                                                   int expected_pages_count,
                                                   bool is_scripted) {
   PrintHostMsg_ScriptedPrint_Params params;
   PrintMsg_PrintPages_Params print_settings;
 
   params.cookie = print_pages_params_->params.document_cookie;
   params.has_selection = frame->hasSelection();
   params.expected_pages_count = expected_pages_count;
   MarginType margin_type = DEFAULT_MARGINS;
-  if (PrintingNodeOrPdfFrame(frame, node))
-    margin_type = GetMarginsForPdf(frame, node);
+  if (PrintingNodeOrPdfFrame(frame, node)) {
+    margin_type =
+        GetMarginsForPdf(frame, node, print_pages_params_->params);
+  }
   params.margin_type = margin_type;
   params.is_scripted = is_scripted;
 
   Send(new PrintHostMsg_DidShowPrintDialog(routing_id()));
 
   // PrintHostMsg_ScriptedPrint will reset print_scaling_option, so we save the
   // value before and restore it afterwards.
   blink::WebPrintScalingOption scaling_option =
       print_pages_params_->params.print_scaling_option;
 
@@ skipping 458 matching lines @@
       blink::WebConsoleMessage::LevelWarning, message));
   return false;
 }
 
 void PrintWebViewHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing