Check for PrintWebViewHelper validity when running nested message loops.

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/callback_helpers.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"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 489 matching lines @@
       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;
 }
 
+void SendScriptedPrint(
+    PrintWebViewHelper* print_helper,
+    const PrintHostMsg_ScriptedPrint_Params& params,
+    blink::WebPrintScalingOption scaling_option,
+    const PrintWebViewHelper::GetPrintSettingsFromUserCallback& done_callback) {
+  PrintMsg_PrintPages_Params print_settings;
+  auto msg = base::MakeUnique<PrintHostMsg_ScriptedPrint>(
+      print_helper->routing_id(), params, &print_settings);
+  msg->EnableMessagePumping();
+
+  // WARNING: |print_helper| may no longer be valid when Send() returns.
+  print_helper->Send(msg.release());
+  print_settings.params.print_scaling_option = scaling_option;
+  done_callback.Run(print_settings);
+}
+
+void SendSetupScriptedPrintPreview(PrintWebViewHelper* print_helper,
+                                   const base::Closure& done_callback) {
+  auto msg = base::MakeUnique<PrintHostMsg_SetupScriptedPrintPreview>(
+      print_helper->routing_id());
+  msg->EnableMessagePumping();
+
+  // WARNING: |print_helper| may no longer be valid when Send() returns.
+  print_helper->Send(msg.release());
+  done_callback.Run();
+}
+
 }  // namespace
 
 FrameReference::FrameReference(blink::WebLocalFrame* frame) {
   Reset(frame);
 }
 
 FrameReference::FrameReference() {
   Reset(NULL);
 }
 
@@ skipping 423 matching lines @@
   if (!IsScriptInitiatedPrintAllowed(web_frame, user_initiated))
     return;
 
   if (delegate_->OverridePrint(web_frame))
     return;
 
   if (g_is_preview_enabled) {
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
     print_preview_context_.InitWithFrame(web_frame);
     RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
+    // WARNING: |this| may be gone at this point. Do not do any more work here
+    // and just return.
 #endif
-  } else {
+    return;
+  }
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
-    Print(web_frame, blink::WebNode(), true /* is_scripted? */);
+  StartPrint(web_frame, blink::WebNode(), true /* is_scripted? */,
+             false /* reset_print_node_in_progress? */);
+  // WARNING: |this| may be gone at this point. Do not do any more work here and
+  // just return.
 #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.
@@ skipping 28 matching lines @@
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
 void PrintWebViewHelper::OnPrintPages() {
   if (ipc_nesting_level_> 1)
     return;
 
   blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
 
   // 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? */);
+  StartPrint(frame, plugin, false /* is_scripted? */,
+             false /* reset_print_node_in_progress? */);
+  // WARNING: |this| may be gone at this point. Do not do any more work here and
+  // just return.
 }
 
 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);
+  StartPrint(frame, print_preview_context_.source_node(), false,
+             false /* reset_print_node_in_progress? */);
+  // WARNING: |this| may be gone at this point. Do not do any more work here and
+  // just return.
 }
 #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;
@@ skipping 368 matching lines @@
 
   if (print_node_in_progress_) {
     // 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 (g_is_preview_enabled) {
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
     print_preview_context_.InitWithNode(node);
     RequestPrintPreview(PRINT_PREVIEW_USER_INITIATED_CONTEXT_NODE);
 #endif
-  } else {
-#if BUILDFLAG(ENABLE_BASIC_PRINTING)
-    blink::WebNode duplicate_node(node);
-    Print(duplicate_node.document().frame(), duplicate_node, false);
-#endif
+    print_node_in_progress_ = false;
+    return;
   }
 
-  print_node_in_progress_ = false;
+#if BUILDFLAG(ENABLE_BASIC_PRINTING)
+  // Make a copy of the node, in case RenderView::OnContextMenuClosed() resets
+  // its |context_menu_node_|.
+  blink::WebNode duplicate_node(node);
+  StartPrint(duplicate_node.document().frame(), duplicate_node,
+             false /* is_scripted? */,
+             true /* reset_print_node_in_progress? */);
+  // WARNING: |this| may be gone at this point. Do not do any more work here and
+  // just return.
+#endif
 }
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
-void PrintWebViewHelper::Print(blink::WebLocalFrame* frame,
-                               const blink::WebNode& node,
-                               bool is_scripted) {
+void PrintWebViewHelper::StartPrint(blink::WebLocalFrame* frame,
+                                    const blink::WebNode& node,
+                                    bool is_scripted,
+                                    bool reset_print_node_in_progress) {
+  std::unique_ptr<base::ScopedClosureRunner> on_finish_callback;
+  if (reset_print_node_in_progress) {
+    on_finish_callback = base::MakeUnique<base::ScopedClosureRunner>(
+        base::Bind(&PrintWebViewHelper::print_node_in_progress_finished,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
   // If still not finished with earlier print request simply ignore.
   if (prep_frame_view_)
     return;
 
-  FrameReference frame_ref(frame);
+  auto frame_ref = base::MakeUnique<FrameReference>(frame);
 
   int expected_page_count = 0;
   if (!CalculateNumberOfPages(frame, node, &expected_page_count)) {
     DidFinishPrinting(FAIL_PRINT_INIT);
     return;  // Failed to init print page settings.
   }
 
   // Some full screen plugins can say they don't want to print.
   if (!expected_page_count) {
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
+  // If the browser does not want to show the UI, then just go ahead and print.
+  if (!delegate_->IsAskPrintSettingsEnabled()) {
+    FinishPrint(std::move(frame_ref), node);
+    return;
+  }
+
   // Ask the browser to show UI to retrieve the final print settings.
-  if (delegate_->IsAskPrintSettingsEnabled() &&
-      !GetPrintSettingsFromUser(frame_ref.GetFrame(), node, expected_page_count,
-                                is_scripted)) {
-    DidFinishPrinting(OK);  // Release resources and fail silently.
-    return;
-  }
+  GetPrintSettingsFromUser(std::move(frame_ref), node, expected_page_count,
+                           is_scripted, std::move(on_finish_callback));
+  // WARNING: |this| may be gone at this point. Do not do any more work here and
+  // just return.
+}
 
+void PrintWebViewHelper::FinishPrint(std::unique_ptr<FrameReference> frame_ref,
+                                     const blink::WebNode& node) {
   // Render Pages for printing.
-  if (!RenderPagesForPrint(frame_ref.GetFrame(), node)) {
+  if (!RenderPagesForPrint(frame_ref->GetFrame(), node)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
   scripting_throttler_.Reset();
 }
 #endif  // BUILDFLAG(ENABLE_BASIC_PRINTING)
 
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   switch (result) {
     case OK:
@@ skipping 245 matching lines @@
     }
 
     settings.params.print_to_pdf = IsPrintToPdfRequested(*job_settings);
     UpdateFrameMarginsCssInfo(*job_settings);
     settings.params.print_scaling_option = GetPrintScalingOption(
         frame, node, source_is_html, *job_settings, settings.params);
   }
 
   SetPrintPagesParams(settings);
 
-  if (!PrintMsg_Print_Params_IsValid(settings.params)) {
-    if (!print_for_preview_)
-      print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
-    else
-      Send(new PrintHostMsg_ShowInvalidPrinterSettingsError(routing_id()));
+  if (PrintMsg_Print_Params_IsValid(settings.params))
+    return true;
 
-    return false;
-  }
-
-  return true;
+  if (print_for_preview_)
+    Send(new PrintHostMsg_ShowInvalidPrinterSettingsError(routing_id()));
+  else
+    print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
+  return false;
 }
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
-bool PrintWebViewHelper::GetPrintSettingsFromUser(blink::WebLocalFrame* frame,
-                                                  const blink::WebNode& node,
-                                                  int expected_pages_count,
-                                                  bool is_scripted) {
+void PrintWebViewHelper::GetPrintSettingsFromUser(
+    std::unique_ptr<FrameReference> frame_ref,
+    const blink::WebNode& node,
+    int expected_pages_count,
+    bool is_scripted,
+    std::unique_ptr<base::ScopedClosureRunner> on_finish_callback) {
+  blink::WebLocalFrame* frame = frame_ref->GetFrame();
   PrintHostMsg_ScriptedPrint_Params params;
-  PrintMsg_PrintPages_Params print_settings;
-
   params.cookie = print_pages_params_->params.document_cookie;
   params.has_selection = frame->hasSelection();
   params.expected_pages_count = expected_pages_count;
   MarginType margin_type = DEFAULT_MARGINS;
-  if (PrintingNodeOrPdfFrame(frame, node)) {
-    margin_type =
-        GetMarginsForPdf(frame, node, print_pages_params_->params);
-  }
+  if (PrintingNodeOrPdfFrame(frame, node))
+    margin_type = GetMarginsForPdf(frame, node, print_pages_params_->params);
   params.margin_type = margin_type;
   params.is_scripted = is_scripted;
   params.is_modifiable = !PrintingNodeOrPdfFrame(frame, node);
 
   Send(new PrintHostMsg_DidShowPrintDialog(routing_id()));
 
-  // PrintHostMsg_ScriptedPrint will reset print_scaling_option, so we save the
-  // value before and restore it afterwards.
+  // PrintHostMsg_ScriptedPrint in SendScriptedPrint() will reset
+  // |print_scaling_option|, so save the value before and restore it afterwards.
   blink::WebPrintScalingOption scaling_option =
       print_pages_params_->params.print_scaling_option;
 
   print_pages_params_.reset();
-  IPC::SyncMessage* msg =
-      new PrintHostMsg_ScriptedPrint(routing_id(), params, &print_settings);
-  msg->EnableMessagePumping();
-  Send(msg);
-  print_settings.params.print_scaling_option = scaling_option;
+
+  GetPrintSettingsFromUserCallback ask_user_done_callback =
+      base::Bind(&PrintWebViewHelper::OnGetPrintSettingsFromUser,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&frame_ref), node,
+                 base::Passed(&on_finish_callback));
+  SendScriptedPrint(this, params, scaling_option, ask_user_done_callback);
+  // WARNING: |this| may be gone at this point. Do not do any more work here and
+  // just return. Put any work that needs to be done in |done_callback| above.
+}
+
+void PrintWebViewHelper::OnGetPrintSettingsFromUser(
+    std::unique_ptr<FrameReference> frame_ref,
+    const blink::WebNode& node,
+    std::unique_ptr<base::ScopedClosureRunner> on_finish_callback,
+    const PrintMsg_PrintPages_Params& print_settings) {
   SetPrintPagesParams(print_settings);
-  return (print_settings.params.dpi && print_settings.params.document_cookie);
+  if (print_settings.params.dpi && print_settings.params.document_cookie) {
+    FinishPrint(std::move(frame_ref), node);
+    return;
+  }
+  DidFinishPrinting(OK);  // Release resources and fail silently on failure.
 }
 
 bool PrintWebViewHelper::RenderPagesForPrint(blink::WebLocalFrame* frame,
                                              const blink::WebNode& node) {
   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(
@@ skipping 143 matching lines @@
         // |is_modifiable| value until they are fully loaded, which occurs when
         // DidStopLoading() is called. Defer showing the preview until then.
         on_stop_loading_closure_ =
             base::Bind(&PrintWebViewHelper::ShowScriptedPrintPreview,
                        base::Unretained(this));
       } else {
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, base::Bind(&PrintWebViewHelper::ShowScriptedPrintPreview,
                                   weak_ptr_factory_.GetWeakPtr()));
       }
-      IPC::SyncMessage* msg =
-          new PrintHostMsg_SetupScriptedPrintPreview(routing_id());
-      msg->EnableMessagePumping();
-      Send(msg);

[lfg, 2016/11/24 05:25:47]

Wouldn't it be simpler to do:

auto ptr = weak_ptr_factory_.GetWeakPtr();
Send();
if(!ptr)
  return;

[Lei Zhang, 2016/11/24 07:46:34]

Yes, thank you.

-      is_scripted_preview_delayed_ = false;
+      base::Closure done_callback =
+          base::Bind(&PrintWebViewHelper::reset_scripted_preview_delayed,
+                     weak_ptr_factory_.GetWeakPtr());
+      SendSetupScriptedPrintPreview(this, done_callback);
+      // WARNING: |this| may be gone at this point. Do not do any more work
+      // here and just return. Put any work that needs to be done in
+      // |done_callback| above.
       return;
     }
     case PRINT_PREVIEW_USER_INITIATED_ENTIRE_FRAME: {
       // Wait for DidStopLoading. Continuing with this function while
       // |is_loading_| is true will cause print preview to hang when try to
       // print a PDF document.
       if (is_loading_ && GetPlugin(print_preview_context_.source_frame())) {
         on_stop_loading_closure_ =
             base::Bind(&PrintWebViewHelper::RequestPrintPreview,
                        base::Unretained(this), type);
@@ skipping 356 matching lines @@
       blink::WebConsoleMessage::LevelWarning, message));
   return false;
 }
 
 void PrintWebViewHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing