Make printing work better with OOPIF. (try 2)

chrome/browser/printing/printing_message_filter.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/browser/printing/printing_message_filter.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/printing/print_job_manager.h"
 #include "chrome/browser/printing/printer_query.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/printing/browser/print_manager_utils.h"
 #include "components/printing/common/print_messages.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "printing/features/features.h"
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "base/file_descriptor_posix.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/printing/print_view_manager_basic.h"
 #endif
 
 using content::BrowserThread;
 
 namespace printing {
 
 namespace {
 
 #if defined(OS_ANDROID)
-content::WebContents* GetWebContentsForRenderView(int render_process_id,
-                                                  int render_view_id) {
+content::WebContents* GetWebContentsForRenderFrame(int render_process_id,
+                                                   int render_frame_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  content::RenderViewHost* view = content::RenderViewHost::FromID(
-      render_process_id, render_view_id);
-  return view ? content::WebContents::FromRenderViewHost(view) : nullptr;
+  content::RenderFrameHost* frame =
+      content::RenderFrameHost::FromID(render_process_id, render_frame_id);
+  return frame ? content::WebContents::FromRenderFrameHost(frame) : nullptr;
 }
 
 PrintViewManagerBasic* GetPrintManager(int render_process_id,
-                                       int render_view_id) {
+                                       int render_frame_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   content::WebContents* web_contents =
-      GetWebContentsForRenderView(render_process_id, render_view_id);
+      GetWebContentsForRenderFrame(render_process_id, render_frame_id);
   return web_contents ? PrintViewManagerBasic::FromWebContents(web_contents)
                       : nullptr;
 }
 #endif
 
 }  // namespace
 
 PrintingMessageFilter::PrintingMessageFilter(int render_process_id,
                                              Profile* profile)
     : BrowserMessageFilter(PrintMsgStart),
@@ skipping 21 matching lines @@
 
 bool PrintingMessageFilter::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintingMessageFilter, message)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(PrintHostMsg_AllocateTempFileForPrinting,
                         OnAllocateTempFileForPrinting)
     IPC_MESSAGE_HANDLER(PrintHostMsg_TempFileForPrintingWritten,
                         OnTempFileForPrintingWritten)
 #endif
-    IPC_MESSAGE_HANDLER(PrintHostMsg_IsPrintingEnabled, OnIsPrintingEnabled)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_GetDefaultPrintSettings,
                                     OnGetDefaultPrintSettings)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrint, OnScriptedPrint)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_UpdatePrintSettings,
                                     OnUpdatePrintSettings)
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
     IPC_MESSAGE_HANDLER(PrintHostMsg_CheckForCancel, OnCheckForCancel)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 #if defined(OS_ANDROID)
 void PrintingMessageFilter::OnAllocateTempFileForPrinting(
-    int render_view_id,
+    int render_frame_id,
     base::FileDescriptor* temp_file_fd,
     int* sequence_number) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrintViewManagerBasic* print_view_manager =
-      GetPrintManager(render_process_id_, render_view_id);
+      GetPrintManager(render_process_id_, render_frame_id);
   if (!print_view_manager)
     return;
+
   // The file descriptor is originally created in & passed from the Android
   // side, and it will handle the closing.
   temp_file_fd->fd = print_view_manager->file_descriptor().fd;
   temp_file_fd->auto_close = false;
 }
 
-void PrintingMessageFilter::OnTempFileForPrintingWritten(int render_view_id,
+void PrintingMessageFilter::OnTempFileForPrintingWritten(int render_frame_id,
                                                          int sequence_number) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrintViewManagerBasic* print_view_manager =
-      GetPrintManager(render_process_id_, render_view_id);
+      GetPrintManager(render_process_id_, render_frame_id);
   if (print_view_manager)
     print_view_manager->PdfWritingDone(true);
 }
 #endif  // defined(OS_ANDROID)
 
-void PrintingMessageFilter::OnIsPrintingEnabled(bool* is_enabled) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  *is_enabled = is_printing_enabled_->GetValue();
-}
-
 void PrintingMessageFilter::OnGetDefaultPrintSettings(IPC::Message* reply_msg) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   scoped_refptr<PrinterQuery> printer_query;
   if (!is_printing_enabled_->GetValue()) {
     // Reply with NULL query.
     OnGetDefaultPrintSettingsReply(printer_query, reply_msg);
     return;
   }
   printer_query = queue_->PopPrinterQuery(0);
   if (!printer_query.get()) {
@@ skipping 81 matching lines @@
                      routing_id, file_descriptor));
     }
 #endif
     queue_->QueuePrinterQuery(printer_query.get());
   } else {
     printer_query->StopWorker();
   }
 }
 
 #if defined(OS_ANDROID)
-void PrintingMessageFilter::UpdateFileDescriptor(int render_view_id, int fd) {
+void PrintingMessageFilter::UpdateFileDescriptor(int render_frame_id, int fd) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrintViewManagerBasic* print_view_manager =
-      GetPrintManager(render_process_id_, render_view_id);
+      GetPrintManager(render_process_id_, render_frame_id);
   if (print_view_manager)
     print_view_manager->set_file_descriptor(base::FileDescriptor(fd, false));
 }
 #endif
 
 void PrintingMessageFilter::OnUpdatePrintSettings(
     int document_cookie, const base::DictionaryValue& job_settings,
     IPC::Message* reply_msg) {
   std::unique_ptr<base::DictionaryValue> new_settings(job_settings.DeepCopy());
 
@@ skipping 54 matching lines @@
 void PrintingMessageFilter::OnCheckForCancel(int32_t preview_ui_id,
                                              int preview_request_id,
                                              bool* cancel) {
   PrintPreviewUI::GetCurrentPrintPreviewStatus(preview_ui_id,
                                                preview_request_id,
                                                cancel);
 }
 #endif
 
 }  // namespace printing