M59: Defer deletion in PrintWebViewHelper while handling IPC messages.

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>
@@ skipping 894 matching lines @@
       is_print_ready_metafile_sent_(false),
       ignore_css_margins_(false),
       is_printing_enabled_(true),
       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),
+      render_frame_gone_(false),
       weak_ptr_factory_(this) {
   if (!delegate_->IsPrintPreviewEnabled())
     DisablePreview();
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {
 }
 
 // static
 void PrintWebViewHelper::DisablePreview() {
@@ skipping 61 matching lines @@
 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_;
 
-  auto self = weak_ptr_factory_.GetWeakPtr();
-
   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_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
-  // Check if |this| is still valid. e.g. when OnPrintPages() returns.
-  if (self)
-    --ipc_nesting_level_;
+  --ipc_nesting_level_;
+  if (ipc_nesting_level_ == 0 && render_frame_gone_)
+    base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
   return handled;
 }
 
 void PrintWebViewHelper::OnDestruct() {
+  if (ipc_nesting_level_ > 0) {
+    render_frame_gone_ = true;
+    return;
+  }
   delete this;
 }
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
 void PrintWebViewHelper::OnPrintPages() {
   if (ipc_nesting_level_> 1)
     return;
 
   blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
 
@@ skipping 170 matching lines @@
     return;
   }
 
   const PrintMsg_Print_Params& print_params = print_pages_params_->params;
   prep_frame_view_ = base::MakeUnique<PrepareFrameAndViewForPrint>(
       print_params, print_preview_context_.source_frame(),
       print_preview_context_.source_node(), ignore_css_margins_);
   prep_frame_view_->CopySelectionIfNeeded(
       render_frame()->GetWebkitPreferences(),
       base::Bind(&PrintWebViewHelper::OnFramePreparedForPreviewDocument,
-                 base::Unretained(this)));
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PrintWebViewHelper::OnFramePreparedForPreviewDocument() {
   if (reset_prep_frame_view_) {
     PrepareFrameForPreviewDocument();
     return;
   }
   DidFinishPrinting(CreatePreviewDocument() ? OK : FAIL_PREVIEW);
 }
 
@@ skipping 607 matching lines @@
 
   const PrintMsg_PrintPages_Params& params = *print_pages_params_;
   const PrintMsg_Print_Params& print_params = params.params;
   prep_frame_view_ = base::MakeUnique<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(),
       base::Bind(&PrintWebViewHelper::OnFramePreparedForPrintPages,
-                 base::Unretained(this)));
+                 weak_ptr_factory_.GetWeakPtr()));
   return true;
 }
 #endif  // BUILDFLAG(ENABLE_BASIC_PRINTING)
 
 #if !defined(OS_MACOSX)
 void PrintWebViewHelper::PrintPageInternal(const PrintMsg_Print_Params& params,
                                            int page_number,
                                            blink::WebLocalFrame* frame,
                                            PdfMetafileSkia* metafile,
                                            gfx::Size* page_size_in_dpi,
@@ skipping 123 matching lines @@
       //    pumping messages here.
       // 2. PrintHostMsg_ShowScriptedPrintPreview shows preview once the
       //    document has been loaded.
       is_scripted_preview_delayed_ = true;
       if (is_loading_ && GetPlugin(print_preview_context_.source_frame())) {
         // Wait for DidStopLoading. Plugins may not know the correct
         // |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));
+                       weak_ptr_factory_.GetWeakPtr());
       } else {
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, base::Bind(&PrintWebViewHelper::ShowScriptedPrintPreview,
                                   weak_ptr_factory_.GetWeakPtr()));
       }
       auto msg = base::MakeUnique<PrintHostMsg_SetupScriptedPrintPreview>(
           routing_id());
       msg->EnableMessagePumping();
       auto self = weak_ptr_factory_.GetWeakPtr();
       Send(msg.release());
       // Check if |this| is still valid.
       if (self)
         is_scripted_preview_delayed_ = false;
       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);
+                       weak_ptr_factory_.GetWeakPtr(), type);
         return;
       }
 
       break;
     }
     case PRINT_PREVIEW_USER_INITIATED_SELECTION: {
       DCHECK(has_selection);
       DCHECK(!GetPlugin(print_preview_context_.source_frame()));
       params.selection_only = has_selection;
       break;
     }
     case PRINT_PREVIEW_USER_INITIATED_CONTEXT_NODE: {
       if (is_loading_ && GetPlugin(print_preview_context_.source_frame())) {
         on_stop_loading_closure_ =
             base::Bind(&PrintWebViewHelper::RequestPrintPreview,
-                       base::Unretained(this), type);
+                       weak_ptr_factory_.GetWeakPtr(), type);
         return;
       }
 
       params.webnode_only = true;
       break;
     }
     default: {
       NOTREACHED();
       return;
     }
@@ skipping 48 matching lines @@
 
   Send(new PrintHostMsg_DidPreviewPage(routing_id(), preview_page_params));
   return true;
 }
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 PrintWebViewHelper::PrintPreviewContext::PrintPreviewContext()
     : total_page_count_(0),
       current_page_index_(0),
       generate_draft_pages_(true),
+      is_modifiable_(true),
       print_ready_metafile_page_count_(0),
       error_(PREVIEW_ERROR_NONE),
-      state_(UNINITIALIZED) {
-}
+      state_(UNINITIALIZED) {}
 
 PrintWebViewHelper::PrintPreviewContext::~PrintPreviewContext() {
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithFrame(
     blink::WebLocalFrame* web_frame) {
   DCHECK(web_frame);
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
   source_frame_.Reset(web_frame);
   source_node_.Reset();
+  CalculateIsModifiable();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithNode(
     const blink::WebNode& web_node) {
   DCHECK(!web_node.IsNull());
   DCHECK(web_node.GetDocument().GetFrame());
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
   source_frame_.Reset(web_node.GetDocument().GetFrame());
   source_node_ = web_node;
+  CalculateIsModifiable();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
   DCHECK_EQ(INITIALIZED, state_);
   ClearContext();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::CreatePreviewDocument(
     PrepareFrameAndViewForPrint* prepared_frame,
     const std::vector<int>& pages) {
@@ skipping 105 matching lines @@
   DCHECK_EQ(RENDERING, state_);
   if (IsFinalPageRendered())
     return -1;
   return pages_to_render_[current_page_index_++];
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsRendering() const {
   return state_ == RENDERING || state_ == DONE;
 }
 
-bool PrintWebViewHelper::PrintPreviewContext::IsModifiable() {
-  // The only kind of node we can print right now is a PDF node.
-  return !PrintingNodeOrPdfFrame(source_frame(), source_node_);
+bool PrintWebViewHelper::PrintPreviewContext::IsModifiable() const {
+  DCHECK(state_ != UNINITIALIZED);
+  return is_modifiable_;
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::HasSelection() {
   return IsModifiable() && source_frame()->HasSelection();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsLastPageOfPrintReadyMetafile()
     const {
   DCHECK(IsRendering());
   return current_page_index_ == print_ready_metafile_page_count_;
@@ skipping 56 matching lines @@
   return error_;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }
 
+void PrintWebViewHelper::PrintPreviewContext::CalculateIsModifiable() {
+  // The only kind of node we can print right now is a PDF node.
+  is_modifiable_ = !PrintingNodeOrPdfFrame(source_frame(), source_node_);
+}
+
 void PrintWebViewHelper::SetPrintPagesParams(
     const PrintMsg_PrintPages_Params& settings) {
   print_pages_params_ = base::MakeUnique<PrintMsg_PrintPages_Params>(settings);
   Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
                                              settings.params.document_cookie));
 }
 
 PrintWebViewHelper::ScriptingThrottler::ScriptingThrottler() : count_(0) {
 }
 
@@ skipping 34 matching lines @@
       blink::WebConsoleMessage::kLevelWarning, message));
   return false;
 }
 
 void PrintWebViewHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing