[Print Preview] Modified PrepareFrameAndViewPrint class to call the new printBegin function to supp…

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 15 matching lines @@
 #include "printing/units.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCanvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPlugin.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebPrintScalingOption.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSize.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 #include "webkit/glue/webpreferences.h"
 
 #if defined(OS_POSIX)
 #include "base/process_util.h"
 #endif
@@ skipping 83 matching lines @@
     const PrintMsg_PrintPages_Params& oldParams,
     const PrintMsg_PrintPages_Params& newParams) {
   return PageLayoutIsEqual(oldParams, newParams) &&
          oldParams.params.max_shrink == newParams.params.max_shrink &&
          oldParams.params.min_shrink == newParams.params.min_shrink &&
          oldParams.params.selection_only == newParams.params.selection_only &&
          oldParams.params.supports_alpha_blend ==
              newParams.params.supports_alpha_blend &&
          oldParams.pages.size() == newParams.pages.size() &&
          oldParams.params.print_to_pdf == newParams.params.print_to_pdf &&
-         oldParams.params.fit_to_paper_size ==
-             newParams.params.fit_to_paper_size &&
+         oldParams.params.print_scaling_option ==
+             newParams.params.print_scaling_option &&
          oldParams.params.display_header_footer ==
              newParams.params.display_header_footer &&
          oldParams.params.date == newParams.params.date &&
          oldParams.params.title == newParams.params.title &&
          oldParams.params.url == newParams.params.url &&
          std::equal(oldParams.pages.begin(), oldParams.pages.end(),
              newParams.pages.begin());
 }
 
 PrintMsg_Print_Params GetCssPrintParams(
@@ skipping 147 matching lines @@
   // Swap the |width| and |height| values.
   page_params->page_size.SetSize(page_params->page_size.height(),
                                  page_params->page_size.width());
   page_params->content_size.SetSize(page_params->content_size.height(),
                                     page_params->content_size.width());
   page_params->printable_area.set_size(
       gfx::Size(page_params->printable_area.height(),
                 page_params->printable_area.width()));
 }
 
-void CalculatePrintCanvasSize(const PrintMsg_Print_Params& print_params,
-                              gfx::Size* result) {
+void ComputePrintParamsInDesiredDpi(const PrintMsg_Print_Params& print_params,
+                                    WebKit::WebRect* content_size,
+                                    WebKit::WebRect* printable_area,
+                                    WebKit::WebSize* paper_size) {
   int dpi = GetDPI(&print_params);
-  result->set_width(ConvertUnit(print_params.content_size.width(), dpi,
-                                print_params.desired_dpi));
+  content_size->width = ConvertUnit(print_params.content_size.width(), dpi,
+                                   print_params.desired_dpi);
 
-  result->set_height(ConvertUnit(print_params.content_size.height(), dpi,
-                                 print_params.desired_dpi));
+  content_size->height = ConvertUnit(print_params.content_size.height(), dpi,
+                                    print_params.desired_dpi);
+
+  printable_area->x = ConvertUnit(print_params.printable_area.x(), dpi,
+                                  print_params.desired_dpi);
+  printable_area->y = ConvertUnit(print_params.printable_area.y(), dpi,
+                                  print_params.desired_dpi);
+  printable_area->width = ConvertUnit(print_params.printable_area.width(), dpi,
+                                      print_params.desired_dpi);
+  printable_area->height = ConvertUnit(print_params.printable_area.height(),
+                                       dpi, print_params.desired_dpi);
+  paper_size->width = ConvertUnit(print_params.page_size.width(), dpi,
+                                 print_params.desired_dpi);
+  paper_size->height = ConvertUnit(print_params.page_size.height(), dpi,
+                                   print_params.desired_dpi);
 }
 
 bool PrintingNodeOrPdfFrame(const WebFrame* frame, const WebNode& node) {
   if (!node.isNull())
     return true;
   if (!frame->document().isPluginDocument())
     return false;
   WebPlugin* plugin = frame->document().to<WebPluginDocument>().plugin();
   return plugin && plugin->supportsPaginatedPrint();
 }
@@ skipping 11 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 309 matching lines @@
 #endif
 }
 
 PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
     const PrintMsg_Print_Params& print_params,
     WebFrame* frame,
     const WebNode& node)
         : frame_(frame),
           node_to_print_(node),
           web_view_(frame->view()),
-          dpi_(static_cast<int>(print_params.dpi)),
           expected_pages_count_(0),
           use_browser_overlays_(true),
           finished_(false) {
-  gfx::Size canvas_size;
-  CalculatePrintCanvasSize(print_params, &canvas_size);
+  WebKit::WebRect canvas_area;
+  WebKit::WebRect printable_area;
+  WebKit::WebSize paper_size;
+  ComputePrintParamsInDesiredDpi(print_params, &canvas_area, &printable_area,
+                                 &paper_size);
 
   if (WebFrame* web_frame = web_view_->mainFrame())
     prev_scroll_offset_ = web_frame->scrollOffset();
   prev_view_size_ = web_view_->size();
 
-  StartPrinting(canvas_size);
+  StartPrinting(canvas_area, printable_area, paper_size,
+                static_cast<int>(print_params.dpi),
+                print_params.print_scaling_option);
 }
 
 PrepareFrameAndViewForPrint::~PrepareFrameAndViewForPrint() {
   FinishPrinting();
 }
 
 void PrepareFrameAndViewForPrint::UpdatePrintParams(
     const PrintMsg_Print_Params& print_params) {
   DCHECK(!finished_);
-  gfx::Size canvas_size;
-  CalculatePrintCanvasSize(print_params, &canvas_size);
-  if (canvas_size == print_canvas_size_)
+  WebKit::WebRect canvas_area;
+  WebKit::WebRect printable_area;
+  WebKit::WebSize paper_size;
+  ComputePrintParamsInDesiredDpi(print_params, &canvas_area, &printable_area,
+                                 &paper_size);
+  if (canvas_area == web_print_params_.printContentArea &&
+      printable_area == web_print_params_.printableArea &&
+      paper_size == web_print_params_.paperSize &&
+      print_params.print_scaling_option ==
+          web_print_params_.printScalingOption) {
     return;
+  }
 
   frame_->printEnd();
-  dpi_ = static_cast<int>(print_params.dpi);
-  StartPrinting(canvas_size);
+  StartPrinting(canvas_area, printable_area, paper_size,
+                static_cast<int>(print_params.dpi),
+                print_params.print_scaling_option);
 }
 
 void PrepareFrameAndViewForPrint::StartPrinting(

[vandebo (ex-Chrome), 2012/05/14 17:45:46]

It looks like this should take a web print params.  If that's so, then
ComputePrintParamsInDesiredDpi probably should fill out one of those too.

[kmadhusu, 2012/05/14 18:50:43]

Done.

-    const gfx::Size& print_canvas_size) {
-  print_canvas_size_ = print_canvas_size;
+    const WebKit::WebRect& print_canvas_area,
+    const WebKit::WebRect& printable_area,
+    const WebKit::WebSize& paper_size,
+    int dpi,
+    const WebKit::WebPrintScalingOption& scaling_option) {
+  web_print_params_.printContentArea = print_canvas_area;
+  web_print_params_.printableArea = printable_area;
+  web_print_params_.paperSize = paper_size;
+  web_print_params_.printerDPI = dpi;
+  web_print_params_.printScalingOption = scaling_option;
 
   // Layout page according to printer page size. Since WebKit shrinks the
   // size of the page automatically (from 125% to 200%) we trick it to
   // think the page is 125% larger so the size of the page is correct for
   // minimum (default) scaling.
   // This is important for sites that try to fill the page.
-  gfx::Size print_layout_size(print_canvas_size_);
+  gfx::Size print_layout_size(print_canvas_area.width,
+                              print_canvas_area.height);
   print_layout_size.set_height(static_cast<int>(
       static_cast<double>(print_layout_size.height()) * 1.25));
 
   web_view_->resize(print_layout_size);
 
-  expected_pages_count_ = frame_->printBegin(print_canvas_size_, node_to_print_,
-                                             dpi_, &use_browser_overlays_);
+  expected_pages_count_ = frame_->printBegin(web_print_params_,
+                                             node_to_print_,
+                                             &use_browser_overlays_);
 }
 
 void PrepareFrameAndViewForPrint::FinishPrinting() {
   if (!finished_) {
     finished_ = true;
     frame_->printEnd();
     web_view_->resize(prev_view_size_);
     if (WebFrame* web_frame = web_view_->mainFrame())
       web_frame->setScrollOffset(prev_scroll_offset_);
   }
@@ skipping 161 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;
 }
 
+WebKit::WebPrintScalingOption PrintWebViewHelper::GetPrintScalingOption(
+    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 WebKit::WebPrintScalingOptionSourceSize;
+
+  if (!source_is_html) {
+    if (!FitToPageEnabled(job_settings))
+      return WebKit::WebPrintScalingOptionNone;
+
+    // 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 WebKit::WebPrintScalingOptionNone;
+  }
+  return WebKit::WebPrintScalingOptionFitToPrintableArea;
+}
+
 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 361 matching lines @@
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::ComputePageLayoutInPointsForCss(
     WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& page_params,
     bool ignore_css_margins,
     double* scale_factor,
     PageSizeMargins* page_layout_in_points) {
   PrintMsg_Print_Params params = CalculatePrintParamsForCss(
       frame, page_index, page_params, ignore_css_margins,
-      page_params.fit_to_paper_size, scale_factor);
+      page_params.print_scaling_option ==
+          WebKit::WebPrintScalingOptionFitToPrintableArea,
+      scale_factor);
   CalculatePageLayoutFromPrintParams(params, page_layout_in_points);
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::UpdateFrameAndViewFromCssPageLayout(
     WebFrame* frame,
     const WebNode& node,
     PrepareFrameAndViewForPrint* prepare,
     const PrintMsg_Print_Params& params,
     bool ignore_css_margins) {
   if (PrintingNodeOrPdfFrame(frame, node))
     return;
   PrintMsg_Print_Params print_params = CalculatePrintParamsForCss(
       frame, 0, params, ignore_css_margins,
-      ignore_css_margins && params.fit_to_paper_size, NULL);
+      ignore_css_margins &&
+          params.print_scaling_option ==
+              WebKit::WebPrintScalingOptionFitToPrintableArea,
+      NULL);
   prepare->UpdatePrintParams(print_params);
 }
 
-bool PrintWebViewHelper::InitPrintSettings() {
+bool PrintWebViewHelper::InitPrintSettings(bool fit_to_paper_size) {
   PrintMsg_PrintPages_Params settings;
   Send(new PrintHostMsg_GetDefaultPrintSettings(routing_id(),
                                                 &settings.params));
   // Check if the printer returned any settings, if the settings is empty, we
   // can safely assume there are no printer drivers configured. So we safely
   // terminate.
   bool result = true;
   if (!PrintMsg_Print_Params_IsValid(settings.params))
     result = false;
 
   if (result &&
       (settings.params.dpi < kMinDpi || settings.params.document_cookie == 0)) {
     // Invalid print page settings.
     NOTREACHED();
     result = false;
   }
 
   // Reset to default values.
   ignore_css_margins_ = false;
-  settings.params.fit_to_paper_size = true;
   settings.pages.clear();
+  settings.params.print_scaling_option = fit_to_paper_size ?
+      WebKit::WebPrintScalingOptionFitToPrintableArea :
+      WebKit::WebPrintScalingOptionSourceSize;
 
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
   return result;
 }
 
 bool PrintWebViewHelper::InitPrintSettingsAndPrepareFrame(
     WebKit::WebFrame* frame, const WebKit::WebNode& node,
     scoped_ptr<PrepareFrameAndViewForPrint>* prepare) {
   DCHECK(frame);
-  if (!InitPrintSettings()) {
+
+  // If the source is html, fit to paper size else print the source pdf size.
+  bool fit_to_paper_size = !(PrintingNodeOrPdfFrame(frame, node));
+  if (!InitPrintSettings(fit_to_paper_size)) {
     notify_browser_of_print_failure_ = false;
     render_view()->RunModalAlertDialog(
         frame,
         l10n_util::GetStringUTF16(IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
     return false;
   }
 
   DCHECK(!prepare->get());
   prepare->reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
                                                  frame, node));
@@ skipping 95 matching lines @@
                                   &(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);
     UpdateFrameMarginsCssInfo(*job_settings);
-
-    // Fit to paper size.
-    settings.params.fit_to_paper_size = source_is_html &&
-                                        !IsPrintToPdfRequested(*job_settings);
+    settings.params.print_scaling_option = GetPrintScalingOption(
+        source_is_html, *job_settings, settings.params);
 
     // 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 20 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 print scaling option value.
+  WebKit::WebPrintScalingOption scaling_option =
+      print_pages_params_->params.print_scaling_option;
   print_pages_params_.reset();
   IPC::SyncMessage* msg =
       new PrintHostMsg_ScriptedPrint(routing_id(), params, &print_settings);
   msg->EnableMessagePumping();
   Send(msg);
+
+  // When we get new |print_settings| from native print dialog we will have
+  // |print_scaling_option| value set to
+  // WebKit::WebPrintScalingOptionSourceSize. So we should restore the
+  // calculated value in new |print_settings|.
+  print_settings.params.print_scaling_option = scaling_option;
+
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(print_settings));
   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 366 matching lines @@
 const PrintMsg_Print_Params&
 PrintWebViewHelper::PrintPreviewContext::print_params() const {
   DCHECK(state_ != UNINITIALIZED);
   return *print_params_;
 }
 
 int PrintWebViewHelper::PrintPreviewContext::last_error() const {
   return error_;
 }
 
-const gfx::Size&
-PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
+gfx::Size PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
   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;
 }