Fixed print_web_view_helper for CEF.

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 756 matching lines @@
     if (owns_web_view_) {
       DCHECK(!frame->isLoading());
       owns_web_view_ = false;
       web_view->close();
     }
   }
   frame_.Reset(NULL);
   on_ready_.Reset();
 }
 
-PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view)
+PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view,
+                                       bool preview_enabled,

[Vitaly Buka (NO REVIEWS), 2014/09/08 09:43:59]

preview_enabled is always false because you build without ENABLE_FULL_PRINTING.

Do you think scripted_print_throttling_disabled is necessary?

[Marshall, 2014/09/09 16:24:51]

Building without ENABLE_FULL_PRINTING is problematic currently.

1. Compilation will fail in chrome/common/chrome_utility_printing_messages.h if
ENABLE_FULL_PRINTING is not enabled. CEF shares this file with Chrome for the
PDF utility process implementation.

2. Printing from a PDF file will fail because code in
content/renderer/pepper/pepper_plugin_instance_impl.cc requires
ENABLE_FULL_PRINTING. To reproduce: Load a PDF file as a in-process plugin and
click the Print button from the PDF toolbar.

Is it OK to remove the checks for ENABLE_FULL_PRINTING in these files?
It seems that scripted print throttling is intended to protect against code like
this:

setInterval(function(){ window.print(); }, 1000);

Without any throttling the print dialog will be displayed again before the
previous print operation has completed. For example, if you select print to file
the next print dialog will displayed while the "Save As" file dialog is still
displayed.

+                                       bool scripted_print_throttling_disabled)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       reset_prep_frame_view_(false),
+      is_preview_enabled_(preview_enabled),
+      is_scripted_print_throttling_disabled_(scripted_print_throttling_disabled),
       is_print_ready_metafile_sent_(false),
       ignore_css_margins_(false),
+      user_cancelled_scripted_print_count_(0),
       is_scripted_printing_blocked_(false),
       notify_browser_of_print_failure_(true),
       print_for_preview_(false),
       print_node_in_progress_(false),
       is_loading_(false),
       is_scripted_preview_delayed_(false),
       weak_ptr_factory_(this) {
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(
     blink::WebFrame* frame, bool user_initiated) {
 #if defined(OS_ANDROID)
   return false;
 #endif  // defined(OS_ANDROID)
   if (is_scripted_printing_blocked_)
     return false;
+  // If preview is enabled, then the print dialog is tab modal, and the user
+  // can always close the tab on a mis-behaving page (the system print dialog
+  // is app modal). If the print was initiated through user action, don't
+  // throttle. Or, if the command line flag to skip throttling has been set.
+  if (!is_scripted_print_throttling_disabled_ &&
+      !is_preview_enabled_ &&
+      !user_initiated)
+    return !IsScriptInitiatedPrintTooFrequent(frame);
   return true;
 }
 
 void PrintWebViewHelper::DidStartLoading() {
   is_loading_ = true;
 }
 
 void PrintWebViewHelper::DidStopLoading() {
   is_loading_ = false;
   if (!on_stop_loading_closure_.is_null()) {
     on_stop_loading_closure_.Run();
     on_stop_loading_closure_.Reset();
   }
 }
 
 // Prints |frame| which called window.print().
 void PrintWebViewHelper::PrintPage(blink::WebLocalFrame* frame,
                                    bool user_initiated) {
   DCHECK(frame);
 
   // Allow Prerendering to cancel this print request if necessary.
   if (prerender::PrerenderHelper::IsPrerendering(
           render_view()->GetMainRenderFrame())) {
     Send(new ChromeViewHostMsg_CancelPrerenderForPrinting(routing_id()));
     return;
   }
 
   if (!IsScriptInitiatedPrintAllowed(frame, user_initiated))
     return;
-  print_preview_context_.InitWithFrame(frame);
-  RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
+  IncrementScriptedPrintCount();
+
+  if (is_preview_enabled_) {
+    print_preview_context_.InitWithFrame(frame);
+    RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
+  } else {
+    Print(frame, blink::WebNode());
+  }
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
 #if !defined(DISABLE_BASIC_PRINTING)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForSystemDialog, OnPrintForSystemDialog)
 #endif  // !DISABLE_BASIC_PRINTING
     IPC_MESSAGE_HANDLER(PrintMsg_InitiatePrintPreview, OnInitiatePrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPreview, OnPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForPrintPreview, OnPrintForPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintingDone, OnPrintingDone)
     IPC_MESSAGE_HANDLER(PrintMsg_SetScriptedPrintingBlocked,
                         SetScriptedPrintBlocked)
     IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PrintWebViewHelper::OnPrintForPrintPreview(
     const base::DictionaryValue& job_settings) {
+  DCHECK(is_preview_enabled_);
   // If still not finished with earlier print request simply ignore.
   if (prep_frame_view_)
     return;
 
   if (!render_view()->GetWebView())
     return;
   blink::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
   if (!main_frame)
     return;
 
@@ skipping 114 matching lines @@
 
 bool PrintWebViewHelper::IsPrintToPdfRequested(
     const base::DictionaryValue& job_settings) {
   bool print_to_pdf = false;
   if (!job_settings.GetBoolean(kSettingPrintToPDF, &print_to_pdf))
     NOTREACHED();
   return print_to_pdf;
 }
 
 void PrintWebViewHelper::OnPrintPreview(const base::DictionaryValue& settings) {
+  DCHECK(is_preview_enabled_);
   print_preview_context_.OnPrintPreview();
 
   UMA_HISTOGRAM_ENUMERATION("PrintPreview.PreviewEvent",
                             PREVIEW_EVENT_REQUESTED, PREVIEW_EVENT_MAX);
 
   if (!print_preview_context_.source_frame()) {
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
@@ skipping 182 matching lines @@
   if (!success)
     LOG(ERROR) << "Failure in OnPrintingDone";
   DidFinishPrinting(success ? OK : FAIL_PRINT);
 }
 
 void PrintWebViewHelper::SetScriptedPrintBlocked(bool blocked) {
   is_scripted_printing_blocked_ = blocked;
 }
 
 void PrintWebViewHelper::OnInitiatePrintPreview(bool selection_only) {
+  DCHECK(is_preview_enabled_);
   blink::WebLocalFrame* frame = NULL;
   GetPrintFrame(&frame);
   DCHECK(frame);
   print_preview_context_.InitWithFrame(frame);
   RequestPrintPreview(selection_only ?
                       PRINT_PREVIEW_USER_INITIATED_SELECTION :
                       PRINT_PREVIEW_USER_INITIATED_ENTIRE_FRAME);
 }
 
 bool PrintWebViewHelper::IsPrintingEnabled() {
@@ skipping 13 matching lines @@
     // This can happen as a result of processing sync messages when printing
     // from ppapi plugins. It's a rare case, so its OK to just fail here.
     // See http://crbug.com/159165.
     return;
   }
 
   print_node_in_progress_ = true;
 
   // Make a copy of the node, in case RenderView::OnContextMenuClosed resets
   // its |context_menu_node_|.
-  print_preview_context_.InitWithNode(node);
-  RequestPrintPreview(PRINT_PREVIEW_USER_INITIATED_CONTEXT_NODE);
+  if (is_preview_enabled_) {
+    print_preview_context_.InitWithNode(node);
+    RequestPrintPreview(PRINT_PREVIEW_USER_INITIATED_CONTEXT_NODE);
+  } else {
+    blink::WebNode duplicate_node(node);
+    Print(duplicate_node.document().frame(), duplicate_node);
+  }
 
   print_node_in_progress_ = false;
 }
 
 #if !defined(DISABLE_BASIC_PRINTING)
 void PrintWebViewHelper::Print(blink::WebLocalFrame* frame,
                                const blink::WebNode& node) {
   // If still not finished with earlier print request simply ignore.
   if (prep_frame_view_)
     return;
@@ skipping 17 matching lines @@
                                 expected_page_count)) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(frame_ref.GetFrame(), node)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
+  ResetScriptedPrintCount();
 }
 #endif  // !DISABLE_BASIC_PRINTING
 
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   switch (result) {
     case OK:
       break;
 
     case FAIL_PRINT_INIT:
       DCHECK(!notify_browser_of_print_failure_);
       break;
 
     case FAIL_PRINT:
       if (notify_browser_of_print_failure_ && print_pages_params_) {
         int cookie = print_pages_params_->params.document_cookie;
         Send(new PrintHostMsg_PrintingFailed(routing_id(), cookie));
       }
       break;
 
     case FAIL_PREVIEW:
+      DCHECK(is_preview_enabled_);
       int cookie = print_pages_params_ ?
           print_pages_params_->params.document_cookie : 0;
       if (notify_browser_of_print_failure_) {
         LOG(ERROR) << "CreatePreviewDocument failed";
         Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
       } else {
         Send(new PrintHostMsg_PrintPreviewCancelled(routing_id(), cookie));
       }
       print_preview_context_.Failed(notify_browser_of_print_failure_);
       break;
@@ skipping 147 matching lines @@
   const blink::WebNode& source_node = print_preview_context_.source_node();
 
   params.is_scaling_disabled =
       source_frame->isPrintScalingDisabledForPlugin(source_node);
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
     blink::WebLocalFrame* frame,
     const blink::WebNode& node,
     const base::DictionaryValue& passed_job_settings) {
+  DCHECK(is_preview_enabled_);
   const base::DictionaryValue* job_settings = &passed_job_settings;
   base::DictionaryValue modified_job_settings;
   if (job_settings->empty()) {
     if (!print_for_preview_)
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
 
   bool source_is_html = true;
   if (print_for_preview_) {
@@ skipping 122 matching lines @@
     if (shared_buf->Map(buf_size)) {
       metafile->GetData(shared_buf->memory(), buf_size);
       return shared_buf->GiveToProcess(base::GetCurrentProcessHandle(),
                                        shared_mem_handle);
     }
   }
   return false;
 }
 #endif  // defined(OS_POSIX)
 
+bool PrintWebViewHelper::IsScriptInitiatedPrintTooFrequent(
+    blink::WebFrame* frame) {
+  const int kMinSecondsToIgnoreJavascriptInitiatedPrint = 2;
+  const int kMaxSecondsToIgnoreJavascriptInitiatedPrint = 32;
+  bool too_frequent = false;
+
+  // Check if there is script repeatedly trying to print and ignore it if too
+  // frequent.  The first 3 times, we use a constant wait time, but if this
+  // gets excessive, we switch to exponential wait time. So for a page that
+  // calls print() in a loop the user will need to cancel the print dialog
+  // after: [2, 2, 2, 4, 8, 16, 32, 32, ...] seconds.
+  // This gives the user time to navigate from the page.
+  if (user_cancelled_scripted_print_count_ > 0) {
+    base::TimeDelta diff = base::Time::Now() - last_cancelled_script_print_;
+    int min_wait_seconds = kMinSecondsToIgnoreJavascriptInitiatedPrint;
+    if (user_cancelled_scripted_print_count_ > 3) {
+      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)
+    return false;
+
+  blink::WebString message(
+      blink::WebString::fromUTF8("Ignoring too frequent calls to print()."));
+  frame->addMessageToConsole(
+      blink::WebConsoleMessage(
+          blink::WebConsoleMessage::LevelWarning, message));
+  return true;
+}
+
+void PrintWebViewHelper::ResetScriptedPrintCount() {
+  // Reset cancel counter on successful print.
+  user_cancelled_scripted_print_count_ = 0;
+}
+
+void PrintWebViewHelper::IncrementScriptedPrintCount() {
+  ++user_cancelled_scripted_print_count_;
+  last_cancelled_script_print_ = base::Time::Now();
+}
+
+
 void PrintWebViewHelper::ShowScriptedPrintPreview() {
   if (is_scripted_preview_delayed_) {
     is_scripted_preview_delayed_ = false;
     Send(new PrintHostMsg_ShowScriptedPrintPreview(routing_id(),
             print_preview_context_.IsModifiable()));
   }
 }
 
 void PrintWebViewHelper::RequestPrintPreview(PrintPreviewRequestType type) {
   const bool is_modifiable = print_preview_context_.IsModifiable();
@@ skipping 363 matching lines @@
 }
 
 void PrintWebViewHelper::SetPrintPagesParams(
     const PrintMsg_PrintPages_Params& settings) {
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
   Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
                                              settings.params.document_cookie));
 }
 
 }  // namespace printing