Removed --disable-print-preview switch and policy.

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 382 matching lines @@
   }
 
   if (fit_to_page) {
     double factor = FitPrintParamsToPage(params, &result_params);
     if (scale_factor)
       *scale_factor = factor;
   }
   return result_params;
 }
 
-bool IsPrintPreviewEnabled() {
-  return CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kRendererPrintPreview);
-}
-
-bool IsPrintThrottlingDisabled() {
-  return CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableScriptedPrintThrottling);
-}
-
 }  // namespace
 
 FrameReference::FrameReference(blink::WebLocalFrame* frame) {
   Reset(frame);
 }
 
 FrameReference::FrameReference() {
   Reset(NULL);
 }
 
@@ skipping 351 matching lines @@
     }
   }
   frame_.Reset(NULL);
   on_ready_.Reset();
 }
 
 PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       reset_prep_frame_view_(false),
-      is_preview_enabled_(IsPrintPreviewEnabled()),
-      is_scripted_print_throttling_disabled_(IsPrintThrottlingDisabled()),
       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;
-  IncrementScriptedPrintCount();
-
-  if (is_preview_enabled_) {
-    print_preview_context_.InitWithFrame(frame);
-    RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
-  } else {
-    Print(frame, blink::WebNode());
-  }
+  print_preview_context_.InitWithFrame(frame);
+  RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForSystemDialog, OnPrintForSystemDialog)
     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_ResetScriptedPrintCount,
-                        ResetScriptedPrintCount)
     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 113 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_|.
-  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_preview_context_.InitWithNode(node);
+  RequestPrintPreview(PRINT_PREVIEW_USER_INITIATED_CONTEXT_NODE);
 
   print_node_in_progress_ = false;
 }
 
 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 16 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();
 }
 
 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 148 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 128 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