[Print Preview]: Added code to support pdf fit to page functionality.

chrome/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 "chrome/renderer/print_web_view_helper.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 323 matching lines @@
   return frame_has_custom_page_size_style;
 }
 
 printing::MarginType GetMarginsForPdf(WebFrame* frame, const WebNode& node) {
   if (frame->isPrintScalingDisabledForPlugin(node))
     return printing::NO_MARGINS;
   else
     return printing::PRINTABLE_AREA_MARGINS;
 }
 
+bool FitToPageEnabled(const DictionaryValue& job_settings) {
+  bool fit_to_paper_size = false;
+  if (!job_settings.GetBoolean(printing::kSettingFitToPageEnabled,
+                               &fit_to_paper_size)) {
+    NOTREACHED();
+  }
+  return fit_to_paper_size;
+}
+
 // Get the (x, y) coordinate from where printing of the current text should
 // start depending on the horizontal alignment (LEFT, RIGHT, CENTER) and
 // vertical alignment (TOP, BOTTOM).
 SkPoint GetHeaderFooterPosition(
     float webkit_scale_factor,
     const PageSizeMargins& page_layout,
     printing::HorizontalHeaderFooterPosition horizontal_position,
     printing::VerticalHeaderFooterPosition vertical_position,
     double offset_to_baseline,
     double text_width_in_points) {
@@ skipping 472 matching lines @@
 }
 
 bool PrintWebViewHelper::IsPrintToPdfRequested(
     const DictionaryValue& job_settings) {
   bool print_to_pdf = false;
   if (!job_settings.GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf))
     NOTREACHED();
   return print_to_pdf;
 }
 
+bool PrintWebViewHelper::IsFitToPaperSizeRequested(
+    bool source_is_html, const DictionaryValue& job_settings,
+    const PrintMsg_Print_Params& params) {
+  DCHECK(!print_for_preview_);
+
+  // Do not fit to paper size when the user is saving the print contents as pdf.
+  if (params.print_to_pdf)
+    return false;
+
+  if (!source_is_html) {
+    if (!FitToPageEnabled(job_settings))
+      return false;
+
+    // Get the print scaling option for the initiator renderer pdf.
+    bool print_scaling_disabled_for_plugin =
+        print_preview_context_.frame()->isPrintScalingDisabledForPlugin(
+            print_preview_context_.node());
+
+    // If this is the first preview request, UI doesn't know about the print
+    // scaling option of the plugin. Therefore, check the print scaling option
+    // and update the print params accordingly.
+    //
+    // If this is not the first preview request, update print params based on
+    // preview job settings.
+    if (params.is_first_request && print_scaling_disabled_for_plugin)
+      return false;
+  }
+  return true;
+}
+
 void PrintWebViewHelper::OnPrintPreview(const DictionaryValue& settings) {
   DCHECK(is_preview_enabled_);
   print_preview_context_.OnPrintPreview();
 
   if (!UpdatePrintSettings(print_preview_context_.frame(),
                            print_preview_context_.node(), settings)) {
     if (print_preview_context_.last_error() != PREVIEW_ERROR_BAD_SETTING) {
       Send(new PrintHostMsg_PrintPreviewInvalidPrinterSettings(
           routing_id(), print_pages_params_->params.document_cookie));
       notify_browser_of_print_failure_ = false;  // Already sent.
@@ skipping 14 matching lines @@
     preview_params.expected_pages_count =
         print_preview_context_.total_page_count();
     preview_params.modifiable = print_preview_context_.IsModifiable();
     preview_params.preview_request_id =
         print_pages_params_->params.preview_request_id;
 
     Send(new PrintHostMsg_MetafileReadyForPrinting(routing_id(),
                                                    preview_params));
     return;
   }
+
+  // If we are previewing a pdf and the print scaling is disabled, send a
+  // message to browser.
+  if (print_pages_params_->params.is_first_request &&
+      !print_preview_context_.IsModifiable() &&
+      print_preview_context_.frame()->isPrintScalingDisabledForPlugin(
+          print_preview_context_.node())) {
+    Send(new PrintHostMsg_PrintPreviewScalingDisabled(routing_id()));
+  }
+
   // Always clear |old_print_pages_params_| before rendering the pages.
   old_print_pages_params_.reset();
   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(printing::kSettingGenerateDraftData,
                            &generate_draft_pages)) {
@@ skipping 422 matching lines @@
       NOTREACHED();
     }
   } else {
     source_is_html = !PrintingNodeOrPdfFrame(frame, node);
   }
 
   if (print_for_preview_ || !source_is_html) {
     modified_job_settings.MergeDictionary(job_settings);
     modified_job_settings.SetBoolean(printing::kSettingHeaderFooterEnabled,
                                      false);
-
-    // - On Windows, we don't add a margin until we turn it into an EMF when
-    //   printing for print preview (We could add it in the plugin).
-    // - On Mac with Skia, we don't add a margin until we send it to the printer
-    //   using the CG PDF class (We could add it in the plugin).
-    // - On Mac with CG, we can add a margin when generating the preview.
-    // - On Linux, we never add a margin (We Could add it in the plugin).
-#if defined(OS_MACOSX) && !defined(USE_SKIA)
-    bool get_margins_from_pdf = !source_is_html && !print_for_preview_;
-#elif defined(OS_WIN) || defined(OS_MACOSX)
-    bool get_margins_from_pdf = !source_is_html && print_for_preview_;
-#else
-    bool get_margins_from_pdf = false;
-#endif
-
-    printing::MarginType margin_type = printing::NO_MARGINS;
-    if (get_margins_from_pdf)
-      margin_type = GetMarginsForPdf(frame, node);
     modified_job_settings.SetInteger(printing::kSettingMarginsType,
-                                     margin_type);
+                                     printing::NO_MARGINS);
     job_settings = &modified_job_settings;
   }
 
   // Send the cookie so that UpdatePrintSettings can reuse PrinterQuery when
   // possible.
   int cookie = print_pages_params_.get() ?
       print_pages_params_->params.document_cookie : 0;
   PrintMsg_PrintPages_Params settings;
   Send(new PrintHostMsg_UpdatePrintSettings(routing_id(),
       cookie, *job_settings, &settings));
@@ skipping 30 matching lines @@
         !job_settings->GetInteger(printing::kPreviewRequestID,
                                   &(settings.params.preview_request_id)) ||
         !job_settings->GetBoolean(printing::kIsFirstRequest,
                                   &(settings.params.is_first_request))) {
       NOTREACHED();
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
       return false;
     }
 
     settings.params.print_to_pdf = IsPrintToPdfRequested(*job_settings);
+    settings.params.fit_to_paper_size = IsFitToPaperSizeRequested(
+        source_is_html, *job_settings, settings.params);
     UpdateFrameMarginsCssInfo(*job_settings);
 
-    // Fit to paper size.
-    settings.params.fit_to_paper_size = source_is_html &&
-                                        !IsPrintToPdfRequested(*job_settings);
-
     // Header/Footer: Set |header_footer_info_|.
     if (settings.params.display_header_footer) {
       header_footer_info_.reset(new DictionaryValue());
       header_footer_info_->SetString(printing::kSettingHeaderFooterDate,
                                      settings.params.date);
       header_footer_info_->SetString(printing::kSettingHeaderFooterURL,
                                      settings.params.url);
       header_footer_info_->SetString(printing::kSettingHeaderFooterTitle,
                                      settings.params.title);
     }
@@ skipping 19 matching lines @@
   params.cookie = print_pages_params_->params.document_cookie;
   params.has_selection = frame->hasSelection();
   params.expected_pages_count = expected_pages_count;
   printing::MarginType margin_type = printing::DEFAULT_MARGINS;
   if (PrintingNodeOrPdfFrame(frame, node))
     margin_type = GetMarginsForPdf(frame, node);
   params.margin_type = margin_type;
 
   Send(new PrintHostMsg_DidShowPrintDialog(routing_id()));
 
+  // Store the calculated fit_to_paper_size value.
+  bool fit_to_paper_size = print_pages_params_->params.fit_to_paper_size;
+
   print_pages_params_.reset();
   IPC::SyncMessage* msg =
       new PrintHostMsg_ScriptedPrint(routing_id(), params, &print_settings);
   msg->EnableMessagePumping();
   Send(msg);
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(print_settings));
+  print_pages_params_->params.fit_to_paper_size = fit_to_paper_size;

[kmadhusu, 2012/05/06 20:10:15]

While testing the native printing workflow, I found that the new code failed to
honor the html print css, that's because we are getting a new print settings
(with fit_to_paper_size value set to false) from the print dialog. So I need to
restore the calculated fit to paper size value in the new print params.

[Lei Zhang, 2012/05/07 18:54:05]

You may want to add a comment here to explain that.

[kmadhusu, 2012/05/16 18:45:11]

Done.

   return (print_settings.params.dpi && print_settings.params.document_cookie);
 }
 
 bool PrintWebViewHelper::RenderPagesForPrint(
     WebKit::WebFrame* frame,
     const WebKit::WebNode& node) {
   if (print_pages_params_->params.selection_only)
     return CopyAndPrint(frame);
   return PrintPages(frame, node);
 }
@@ skipping 377 matching lines @@
   DCHECK(IsRendering());
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }