Cleanup of PrepareFrameAndViewForPrint code.

chrome/renderer/printing/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/printing/print_web_view_helper.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 457 matching lines @@
                          content_area.size().width() / scale_factor,
                          content_area.size().height() / scale_factor));
     SkIRect clip_int_rect;
     clip_rect.roundOut(&clip_int_rect);
     SkRegion clip_region(clip_int_rect);
     canvas->setClipRegion(clip_region);
   }
   return frame->printPage(page_number, canvas);
 }
 
+// Class that calls the Begin and End print functions on the frame and changes
+// the size of the view temporarily to support full page printing..
+// Do not serve any events in the time between construction and destruction of
+// this class because it will cause flicker.
+class PrepareFrameAndViewForPrint {
+ public:
+  // Prints |frame|.  If |node| is not NULL, then only that node will be
+  // printed.
+   PrepareFrameAndViewForPrint(const PrintMsg_Print_Params& params,
+                               WebKit::WebFrame* frame,
+                               const WebKit::WebNode& node,
+                               bool ignore_css_margins);
+  ~PrepareFrameAndViewForPrint();
+
+  void StartPrinting();
+
+  int GetExpectedPageCount() const {
+    return expected_pages_count_;
+  }
+
+  gfx::Size GetPrintCanvasSize() const;
+
+  void FinishPrinting();
+
+ private:
+  WebKit::WebFrame* frame_;
+  WebKit::WebNode node_to_print_;
+  WebKit::WebPrintParams web_print_params_;
+  gfx::Size prev_view_size_;
+  gfx::Size prev_scroll_offset_;
+  int expected_pages_count_;
+  bool should_print_backgrounds_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrepareFrameAndViewForPrint);
+};
+
+
 PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
-    const PrintMsg_Print_Params& print_params,
+    const PrintMsg_Print_Params& params,
     WebKit::WebFrame* frame,
-    const WebKit::WebNode& node)
-        : frame_(frame),
-          node_to_print_(node),
-          web_view_(frame->view()),
-          expected_pages_count_(0),
-          use_browser_overlays_(true),
-          finished_(false),
-          should_print_backgrounds_(print_params.should_print_backgrounds) {
-  WebKit::WebPrintParams webkit_print_params;
-  ComputeWebKitPrintParamsInDesiredDpi(print_params, &webkit_print_params);
+    const WebKit::WebNode& node,
+    bool ignore_css_margins)
+    : frame_(frame),
+      node_to_print_(node),
+      expected_pages_count_(0),
+      should_print_backgrounds_(params.should_print_backgrounds) {
+  PrintMsg_Print_Params print_params = params;
 
-  if (WebKit::WebFrame* web_frame = web_view_->mainFrame())
+  if (WebKit::WebFrame* web_frame = frame->view()->mainFrame())
     prev_scroll_offset_ = web_frame->scrollOffset();
-  prev_view_size_ = web_view_->size();
+  prev_view_size_ = frame->view()->size();
 
-  StartPrinting(webkit_print_params);
+  if (!PrintingNodeOrPdfFrame(frame_, node_to_print_)) {
+    bool fit_to_page = ignore_css_margins &&
+                       print_params.print_scaling_option ==
+                            WebKit::WebPrintScalingOptionFitToPrintableArea;
+    print_params = CalculatePrintParamsForCss(frame_, 0, print_params,
+                                              ignore_css_margins, fit_to_page,
+                                              NULL);
+  }
+
+  ComputeWebKitPrintParamsInDesiredDpi(print_params, &web_print_params_);
 }
 
 PrepareFrameAndViewForPrint::~PrepareFrameAndViewForPrint() {
   FinishPrinting();
 }
 
-void PrepareFrameAndViewForPrint::UpdatePrintParams(
-    const PrintMsg_Print_Params& print_params) {
-  DCHECK(!finished_);
-  WebKit::WebPrintParams webkit_print_params;
-  ComputeWebKitPrintParamsInDesiredDpi(print_params, &webkit_print_params);
-
-  should_print_backgrounds_ = print_params.should_print_backgrounds;
-
-  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();
-  StartPrinting(webkit_print_params);
-}
-
-gfx::Size PrepareFrameAndViewForPrint::GetPrintCanvasSize() const {
-  return gfx::Size(web_print_params_.printContentArea.width,
-                   web_print_params_.printContentArea.height);
-}
-
-void PrepareFrameAndViewForPrint::StartPrinting(
-    const WebKit::WebPrintParams& webkit_print_params) {
-  web_print_params_ = webkit_print_params;
-
+void PrepareFrameAndViewForPrint::StartPrinting() {
   // 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(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);
+  WebKit::WebView* web_view = frame_->view();
+  web_view->resize(print_layout_size);
+  web_view->settings()->setShouldPrintBackgrounds(should_print_backgrounds_);
 
-  expected_pages_count_ = frame_->printBegin(web_print_params_,
-                                             node_to_print_,
-                                             &use_browser_overlays_);
+  // TODO(vitalybuka): Update call after
+  // https://bugs.webkit.org/show_bug.cgi?id=107718 is fixed.
+  expected_pages_count_ = frame_->printBegin(web_print_params_, node_to_print_,
+                                             NULL);
+}
 
-  web_view_->settings()->setShouldPrintBackgrounds(should_print_backgrounds_);
+gfx::Size PrepareFrameAndViewForPrint::GetPrintCanvasSize() const {
+  return gfx::Size(web_print_params_.printContentArea.width,
+                   web_print_params_.printContentArea.height);
 }
 
 void PrepareFrameAndViewForPrint::FinishPrinting() {
-  if (!finished_) {
-    finished_ = true;
+  if (frame_) {
     frame_->printEnd();
-    web_view_->resize(prev_view_size_);
-    if (WebKit::WebFrame* web_frame = web_view_->mainFrame())
+    WebKit::WebView* web_view = frame_->view();
+    web_view->resize(prev_view_size_);
+    if (WebKit::WebFrame* web_frame = web_view->mainFrame())
       web_frame->setScrollOffset(prev_scroll_offset_);
-    web_view_->settings()->setShouldPrintBackgrounds(false);
+    web_view->settings()->setShouldPrintBackgrounds(false);
   }
+  frame_ = NULL;
 }
 
 PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       print_web_view_(NULL),
       is_preview_enabled_(IsPrintPreviewEnabled()),
       is_scripted_print_throttling_disabled_(IsPrintThrottlingDisabled()),
       is_print_ready_metafile_sent_(false),
       ignore_css_margins_(false),
@@ skipping 431 matching lines @@
 
   print_node_in_progress_ = false;
 }
 
 void PrintWebViewHelper::Print(WebKit::WebFrame* frame,
                                const WebKit::WebNode& node) {
   // If still not finished with earlier print request simply ignore.
   if (print_web_view_)
     return;
 
-  // Initialize print settings.
-  scoped_ptr<PrepareFrameAndViewForPrint> prepare;
-  if (!InitPrintSettingsAndPrepareFrame(frame, node, &prepare)) {
+  int expected_page_count = 0;
+  if (!CalculateNumberOfPages(frame, node, &expected_page_count)) {
     DidFinishPrinting(FAIL_PRINT_INIT);
     return;  // Failed to init print page settings.
   }
 
-  int expected_page_count = 0;
-  bool use_browser_overlays = true;
-
-  expected_page_count = prepare->GetExpectedPageCount();
-  if (expected_page_count)
-    use_browser_overlays = prepare->ShouldUseBrowserOverlays();
-
-  // Release the prepare before going any further, since we are going to
-  // show UI and wait for the user.
-  prepare.reset();
-
   // Some full screen plugins can say they don't want to print.
   if (!expected_page_count) {
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
   // Ask the browser to show UI to retrieve the final print settings.
-  if (!GetPrintSettingsFromUser(frame, node, expected_page_count,
-                                use_browser_overlays)) {
+  if (!GetPrintSettingsFromUser(frame, node, expected_page_count)) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(frame, node)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
   ResetScriptedPrintCount();
@@ skipping 63 matching lines @@
   url_str.append(html);
   GURL url(url_str);
 
   // When loading is done this will call didStopLoading() and that will do the
   // actual printing.
   print_web_view_->mainFrame()->loadRequest(WebKit::WebURLRequest(url));
 
   return true;
 }
 
-#if defined(OS_MACOSX) || defined(OS_WIN)
 bool PrintWebViewHelper::PrintPages(WebKit::WebFrame* frame,
                                     const WebKit::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_);
+  PrepareFrameAndViewForPrint prep_frame_view(print_params, frame, node,
+                                              ignore_css_margins_);
+  prep_frame_view.StartPrinting();
 
   int page_count = prep_frame_view.GetExpectedPageCount();
   if (!page_count)
     return false;
+
+#if !defined(OS_CHROMEOS)
   // TODO(vitalybuka): should be page_count or valid pages from params.pages.
   // See http://crbug.com/161576
   Send(new PrintHostMsg_DidGetPrintedPagesCount(routing_id(),
                                                 print_params.document_cookie,
                                                 page_count));
+#endif
 
-  const gfx::Size& canvas_size = prep_frame_view.GetPrintCanvasSize();
+  return PrintPagesNative(frame, node, page_count,
+                          prep_frame_view.GetPrintCanvasSize());
+}
+
+#if defined(OS_MACOSX) || defined(OS_WIN)
+bool PrintWebViewHelper::PrintPagesNative(WebKit::WebFrame* frame,
+                                          const WebKit::WebNode& node,
+                                          int page_count,
+                                          const gfx::Size& canvas_size) {
+  const PrintMsg_PrintPages_Params& params = *print_pages_params_;
+  const PrintMsg_Print_Params& print_params = params.params;
+
   PrintMsg_PrintPage_Params page_params;
   page_params.params = print_params;
   if (params.pages.empty()) {
     for (int i = 0; i < page_count; ++i) {
       page_params.page_number = i;
       PrintPageInternal(page_params, canvas_size, frame);
     }
   } else {
     for (size_t i = 0; i < params.pages.size(); ++i) {
       if (params.pages[i] >= page_count)
         break;
       page_params.page_number = params.pages[i];
       PrintPageInternal(page_params, canvas_size, frame);
     }
   }
   return true;
 }
+
 #endif  // OS_MACOSX || OS_WIN
 
 void PrintWebViewHelper::didStopLoading() {
   PrintPages(print_web_view_->mainFrame(), WebKit::WebNode());
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::ComputePageLayoutInPointsForCss(
     WebKit::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.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(
-    WebKit::WebFrame* frame,
-    const WebKit::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, fit_to_page, NULL);
-  prepare->UpdatePrintParams(print_params);
-}
-
 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;
@@ skipping 13 matching lines @@
       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) {
+bool PrintWebViewHelper::CalculateNumberOfPages(WebKit::WebFrame* frame,
+                                                const WebKit::WebNode& node,
+                                                int* number_of_pages) {
   DCHECK(frame);
-
   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));
-  UpdateFrameAndViewFromCssPageLayout(frame, node, prepare->get(),
-                                      print_pages_params_->params,
-                                      ignore_css_margins_);
-  Send(new PrintHostMsg_DidGetDocumentCookie(
-        routing_id(), print_pages_params_->params.document_cookie));
+  const PrintMsg_Print_Params& params = print_pages_params_->params;
+  PrepareFrameAndViewForPrint prepare(params, frame, node, ignore_css_margins_);
+  prepare.StartPrinting();
+
+  Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
+                                             params.document_cookie));
+  *number_of_pages = prepare.GetExpectedPageCount();
   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;
   DictionaryValue modified_job_settings;
@@ skipping 84 matching lines @@
 
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
   Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
                                              settings.params.document_cookie));
 
   return true;
 }
 
 bool PrintWebViewHelper::GetPrintSettingsFromUser(WebKit::WebFrame* frame,
                                                   const WebKit::WebNode& node,
-                                                  int expected_pages_count,
-                                                  bool use_browser_overlays) {
+                                                  int expected_pages_count) {
   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);
   params.margin_type = margin_type;
@@ skipping 12 matching lines @@
   Send(msg);
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(print_settings));
 
   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)
+  if (print_pages_params_->params.selection_only) {
+    DCHECK(print_pages_params_->pages.empty());
     return CopyAndPrint(frame);
+  }
   return PrintPages(frame, node);
 }
 
 #if defined(OS_POSIX)
 bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
     Metafile* metafile,
     base::SharedMemoryHandle* shared_mem_handle) {
   uint32 buf_size = metafile->GetDataSize();
   scoped_ptr<base::SharedMemory> shared_buf(
       content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(
@@ skipping 182 matching lines @@
   DCHECK_EQ(INITIALIZED, state_);
   state_ = RENDERING;
 
   metafile_.reset(new 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);
+    // Need to make sure old object gets destroyed first.
+  prep_frame_view_.reset(
+      new PrepareFrameAndViewForPrint(print_params, frame(), node(),
+                                      ignore_css_margins));
+  prep_frame_view_->StartPrinting();
 
   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;
   }
 
   int selected_page_count = pages.size();
   current_page_index_ = 0;
@@ skipping 147 matching lines @@
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }
 
 }  // namespace printing