[printing] Convert PrintHostMsg_UpdatePrintSettings to Mojo

This CL converts PrintHostMsg_UpdatePrintSettings message to
UpdatePrintSettings() in mojom::PrintManagerHost.

It introduces several helper functions to access PrinterQuery which
runs on IO thread like GetDefaultPrintSettings().
UpdatePrintSettings() is called on UI thread and posted to IO
thread for PrintViewManagerBase to update the settings.

It removes NupPrintingTestDelegate and
PrintingMessageFilter::TestDelegate. Instead, it adds
TestPrintViewManager to override UpdatePrintSettings() for N-up
setting.

Bug: 1008939
Change-Id: I2f5d876c9139122673e103fb31a425a61398bdbd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2452129Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Sam McNally <sammc@chromium.org>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Commit-Queue: Julie Kim <jkim@igalia.com>
Cr-Commit-Position: refs/heads/master@{#818768}

chrome/browser/printing/print_browsertest.cc

@@ -13,8 +13,12 @@
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
+#include "build/build_config.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
+#include "chrome/browser/printing/print_job_manager.h"
+#include "chrome/browser/printing/print_view_manager_base.h"
 #include "chrome/browser/printing/print_view_manager_common.h"
+#include "chrome/browser/printing/printer_query.h"
 #include "chrome/browser/printing/printing_message_filter.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
@@ -32,6 +36,8 @@
 #include "components/printing/common/print.mojom.h"
 #include "components/printing/common/print_messages.h"
 #include "content/public/browser/browser_message_filter.h"
+#include "content/public/browser/browser_task_traits.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_features.h"
@@ -53,6 +59,72 @@ namespace {
 
 constexpr int kDefaultDocumentCookie = 1234;
 
+mojom::PrintParamsPtr GetPrintParams() {
+  auto params = mojom::PrintParams::New();
+  params->page_size = gfx::Size(612, 792);
+  params->content_size = gfx::Size(540, 720);
+  params->printable_area = gfx::Rect(612, 792);
+  params->dpi = gfx::Size(72, 72);
+  params->document_cookie = kDefaultDocumentCookie;
+  params->pages_per_sheet = 4;
+  params->printed_doc_type = IsOopifEnabled() ? mojom::SkiaDocumentType::kMSKP
+                                              : mojom::SkiaDocumentType::kPDF;
+  return params;
+}
+
+void UpdatePrintSettingsReplyOnIO(
+    scoped_refptr<PrintQueriesQueue> queue,
+    std::unique_ptr<PrinterQuery> printer_query,
+    mojom::PrintManagerHost::UpdatePrintSettingsCallback callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK(printer_query);
+  auto params = mojom::PrintPagesParams::New();
+  params->params = mojom::PrintParams::New();
+  if (printer_query->last_status() == PrintingContext::OK) {
+    RenderParamsFromPrintSettings(printer_query->settings(),
+                                  params->params.get());
+    params->params->document_cookie = printer_query->cookie();
+    params->pages = PageRange::GetPages(printer_query->settings().ranges());
+  }
+  bool canceled = printer_query->last_status() == PrintingContext::CANCEL;
+
+  params->params = GetPrintParams();
+
+  content::GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](mojom::PrintManagerHost::UpdatePrintSettingsCallback callback,
+             mojom::PrintPagesParamsPtr params, bool canceled) {
+            DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+            std::move(callback).Run(std::move(params), canceled);
+          },
+          std::move(callback), std::move(params), canceled));
+
+  if (printer_query->cookie() && printer_query->settings().dpi()) {
+    queue->QueuePrinterQuery(std::move(printer_query));
+  } else {
+    printer_query->StopWorker();
+  }
+}
+
+void UpdatePrintSettingsOnIO(
+    int32_t cookie,
+    mojom::PrintManagerHost::UpdatePrintSettingsCallback callback,
+    scoped_refptr<PrintQueriesQueue> queue,
+    base::Value job_settings) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  std::unique_ptr<PrinterQuery> printer_query = queue->PopPrinterQuery(cookie);
+  if (!printer_query) {
+    printer_query = queue->CreatePrinterQuery(
+        content::ChildProcessHost::kInvalidUniqueID, MSG_ROUTING_NONE);
+  }
+  auto* printer_query_ptr = printer_query.get();
+  printer_query_ptr->SetSettings(
+      std::move(job_settings),
+      base::BindOnce(&UpdatePrintSettingsReplyOnIO, queue,
+                     std::move(printer_query), std::move(callback)));
+}
+
 class PrintPreviewObserver : PrintPreviewUI::TestDelegate {
  public:
   explicit PrintPreviewObserver(bool wait_for_loaded) {
@@ -117,33 +189,6 @@ class PrintPreviewObserver : PrintPreviewUI::TestDelegate {
   DISALLOW_COPY_AND_ASSIGN(PrintPreviewObserver);
 };
 
-class NupPrintingTestDelegate : public PrintingMessageFilter::TestDelegate {
- public:
-  NupPrintingTestDelegate() {
-    PrintingMessageFilter::SetDelegateForTesting(this);
-  }
-  ~NupPrintingTestDelegate() override {
-    PrintingMessageFilter::SetDelegateForTesting(nullptr);
-  }
-
-  // PrintingMessageFilter::TestDelegate:
-  mojom::PrintParamsPtr GetPrintParams() override {
-    auto params = mojom::PrintParams::New();
-    params->page_size = gfx::Size(612, 792);
-    params->content_size = gfx::Size(540, 720);
-    params->printable_area = gfx::Rect(612, 792);
-    params->dpi = gfx::Size(72, 72);
-    params->document_cookie = kDefaultDocumentCookie;
-    params->pages_per_sheet = 4;
-    params->printed_doc_type = IsOopifEnabled() ? mojom::SkiaDocumentType::kMSKP
-                                                : mojom::SkiaDocumentType::kPDF;
-    return params;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(NupPrintingTestDelegate);
-};
-
 class TestPrintRenderFrame
     : public mojom::PrintRenderFrameInterceptorForTesting {
  public:
@@ -269,6 +314,26 @@ class KillPrintRenderFrame
 
 }  // namespace
 
+class TestPrintViewManager : public PrintViewManagerBase {
+ public:
+  explicit TestPrintViewManager(content::WebContents* web_contents)
+      : PrintViewManagerBase(web_contents) {}
+  TestPrintViewManager(const TestPrintViewManager&) = delete;
+  TestPrintViewManager& operator=(const TestPrintViewManager&) = delete;
+  ~TestPrintViewManager() override = default;
+
+ private:
+  // printing::mojom::PrintManagerHost:
+  void UpdatePrintSettings(int32_t cookie,
+                           base::Value job_settings,
+                           UpdatePrintSettingsCallback callback) override {
+    content::GetIOThreadTaskRunner({})->PostTask(
+        FROM_HERE,
+        base::BindOnce(&UpdatePrintSettingsOnIO, cookie, std::move(callback),
+                       queue_, std::move(job_settings)));
+  }
+};
+
 class PrintBrowserTest : public InProcessBrowserTest {
  public:
   PrintBrowserTest() = default;
@@ -913,21 +978,33 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessPrintExtensionBrowserTest,
 // Printing frame content for the main frame of a generic webpage with N-up
 // priting. This is a regression test for https://crbug.com/937247
 IN_PROC_BROWSER_TEST_F(PrintBrowserTest, PrintNup) {
-  NupPrintingTestDelegate test_delegate;
   ASSERT_TRUE(embedded_test_server()->Started());
   GURL url(embedded_test_server()->GetURL("/printing/test1.html"));
   ui_test_utils::NavigateToURL(browser(), url);
 
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  ASSERT_TRUE(web_contents);
+  content::RemoveWebContentsReceiverSet(web_contents,
+                                        mojom::PrintManagerHost::Name_);
+  TestPrintViewManager print_view_manager(web_contents);
+
   PrintAndWaitUntilPreviewIsReady(/*print_only_selection=*/false);
 }
 
 // Site per process version of PrintBrowserTest.PrintNup.
 IN_PROC_BROWSER_TEST_F(SitePerProcessPrintBrowserTest, PrintNup) {
-  NupPrintingTestDelegate test_delegate;
   ASSERT_TRUE(embedded_test_server()->Started());
   GURL url(embedded_test_server()->GetURL("/printing/test1.html"));
   ui_test_utils::NavigateToURL(browser(), url);
 
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  ASSERT_TRUE(web_contents);
+  content::RemoveWebContentsReceiverSet(web_contents,
+                                        mojom::PrintManagerHost::Name_);
+  TestPrintViewManager print_view_manager(web_contents);
+
   PrintAndWaitUntilPreviewIsReady(/*print_only_selection=*/false);
 }
 

chrome/browser/printing/print_view_manager_base.cc

@@ -25,6 +25,7 @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/browser/printing/print_job_manager.h"
+#include "chrome/browser/printing/print_view_manager.h"
 #include "chrome/browser/printing/print_view_manager_common.h"
 #include "chrome/browser/printing/printer_query.h"
 #include "chrome/browser/profiles/profile.h"
@@ -166,6 +167,104 @@ void GetDefaultPrintSettingsOnIO(
                      std::move(printer_query), std::move(callback)));
 }
 
+// Runs |callback| with |params| to reply to
+// mojom::PrintManagerHost::UpdatePrintSettings.
+void UpdatePrintSettingsReply(
+    mojom::PrintManagerHost::UpdatePrintSettingsCallback callback,
+    mojom::PrintPagesParamsPtr params,
+    bool canceled) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!params) {
+    // Fills |params| with initial values.
+    params = mojom::PrintPagesParams::New();
+    params->params = mojom::PrintParams::New();
+  }
+  std::move(callback).Run(std::move(params), canceled);
+}
+
+#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
+content::WebContents* GetWebContentsForRenderFrame(int render_process_id,
+                                                   int render_frame_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  content::RenderFrameHost* frame =
+      content::RenderFrameHost::FromID(render_process_id, render_frame_id);
+  return frame ? content::WebContents::FromRenderFrameHost(frame) : nullptr;
+}
+
+PrintViewManager* GetPrintViewManager(int render_process_id,
+                                      int render_frame_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  content::WebContents* web_contents =
+      GetWebContentsForRenderFrame(render_process_id, render_frame_id);
+  return web_contents ? PrintViewManager::FromWebContents(web_contents)
+                      : nullptr;
+}
+
+void NotifySystemDialogCancelled(int render_process_id, int routing_id) {
+  PrintViewManager* manager =
+      GetPrintViewManager(render_process_id, routing_id);
+  if (manager)
+    manager->SystemDialogCancelled();
+}
+#endif
+
+void UpdatePrintSettingsReplyOnIO(
+    scoped_refptr<PrintQueriesQueue> queue,
+    std::unique_ptr<PrinterQuery> printer_query,
+    mojom::PrintManagerHost::UpdatePrintSettingsCallback callback,
+    int process_id,
+    int routing_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK(printer_query);
+  auto params = mojom::PrintPagesParams::New();
+  params->params = mojom::PrintParams::New();
+  if (printer_query->last_status() == PrintingContext::OK) {
+    RenderParamsFromPrintSettings(printer_query->settings(),
+                                  params->params.get());
+    params->params->document_cookie = printer_query->cookie();
+    params->pages = PageRange::GetPages(printer_query->settings().ranges());
+  }
+  bool canceled = printer_query->last_status() == PrintingContext::CANCEL;
+#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
+  if (canceled) {
+    content::GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
+        base::BindOnce(&NotifySystemDialogCancelled, process_id, routing_id));
+  }
+#endif
+
+  content::GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(&UpdatePrintSettingsReply, std::move(callback),
+                                std::move(params), canceled));
+
+  if (printer_query->cookie() && printer_query->settings().dpi()) {
+    queue->QueuePrinterQuery(std::move(printer_query));
+  } else {
+    printer_query->StopWorker();
+  }
+}
+
+void UpdatePrintSettingsOnIO(
+    int32_t cookie,
+    mojom::PrintManagerHost::UpdatePrintSettingsCallback callback,
+    scoped_refptr<PrintQueriesQueue> queue,
+    base::Value job_settings,
+    int process_id,
+    int routing_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  std::unique_ptr<PrinterQuery> printer_query = queue->PopPrinterQuery(cookie);
+  if (!printer_query) {
+    printer_query = queue->CreatePrinterQuery(
+        content::ChildProcessHost::kInvalidUniqueID, MSG_ROUTING_NONE);
+  }
+  auto* printer_query_ptr = printer_query.get();
+  printer_query_ptr->SetSettings(
+      std::move(job_settings),
+      base::BindOnce(&UpdatePrintSettingsReplyOnIO, queue,
+                     std::move(printer_query), std::move(callback), process_id,
+                     routing_id));
+}
+
 }  // namespace
 
 PrintViewManagerBase::PrintViewManagerBase(content::WebContents* web_contents)
@@ -437,6 +536,32 @@ void PrintViewManagerBase::GetDefaultPrintSettings(
                      render_frame_host->GetRoutingID()));
 }
 
+void PrintViewManagerBase::UpdatePrintSettings(
+    int32_t cookie,
+    base::Value job_settings,
+    UpdatePrintSettingsCallback callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!printing_enabled_.GetValue()) {
+    UpdatePrintSettingsReply(std::move(callback), nullptr, false);
+    return;
+  }
+
+  if (!job_settings.FindIntKey(kSettingPrinterType)) {
+    UpdatePrintSettingsReply(std::move(callback), nullptr, false);
+    return;
+  }
+
+  content::RenderFrameHost* render_frame_host =
+      print_manager_host_receivers_.GetCurrentTargetFrame();
+
+  content::GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE,
+      base::BindOnce(&UpdatePrintSettingsOnIO, cookie, std::move(callback),
+                     queue_, std::move(job_settings),
+                     render_frame_host->GetProcess()->GetID(),
+                     render_frame_host->GetRoutingID()));
+}
+
 void PrintViewManagerBase::PrintingFailed(int32_t cookie) {
   PrintManager::PrintingFailed(cookie);
 

chrome/browser/printing/print_view_manager_base.h

@@ -84,6 +84,9 @@ class PrintViewManagerBase : public content::NotificationObserver,
 #endif
   void GetDefaultPrintSettings(
       GetDefaultPrintSettingsCallback callback) override;
+  void UpdatePrintSettings(int32_t cookie,
+                           base::Value job_settings,
+                           UpdatePrintSettingsCallback callback) override;
   void ShowInvalidPrinterSettingsError() override;
   void PrintingFailed(int32_t cookie) override;
 
@@ -116,6 +119,8 @@ class PrintViewManagerBase : public content::NotificationObserver,
   scoped_refptr<PrintJob> print_job_;
 
  private:
+  friend class TestPrintViewManager;
+
   // content::NotificationObserver implementation.
   void Observe(int type,
                const content::NotificationSource& source,

chrome/browser/printing/printing_message_filter.cc

@@ -43,8 +43,6 @@ namespace printing {
 
 namespace {
 
-PrintingMessageFilter::TestDelegate* g_test_delegate = nullptr;
-
 class PrintingMessageFilterShutdownNotifierFactory
     : public BrowserContextKeyedServiceShutdownNotifierFactory {
  public:
@@ -65,32 +63,8 @@ class PrintingMessageFilterShutdownNotifierFactory
   DISALLOW_COPY_AND_ASSIGN(PrintingMessageFilterShutdownNotifierFactory);
 };
 
-#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
-content::WebContents* GetWebContentsForRenderFrame(int render_process_id,
-                                                   int render_frame_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  content::RenderFrameHost* frame =
-      content::RenderFrameHost::FromID(render_process_id, render_frame_id);
-  return frame ? content::WebContents::FromRenderFrameHost(frame) : nullptr;
-}
-
-PrintViewManager* GetPrintViewManager(int render_process_id,
-                                      int render_frame_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  content::WebContents* web_contents =
-      GetWebContentsForRenderFrame(render_process_id, render_frame_id);
-  return web_contents ? PrintViewManager::FromWebContents(web_contents)
-                      : nullptr;
-}
-#endif  // defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
-
 }  // namespace
 
-// static
-void PrintingMessageFilter::SetDelegateForTesting(TestDelegate* delegate) {
-  g_test_delegate = delegate;
-}
-
 PrintingMessageFilter::PrintingMessageFilter(int render_process_id,
                                              Profile* profile)
     : BrowserMessageFilter(PrintMsgStart),
@@ -124,8 +98,6 @@ bool PrintingMessageFilter::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintingMessageFilter, message)
     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
@@ -177,82 +149,6 @@ void PrintingMessageFilter::OnScriptedPrintReply(
   }
 }
 
-void PrintingMessageFilter::OnUpdatePrintSettings(int document_cookie,
-                                                  base::Value job_settings,
-                                                  IPC::Message* reply_msg) {
-  if (!is_printing_enabled_.GetValue()) {
-    // Reply with null query.
-    OnUpdatePrintSettingsReply(nullptr, reply_msg);
-    return;
-  }
-
-  if (!job_settings.is_dict() ||
-      !job_settings.FindIntKey(kSettingPrinterType)) {
-    // Reply with null query.
-    OnUpdatePrintSettingsReply(nullptr, reply_msg);
-    return;
-  }
-
-  std::unique_ptr<PrinterQuery> printer_query =
-      queue_->PopPrinterQuery(document_cookie);
-  if (!printer_query) {
-    printer_query = queue_->CreatePrinterQuery(
-        content::ChildProcessHost::kInvalidUniqueID, MSG_ROUTING_NONE);
-  }
-  auto* printer_query_ptr = printer_query.get();
-  printer_query_ptr->SetSettings(
-      std::move(job_settings),
-      base::BindOnce(&PrintingMessageFilter::OnUpdatePrintSettingsReply, this,
-                     std::move(printer_query), reply_msg));
-}
-
-#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
-void PrintingMessageFilter::NotifySystemDialogCancelled(int routing_id) {
-  PrintViewManager* manager =
-      GetPrintViewManager(render_process_id_, routing_id);
-  manager->SystemDialogCancelled();
-}
-#endif
-
-void PrintingMessageFilter::OnUpdatePrintSettingsReply(
-    std::unique_ptr<PrinterQuery> printer_query,
-    IPC::Message* reply_msg) {
-  mojom::PrintPagesParams params;
-  params.params = mojom::PrintParams::New();
-  if (printer_query && printer_query->last_status() == PrintingContext::OK) {
-    RenderParamsFromPrintSettings(printer_query->settings(),
-                                  params.params.get());
-    params.params->document_cookie = printer_query->cookie();
-    params.pages = PageRange::GetPages(printer_query->settings().ranges());
-  }
-  bool canceled = printer_query &&
-                  (printer_query->last_status() == PrintingContext::CANCEL);
-#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
-  if (canceled) {
-    int routing_id = reply_msg->routing_id();
-    content::GetUIThreadTaskRunner({})->PostTask(
-        FROM_HERE,
-        base::BindOnce(&PrintingMessageFilter::NotifySystemDialogCancelled,
-                       this, routing_id));
-  }
-#endif
-
-  if (g_test_delegate)
-    params.params = g_test_delegate->GetPrintParams();
-
-  PrintHostMsg_UpdatePrintSettings::WriteReplyParams(reply_msg, params,
-                                                     canceled);
-  Send(reply_msg);
-  // If user hasn't cancelled.
-  if (printer_query) {
-    if (printer_query->cookie() && printer_query->settings().dpi()) {
-      queue_->QueuePrinterQuery(std::move(printer_query));
-    } else {
-      printer_query->StopWorker();
-    }
-  }
-}
-
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
 void PrintingMessageFilter::OnCheckForCancel(const mojom::PreviewIds& ids,
                                              bool* cancel) {

chrome/browser/printing/printing_message_filter.h

@@ -31,17 +31,6 @@ class PrinterQuery;
 // renderer process on the IPC thread.
 class PrintingMessageFilter : public content::BrowserMessageFilter {
  public:
-  class TestDelegate {
-   public:
-    // Returns the print params to be used in OnUpdatePrintSettingsReply().
-    virtual mojom::PrintParamsPtr GetPrintParams() = 0;
-
-   protected:
-    virtual ~TestDelegate() = default;
-  };
-
-  static void SetDelegateForTesting(TestDelegate* delegate);
-
   PrintingMessageFilter(int render_process_id, Profile* profile);
 
   // content::BrowserMessageFilter:
@@ -65,21 +54,9 @@ class PrintingMessageFilter : public content::BrowserMessageFilter {
   void OnScriptedPrintReply(std::unique_ptr<PrinterQuery> printer_query,
                             IPC::Message* reply_msg);
 
-  // Modify the current print settings based on |job_settings|. The task is
-  // handled by the print worker thread and the UI thread. The reply occurs on
-  // the IO thread.
-  void OnUpdatePrintSettings(int document_cookie,
-                             base::Value job_settings,
-                             IPC::Message* reply_msg);
-  void OnUpdatePrintSettingsReply(std::unique_ptr<PrinterQuery> printer_query,
-                                  IPC::Message* reply_msg);
-
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   // Check to see if print preview has been cancelled.
   void OnCheckForCancel(const mojom::PreviewIds& ids, bool* cancel);
-#if defined(OS_WIN)
-  void NotifySystemDialogCancelled(int routing_id);
-#endif
 #endif
 
   std::unique_ptr<KeyedServiceShutdownNotifier::Subscription>

components/printing/browser/print_manager.cc

@@ -112,6 +112,14 @@ void PrintManager::SetAccessibilityTree(
     const ui::AXTreeUpdate& accessibility_tree) {}
 #endif
 
+void PrintManager::UpdatePrintSettings(int32_t cookie,
+                                       base::Value job_settings,
+                                       UpdatePrintSettingsCallback callback) {
+  auto params = mojom::PrintPagesParams::New();
+  params->params = mojom::PrintParams::New();
+  std::move(callback).Run(std::move(params), false);
+}
+
 void PrintManager::DidShowPrintDialog() {}
 
 void PrintManager::ShowInvalidPrinterSettingsError() {}

components/printing/browser/print_manager.h

@@ -52,6 +52,9 @@ class PrintManager : public content::WebContentsObserver,
       int32_t cookie,
       const ui::AXTreeUpdate& accessibility_tree) override;
 #endif
+  void UpdatePrintSettings(int32_t cookie,
+                           base::Value job_settings,
+                           UpdatePrintSettingsCallback callback) override;
   void DidShowPrintDialog() override;
   void ShowInvalidPrinterSettingsError() override;
   void PrintingFailed(int32_t cookie) override;

components/printing/common/print.mojom

@@ -292,6 +292,13 @@ interface PrintManagerHost {
   [Sync]
   GetDefaultPrintSettings() => (PrintParams default_settings);
 
+  // Update the current print settings with new |job_settings|.
+  [Sync]
+  UpdatePrintSettings(
+      int32 cookie,
+      mojo_base.mojom.DictionaryValue job_settings)
+      => (PrintPagesParams current_settings, bool canceled);
+
   // Tells the browser that the print dialog has been shown.
   DidShowPrintDialog();
 

components/printing/common/print_messages.h

@@ -277,15 +277,6 @@ IPC_SYNC_MESSAGE_ROUTED1_1(PrintHostMsg_DidPrintDocument,
                            /* page content */,
                            bool /* completed */)
 
-// The renderer wants to update the current print settings with new
-// |job_settings|.
-IPC_SYNC_MESSAGE_ROUTED2_2(
-    PrintHostMsg_UpdatePrintSettings,
-    int /* document_cookie */,
-    base::DictionaryValue /* job_settings */,
-    printing::mojom::PrintPagesParams /* current_settings */,
-    bool /* canceled */)
-
 // It's the renderer that controls the printing process when it is generated
 // by javascript. This step is about showing UI to the user to select the
 // final print settings. The output parameter is the same as

components/printing/renderer/print_render_frame_helper.cc

@@ -2167,11 +2167,10 @@ bool PrintRenderFrameHelper::UpdatePrintSettings(
   // possible.
   int cookie =
       print_pages_params_ ? print_pages_params_->params->document_cookie : 0;
-  mojom::PrintPagesParams settings;
-  settings.params = mojom::PrintParams::New();
+  mojom::PrintPagesParamsPtr settings;
   bool canceled = false;
-  Send(new PrintHostMsg_UpdatePrintSettings(routing_id(), cookie, *job_settings,
-                                            &settings, &canceled));
+  GetPrintManagerHost()->UpdatePrintSettings(cookie, job_settings->Clone(),
+                                             &settings, &canceled);
   if (canceled) {
     notify_browser_of_print_failure_ = false;
     return false;
@@ -2179,7 +2178,7 @@ bool PrintRenderFrameHelper::UpdatePrintSettings(
 
   // TODO(dhoss): Replace deprecated base::DictionaryValue::Get<Type>() calls
   if (!job_settings->GetInteger(kPreviewUIID,
-                                &settings.params->preview_ui_id)) {
+                                &settings->params->preview_ui_id)) {
     NOTREACHED();
     print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
@@ -2187,22 +2186,22 @@ bool PrintRenderFrameHelper::UpdatePrintSettings(
 
   // Validate expected print preview settings.
   if (!job_settings->GetInteger(kPreviewRequestID,
-                                &settings.params->preview_request_id) ||
+                                &settings->params->preview_request_id) ||
       !job_settings->GetBoolean(kIsFirstRequest,
-                                &settings.params->is_first_request)) {
+                                &settings->params->is_first_request)) {
     NOTREACHED();
     print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
 
-  settings.params->print_to_pdf = IsPrintToPdfRequested(*job_settings);
+  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);
+  settings->params->print_scaling_option = GetPrintScalingOption(
+      frame, node, source_is_html, *job_settings, *settings->params);
 
-  SetPrintPagesParams(settings);
+  SetPrintPagesParams(*settings);
 
-  if (PrintMsg_Print_Params_IsValid(*settings.params))
+  if (PrintMsg_Print_Params_IsValid(*settings->params))
     return true;
 
   print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);

components/printing/test/print_mock_render_thread.cc

@@ -7,13 +7,10 @@
 #include <stddef.h>
 
 #include "base/run_loop.h"
-#include "base/values.h"
-#include "build/build_config.h"
 #include "components/printing/common/print.mojom.h"
 #include "components/printing/test/mock_printer.h"
 #include "ipc/ipc_sync_message.h"
 #include "printing/buildflags/buildflags.h"
-#include "printing/page_range.h"
 #include "printing/print_job_constants.h"
 #include "printing/units.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -54,8 +51,6 @@ bool PrintMockRenderThread::OnMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(PrintMockRenderThread, msg)
 #if BUILDFLAG(ENABLE_PRINTING)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrint, OnScriptedPrint)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_UpdatePrintSettings,
-                                    OnUpdatePrintSettings)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_DidPrintDocument,
                                     OnDidPrintDocument)
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
@@ -117,98 +112,6 @@ void PrintMockRenderThread::OnCheckForCancel(
 }
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
-void PrintMockRenderThread::OnUpdatePrintSettings(
-    int document_cookie,
-    const base::DictionaryValue& job_settings,
-    IPC::Message* reply_msg) {
-  printing::mojom::PrintPagesParams params;
-  params.params = printing::mojom::PrintParams::New();
-  bool canceled = false;
-
-  // Check and make sure the required settings are all there.
-  // We don't actually care about the values.
-  base::Optional<int> margins_type =
-      job_settings.FindIntKey(printing::kSettingMarginsType);
-  if (!margins_type.has_value() ||
-      !job_settings.FindBoolKey(printing::kSettingLandscape) ||
-      !job_settings.FindBoolKey(printing::kSettingCollate) ||
-      !job_settings.FindIntKey(printing::kSettingColor) ||
-      !job_settings.FindIntKey(printing::kSettingPrinterType) ||
-      !job_settings.FindBoolKey(printing::kIsFirstRequest) ||
-      !job_settings.FindStringKey(printing::kSettingDeviceName) ||
-      !job_settings.FindIntKey(printing::kSettingDuplexMode) ||
-      !job_settings.FindIntKey(printing::kSettingCopies) ||
-      !job_settings.FindIntKey(printing::kPreviewUIID) ||
-      !job_settings.FindIntKey(printing::kPreviewRequestID)) {
-    PrintHostMsg_UpdatePrintSettings::WriteReplyParams(reply_msg, params,
-                                                       canceled);
-    Send(reply_msg);
-    return;
-  }
-
-  // Just return the default settings.
-  const base::Value* page_range =
-      job_settings.FindListKey(printing::kSettingPageRange);
-  printing::PageRanges new_ranges;
-  if (page_range) {
-    for (const base::Value& dict : page_range->GetList()) {
-      if (!dict.is_dict())
-        continue;
-
-      base::Optional<int> range_from =
-          dict.FindIntKey(printing::kSettingPageRangeFrom);
-      base::Optional<int> range_to =
-          dict.FindIntKey(printing::kSettingPageRangeTo);
-      if (!range_from || !range_to)
-        continue;
-
-      // Page numbers are 1-based in the dictionary.
-      // Page numbers are 0-based for the printing context.
-      printing::PageRange range;
-      range.from = range_from.value() - 1;
-      range.to = range_to.value() - 1;
-      new_ranges.push_back(range);
-    }
-  }
-
-  // Get media size
-  const base::Value* media_size_value =
-      job_settings.FindDictKey(printing::kSettingMediaSize);
-  gfx::Size page_size;
-  if (media_size_value) {
-    base::Optional<int> width_microns =
-        media_size_value->FindIntKey(printing::kSettingMediaSizeWidthMicrons);
-    base::Optional<int> height_microns =
-        media_size_value->FindIntKey(printing::kSettingMediaSizeHeightMicrons);
-
-    if (width_microns && height_microns) {
-      float device_microns_per_unit =
-          static_cast<float>(printing::kMicronsPerInch) /
-          printing::kDefaultPdfDpi;
-      page_size = gfx::Size(width_microns.value() / device_microns_per_unit,
-                            height_microns.value() / device_microns_per_unit);
-    }
-  }
-
-  // Get scaling
-  base::Optional<int> setting_scale_factor =
-      job_settings.FindIntKey(printing::kSettingScaleFactor);
-  int scale_factor = setting_scale_factor.value_or(100);
-
-  std::vector<uint32_t> pages(printing::PageRange::GetPages(new_ranges));
-  printer_->UpdateSettings(document_cookie, &params, pages,
-                           margins_type.value(), page_size, scale_factor);
-  base::Optional<bool> selection_only =
-      job_settings.FindBoolKey(printing::kSettingShouldPrintSelectionOnly);
-  base::Optional<bool> should_print_backgrounds =
-      job_settings.FindBoolKey(printing::kSettingShouldPrintBackgrounds);
-  params.params->selection_only = selection_only.value();
-  params.params->should_print_backgrounds = should_print_backgrounds.value();
-  PrintHostMsg_UpdatePrintSettings::WriteReplyParams(reply_msg, params,
-                                                     canceled);
-  Send(reply_msg);
-}
-
 MockPrinter* PrintMockRenderThread::printer() {
   return printer_.get();
 }

components/printing/test/print_mock_render_thread.h

@@ -20,10 +20,6 @@
 #include "printing/buildflags/buildflags.h"
 #include "printing/print_job_constants.h"
 
-namespace base {
-class DictionaryValue;
-}
-
 class MockPrinter;
 
 // Extends content::MockRenderThread to know about printing
@@ -82,11 +78,6 @@ class PrintMockRenderThread : public content::MockRenderThread {
   void OnCheckForCancel(const printing::mojom::PreviewIds& ids, bool* cancel);
 #endif
 
-  // For print preview, PrintRenderFrameHelper will update settings.
-  void OnUpdatePrintSettings(int document_cookie,
-                             const base::DictionaryValue& job_settings,
-                             IPC::Message* reply_msg);
-
   // A mock printer device used for printing tests.
   std::unique_ptr<MockPrinter> printer_;
 

components/printing/test/print_render_frame_helper_browsertest.cc

@@ -28,6 +28,7 @@
 #include "ipc/ipc_listener.h"
 #include "printing/buildflags/buildflags.h"
 #include "printing/mojom/print.mojom.h"
+#include "printing/page_range.h"
 #include "printing/print_job_constants.h"
 #include "printing/units.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -235,6 +236,93 @@ class TestPrintManagerHost
         printer_->GetDefaultPrintSettings();
     std::move(callback).Run(std::move(params));
   }
+  void UpdatePrintSettings(int32_t cookie,
+                           base::Value job_settings,
+                           UpdatePrintSettingsCallback callback) override {
+    auto params = printing::mojom::PrintPagesParams::New();
+    params->params = printing::mojom::PrintParams::New();
+    bool canceled = false;
+
+    // Check and make sure the required settings are all there.
+    // We don't actually care about the values.
+    base::Optional<int> margins_type =
+        job_settings.FindIntKey(printing::kSettingMarginsType);
+    if (!margins_type.has_value() ||
+        !job_settings.FindBoolKey(printing::kSettingLandscape) ||
+        !job_settings.FindBoolKey(printing::kSettingCollate) ||
+        !job_settings.FindIntKey(printing::kSettingColor) ||
+        !job_settings.FindIntKey(printing::kSettingPrinterType) ||
+        !job_settings.FindBoolKey(printing::kIsFirstRequest) ||
+        !job_settings.FindStringKey(printing::kSettingDeviceName) ||
+        !job_settings.FindIntKey(printing::kSettingDuplexMode) ||
+        !job_settings.FindIntKey(printing::kSettingCopies) ||
+        !job_settings.FindIntKey(printing::kPreviewUIID) ||
+        !job_settings.FindIntKey(printing::kPreviewRequestID)) {
+      std::move(callback).Run(std::move(params), canceled);
+      return;
+    }
+
+    // Just return the default settings.
+    const base::Value* page_range =
+        job_settings.FindListKey(printing::kSettingPageRange);
+    printing::PageRanges new_ranges;
+    if (page_range) {
+      for (const base::Value& dict : page_range->GetList()) {
+        if (!dict.is_dict())
+          continue;
+
+        base::Optional<int> range_from =
+            dict.FindIntKey(printing::kSettingPageRangeFrom);
+        base::Optional<int> range_to =
+            dict.FindIntKey(printing::kSettingPageRangeTo);
+        if (!range_from || !range_to)
+          continue;
+
+        // Page numbers are 1-based in the dictionary.
+        // Page numbers are 0-based for the printing context.
+        printing::PageRange range;
+        range.from = range_from.value() - 1;
+        range.to = range_to.value() - 1;
+        new_ranges.push_back(range);
+      }
+    }
+
+    // Get media size
+    const base::Value* media_size_value =
+        job_settings.FindDictKey(printing::kSettingMediaSize);
+    gfx::Size page_size;
+    if (media_size_value) {
+      base::Optional<int> width_microns =
+          media_size_value->FindIntKey(printing::kSettingMediaSizeWidthMicrons);
+      base::Optional<int> height_microns = media_size_value->FindIntKey(
+          printing::kSettingMediaSizeHeightMicrons);
+
+      if (width_microns && height_microns) {
+        float device_microns_per_unit =
+            static_cast<float>(printing::kMicronsPerInch) /
+            printing::kDefaultPdfDpi;
+        page_size = gfx::Size(width_microns.value() / device_microns_per_unit,
+                              height_microns.value() / device_microns_per_unit);
+      }
+    }
+
+    // Get scaling
+    base::Optional<int> setting_scale_factor =
+        job_settings.FindIntKey(printing::kSettingScaleFactor);
+    int scale_factor = setting_scale_factor.value_or(100);
+
+    std::vector<uint32_t> pages(printing::PageRange::GetPages(new_ranges));
+    printer_->UpdateSettings(cookie, params.get(), pages, margins_type.value(),
+                             page_size, scale_factor);
+    base::Optional<bool> selection_only =
+        job_settings.FindBoolKey(printing::kSettingShouldPrintSelectionOnly);
+    base::Optional<bool> should_print_backgrounds =
+        job_settings.FindBoolKey(printing::kSettingShouldPrintBackgrounds);
+    params->params->selection_only = selection_only.value();
+    params->params->should_print_backgrounds = should_print_backgrounds.value();
+    std::move(callback).Run(std::move(params), canceled);
+  }
+
   void DidShowPrintDialog() override {}
 
   void SetExpectedPagesCount(uint32_t number_pages) {