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 354 matching lines @@
 #if defined(USE_SKIA)
   device->setDrawingArea(SkPDFDevice::kContent_DrawingArea);
 #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);
 
   if (WebFrame* web_frame = web_view_->mainFrame())
     prev_scroll_offset_ = web_frame->scrollOffset();
   prev_view_size_ = web_view_->size();
 
-  StartPrinting(canvas_size);
+  frame_->printBegin(node);
+  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_)
+  int dpi = static_cast<int>(print_params.dpi);
+  if (canvas_size == print_canvas_size_ && dpi == dpi_)
     return;
 
-  frame_->printEnd();
-  dpi_ = static_cast<int>(print_params.dpi);
-  StartPrinting(canvas_size);
+  StartPrinting(canvas_size, 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;
+  dpi_ = dpi;
 
   // 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 306 matching lines @@
     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(OK);  // Release resources and fail silently.
     return;
   }
 
   // Ask the browser to show UI to retrieve the final print settings.
   if (!GetPrintSettingsFromUser(frame, node, 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())) {
     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 786 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;
 }