Print preview page selection should not require a rerendering of draft pages.

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 159 matching lines @@
     if (WebFrame* web_frame = web_view_->mainFrame())
       web_frame->setScrollOffset(prev_scroll_offset_);
   }
 }
 
 PrintWebViewHelper::PrintWebViewHelper(RenderView* render_view)
     : RenderViewObserver(render_view),
       RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       print_web_view_(NULL),
       is_preview_(switches::IsPrintPreviewEnabled()),
+      is_print_ready_metafile_sent_(false),
       user_cancelled_scripted_print_count_(0),
       notify_browser_of_print_failure_(true) {
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 // Prints |frame| which called window.print().
 void PrintWebViewHelper::PrintPage(WebKit::WebFrame* frame) {
   DCHECK(frame);
 
@@ skipping 116 matching lines @@
 
 void PrintWebViewHelper::OnPrintPreview(const DictionaryValue& settings) {
   DCHECK(is_preview_);
   print_preview_context_.OnPrintPreview();
 
   if (!InitPrintSettings(print_preview_context_.frame(),
                          print_preview_context_.node())) {
     NOTREACHED();
     return;
   }
-
   if (!UpdatePrintSettings(settings)) {
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   if (print_pages_params_->params.preview_request_id != 0 &&
       old_print_pages_params_.get() &&
       PrintMsg_Print_Params_IsEqual(*old_print_pages_params_,
                                     *print_pages_params_)) {
     PrintHostMsg_DidPreviewDocument_Params preview_params;
     preview_params.reuse_existing_data = true;
     preview_params.data_size = 0;
     preview_params.document_cookie =
         print_pages_params_->params.document_cookie;
     preview_params.expected_pages_count =
         print_preview_context_.total_page_count();
     preview_params.modifiable = print_preview_context_.IsModifiable();
     preview_params.preview_request_id =
         print_pages_params_->params.preview_request_id;
 
-    Send(new PrintHostMsg_PagesReadyForPreview(routing_id(), preview_params));
+    Send(new PrintHostMsg_MetafileReadyForPrinting(routing_id(),
+                                                   preview_params));
     return;
   }
   // 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;
+  if (!settings.GetBoolean(printing::kSettingGenerateDraftData,
+                           &generate_draft_pages)) {
+    NOTREACHED();
+  }
+  print_preview_context_.set_generate_draft_pages(generate_draft_pages);
+
   if (!CreatePreviewDocument())
     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))
     return false;
   int page_count = print_preview_context_.total_page_count();
   bool is_modifiable = print_preview_context_.IsModifiable();
   int document_cookie = print_pages_params_->params.document_cookie;
-  Send(new PrintHostMsg_DidGetPreviewPageCount(routing_id(), document_cookie,
-                                               page_count, is_modifiable));
+  Send(new PrintHostMsg_DidGetPreviewPageCount(
+      routing_id(),
+      document_cookie,
+      page_count,
+      is_modifiable,
+      print_preview_context_.generate_draft_pages()));
   PreviewPageRendered(printing::INVALID_PAGE_INDEX, NULL);
   return true;
 }
 
-void PrintWebViewHelper::OnContinuePreview(int requested_preview_page_index) {
+void PrintWebViewHelper::OnContinuePreview() {
   // Spurious message. We already finished/cancelled/aborted the print preview.
   if (!print_preview_context_.IsBusy())
     return;
-  int page_number;
-#if defined(USE_SKIA)
-  if (requested_preview_page_index >= printing::FIRST_PAGE_INDEX) {
-    page_number = requested_preview_page_index;
-  } else
-#endif
-  {
-    page_number = print_preview_context_.GetNextPageNumber();
-  }
+  int page_number = print_preview_context_.GetNextPageNumber();
 
   if (page_number >= printing::FIRST_PAGE_INDEX) {
     // Continue generating the print preview.
     RenderPreviewPage(page_number);
-    return;
   }
 
-  // Finished generating preview. Finalize the document.
-  if (FinalizePreviewDocument()) {
+  if (print_preview_context_.IsFinalPageRendered())
+    print_preview_context_.AllPagesRendered();
+
+  if (print_preview_context_.IsLastPageOfPrintReadyMetafile()) {
+    // Finished generating preview. Finalize the document.
+    if (!FinalizePrintReadyDocument())
+      DidFinishPrinting(FAIL_PREVIEW);
+  }
+
+  if (page_number == printing::INVALID_PAGE_INDEX) {
     print_preview_context_.Finished();
     DidFinishPrinting(OK);
-  } else {
-    DidFinishPrinting(FAIL_PREVIEW);
   }
 }
 
 void PrintWebViewHelper::OnAbortPreview() {
   DidFinishPrinting(ABORT_PREVIEW);
   return;
 }
 
-bool PrintWebViewHelper::FinalizePreviewDocument() {
-  print_preview_context_.FinalizePreviewDocument();
+bool PrintWebViewHelper::FinalizePrintReadyDocument() {
+  DCHECK(!is_print_ready_metafile_sent_);
+  print_preview_context_.FinalizePrintReadyDocument();
 
   // Get the size of the resulting metafile.
   printing::PreviewMetafile* metafile = print_preview_context_.metafile();
   uint32 buf_size = metafile->GetDataSize();
   DCHECK_GT(buf_size, 0u);
 
   PrintHostMsg_DidPreviewDocument_Params preview_params;
   preview_params.reuse_existing_data = false;
   preview_params.data_size = buf_size;
   preview_params.document_cookie = print_pages_params_->params.document_cookie;
   preview_params.expected_pages_count =
       print_preview_context_.total_page_count();
   preview_params.modifiable = print_preview_context_.IsModifiable();
   preview_params.preview_request_id =
       print_pages_params_->params.preview_request_id;
 
   // Ask the browser to create the shared memory for us.
   if (!CopyMetafileDataToSharedMem(metafile,
                                    &(preview_params.metafile_data_handle))) {
     return false;
   }
-  Send(new PrintHostMsg_PagesReadyForPreview(routing_id(), preview_params));
+  is_print_ready_metafile_sent_ = true;
+
+  Send(new PrintHostMsg_MetafileReadyForPrinting(routing_id(), preview_params));
   return true;
 }
 
 void PrintWebViewHelper::OnPrintingDone(bool success) {
   notify_browser_of_print_failure_ = false;
   DidFinishPrinting(success ? OK : FAIL_PRINT);
 }
 
 void PrintWebViewHelper::OnPrintNodeUnderContextMenu() {
   const WebNode& context_menu_node = render_view()->context_menu_node();
@@ skipping 473 matching lines @@
 
 void PrintWebViewHelper::RequestPrintPreview() {
   old_print_pages_params_.reset();
   Send(new PrintHostMsg_RequestPrintPreview(routing_id()));
 }
 
 void PrintWebViewHelper::PreviewPageRendered(int page_number,
                                              printing::Metafile* metafile) {
   if ((page_number == printing::INVALID_PAGE_INDEX && metafile) ||
        (page_number >= printing::FIRST_PAGE_INDEX && !metafile &&
-        print_preview_context_.IsModifiable())) {
+        print_preview_context_.IsModifiable() &&
+        print_preview_context_.generate_draft_pages())) {
     NOTREACHED();
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   uint32 buf_size = 0;
   PrintHostMsg_DidPreviewPage_Params preview_page_params;
   // Get the size of the resulting metafile.
   if (metafile) {
     buf_size = metafile->GetDataSize();
     DCHECK_GT(buf_size, 0u);
     if (!CopyMetafileDataToSharedMem(
             metafile, &(preview_page_params.metafile_data_handle))) {
       DidFinishPrinting(FAIL_PREVIEW);
       return;
     }
   }
   preview_page_params.data_size = buf_size;
   preview_page_params.page_number = page_number;
   Send(new PrintHostMsg_DidPreviewPage(routing_id(), preview_page_params));
 }
 
 PrintWebViewHelper::PrintPreviewContext::PrintPreviewContext()
     : frame_(NULL),
       total_page_count_(0),
-      actual_page_count_(0),
-      current_page_number_(0),
+      render_page_list_index_(-1),
+      generate_draft_pages_(true),
+      print_ready_metafile_page_count_(0),
       state_(UNINITIALIZED) {
 }
 
 PrintWebViewHelper::PrintPreviewContext::~PrintPreviewContext() {
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithFrame(
     WebKit::WebFrame* web_frame) {
   DCHECK(web_frame);
   if (IsReadyToRender())
@@ skipping 33 matching lines @@
   // Need to make sure old object gets destroyed first.
   prep_frame_view_.reset(new PrepareFrameAndViewForPrint(*print_params, frame(),
                                                          node()));
   UpdatePrintableSizeInPrintParameters(frame_, node_.get(),
                                        prep_frame_view_.get(), print_params);
 
   total_page_count_ = prep_frame_view_->GetExpectedPageCount();
   if (total_page_count_ == 0)
     return false;
 
-  current_page_number_ = 0;
-  if (pages.empty()) {
-    actual_page_count_ = total_page_count_;
-    rendered_pages_ = std::vector<PreviewPageInfo>(total_page_count_,
-                                                   std::make_pair(false, -1));
-  } else {
-    actual_page_count_ = pages.size();
-    rendered_pages_ = std::vector<PreviewPageInfo>(total_page_count_,
-                                                   std::make_pair(true, -1));
-    for (int i = 0; i < actual_page_count_; ++i) {
-      int page_number = pages[i];
-      if (page_number < printing::FIRST_PAGE_INDEX ||
-          page_number >= total_page_count_) {
-        return false;
+  int selected_page_count = pages.size();
+  render_page_list_index_ = -1;
+  print_ready_metafile_page_count_ = pages.empty() ? total_page_count_ :
+                                                  selected_page_count;
+  render_page_list_ = pages;
+  if (selected_page_count == 0) {
+    // Render all pages.
+    for (int i = 0; i < total_page_count_; i++)
+      render_page_list_.push_back(i);
+  } else if (generate_draft_pages_) {
+    int pages_index = 0;
+    for (int i = 0; i < total_page_count_; i++) {
+      if (pages_index < selected_page_count && i == pages[pages_index]) {
+        pages_index++;
+        continue;
       }
-      rendered_pages_[page_number].first = false;
-      rendered_pages_[page_number].second = i;
+      render_page_list_.push_back(i);
     }
   }
 
   document_render_time_ = base::TimeDelta();
   begin_time_ = base::TimeTicks::Now();
 
   return true;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::RenderedPreviewPage(
     const base::TimeDelta& page_time) {
   DCHECK_EQ(RENDERING, state_);
   document_render_time_ += page_time;
   UMA_HISTOGRAM_TIMES("PrintPreview.RenderPDFPageTime", page_time);
 }
 
-void PrintWebViewHelper::PrintPreviewContext::FinalizePreviewDocument() {
+void PrintWebViewHelper::PrintPreviewContext::AllPagesRendered() {
   DCHECK_EQ(RENDERING, state_);
   state_ = DONE;
+  prep_frame_view_->FinishPrinting();
+}
+
+void PrintWebViewHelper::PrintPreviewContext::FinalizePrintReadyDocument() {
+  if (state_ != DONE && state_ != RENDERING)
+    NOTREACHED();
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
-
-  prep_frame_view_->FinishPrinting();
   metafile_->FinishDocument();
 
-  if (actual_page_count_ <= 0) {
+  if (print_ready_metafile_page_count_ <= 0) {
     NOTREACHED();
     return;
   }
 
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderToPDFTime",
                              document_render_time_);
   base::TimeDelta total_time = (base::TimeTicks::Now() - begin_time) +
                                document_render_time_;
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTime",
                              total_time);
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTimeAvgPerPage",
-                             total_time / actual_page_count_);
+                             total_time / render_page_list_.size());
 }
 
 void PrintWebViewHelper::PrintPreviewContext::Finished() {
   DCHECK_EQ(DONE, state_);
   ClearContext();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::Failed() {
   DCHECK(IsBusy());
   state_ = INITIALIZED;
   ClearContext();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::Abort() {
   state_ = UNINITIALIZED;
   ClearContext();
   frame_ = NULL;
   node_.reset();
 }
 
 int PrintWebViewHelper::PrintPreviewContext::GetNextPageNumber() {
   DCHECK_EQ(RENDERING, state_);
-  for (int i = 0; i < total_page_count_; i++) {
-    if (!rendered_pages_[current_page_number_].first)
-      break;
-    current_page_number_ = (current_page_number_ + 1) % total_page_count_;
-  }
-  if (rendered_pages_[current_page_number_].first)
+  if (IsFinalPageRendered())
     return printing::INVALID_PAGE_INDEX;
-  rendered_pages_[current_page_number_].first = true;
-  return current_page_number_;
+  render_page_list_index_++;
+  return render_page_list_[render_page_list_index_];
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsReadyToRender() const {
   return state_ != UNINITIALIZED;
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsBusy() const {
   return state_ == INITIALIZED || state_ == RENDERING;
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsModifiable() const {
   // TODO(vandebo) I think this should only return false if the content is a
   // PDF, just because we are printing a particular node does not mean it's
   // a PDF (right?), we should check the mime type of the node.
   if (node())
     return false;
   std::string mime(frame()->dataSource()->response().mimeType().utf8());
   return mime != "application/pdf";
 }
 
+bool PrintWebViewHelper::PrintPreviewContext::IsLastPageOfPrintReadyMetafile()
+    const {
+  return render_page_list_index_ == print_ready_metafile_page_count_ - 1;
+}
+
+bool PrintWebViewHelper::PrintPreviewContext::IsFinalPageRendered() const {
+  return (size_t)(render_page_list_index_ + 1) == render_page_list_.size();
+}
+
+void PrintWebViewHelper::PrintPreviewContext::set_generate_draft_pages(
+    bool generate_draft_pages) {
+  generate_draft_pages_ = generate_draft_pages;
+}
+
 WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::frame() const {
   return frame_;
 }
 
 WebKit::WebNode* PrintWebViewHelper::PrintPreviewContext::node() const {
   return node_.get();
 }
 
 int PrintWebViewHelper::PrintPreviewContext::total_page_count() const {
   return total_page_count_;
 }
 
+bool PrintWebViewHelper::PrintPreviewContext::generate_draft_pages() {
+  return generate_draft_pages_;
+}
+
 printing::PreviewMetafile*
 PrintWebViewHelper::PrintPreviewContext::metafile() const {
   return metafile_.get();
 }
 
 const PrintMsg_Print_Params&
 PrintWebViewHelper::PrintPreviewContext::print_params() const {
   return *print_params_;
 }
 
 const gfx::Size&
 PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
-  rendered_pages_.clear();
+  render_page_list_.clear();
 }