Revert of Make printing work better with OOPIF.

components/printing/renderer/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 "components/printing/renderer/print_web_view_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
-#include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process_handle.h"
@@ skipping 480 matching lines @@
                   result_params.page_size.height() - result_params.margin_top -
                       default_margin_bottom);
   } else {
     // Using the CSS parameters. Scale CSS content size.
     result_params.content_size =
         ScaleAndRoundSize(result_params.content_size, *scale_factor);
     if (fit_to_page) {
       double factor = FitPrintParamsToPage(params, &result_params);
       if (scale_factor)
         *scale_factor = (*scale_factor) * factor;
-    } else {
+    } else { // !fit_to_page
       // Already scaled the page, need to also scale the CSS margins since they
       // are begin applied
       result_params.margin_left =
           ScaleAndRound(result_params.margin_left, page_scaling);
       result_params.margin_top =
           ScaleAndRound(result_params.margin_top, page_scaling);
     }
   }
 
   return result_params;
@@ skipping 226 matching lines @@
   // the number that produces output with the correct physical size for elements
   // that are specified in cm, mm, pt etc.
   // This is important for sites that try to fill the page.
   gfx::Size print_layout_size(web_print_params_.printContentArea.width,
                               web_print_params_.printContentArea.height);
   print_layout_size.set_height(
       ScaleAndRound(print_layout_size.height(), kPrintingMinimumShrinkFactor));
 
   if (!frame())
     return;
-
-  // Backup size and offset if it's a local frame.
   blink::WebView* web_view = frame_.view();
-  if (blink::WebFrame* web_frame = web_view->mainFrame()) {
-    if (web_frame->isWebLocalFrame())
-      prev_scroll_offset_ = web_frame->scrollOffset();
-  }
+  // Backup size and offset.
+  if (blink::WebFrame* web_frame = web_view->mainFrame())
+    prev_scroll_offset_ = web_frame->scrollOffset();
   prev_view_size_ = web_view->size();
 
   web_view->resize(print_layout_size);
 }
 
 void PrepareFrameAndViewForPrint::StartPrinting() {
   blink::WebView* web_view = frame_.view();
   web_view->settings()->setShouldPrintBackgrounds(should_print_backgrounds_);
   expected_pages_count_ =
       frame()->printBegin(web_print_params_, node_to_print_);
@@ skipping 66 matching lines @@
   blink::WebLocalFrame* frame = blink::WebLocalFrame::create(scope, this);
   parent->appendChild(frame);
   return frame;
 }
 
 void PrepareFrameAndViewForPrint::CallOnReady() {
   return on_ready_.Run();  // Can delete |this|.
 }
 
 void PrepareFrameAndViewForPrint::RestoreSize() {
-  if (!frame())
-    return;
-
-  blink::WebView* web_view = frame_.GetFrame()->view();
-  web_view->resize(prev_view_size_);
-  if (blink::WebFrame* web_frame = web_view->mainFrame()) {
-    if (web_frame->isWebLocalFrame())
+  if (frame()) {
+    blink::WebView* web_view = frame_.GetFrame()->view();
+    web_view->resize(prev_view_size_);
+    if (blink::WebFrame* web_frame = web_view->mainFrame())
       web_frame->setScrollOffset(prev_scroll_offset_);
   }
 }
 
 void PrepareFrameAndViewForPrint::FinishPrinting() {
   blink::WebLocalFrame* frame = frame_.GetFrame();
   if (frame) {
     blink::WebView* web_view = frame->view();
     if (is_printing_started_) {
       is_printing_started_ = false;
@@ skipping 15 matching lines @@
 }
 
 bool PrintWebViewHelper::Delegate::IsAskPrintSettingsEnabled() {
   return true;
 }
 
 bool PrintWebViewHelper::Delegate::IsScriptedPrintEnabled() {
   return true;
 }
 
-PrintWebViewHelper::PrintWebViewHelper(content::RenderFrame* render_frame,
+PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view,
                                        std::unique_ptr<Delegate> delegate)
-    : content::RenderFrameObserver(render_frame),
-      content::RenderFrameObserverTracker<PrintWebViewHelper>(render_frame),
+    : content::RenderViewObserver(render_view),
+      content::RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       reset_prep_frame_view_(false),
       is_print_ready_metafile_sent_(false),
       ignore_css_margins_(false),
-      is_printing_enabled_(true),
+      is_scripted_printing_blocked_(false),
       notify_browser_of_print_failure_(true),
       print_for_preview_(false),
       delegate_(std::move(delegate)),
       print_node_in_progress_(false),
       is_loading_(false),
       is_scripted_preview_delayed_(false),
       ipc_nesting_level_(0),
       weak_ptr_factory_(this) {
   if (!delegate_->IsPrintPreviewEnabled())
     DisablePreview();
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {
 }
 
 // static
 void PrintWebViewHelper::DisablePreview() {
   g_is_preview_enabled = false;
 }
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(blink::WebFrame* frame,
                                                        bool user_initiated) {
-  if (!is_printing_enabled_ || !delegate_->IsScriptedPrintEnabled())
+  if (!delegate_->IsScriptedPrintEnabled())
     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.
-  return user_initiated || g_is_preview_enabled ||
-         scripting_throttler_.IsAllowed(frame);
+  return !is_scripted_printing_blocked_ &&
+         (user_initiated || g_is_preview_enabled ||
+          scripting_throttler_.IsAllowed(frame));
 }
 
-void PrintWebViewHelper::DidStartProvisionalLoad() {
+void PrintWebViewHelper::DidStartLoading() {
   is_loading_ = true;
 }
 
-void PrintWebViewHelper::DidFailProvisionalLoad(
-    const blink::WebURLError& error) {
-  DidFinishLoad();
-}
-
-void PrintWebViewHelper::DidFinishLoad() {
+void PrintWebViewHelper::DidStopLoading() {
   is_loading_ = false;
   if (!on_stop_loading_closure_.is_null()) {
     on_stop_loading_closure_.Run();
     on_stop_loading_closure_.Reset();
   }
 }
 
-void PrintWebViewHelper::ScriptedPrint(bool user_initiated) {
+// 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 (delegate_->CancelPrerender(render_frame()))
+  if (delegate_->CancelPrerender(render_view(), routing_id()))
     return;
 
-  blink::WebLocalFrame* web_frame = render_frame()->GetWebFrame();
-  if (!IsScriptInitiatedPrintAllowed(web_frame, user_initiated))
+  if (!IsScriptInitiatedPrintAllowed(frame, user_initiated))
     return;
 
-  if (delegate_->OverridePrint(web_frame))
+  if (delegate_->OverridePrint(frame))
     return;
 
   if (g_is_preview_enabled) {
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
-    print_preview_context_.InitWithFrame(web_frame);
+    print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
 #endif
   } else {
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
-    Print(web_frame, blink::WebNode(), true /* is_scripted? */);
+    Print(frame, blink::WebNode(), true);
 #endif
   }
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   // The class is not designed to handle recursive messages. This is not
   // expected during regular flow. However, during rendering of content for
   // printing, lower level code may run nested message loop. E.g. PDF may has
   // script to show message box http://crbug.com/502562. In that moment browser
   // may receive updated printer capabilities and decide to restart print
   // preview generation. When this happened message handling function may
   // choose to ignore message or safely crash process.
   ++ipc_nesting_level_;
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForSystemDialog, OnPrintForSystemDialog)
 #endif  // BUILDFLAG(ENABLE_BASIC_PRINTING)
 #if BUILDFLAG(ENABLE_BASIC_PRINTING) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForPrintPreview, OnPrintForPrintPreview)
 #endif
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
     IPC_MESSAGE_HANDLER(PrintMsg_InitiatePrintPreview, OnInitiatePrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPreview, OnPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintingDone, OnPrintingDone)
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
-    IPC_MESSAGE_HANDLER(PrintMsg_SetPrintingEnabled, OnSetPrintingEnabled)
+    IPC_MESSAGE_HANDLER(PrintMsg_SetScriptedPrintingBlocked,
+                        SetScriptedPrintBlocked)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   --ipc_nesting_level_;
   return handled;
 }
 
 void PrintWebViewHelper::OnDestruct() {
   delete this;
 }
 
+bool PrintWebViewHelper::GetPrintFrame(blink::WebLocalFrame** frame) {
+  DCHECK(frame);
+  blink::WebView* webView = render_view()->GetWebView();
+  DCHECK(webView);
+  if (!webView)
+    return false;
+
+  // If the user has selected text in the currently focused frame we print
+  // only that frame (this makes print selection work for multiple frames).
+  blink::WebLocalFrame* focusedFrame = webView->focusedFrame();
+  *frame = focusedFrame->hasSelection()
+               ? focusedFrame
+               : webView->mainFrame()->toWebLocalFrame();
+  return true;
+}
+
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
 void PrintWebViewHelper::OnPrintPages() {
   if (ipc_nesting_level_> 1)
     return;
-
-  blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
-
+  blink::WebLocalFrame* frame;
+  if (!GetPrintFrame(&frame))
+    return;
   // If we are printing a PDF extension frame, find the plugin node and print
   // that instead.
   auto plugin = delegate_->GetPdfElement(frame);
-  Print(frame, plugin, false /* is_scripted? */);
+  Print(frame, plugin, false);
 }
 
 void PrintWebViewHelper::OnPrintForSystemDialog() {
   if (ipc_nesting_level_> 1)
     return;
   blink::WebLocalFrame* frame = print_preview_context_.source_frame();
   if (!frame) {
     NOTREACHED();
     return;
   }
   Print(frame, print_preview_context_.source_node(), false);
 }
 #endif  // BUILDFLAG(ENABLE_BASIC_PRINTING)
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
 void PrintWebViewHelper::OnPrintForPrintPreview(
     const base::DictionaryValue& job_settings) {
   CHECK_LE(ipc_nesting_level_, 1);
   // If still not finished with earlier print request simply ignore.
   if (prep_frame_view_)
     return;
 
-  blink::WebDocument document = render_frame()->GetWebFrame()->document();
+  if (!render_view()->GetWebView())
+    return;
+  blink::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
+  if (!main_frame)
+    return;
+
+  blink::WebDocument document = main_frame->document();
   // <object>/<iframe> with id="pdf-viewer" is created in
   // chrome/browser/resources/print_preview/print_preview.js
   blink::WebElement pdf_element = document.getElementById("pdf-viewer");
   if (pdf_element.isNull()) {
     NOTREACHED();
     return;
   }
 
   // The out-of-process plugin element is nested within a frame. In tests, there
   // may not be an iframe containing the out-of-process plugin, so continue with
@@ skipping 126 matching lines @@
   if (prep_frame_view_ && prep_frame_view_->IsLoadingSelection()) {
     reset_prep_frame_view_ = true;
     return;
   }
 
   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_frame()->GetWebkitPreferences(),
+      render_view()->GetWebkitPreferences(),
       base::Bind(&PrintWebViewHelper::OnFramePreparedForPreviewDocument,
                  base::Unretained(this)));
 }
 
 void PrintWebViewHelper::OnFramePreparedForPreviewDocument() {
   if (reset_prep_frame_view_) {
     PrepareFrameForPreviewDocument();
     return;
   }
   DidFinishPrinting(CreatePreviewDocument() ? OK : FAIL_PREVIEW);
@@ skipping 164 matching lines @@
 
 void PrintWebViewHelper::OnPrintingDone(bool success) {
   if (ipc_nesting_level_ > 1)
     return;
   notify_browser_of_print_failure_ = false;
   if (!success)
     LOG(ERROR) << "Failure in OnPrintingDone";
   DidFinishPrinting(success ? OK : FAIL_PRINT);
 }
 
-void PrintWebViewHelper::OnSetPrintingEnabled(bool enabled) {
-  is_printing_enabled_ = enabled;
+void PrintWebViewHelper::SetScriptedPrintBlocked(bool blocked) {
+  is_scripted_printing_blocked_ = blocked;
 }
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
-void PrintWebViewHelper::OnInitiatePrintPreview(bool has_selection) {
+void PrintWebViewHelper::OnInitiatePrintPreview(bool selection_only) {
   if (ipc_nesting_level_ > 1)
     return;
-
-  blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
-
+  blink::WebLocalFrame* frame = NULL;
+  GetPrintFrame(&frame);
+  DCHECK(frame);
   // If we are printing a PDF extension frame, find the plugin node and print
   // that instead.
   auto plugin = delegate_->GetPdfElement(frame);
   if (!plugin.isNull()) {
     PrintNode(plugin);
     return;
   }
   print_preview_context_.InitWithFrame(frame);
-  RequestPrintPreview(has_selection
+  RequestPrintPreview(selection_only
                           ? PRINT_PREVIEW_USER_INITIATED_SELECTION
                           : PRINT_PREVIEW_USER_INITIATED_ENTIRE_FRAME);
 }
 #endif
 
-bool PrintWebViewHelper::IsPrintingEnabled() const {
-  return is_printing_enabled_;
+bool PrintWebViewHelper::IsPrintingEnabled() {
+  bool result = false;
+  Send(new PrintHostMsg_IsPrintingEnabled(routing_id(), &result));
+  return result;
 }
 
 void PrintWebViewHelper::PrintNode(const blink::WebNode& node) {
   if (node.isNull() || !node.document().frame()) {
     // This can occur when the context menu refers to an invalid WebNode.
     // See http://crbug.com/100890#c17 for a repro case.
     return;
   }
 
   if (print_node_in_progress_) {
@@ skipping 374 matching lines @@
   if (!frame || prep_frame_view_)
     return false;
 
   const PrintMsg_PrintPages_Params& params = *print_pages_params_;
   const PrintMsg_Print_Params& print_params = params.params;
   prep_frame_view_.reset(new PrepareFrameAndViewForPrint(
       print_params, frame, node, ignore_css_margins_));
   DCHECK(!print_pages_params_->params.selection_only ||
          print_pages_params_->pages.empty());
   prep_frame_view_->CopySelectionIfNeeded(
-      render_frame()->GetWebkitPreferences(),
+      render_view()->GetWebkitPreferences(),
       base::Bind(&PrintWebViewHelper::OnFramePreparedForPrintPages,
                  base::Unretained(this)));
   return true;
 }
 #endif  // BUILDFLAG(ENABLE_BASIC_PRINTING)
 
 #if !defined(OS_MACOSX)
 void PrintWebViewHelper::PrintPageInternal(
     const PrintMsg_PrintPage_Params& params,
     blink::WebLocalFrame* frame,
@@ skipping 509 matching lines @@
       blink::WebConsoleMessage::LevelWarning, message));
   return false;
 }
 
 void PrintWebViewHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing