Merge 97702, 97820, 97976

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"
 #include "base/metrics/histogram.h"
-#include "base/process_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/print_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "content/renderer/render_view.h"
 #include "grit/generated_resources.h"
 #include "printing/metafile_impl.h"
 #include "printing/print_job_constants.h"
 #include "printing/units.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_POSIX)
+#include "base/process_util.h"
 #include "content/common/view_messages.h"
 #endif
 
 using printing::ConvertPixelsToPoint;
 using printing::ConvertPixelsToPointDouble;
 using printing::ConvertUnit;
 using printing::ConvertUnitDouble;
 using WebKit::WebConsoleMessage;
 using WebKit::WebDocument;
 using WebKit::WebElement;
@@ skipping 165 matching lines @@
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForSystemDialog, OnPrintForSystemDialog)
     IPC_MESSAGE_HANDLER(PrintMsg_InitiatePrintPreview, OnInitiatePrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintNodeUnderContextMenu,
                         OnPrintNodeUnderContextMenu)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPreview, OnPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForPrintPreview, OnPrintForPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintingDone, OnPrintingDone)
     IPC_MESSAGE_HANDLER(PrintMsg_ResetScriptedPrintCount,
                         ResetScriptedPrintCount)
-    IPC_MESSAGE_HANDLER(PrintMsg_ContinuePreview, OnContinuePreview)
-    IPC_MESSAGE_HANDLER(PrintMsg_AbortPreview, OnAbortPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PreviewPrintingRequestCancelled,
                         DisplayPrintJobError)
     IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PrintWebViewHelper::OnPrintForPrintPreview(
     const DictionaryValue& job_settings) {
   DCHECK(is_preview_);
@@ skipping 16 matching lines @@
     return;
   }
 
   WebFrame* pdf_frame = pdf_element.document().frame();
   scoped_ptr<PrepareFrameAndViewForPrint> prepare;
   if (!InitPrintSettingsAndPrepareFrame(pdf_frame, &pdf_element, &prepare)) {
     NOTREACHED() << "Failed to initialize print page settings";
     return;
   }
 
-  if (!UpdatePrintSettings(job_settings)) {
+  if (!UpdatePrintSettings(job_settings, false)) {
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(pdf_frame, &pdf_element, prepare.get()))
     DidFinishPrinting(FAIL_PRINT);
 }
 
 bool PrintWebViewHelper::GetPrintFrame(WebKit::WebFrame** frame) {
@@ skipping 37 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)) {
+  if (!UpdatePrintSettings(settings, true)) {
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   if (!print_pages_params_->params.is_first_request &&
       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));
     return;
   }
   // Always clear |old_print_pages_params_| before rendering the pages.
   old_print_pages_params_.reset();
 
   // PDF printer device supports alpha blending.
   print_pages_params_->params.supports_alpha_blend = true;
-  if (!CreatePreviewDocument())
+  if (CreatePreviewDocument())
+    DidFinishPrinting(OK);
+  else
     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;
   PrintHostMsg_DidGetPreviewPageCount_Params params;
   params.page_count = print_preview_context_.total_page_count();
   params.is_modifiable = print_preview_context_.IsModifiable();
   params.document_cookie = print_pages_params_->params.document_cookie;
   params.preview_request_id = print_pages_params_->params.preview_request_id;
   Send(new PrintHostMsg_DidGetPreviewPageCount(routing_id(), params));
-  PreviewPageRendered(printing::INVALID_PAGE_INDEX, NULL);
-  return true;
-}
+  if (CheckForCancel())
+    return false;
 
-void PrintWebViewHelper::OnContinuePreview(int requested_preview_page_index) {
-  // 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();
-  }
-
-  if (page_number >= printing::FIRST_PAGE_INDEX) {
-    // Continue generating the print preview.
-    RenderPreviewPage(page_number);
-    return;
-  }
+  while ((page_number = print_preview_context_.GetNextPageNumber()) >= 0) {
+    if (!RenderPreviewPage(page_number))
+      return false;
+    if (CheckForCancel())
+      return false;
+  };
 
   // Finished generating preview. Finalize the document.
-  if (FinalizePreviewDocument()) {
-    print_preview_context_.Finished();
-    DidFinishPrinting(OK);
-  } else {
-    DidFinishPrinting(FAIL_PREVIEW);
-  }
-}
-
-void PrintWebViewHelper::OnAbortPreview() {
-  DidFinishPrinting(ABORT_PREVIEW);
-  return;
+  if (!FinalizePreviewDocument())
+    return false;
+  print_preview_context_.Finished();
+  return true;
 }
 
 bool PrintWebViewHelper::FinalizePreviewDocument() {
   print_preview_context_.FinalizePreviewDocument();
 
   // Get the size of the resulting metafile.
   printing::Metafile* metafile = print_preview_context_.metafile();
   uint32 buf_size = metafile->GetDataSize();
   DCHECK_GT(buf_size, 0u);
 
@@ skipping 94 matching lines @@
     DisplayPrintJobError();
 
     if (notify_browser_of_print_failure_) {
       int cookie = print_pages_params_->params.document_cookie;
       Send(new PrintHostMsg_PrintingFailed(routing_id(), cookie));
     }
   } else if (result == FAIL_PREVIEW) {
     DCHECK(is_preview_);
     store_print_pages_params = false;
     int cookie = print_pages_params_->params.document_cookie;
-    Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
+    if (notify_browser_of_print_failure_)
+      Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
+    else
+      Send(new PrintHostMsg_PrintPreviewCancelled(routing_id(), cookie));
     print_preview_context_.Failed();
-  } else if (result == ABORT_PREVIEW) {
-    DCHECK(is_preview_);
-    store_print_pages_params = false;
-    print_preview_context_.Abort();
   }
 
   if (print_web_view_) {
     print_web_view_->close();
     print_web_view_ = NULL;
   }
 
   if (store_print_pages_params) {
     old_print_pages_params_.reset(print_pages_params_.release());
   } else {
@@ skipping 217 matching lines @@
   DCHECK(!prepare->get());
   prepare->reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
                                                  frame, node));
   UpdatePrintableSizeInPrintParameters(frame, node, prepare->get(),
                                        &print_pages_params_->params);
   Send(new PrintHostMsg_DidGetDocumentCookie(
         routing_id(), print_pages_params_->params.document_cookie));
   return true;
 }
 
-bool PrintWebViewHelper::UpdatePrintSettingsRequestId(
-    const DictionaryValue& job_settings,
-    PrintMsg_Print_Params* params) {
-  if (!job_settings.GetInteger(printing::kPreviewRequestID,
-                               &(params->preview_request_id))) {
-    NOTREACHED();
-    return false;
-  }
-  return true;
-}
-
 bool PrintWebViewHelper::UpdatePrintSettings(
-    const DictionaryValue& job_settings) {
+    const DictionaryValue& job_settings, bool is_preview) {
   PrintMsg_PrintPages_Params settings;
 
   Send(new PrintHostMsg_UpdatePrintSettings(routing_id(),
       print_pages_params_->params.document_cookie, job_settings, &settings));
-
   if (settings.params.dpi < kMinDpi || !settings.params.document_cookie)
     return false;
 
-  if (!UpdatePrintSettingsRequestId(job_settings, &(settings.params)))
-    return false;
-
-  if (!job_settings.GetBoolean(printing::kIsFirstRequest,
-                               &(settings.params.is_first_request))) {
-    NOTREACHED();
+  if (is_preview) {
+    // Validate expected print preview settings.
+    if (!job_settings.GetString(printing::kPreviewUIAddr,
+                                &(settings.params.preview_ui_addr)) ||
+        !job_settings.GetInteger(printing::kPreviewRequestID,
+                                 &(settings.params.preview_request_id)) ||
+        !job_settings.GetBoolean(printing::kIsFirstRequest,
+                                 &(settings.params.is_first_request))) {
+      NOTREACHED();
+      return false;
+    }
   }
 
   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,
                                                   int expected_pages_count,
@@ skipping 78 matching lines @@
       min_wait_seconds = std::min(
           kMinSecondsToIgnoreJavascriptInitiatedPrint <<
               (user_cancelled_scripted_print_count_ - 3),
           kMaxSecondsToIgnoreJavascriptInitiatedPrint);
     }
     if (diff.InSeconds() < min_wait_seconds) {
       too_frequent = true;
     }
   }
 
-  if (!too_frequent && print_preview_context_.IsBusy())
-    too_frequent = true;
-
   if (!too_frequent)
     return false;
 
   WebString message(WebString::fromUTF8(
       "Ignoring too frequent calls to print()."));
   frame->addMessageToConsole(WebConsoleMessage(WebConsoleMessage::LevelWarning,
                                                message));
   return true;
 }
 
@@ skipping 15 matching lines @@
   render_view()->runModalAlertDialog(
       web_view->mainFrame(),
       l10n_util::GetStringUTF16(IDS_PRINT_SPOOL_FAILED_ERROR_TEXT));
 }
 
 void PrintWebViewHelper::RequestPrintPreview() {
   old_print_pages_params_.reset();
   Send(new PrintHostMsg_RequestPrintPreview(routing_id()));
 }
 
-void PrintWebViewHelper::PreviewPageRendered(int page_number,
+bool PrintWebViewHelper::CheckForCancel() {
+  bool cancel = false;
+  Send(new PrintHostMsg_CheckForCancel(
+      routing_id(),
+      print_pages_params_->params.preview_ui_addr,
+      print_pages_params_->params.preview_request_id,
+      &cancel));
+  if (cancel)
+    notify_browser_of_print_failure_ = false;
+  return cancel;
+}
+
+bool 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())) {
-    NOTREACHED();
-    DidFinishPrinting(FAIL_PREVIEW);
-    return;
+  DCHECK_GE(page_number, printing::FIRST_PAGE_INDEX);
+
+  // For non-modifiable files, |metafile| should be NULL, so do not bother
+  // sending a message.
+  if (!print_preview_context_.IsModifiable()) {
+    DCHECK(!metafile);
+    return true;
   }
 
-  uint32 buf_size = 0;
+  if (!metafile) {
+    NOTREACHED();
+    return false;
+  }
+
   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;
-    }
+  uint32 buf_size = metafile->GetDataSize();
+  DCHECK_GT(buf_size, 0u);
+  if (!CopyMetafileDataToSharedMem(
+      metafile, &(preview_page_params.metafile_data_handle))) {
+    return false;
   }
+
   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),
       total_page_count_(0),
       actual_page_count_(0),
-      current_page_number_(0),
+      current_page_index_(0),
       state_(UNINITIALIZED) {
 }
 
 PrintWebViewHelper::PrintPreviewContext::~PrintPreviewContext() {
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithFrame(
     WebKit::WebFrame* web_frame) {
   DCHECK(web_frame);
-  if (IsReadyToRender())
-    return;
   state_ = INITIALIZED;
   frame_ = web_frame;
   node_.reset();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithNode(
     const WebKit::WebNode& web_node) {
   DCHECK(!web_node.isNull());
-  if (IsReadyToRender())
-    return;
   state_ = INITIALIZED;
   frame_ = web_node.document().frame();
   node_.reset(new WebNode(web_node));
 }
 
 void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
   DCHECK(IsReadyToRender());
   ClearContext();
 }
 
@@ skipping 12 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;
+  current_page_index_ = 0;
   if (pages.empty()) {
     actual_page_count_ = total_page_count_;
-    rendered_pages_ = std::vector<PreviewPageInfo>(total_page_count_,
-                                                   std::make_pair(false, -1));
+    for (int i = 0; i < actual_page_count_; ++i)
+      pages_to_render_.push_back(i);
   } 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;
       }
-      rendered_pages_[page_number].first = false;
-      rendered_pages_[page_number].second = i;
+      pages_to_render_.push_back(page_number);
     }
   }
 
   document_render_time_ = base::TimeDelta();
   begin_time_ = base::TimeTicks::Now();
 
   return true;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::RenderedPreviewPage(
@@ skipping 26 matching lines @@
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTimeAvgPerPage",
                              total_time / actual_page_count_);
 }
 
 void PrintWebViewHelper::PrintPreviewContext::Finished() {
   DCHECK_EQ(DONE, state_);
   ClearContext();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::Failed() {
-  DCHECK(IsBusy());
+  DCHECK(state_ == INITIALIZED || state_ == RENDERING);
   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)
-    return printing::INVALID_PAGE_INDEX;
-  rendered_pages_[current_page_number_].first = true;
-  return current_page_number_;
+  if (current_page_index_ >= actual_page_count_)
+    return -1;
+  return pages_to_render_[current_page_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";
 }
 
 WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::frame() const {
   return frame_;
 }
 
 WebKit::WebNode* PrintWebViewHelper::PrintPreviewContext::node() const {
   return node_.get();
 }
 
 int PrintWebViewHelper::PrintPreviewContext::total_page_count() const {
+  DCHECK(IsReadyToRender());
   return total_page_count_;
 }
 
 printing::Metafile* 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();
+  pages_to_render_.clear();
 }