[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"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/print_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "grit/generated_resources.h"
 #include "printing/metafile_impl.h"
 #include "printing/page_size_margins.h"
 #include "printing/print_job_constants.h"
 #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/platform/WebSize.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/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/platform/WebSize.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/WebPrintScalingOption.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
 
 #if defined(USE_SKIA)
@@ skipping 22 matching lines @@
 using printing::ConvertUnitDouble;
 using printing::GetHeaderFooterSegmentWidth;
 using printing::PageSizeMargins;
 using WebKit::WebConsoleMessage;
 using WebKit::WebDocument;
 using WebKit::WebElement;
 using WebKit::WebFrame;
 using WebKit::WebNode;
 using WebKit::WebPlugin;
 using WebKit::WebPluginDocument;
+using WebKit::WebPrintParams;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebURLRequest;
 using WebKit::WebView;
 
 namespace {
 
 #if defined(USE_SKIA)
 typedef SkPaint HeaderFooterPaint;
 #elif defined(OS_MACOSX)
@@ skipping 39 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 ComputeWebKitPrintParamsInDesiredDpi(
+    const PrintMsg_Print_Params& print_params,
+    WebPrintParams* webkit_print_params) {
   int dpi = GetDPI(&print_params);
-  result->set_width(ConvertUnit(print_params.content_size.width(), dpi,
-                                print_params.desired_dpi));
+  webkit_print_params->printerDPI = dpi;
+  webkit_print_params->printScalingOption = print_params.print_scaling_option;
 
-  result->set_height(ConvertUnit(print_params.content_size.height(), dpi,
-                                 print_params.desired_dpi));
+  webkit_print_params->printContentArea.width =
+      ConvertUnit(print_params.content_size.width(), dpi,
+                  print_params.desired_dpi);
+  webkit_print_params->printContentArea.height =
+      ConvertUnit(print_params.content_size.height(), dpi,
+                  print_params.desired_dpi);
+
+  webkit_print_params->printableArea.x =
+      ConvertUnit(print_params.printable_area.x(), dpi,
+                  print_params.desired_dpi);
+  webkit_print_params->printableArea.y =
+      ConvertUnit(print_params.printable_area.y(), dpi,
+                  print_params.desired_dpi);
+  webkit_print_params->printableArea.width =
+      ConvertUnit(print_params.printable_area.width(), dpi,
+                  print_params.desired_dpi);
+  webkit_print_params->printableArea.height =
+      ConvertUnit(print_params.printable_area.height(),
+                  dpi, print_params.desired_dpi);
+
+  webkit_print_params->paperSize.width =
+      ConvertUnit(print_params.page_size.width(), dpi,
+                  print_params.desired_dpi);
+  webkit_print_params->paperSize.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 345 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);
+  WebPrintParams webkit_print_params;
+  ComputeWebKitPrintParamsInDesiredDpi(print_params, &webkit_print_params);
 
   if (WebFrame* web_frame = web_view_->mainFrame())
     prev_scroll_offset_ = web_frame->scrollOffset();
   prev_view_size_ = web_view_->size();
 
-  StartPrinting(canvas_size);
+  StartPrinting(webkit_print_params);
 }
 
 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_)
+  WebPrintParams webkit_print_params;
+  ComputeWebKitPrintParamsInDesiredDpi(print_params, &webkit_print_params);
+
+  if (webkit_print_params.printContentArea ==
+          web_print_params_.printContentArea &&
+      webkit_print_params.printableArea == web_print_params_.printableArea &&
+      webkit_print_params.paperSize == web_print_params_.paperSize &&
+      webkit_print_params.printScalingOption ==
+          web_print_params_.printScalingOption) {
     return;
+  }
 
   frame_->printEnd();
-  dpi_ = static_cast<int>(print_params.dpi);
-  StartPrinting(canvas_size);
+  StartPrinting(webkit_print_params);
 }
 
 void PrepareFrameAndViewForPrint::StartPrinting(
-    const gfx::Size& print_canvas_size) {
-  print_canvas_size_ = print_canvas_size;
+    const WebPrintParams& webkit_print_params) {
+  web_print_params_ = webkit_print_params;
 
   // 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(web_print_params_.printContentArea.width,
+                              web_print_params_.printContentArea.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;
 }
 
-bool PrintWebViewHelper::IsFitToPaperSizeRequested(
+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 false;
+    return WebKit::WebPrintScalingOptionSourceSize;
 
   if (!source_is_html) {
     if (!FitToPageEnabled(job_settings))
-      return false;
+      return WebKit::WebPrintScalingOptionNone;
 
-    // Get the print scaling option for the initiator renderer pdf.
-    bool print_scaling_disabled_for_plugin =
+    bool no_plugin_scaling =
         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;
+    if (params.is_first_request && no_plugin_scaling)
+      return WebKit::WebPrintScalingOptionNone;
   }
-  return true;
+  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(
@@ skipping 373 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;
+  bool fit_to_page = ignore_css_margins &&
+                     params.print_scaling_option ==
+                          WebKit::WebPrintScalingOptionFitToPrintableArea;
   PrintMsg_Print_Params print_params = CalculatePrintParamsForCss(
-      frame, 0, params, ignore_css_margins,
-      ignore_css_margins && params.fit_to_paper_size, NULL);
+      frame, 0, params, ignore_css_margins, fit_to_page, 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 =
+      WebKit::WebPrintScalingOptionSourceSize;
+  if (fit_to_paper_size) {
+    settings.params.print_scaling_option =
+        WebKit::WebPrintScalingOptionFitToPrintableArea;
+  }
+
   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()) {
+
+  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 76 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(
+    UpdateFrameMarginsCssInfo(*job_settings);
+    settings.params.print_scaling_option = GetPrintScalingOption(
         source_is_html, *job_settings, settings.params);
-    UpdateFrameMarginsCssInfo(*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 22 matching lines @@
   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()));
 
   // PrintHostMsg_ScriptedPrint will reset print_scaling_option, so we save the
   // value before and restore it afterwards.
-  bool fit_to_paper_size = print_pages_params_->params.fit_to_paper_size;
+  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);
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(print_settings));
 
-  print_pages_params_->params.fit_to_paper_size = fit_to_paper_size;
+  print_pages_params_->params.print_scaling_option = scaling_option;
   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 365 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;
 }