Make printing work better with OOPIF.

chrome/browser/printing/print_view_manager_base.cc

 // Copyright 2013 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/browser/printing/print_view_manager_base.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.h"
 #include "components/printing/common/print_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "printing/features/features.h"
 #include "printing/pdf_metafile_skia.h"
 #include "printing/printed_document.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
 #include "chrome/browser/printing/print_error_dialog.h"
 #endif
@@ skipping 18 matching lines @@
   // Block opening dialog from nested task.
   base::AutoReset<bool> auto_reset(&is_dialog_shown, true);
 
   chrome::ShowWarningMessageBox(nullptr, base::string16(), message);
 }
 
 }  // namespace
 
 PrintViewManagerBase::PrintViewManagerBase(content::WebContents* web_contents)
     : PrintManager(web_contents),
+      printing_rfh_(nullptr),
       printing_succeeded_(false),
       inside_inner_message_loop_(false),
 #if !defined(OS_MACOSX)
       expecting_first_page_(true),
 #endif
       queue_(g_browser_process->print_job_manager()->queue()) {
   DCHECK(queue_.get());
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   printing_enabled_.Init(
-      prefs::kPrintingEnabled,
-      profile->GetPrefs(),
-      base::Bind(&PrintViewManagerBase::UpdateScriptedPrintingBlocked,
+      prefs::kPrintingEnabled, profile->GetPrefs(),
+      base::Bind(&PrintViewManagerBase::UpdatePrintingEnabled,
                  base::Unretained(this)));
 }
 
 PrintViewManagerBase::~PrintViewManagerBase() {
   ReleasePrinterQuery();
   DisconnectFromCurrentPrintJob();
 }
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
-bool PrintViewManagerBase::PrintNow() {
-  return PrintNowInternal(new PrintMsg_PrintPages(routing_id()));
+bool PrintViewManagerBase::PrintNow(content::RenderFrameHost* rfh) {
+  DisconnectFromCurrentPrintJob();
+
+  SetPrintingRFH(rfh);
+  int32_t id = rfh->GetRoutingID();
+  return PrintNowInternal(rfh, base::MakeUnique<PrintMsg_PrintPages>(id));
 }
 #endif
 
-void PrintViewManagerBase::UpdateScriptedPrintingBlocked() {
-  Send(new PrintMsg_SetScriptedPrintingBlocked(
-       routing_id(),
-       !printing_enabled_.GetValue()));
+void PrintViewManagerBase::UpdatePrintingEnabled() {
+  web_contents()->ForEachFrame(
+      base::Bind(&PrintViewManagerBase::SendPrintingEnabled,
+                 base::Unretained(this), printing_enabled_.GetValue()));
 }
 
 void PrintViewManagerBase::NavigationStopped() {
   // Cancel the current job, wait for the worker to finish.
   TerminatePrintJob(true);
 }
 
-void PrintViewManagerBase::RenderProcessGone(base::TerminationStatus status) {
-  PrintManager::RenderProcessGone(status);
-  ReleasePrinterQuery();
-
-  if (!print_job_.get())
-    return;
-
-  scoped_refptr<PrintedDocument> document(print_job_->document());
-  if (document.get()) {
-    // If IsComplete() returns false, the document isn't completely rendered.
-    // Since our renderer is gone, there's nothing to do, cancel it. Otherwise,
-    // the print job may finish without problem.
-    TerminatePrintJob(!document->IsComplete());
-  }
-}
-
 base::string16 PrintViewManagerBase::RenderSourceName() {
   base::string16 name(web_contents()->GetTitle());
   if (name.empty())
     name = l10n_util::GetStringUTF16(IDS_DEFAULT_PRINT_DOCUMENT_TITLE);
   return name;
 }
 
 void PrintViewManagerBase::OnDidGetPrintedPagesCount(int cookie,
                                                      int number_pages) {
   PrintManager::OnDidGetPrintedPagesCount(cookie, number_pages);
@@ skipping 92 matching lines @@
 }
 
 void PrintViewManagerBase::OnShowInvalidPrinterSettingsError() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ShowWarningMessageBox,
                             l10n_util::GetStringUTF16(
                                 IDS_PRINT_INVALID_PRINTER_SETTINGS)));
 }
 
 void PrintViewManagerBase::DidStartLoading() {
-  UpdateScriptedPrintingBlocked();
+  UpdatePrintingEnabled();
 }
 
-bool PrintViewManagerBase::OnMessageReceived(const IPC::Message& message) {
+void PrintViewManagerBase::RenderFrameDeleted(
+    content::RenderFrameHost* render_frame_host) {
+  // Terminates or cancels the print job if one was pending.
+  if (render_frame_host != printing_rfh_)
+    return;
+
+  printing_rfh_ = nullptr;
+
+  PrintManager::PrintingRenderFrameDeleted();
+  ReleasePrinterQuery();
+
+  if (!print_job_.get())
+    return;
+
+  scoped_refptr<PrintedDocument> document(print_job_->document());
+  if (document.get()) {
+    // If IsComplete() returns false, the document isn't completely rendered.
+    // Since our renderer is gone, there's nothing to do, cancel it. Otherwise,
+    // the print job may finish without problem.
+    TerminatePrintJob(!document->IsComplete());
+  }
+}
+
+bool PrintViewManagerBase::OnMessageReceived(
+    const IPC::Message& message,
+    content::RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintViewManagerBase, message)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrintPage, OnDidPrintPage)
     IPC_MESSAGE_HANDLER(PrintHostMsg_ShowInvalidPrinterSettingsError,
                         OnShowInvalidPrinterSettingsError)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
-  return handled || PrintManager::OnMessageReceived(message);
+  return handled || PrintManager::OnMessageReceived(message, render_frame_host);
 }
 
 void PrintViewManagerBase::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_PRINT_JOB_EVENT, type);
   OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr());
 }
 
@@ skipping 91 matching lines @@
     // We are in a message loop created by RenderAllMissingPagesNow. Quit from
     // it.
     base::MessageLoop::current()->QuitWhenIdle();
     inside_inner_message_loop_ = false;
   }
 }
 
 bool PrintViewManagerBase::CreateNewPrintJob(PrintJobWorkerOwner* job) {
   DCHECK(!inside_inner_message_loop_);
 
-  // Disconnect the current print_job_.
+  // Disconnect the current |print_job_|.
   DisconnectFromCurrentPrintJob();
 
   // We can't print if there is no renderer.
   if (!web_contents()->GetRenderViewHost() ||
       !web_contents()->GetRenderViewHost()->IsRenderViewLive()) {
     return false;
   }
 
   // Ask the renderer to generate the print preview, create the print preview
   // view and switch to it, initialize the printer and show the print dialog.
@@ skipping 24 matching lines @@
     TerminatePrintJob(true);
   } else {
     // DO NOT wait for the job to finish.
     ReleasePrintJob();
   }
 #if !defined(OS_MACOSX)
   expecting_first_page_ = true;
 #endif
 }
 
-void PrintViewManagerBase::PrintingDone(bool success) {
-  if (!print_job_.get())
-    return;
-  Send(new PrintMsg_PrintingDone(routing_id(), success));
-}
-
 void PrintViewManagerBase::TerminatePrintJob(bool cancel) {
   if (!print_job_.get())
     return;
 
   if (cancel) {
     // We don't need the metafile data anymore because the printing is canceled.
     print_job_->Cancel();
     inside_inner_message_loop_ = false;
   } else {
     DCHECK(!inside_inner_message_loop_);
     DCHECK(!print_job_->document() || print_job_->document()->IsComplete());
 
     // WebContents is either dying or navigating elsewhere. We need to render
     // all the pages in an hurry if a print job is still pending. This does the
     // trick since it runs a blocking message loop:
     print_job_->Stop();
   }
   ReleasePrintJob();
 }
 
 void PrintViewManagerBase::ReleasePrintJob() {
+  content::RenderFrameHost* rfh = printing_rfh_;
+  printing_rfh_ = nullptr;
+
   if (!print_job_.get())
     return;
 
-  PrintingDone(printing_succeeded_);
+  if (rfh) {
+    auto msg = base::MakeUnique<PrintMsg_PrintingDone>(rfh->GetRoutingID(),
+                                                       printing_succeeded_);
+    rfh->Send(msg.release());
+  }
 
   registrar_.Remove(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
                     content::Source<PrintJob>(print_job_.get()));
   print_job_->DisconnectSource();
   // Don't close the worker thread.
-  print_job_ = NULL;
+  print_job_ = nullptr;
 }
 
 bool PrintViewManagerBase::RunInnerMessageLoop() {
   // This value may actually be too low:
   //
   // - If we're looping because of printer settings initialization, the premise
   // here is that some poor users have their print server away on a VPN over a
   // slow connection. In this situation, the simple fact of opening the printer
   // can be dead slow. On the other side, we don't want to die infinitely for a
   // real network error. Give the printer 60 seconds to comply.
@@ skipping 48 matching lines @@
     // Don't kill anything.
     return false;
   }
 
   // Settings are already loaded. Go ahead. This will set
   // print_job_->is_job_pending() to true.
   print_job_->StartPrinting();
   return true;
 }
 
-bool PrintViewManagerBase::PrintNowInternal(IPC::Message* message) {
+bool PrintViewManagerBase::PrintNowInternal(
+    content::RenderFrameHost* rfh,
+    std::unique_ptr<IPC::Message> message) {
   // Don't print / print preview interstitials or crashed tabs.
-  if (web_contents()->ShowingInterstitialPage() ||
-      web_contents()->IsCrashed()) {
-    delete message;
+  if (web_contents()->ShowingInterstitialPage() || web_contents()->IsCrashed())
     return false;
-  }
-  return Send(message);
+  return rfh->Send(message.release());
+}
+
+void PrintViewManagerBase::SetPrintingRFH(content::RenderFrameHost* rfh) {
+  DCHECK(!printing_rfh_);
+  printing_rfh_ = rfh;
 }
 
 void PrintViewManagerBase::ReleasePrinterQuery() {
   if (!cookie_)
     return;
 
   int cookie = cookie_;
   cookie_ = 0;
 
   PrintJobManager* print_job_manager = g_browser_process->print_job_manager();
   // May be NULL in tests.
   if (!print_job_manager)
     return;
 
   scoped_refptr<PrinterQuery> printer_query;
   printer_query = queue_->PopPrinterQuery(cookie);
   if (!printer_query.get())
     return;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PrinterQuery::StopWorker, printer_query));
 }
 
+void PrintViewManagerBase::SendPrintingEnabled(bool enabled,
+                                               content::RenderFrameHost* rfh) {
+  rfh->Send(new PrintMsg_SetPrintingEnabled(rfh->GetRoutingID(), enabled));
+}
+
 }  // namespace printing