Reuse PrintContext to excessively triggering matchMedia('print') listeners.

chrome/renderer/print_web_view_helper.cc

 // Copyright (c) 2011 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/command_line.h"
 #include "base/logging.h"
@@ skipping 410 matching lines @@
   device->setDrawingArea(SkPDFDevice::kContent_DrawingArea);
 #endif
 }
 
 PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
     const PrintMsg_Print_Params& print_params,
     WebFrame* frame,
     WebNode* node)
         : frame_(frame),
           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);
 
   if (WebFrame* web_frame = web_view_->mainFrame())
     prev_scroll_offset_ = web_frame->scrollOffset();
   prev_view_size_ = web_view_->size();
 
+  WebKit::WebNode node_to_print;
   if (node)
-    node_to_print_ = *node;
+    node_to_print = *node;
 
-  StartPrinting(canvas_size);
+  frame_->printBegin(node_to_print);
+  StartPrinting(canvas_size, static_cast<int>(print_params.dpi));
 }
 
 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_)
     return;
 
-  frame_->printEnd();
-  dpi_ = static_cast<int>(print_params.dpi);
-  StartPrinting(canvas_size);
+  StartPrinting(canvas_size, static_cast<int>(print_params.dpi));
+}
+
+bool PrepareFrameAndViewForPrint::ShouldUseBrowserOverlays() const
+{
+    return frame_->shouldUseBrowserOverlays();
 }
 
 void PrepareFrameAndViewForPrint::StartPrinting(
-    const gfx::Size& print_canvas_size) {
+    const gfx::Size& print_canvas_size,
+    int dpi) {
   print_canvas_size_ = print_canvas_size;
 
   // 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_);
   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_->setPageSizeResolution(print_canvas_size_, dpi);
 }
 
 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 315 matching lines @@
   if (!InitPrintSettingsAndPrepareFrame(frame, node, &prepare))
     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();

[vandebo (ex-Chrome), 2011/10/24 20:53:47]

I think the reason this is done is not to make sure that the prepare is updated
with new settings, but to make the source page responsive while the print dialog
is displayed. IIRC, while the print dialog is displayed, there's a nested
message loop, so if the page gets resized it will reflow and without the
prepare.reset(), it will be set to the print size and aspect ratio.

[dominicc (has gone to gerrit), 2011/10/25 04:44:39]

Is that platform-specific, or specific to the new print preview page? Because on
Mac I get a modal dialog.

[Lei Zhang, 2011/10/25 06:40:22]

Unless you changed things in about:flags, in M15+ print preview is turned on
everywhere, but you can still access the native print dialog via ctrl+shift+p.

[vandebo (ex-Chrome), 2011/10/25 17:03:11]

As Lei noted, this code path is only used for the native print flow - follow the
link from the print preview tab or ctrl-shift-p.  This code path is used on all
platforms and what has been in Chrome for years.

-
   // Some full screen plugins can say they don't want to print.
   if (!expected_page_count) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Ask the browser to show UI to retrieve the final print settings.
   if (!GetPrintSettingsFromUser(frame, expected_page_count,
                                 use_browser_overlays)) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Render Pages for printing.
-  if (!RenderPagesForPrint(frame, node, NULL)) {
+  if (!RenderPagesForPrint(frame, node, prepare.get())) {

[Lei Zhang, 2011/09/22 21:48:30]

Not sure if this is right. If you use the |prepare| from
InitPrintSettingsAndPrepareFrame(), you are going to be using the default
settings in |print_pages_params_| from there and not the new settings generated
in GetPrintSettingsFromUser().

[dominicc (has gone to gerrit), 2011/10/24 08:45:13]

This code is quite twisty, but don’t the settings get updated via:

GetPrintSettingsFromUser updates print_pages_params_
RenderPagesForPrint passes print_pages_params_ to PrintPages
UpdatePrintableSizeInPrintParameters updates the existing "prepare"

     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
   ResetScriptedPrintCount();
 }
 
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   bool store_print_pages_params = true;
   if (result == FAIL_PRINT) {
     DisplayPrintJobError();
@@ skipping 703 matching lines @@
 PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }