Async frame preparation for Preview with support if selection.

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 483 matching lines @@
   void CopySelectionIfNeeded(const webkit_glue::WebPreferences& preferences,
                              const base::Closure& on_ready);
 
   // Prepares frame for printing.
   void StartPrinting();
 
   WebKit::WebFrame* frame() const {
     return frame_;
   }
 
-  WebKit::WebNode node() const {
+  const WebKit::WebNode& node() const {
     return node_to_print_;
   }
 
   int GetExpectedPageCount() const {
     return expected_pages_count_;
   }
 
   gfx::Size GetPrintCanvasSize() const;
 
   void FinishPrinting();
@@ skipping 12 matching lines @@
   WebKit::WebFrame* frame_;
   WebKit::WebNode node_to_print_;
   bool should_close_web_view_;
   WebKit::WebPrintParams web_print_params_;
   gfx::Size prev_view_size_;
   gfx::Size prev_scroll_offset_;
   int expected_pages_count_;
   base::Closure on_ready_;
   bool should_print_backgrounds_;
   bool should_print_selection_only_;
+  bool is_printing_started_;
 
   DISALLOW_COPY_AND_ASSIGN(PrepareFrameAndViewForPrint);
 };
 
 PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
     const PrintMsg_Print_Params& params,
     WebKit::WebFrame* frame,
     const WebKit::WebNode& node,
     bool ignore_css_margins)
     : weak_ptr_factory_(this),
       frame_(frame),
       node_to_print_(node),
       should_close_web_view_(false),
       expected_pages_count_(0),
       should_print_backgrounds_(params.should_print_backgrounds),
-      should_print_selection_only_(params.selection_only) {
+      should_print_selection_only_(params.selection_only),
+      is_printing_started_(false) {
   PrintMsg_Print_Params print_params = params;
   if (!should_print_selection_only_ ||
       !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);
   }
@@ skipping 25 matching lines @@
   if (WebKit::WebFrame* web_frame = web_view->mainFrame())
     prev_scroll_offset_ = web_frame->scrollOffset();
   prev_view_size_ = web_view->size();
 
   web_view->resize(print_layout_size);
   web_view->settings()->setShouldPrintBackgrounds(should_print_backgrounds_);
   // 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);
+  is_printing_started_ = true;
 }
 
 void PrepareFrameAndViewForPrint::CopySelectionIfNeeded(
     const webkit_glue::WebPreferences& preferences,
     const base::Closure& on_ready) {
   on_ready_ = on_ready;
   if (should_print_selection_only_)
     CopySelection(preferences);
   else
     didStopLoading();
@@ skipping 38 matching lines @@
   return on_ready_.Run();  // Can delete |this|.
 }
 
 gfx::Size PrepareFrameAndViewForPrint::GetPrintCanvasSize() const {
   return gfx::Size(web_print_params_.printContentArea.width,
                    web_print_params_.printContentArea.height);
 }
 
 void PrepareFrameAndViewForPrint::FinishPrinting() {
   if (frame_) {
-    frame_->printEnd();
+    if (is_printing_started_)
+      frame_->printEnd();
     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);
     if (should_close_web_view_)
       web_view->close();
   }
   frame_ = NULL;
   on_ready_.Reset();
@@ skipping 139 matching lines @@
   return true;
 }
 
 void PrintWebViewHelper::OnPrintPages() {
   WebKit::WebFrame* frame;
   if (GetPrintFrame(&frame))
     Print(frame, WebKit::WebNode());
 }
 
 void PrintWebViewHelper::OnPrintForSystemDialog() {
-  WebKit::WebFrame* frame = print_preview_context_.frame();
+  WebKit::WebFrame* frame = print_preview_context_.source_frame();
   if (!frame) {
     NOTREACHED();
     return;
   }
 
-  Print(frame, print_preview_context_.node());
+  Print(frame, print_preview_context_.source_node());
 }
 
 void PrintWebViewHelper::GetPageSizeAndContentAreaFromPageLayout(
     const PageSizeMargins& page_layout_in_points,
     gfx::Size* page_size,
     gfx::Rect* content_area) {
   *page_size = gfx::Size(
       page_layout_in_points.content_width +
           page_layout_in_points.margin_right +
           page_layout_in_points.margin_left,
@@ skipping 28 matching lines @@
   DCHECK(!print_for_preview_);
 
   if (params.print_to_pdf)
     return WebKit::WebPrintScalingOptionSourceSize;
 
   if (!source_is_html) {
     if (!FitToPageEnabled(job_settings))
       return WebKit::WebPrintScalingOptionNone;
 
     bool no_plugin_scaling =
-        print_preview_context_.frame()->isPrintScalingDisabledForPlugin(
-            print_preview_context_.node());
+        print_preview_context_.source_frame()->isPrintScalingDisabledForPlugin(
+            print_preview_context_.source_node());
 
     if (params.is_first_request && no_plugin_scaling)
       return WebKit::WebPrintScalingOptionNone;
   }
   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 (!UpdatePrintSettings(print_preview_context_.source_frame(),
+                           print_preview_context_.source_node(), settings)) {
     if (print_preview_context_.last_error() != PREVIEW_ERROR_BAD_SETTING) {
       Send(new PrintHostMsg_PrintPreviewInvalidPrinterSettings(
           routing_id(), print_pages_params_->params.document_cookie));
       notify_browser_of_print_failure_ = false;  // Already sent.
     }
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   if (!print_pages_params_->params.is_first_request &&
@@ skipping 13 matching lines @@
 
     Send(new PrintHostMsg_MetafileReadyForPrinting(routing_id(),
                                                    preview_params));
     return;
   }
 
   // If we are previewing a pdf and the print scaling is disabled, send a
   // message to browser.
   if (print_pages_params_->params.is_first_request &&
       !print_preview_context_.IsModifiable() &&
-      print_preview_context_.frame()->isPrintScalingDisabledForPlugin(
-          print_preview_context_.node())) {
+      print_preview_context_.source_frame()->isPrintScalingDisabledForPlugin(
+          print_preview_context_.source_node())) {
     Send(new PrintHostMsg_PrintPreviewScalingDisabled(routing_id()));
   }
 
   // Always clear |old_print_pages_params_| before rendering the pages.
   old_print_pages_params_.reset();
   is_print_ready_metafile_sent_ = false;
 
   // PDF printer device supports alpha blending.
   print_pages_params_->params.supports_alpha_blend = true;
 
   bool generate_draft_pages = false;
   if (!settings.GetBoolean(kSettingGenerateDraftData,
                            &generate_draft_pages)) {
     NOTREACHED();
   }
   print_preview_context_.set_generate_draft_pages(generate_draft_pages);
 
+  PrepareFrameForPreviewDocument();
+}
+
+void PrintWebViewHelper::PrepareFrameForPreviewDocument() {
+  const PrintMsg_Print_Params& print_params = print_pages_params_->params;
+
+  prep_frame_view_.reset(
+      new PrepareFrameAndViewForPrint(print_params,
+                                      print_preview_context_.source_frame(),
+                                      print_preview_context_.source_node(),
+                                      ignore_css_margins_));
+  prep_frame_view_->CopySelectionIfNeeded(
+      render_view()->GetWebkitPreferences(),
+      base::Bind(&PrintWebViewHelper::OnFramePreparedForPreviewDocument,
+                 base::Unretained(this)));
+}
+
+void PrintWebViewHelper::OnFramePreparedForPreviewDocument() {
   if (CreatePreviewDocument()) {
     DidFinishPrinting(OK);
   } else {
     if (notify_browser_of_print_failure_)
       LOG(ERROR) << "CreatePreviewDocument failed";
     DidFinishPrinting(FAIL_PREVIEW);
   }
 }
 
 bool PrintWebViewHelper::CreatePreviewDocument() {
+  if (CheckForCancel())
+    return false;
+
   const 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_)) {
+
+  if (!print_preview_context_.CreatePreviewDocument(prep_frame_view_.release(),
+                                                    pages)) {
     return false;
   }
 
   PageSizeMargins default_page_layout;
-  ComputePageLayoutInPointsForCss(print_preview_context_.frame(), 0,
+  ComputePageLayoutInPointsForCss(print_preview_context_.prepared_frame(), 0,
                                   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_.prepared_frame(),
         print_preview_context_.total_page_count());
     int dpi = GetDPI(&print_params);
 
     gfx::Rect printable_area_in_points(
         ConvertUnit(print_params.printable_area.x(), dpi, kPointsPerInch),
         ConvertUnit(print_params.printable_area.y(), dpi, kPointsPerInch),
         ConvertUnit(print_params.printable_area.width(), dpi, kPointsPerInch),
         ConvertUnit(print_params.printable_area.height(), dpi, kPointsPerInch));
 
     // Margins: Send default page layout to browser process.
@@ skipping 630 matching lines @@
   preview_page_params.data_size = buf_size;
   preview_page_params.page_number = page_number;
   preview_page_params.preview_request_id =
       print_pages_params_->params.preview_request_id;
 
   Send(new PrintHostMsg_DidPreviewPage(routing_id(), preview_page_params));
   return true;
 }
 
 PrintWebViewHelper::PrintPreviewContext::PrintPreviewContext()
-    : frame_(NULL),
+    : source_frame_(NULL),
       total_page_count_(0),
       current_page_index_(0),
       generate_draft_pages_(true),
       print_ready_metafile_page_count_(0),
       error_(PREVIEW_ERROR_NONE),
       state_(UNINITIALIZED) {
 }
 
 PrintWebViewHelper::PrintPreviewContext::~PrintPreviewContext() {
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithFrame(
     WebKit::WebFrame* web_frame) {
   DCHECK(web_frame);
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
-  frame_ = web_frame;
-  node_.reset();
+  source_frame_ = web_frame;
+  source_node_.reset();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithNode(
     const WebKit::WebNode& web_node) {
   DCHECK(!web_node.isNull());
   DCHECK(web_node.document().frame());
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
-  frame_ = web_node.document().frame();
-  node_ = web_node;
+  source_frame_ = web_node.document().frame();
+  source_node_ = web_node;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
   DCHECK_EQ(INITIALIZED, state_);
   ClearContext();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::CreatePreviewDocument(
-    const PrintMsg_Print_Params& print_params,
-    const std::vector<int>& pages,
-    bool ignore_css_margins) {
+    PrepareFrameAndViewForPrint* prepared_frame,
+    const std::vector<int>& pages) {
   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(),
-                                      ignore_css_margins));
+  prep_frame_view_.reset(prepared_frame);
   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;
   }
 
+  metafile_.reset(new PreviewMetafile);
+  if (!metafile_->Init()) {
+    set_error(PREVIEW_ERROR_METAFILE_INIT_FAILED);
+    LOG(ERROR) << "PreviewMetafile Init failed";
+    return false;
+  }
+
   int selected_page_count = pages.size();
   current_page_index_ = 0;
   print_ready_metafile_page_count_ = selected_page_count;
   pages_to_render_ = pages;
 
   if (selected_page_count == 0) {
     print_ready_metafile_page_count_ = total_page_count_;
     // Render all pages.
     for (int i = 0; i < total_page_count_; ++i)
       pages_to_render_.push_back(i);
@@ skipping 71 matching lines @@
     return -1;
   return pages_to_render_[current_page_index_++];
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsRendering() const {
   return state_ == RENDERING || state_ == DONE;
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsModifiable() const {
   // The only kind of node we can print right now is a PDF node.
-  return !PrintingNodeOrPdfFrame(frame_, node_);
+  return !PrintingNodeOrPdfFrame(source_frame_, source_node_);
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsLastPageOfPrintReadyMetafile()
     const {
   DCHECK(IsRendering());
   return current_page_index_ == print_ready_metafile_page_count_;
 }
 
 bool  PrintWebViewHelper::PrintPreviewContext::IsFinalPageRendered() const {
   DCHECK(IsRendering());
   return static_cast<size_t>(current_page_index_) == pages_to_render_.size();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::set_generate_draft_pages(
     bool generate_draft_pages) {
   DCHECK_EQ(INITIALIZED, state_);
   generate_draft_pages_ = generate_draft_pages;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::set_error(
     enum PrintPreviewErrorBuckets error) {
   error_ = error;
 }
 
-WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::frame() {
+WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::source_frame() {
   // TODO(thestig) turn this back into a DCHECK when http://crbug.com/118303 is
   // resolved.
   CHECK(state_ != UNINITIALIZED);
-  return frame_;
+  return source_frame_;
 }
 
-const WebKit::WebNode& PrintWebViewHelper::PrintPreviewContext::node() const {
+const WebKit::WebNode&
+    PrintWebViewHelper::PrintPreviewContext::source_node() const {
   DCHECK(state_ != UNINITIALIZED);
-  return node_;
+  return source_node_;
+}
+
+WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::prepared_frame() {
+  // TODO(thestig) turn this back into a DCHECK when http://crbug.com/118303 is
+  // resolved.
+  CHECK(state_ != UNINITIALIZED);
+  return prep_frame_view_->frame();
+}
+
+const WebKit::WebNode&
+    PrintWebViewHelper::PrintPreviewContext::prepared_node() const {
+  DCHECK(state_ != UNINITIALIZED);
+  return prep_frame_view_->node();
 }
 
 int PrintWebViewHelper::PrintPreviewContext::total_page_count() const {
   DCHECK(state_ != UNINITIALIZED);
   return total_page_count_;
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::generate_draft_pages() const {
   return generate_draft_pages_;
 }
@@ skipping 13 matching lines @@
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }
 
 }  // namespace printing