[Print Preview] Refactored code to support auto 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 111 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.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 514 matching lines @@
   }
 }
 
 PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       print_web_view_(NULL),
       is_preview_enabled_(IsPrintPreviewEnabled()),
       is_print_ready_metafile_sent_(false),
       ignore_css_margins_(false),
-      fit_to_page_(true),
       user_cancelled_scripted_print_count_(0),
       is_scripted_printing_blocked_(false),
       notify_browser_of_print_failure_(true),
       print_for_preview_(false) {
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(
     WebKit::WebFrame* frame) {
@@ skipping 203 matching lines @@
     if (notify_browser_of_print_failure_)
       LOG(ERROR) << "CreatePreviewDocument failed";
     DidFinishPrinting(FAIL_PREVIEW);
   }
 }
 
 bool PrintWebViewHelper::CreatePreviewDocument() {
   PrintMsg_Print_Params print_params = print_pages_params_->params;
   const std::vector<int>& pages = print_pages_params_->pages;
   if (!print_preview_context_.CreatePreviewDocument(&print_params, pages,
-                                                    ignore_css_margins_,
-                                                    fit_to_page_)) {
+                                                    ignore_css_margins_)) {
     return false;
   }
 
   PageSizeMargins default_page_layout;
   ComputePageLayoutInPointsForCss(print_preview_context_.frame(), 0,
-                                  print_params, ignore_css_margins_,
-                                  fit_to_page_, NULL, &default_page_layout);
+                                  print_params, ignore_css_margins_, NULL,
+                                  &default_page_layout);
 
   if (!old_print_pages_params_.get() ||
       !PageLayoutIsEqual(*old_print_pages_params_, *print_pages_params_)) {
     bool has_page_size_style = PrintingFrameHasPageSizeStyle(
         print_preview_context_.frame(),
         print_preview_context_.total_page_count());
     int dpi = GetDPI(&print_params);
     gfx::Rect printable_area_in_points(
       ConvertUnit(print_pages_params_->params.printable_area.x(),
           dpi, printing::kPointsPerInch),
@@ skipping 249 matching lines @@
 
   return true;
 }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
 bool PrintWebViewHelper::PrintPages(WebFrame* frame, const WebNode& node) {
   const PrintMsg_PrintPages_Params& params = *print_pages_params_;
   const PrintMsg_Print_Params& print_params = params.params;
   PrepareFrameAndViewForPrint prep_frame_view(print_params, frame, node);
   UpdateFrameAndViewFromCssPageLayout(frame, node, &prep_frame_view,
-                                      print_params, ignore_css_margins_,
-                                      fit_to_page_);
+                                      print_params, ignore_css_margins_);
 
   int page_count = prep_frame_view.GetExpectedPageCount();
   if (!page_count)
     return false;
   Send(new PrintHostMsg_DidGetPrintedPagesCount(routing_id(),
                                                 print_params.document_cookie,
                                                 page_count));
 
   const gfx::Size& canvas_size = prep_frame_view.GetPrintCanvasSize();
   PrintMsg_PrintPage_Params page_params;
@@ skipping 18 matching lines @@
 void PrintWebViewHelper::didStopLoading() {
   PrintPages(print_web_view_->mainFrame(), WebNode());
 }
 
 // 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,
-    bool fit_to_page,
     double* scale_factor,
     PageSizeMargins* page_layout_in_points) {
-  PrintMsg_Print_Params params = CalculatePrintParamsForCss(frame, page_index,
-                                                            page_params,
-                                                            ignore_css_margins,
-                                                            fit_to_page,
-                                                            scale_factor);
+  PrintMsg_Print_Params params = CalculatePrintParamsForCss(
+      frame, page_index, page_params, ignore_css_margins,
+      page_params.fit_to_paper_size, 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,
-    bool fit_to_page) {
+    bool ignore_css_margins) {
   if (PrintingNodeOrPdfFrame(frame, node))
     return;
   PrintMsg_Print_Params print_params = CalculatePrintParamsForCss(
-      frame, 0, params, ignore_css_margins, ignore_css_margins && fit_to_page,
-      NULL);
+      frame, 0, params, ignore_css_margins,
+      ignore_css_margins && params.fit_to_paper_size, NULL);
   prepare->UpdatePrintParams(print_params);
 }
 
 bool PrintWebViewHelper::InitPrintSettings() {
   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;
-  fit_to_page_ = true;
+  settings.params.fit_to_paper_size = true;
   settings.pages.clear();
 
   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()) {
     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));
   UpdateFrameAndViewFromCssPageLayout(frame, node, prepare->get(),
                                       print_pages_params_->params,
-                                      ignore_css_margins_, fit_to_page_);
+                                      ignore_css_margins_);
   Send(new PrintHostMsg_DidGetDocumentCookie(
         routing_id(), print_pages_params_->params.document_cookie));
   return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
     WebKit::WebFrame* frame, const WebKit::WebNode& node,
     const DictionaryValue& passed_job_settings) {
   DCHECK(is_preview_enabled_);
   const DictionaryValue* job_settings = &passed_job_settings;
@@ skipping 82 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_page_ = source_is_html && !IsPrintToPdfRequested(*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 233 matching lines @@
 }
 
 void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
   DCHECK_EQ(INITIALIZED, state_);
   ClearContext();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::CreatePreviewDocument(
     PrintMsg_Print_Params* print_params,
     const std::vector<int>& pages,
-    bool ignore_css_margins,
-    bool fit_to_page) {
+    bool ignore_css_margins) {
   DCHECK_EQ(INITIALIZED, state_);
   state_ = RENDERING;
 
   metafile_.reset(new printing::PreviewMetafile);
   if (!metafile_->Init()) {
     set_error(PREVIEW_ERROR_METAFILE_INIT_FAILED);
     LOG(ERROR) << "PreviewMetafile Init failed";
     return false;
   }
 
   // Need to make sure old object gets destroyed first.
   prep_frame_view_.reset(new PrepareFrameAndViewForPrint(*print_params, frame(),
                                                          node()));
   UpdateFrameAndViewFromCssPageLayout(frame_, node_, prep_frame_view_.get(),
-                                      *print_params, ignore_css_margins,
-                                      fit_to_page);
+                                      *print_params, ignore_css_margins);
 
   print_params_.reset(new PrintMsg_Print_Params(*print_params));
 
   total_page_count_ = prep_frame_view_->GetExpectedPageCount();
   if (total_page_count_ == 0) {
     LOG(ERROR) << "CreatePreviewDocument got 0 page count";
     set_error(PREVIEW_ERROR_ZERO_PAGES);
     return false;
   }
 
@@ skipping 154 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;
 }