[printing] Convert PrintHostMsg_GetDefaultPrintSettings to Mojo

This CL converts PrintHostMsg_GetDefaultPrintSettings message to
GetDefaultPrintSettings() in mojom::PrintManagerHost.

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

It also updates PrintRenderFrameHelperTestBase with implementing
GetDefaultPrintSettings in TestPrintManagerHost and managing it
based on the frame.

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

android_webview/browser/aw_print_manager.cc

@@ -79,16 +79,14 @@ bool AwPrintManager::PrintNow() {
   return true;
 }
 
-void AwPrintManager::OnGetDefaultPrintSettings(
-    content::RenderFrameHost* render_frame_host,
-    IPC::Message* reply_msg) {
-  // Unlike the printing_message_filter, we do process this in UI thread.
+void AwPrintManager::GetDefaultPrintSettings(
+    GetDefaultPrintSettingsCallback callback) {
+  // Unlike PrintViewManagerBase, we do process this in UI thread.
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  printing::mojom::PrintParams params;
-  printing::RenderParamsFromPrintSettings(*settings_, &params);
-  params.document_cookie = cookie_;
-  PrintHostMsg_GetDefaultPrintSettings::WriteReplyParams(reply_msg, params);
-  render_frame_host->Send(reply_msg);
+  auto params = printing::mojom::PrintParams::New();
+  printing::RenderParamsFromPrintSettings(*settings_, params.get());
+  params->document_cookie = cookie_;
+  std::move(callback).Run(std::move(params));
 }
 
 void AwPrintManager::OnScriptedPrint(

android_webview/browser/aw_print_manager.h

@@ -30,6 +30,10 @@ class AwPrintManager : public printing::PrintManager,
 
   ~AwPrintManager() override;
 
+  // mojom::PrintManagerHost:
+  void GetDefaultPrintSettings(
+      GetDefaultPrintSettingsCallback callback) override;
+
   // printing::PrintManager:
   void PdfWritingDone(int page_count) override;
 
@@ -48,8 +52,6 @@ class AwPrintManager : public printing::PrintManager,
       content::RenderFrameHost* render_frame_host,
       const printing::mojom::DidPrintDocumentParams& params,
       std::unique_ptr<DelayedFrameDispatchHelper> helper) override;
-  void OnGetDefaultPrintSettings(content::RenderFrameHost* render_frame_host,
-                                 IPC::Message* reply_msg) override;
   void OnScriptedPrint(content::RenderFrameHost* render_frame_host,
                        const printing::mojom::ScriptedPrintParams& params,
                        IPC::Message* reply_msg) override;

chrome/browser/printing/print_view_manager_base.cc

@@ -51,6 +51,7 @@
 #include "mojo/public/cpp/system/buffer.h"
 #include "printing/buildflags/buildflags.h"
 #include "printing/metafile_skia.h"
+#include "printing/mojom/print.mojom.h"
 #include "printing/print_settings.h"
 #include "printing/printed_document.h"
 #include "ui/base/l10n/l10n_util.h"
@@ -109,6 +110,62 @@ void CreateQueryWithSettings(base::Value job_settings,
 }
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
+// Runs |callback| with |params| to reply to
+// mojom::PrintManagerHost::GetDefaultPrintSettings.
+void GetDefaultPrintSettingsReply(
+    mojom::PrintManagerHost::GetDefaultPrintSettingsCallback callback,
+    mojom::PrintParamsPtr params) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  std::move(callback).Run(std::move(params));
+}
+
+void GetDefaultPrintSettingsReplyOnIO(
+    scoped_refptr<PrintQueriesQueue> queue,
+    std::unique_ptr<PrinterQuery> printer_query,
+    mojom::PrintManagerHost::GetDefaultPrintSettingsCallback callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  mojom::PrintParamsPtr params = mojom::PrintParams::New();
+  if (printer_query && printer_query->last_status() == PrintingContext::OK) {
+    RenderParamsFromPrintSettings(printer_query->settings(), params.get());
+    params->document_cookie = printer_query->cookie();
+  }
+
+  content::GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(&GetDefaultPrintSettingsReply,
+                                std::move(callback), std::move(params)));
+
+  // If printing was enabled.
+  if (printer_query) {
+    // If user hasn't cancelled.
+    if (printer_query->cookie() && printer_query->settings().dpi()) {
+      queue->QueuePrinterQuery(std::move(printer_query));
+    } else {
+      printer_query->StopWorker();
+    }
+  }
+}
+
+void GetDefaultPrintSettingsOnIO(
+    mojom::PrintManagerHost::GetDefaultPrintSettingsCallback callback,
+    scoped_refptr<PrintQueriesQueue> queue,
+    int process_id,
+    int routing_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  std::unique_ptr<PrinterQuery> printer_query = queue->PopPrinterQuery(0);
+  if (!printer_query)
+    printer_query = queue->CreatePrinterQuery(process_id, routing_id);
+
+  // Loads default settings. This is asynchronous, only the mojo message sender
+  // will hang until the settings are retrieved.
+  auto* printer_query_ptr = printer_query.get();
+  printer_query_ptr->GetSettings(
+      PrinterQuery::GetSettingsAskParam::DEFAULTS, 0, false,
+      printing::mojom::MarginType::kDefaultMargins, false, false,
+      base::BindOnce(&GetDefaultPrintSettingsReplyOnIO, queue,
+                     std::move(printer_query), std::move(callback)));
+}
+
 }  // namespace
 
 PrintViewManagerBase::PrintViewManagerBase(content::WebContents* web_contents)
@@ -361,10 +418,23 @@ void PrintViewManagerBase::OnDidPrintDocument(
   helper->SendCompleted();
 }
 
-void PrintViewManagerBase::OnGetDefaultPrintSettings(
-    content::RenderFrameHost* render_frame_host,
-    IPC::Message* reply_msg) {
-  NOTREACHED() << "should be handled by printing::PrintingMessageFilter";
+void PrintViewManagerBase::GetDefaultPrintSettings(
+    GetDefaultPrintSettingsCallback callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!printing_enabled_.GetValue()) {
+    auto params = mojom::PrintParams::New();
+    GetDefaultPrintSettingsReply(std::move(callback), std::move(params));
+    return;
+  }
+
+  content::RenderFrameHost* render_frame_host =
+      print_manager_host_receivers_.GetCurrentTargetFrame();
+
+  content::GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE,
+      base::BindOnce(&GetDefaultPrintSettingsOnIO, std::move(callback), queue_,
+                     render_frame_host->GetProcess()->GetID(),
+                     render_frame_host->GetRoutingID()));
 }
 
 void PrintViewManagerBase::PrintingFailed(int32_t cookie) {

chrome/browser/printing/print_view_manager_base.h

@@ -82,6 +82,8 @@ class PrintViewManagerBase : public content::NotificationObserver,
       int32_t cookie,
       const ui::AXTreeUpdate& accessibility_tree) override;
 #endif
+  void GetDefaultPrintSettings(
+      GetDefaultPrintSettingsCallback callback) override;
   void ShowInvalidPrinterSettingsError() override;
   void PrintingFailed(int32_t cookie) override;
 
@@ -130,8 +132,6 @@ class PrintViewManagerBase : public content::NotificationObserver,
       content::RenderFrameHost* render_frame_host,
       const mojom::DidPrintDocumentParams& params,
       std::unique_ptr<DelayedFrameDispatchHelper> helper) override;
-  void OnGetDefaultPrintSettings(content::RenderFrameHost* render_frame_host,
-                                 IPC::Message* reply_msg) override;
   void OnScriptedPrint(content::RenderFrameHost* render_frame_host,
                        const mojom::ScriptedPrintParams& params,
                        IPC::Message* reply_msg) override;

chrome/browser/printing/printing_message_filter.cc

@@ -123,8 +123,6 @@ void PrintingMessageFilter::OnDestruct() const {
 bool PrintingMessageFilter::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintingMessageFilter, message)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_GetDefaultPrintSettings,
-                                    OnGetDefaultPrintSettings)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrint, OnScriptedPrint)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_UpdatePrintSettings,
                                     OnUpdatePrintSettings)
@@ -136,50 +134,6 @@ bool PrintingMessageFilter::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
-void PrintingMessageFilter::OnGetDefaultPrintSettings(IPC::Message* reply_msg) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!is_printing_enabled_.GetValue()) {
-    // Reply with null query.
-    OnGetDefaultPrintSettingsReply(nullptr, reply_msg);
-    return;
-  }
-  std::unique_ptr<PrinterQuery> printer_query = queue_->PopPrinterQuery(0);
-  if (!printer_query) {
-    printer_query =
-        queue_->CreatePrinterQuery(render_process_id_, reply_msg->routing_id());
-  }
-
-  // Loads default settings. This is asynchronous, only the IPC message sender
-  // will hang until the settings are retrieved.
-  auto* printer_query_ptr = printer_query.get();
-  printer_query_ptr->GetSettings(
-      PrinterQuery::GetSettingsAskParam::DEFAULTS, 0, false,
-      printing::mojom::MarginType::kDefaultMargins, false, false,
-      base::BindOnce(&PrintingMessageFilter::OnGetDefaultPrintSettingsReply,
-                     this, std::move(printer_query), reply_msg));
-}
-
-void PrintingMessageFilter::OnGetDefaultPrintSettingsReply(
-    std::unique_ptr<PrinterQuery> printer_query,
-    IPC::Message* reply_msg) {
-  mojom::PrintParams params;
-  if (printer_query && printer_query->last_status() == PrintingContext::OK) {
-    RenderParamsFromPrintSettings(printer_query->settings(), &params);
-    params.document_cookie = printer_query->cookie();
-  }
-  PrintHostMsg_GetDefaultPrintSettings::WriteReplyParams(reply_msg, params);
-  Send(reply_msg);
-  // If printing was enabled.
-  if (printer_query) {
-    // If user hasn't cancelled.
-    if (printer_query->cookie() && printer_query->settings().dpi()) {
-      queue_->QueuePrinterQuery(std::move(printer_query));
-    } else {
-      printer_query->StopWorker();
-    }
-  }
-}
-
 void PrintingMessageFilter::OnScriptedPrint(
     const mojom::ScriptedPrintParams& params,
     IPC::Message* reply_msg) {

chrome/browser/printing/printing_message_filter.h

@@ -57,12 +57,6 @@ class PrintingMessageFilter : public content::BrowserMessageFilter {
 
   void ShutdownOnUIThread();
 
-  // Get the default print setting.
-  void OnGetDefaultPrintSettings(IPC::Message* reply_msg);
-  void OnGetDefaultPrintSettingsReply(
-      std::unique_ptr<PrinterQuery> printer_query,
-      IPC::Message* reply_msg);
-
   // The renderer host have to show to the user the print dialog and returns
   // the selected print settings. The task is handled by the print worker
   // thread and the UI thread. The reply occurs on the IO thread.

components/printing/browser/print_manager.cc

@@ -18,10 +18,6 @@ struct PrintManager::FrameDispatchHelper {
 
   bool Send(IPC::Message* msg) { return render_frame_host->Send(msg); }
 
-  void OnGetDefaultPrintSettings(IPC::Message* reply_msg) {
-    manager->OnGetDefaultPrintSettings(render_frame_host, reply_msg);
-  }
-
   void OnScriptedPrint(const mojom::ScriptedPrintParams& scripted_params,
                        IPC::Message* reply_msg) {
     manager->OnScriptedPrint(render_frame_host, scripted_params, reply_msg);
@@ -85,9 +81,6 @@ bool PrintManager::OnMessageReceived(
   FrameDispatchHelper helper = {this, render_frame_host};
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintManager, message)
-    IPC_MESSAGE_FORWARD_DELAY_REPLY(
-        PrintHostMsg_GetDefaultPrintSettings, &helper,
-        FrameDispatchHelper::OnGetDefaultPrintSettings)
     IPC_MESSAGE_FORWARD_DELAY_REPLY(PrintHostMsg_ScriptedPrint, &helper,
                                     FrameDispatchHelper::OnScriptedPrint)
     IPC_MESSAGE_FORWARD_DELAY_REPLY(PrintHostMsg_DidPrintDocument, &helper,

components/printing/browser/print_manager.h

@@ -107,9 +107,6 @@ class PrintManager : public content::WebContentsObserver,
       content::RenderFrameHost* render_frame_host,
       const mojom::DidPrintDocumentParams& params,
       std::unique_ptr<DelayedFrameDispatchHelper> helper) = 0;
-  virtual void OnGetDefaultPrintSettings(
-      content::RenderFrameHost* render_frame_host,
-      IPC::Message* reply_msg) = 0;
   virtual void OnScriptedPrint(content::RenderFrameHost* render_frame_host,
                                const mojom::ScriptedPrintParams& params,
                                IPC::Message* reply_msg) = 0;

components/printing/common/print.mojom

@@ -288,6 +288,10 @@ interface PrintManagerHost {
   [EnableIf=enable_tagged_pdf]
   SetAccessibilityTree(int32 cookie, ax.mojom.AXTreeUpdate accessibility_tree);
 
+  // Request the default print settings.
+  [Sync]
+  GetDefaultPrintSettings() => (PrintParams default_settings);
+
   // Tells the browser that the print dialog has been shown.
   DidShowPrintDialog();
 

components/printing/common/print_messages.h

@@ -277,10 +277,6 @@ IPC_SYNC_MESSAGE_ROUTED1_1(PrintHostMsg_DidPrintDocument,
                            /* page content */,
                            bool /* completed */)
 
-// The renderer wants to know the default print settings.
-IPC_SYNC_MESSAGE_ROUTED0_1(PrintHostMsg_GetDefaultPrintSettings,
-                           printing::mojom::PrintParams /* default_settings */)
-
 // The renderer wants to update the current print settings with new
 // |job_settings|.
 IPC_SYNC_MESSAGE_ROUTED2_2(

components/printing/renderer/print_render_frame_helper.cc

@@ -2133,8 +2133,8 @@ void PrintRenderFrameHelper::IPCProcessed() {
 bool PrintRenderFrameHelper::InitPrintSettings(bool fit_to_paper_size) {
   mojom::PrintPagesParams settings;
   settings.params = mojom::PrintParams::New();
-  Send(new PrintHostMsg_GetDefaultPrintSettings(routing_id(),
-                                                settings.params.get()));
+  GetPrintManagerHost()->GetDefaultPrintSettings(&settings.params);
+
   // Check if the printer returned any settings, if the settings is empty, we
   // can safely assume there are no printer drivers configured. So we safely
   // terminate.

components/printing/test/mock_printer.cc

@@ -103,16 +103,16 @@ void MockPrinter::ResetPrinter() {
   document_cookie_ = -1;
 }
 
-void MockPrinter::GetDefaultPrintSettings(
-    printing::mojom::PrintParams* params) {
+printing::mojom::PrintParamsPtr MockPrinter::GetDefaultPrintSettings() {
   // Verify this printer is not processing a job.
   // Sorry, this mock printer is very fragile.
   EXPECT_EQ(-1, document_cookie_);
 
   // Assign a unit document cookie and set the print settings.
   document_cookie_ = CreateDocumentCookie();
-  *params = printing::mojom::PrintParams();
-  SetPrintParams(params);
+  auto params = printing::mojom::PrintParams::New();
+  SetPrintParams(params.get());
+  return params;
 }
 
 void MockPrinter::SetDefaultPrintSettings(

components/printing/test/mock_printer.h

@@ -74,8 +74,11 @@ class MockPrinter {
   void UseInvalidPageSize();
   void UseInvalidContentSize();
 
+  // Functions that handle mojo messages.
+  printing::mojom::PrintParamsPtr GetDefaultPrintSettings();
+  void SetPrintedPagesCount(int cookie, uint32_t number_pages);
+
   // Functions that handles IPC events.
-  void GetDefaultPrintSettings(printing::mojom::PrintParams* params);
   void ScriptedPrint(int cookie,
                      uint32_t expected_pages_count,
                      bool has_selection,
@@ -86,7 +89,6 @@ class MockPrinter {
                       int margins_type,
                       const gfx::Size& page_size,
                       int scale_factor);
-  void SetPrintedPagesCount(int cookie, uint32_t number_pages);
   void PrintPage(const printing::mojom::DidPrintDocumentParams& params);
 
   // Functions that retrieve the output pages.

components/printing/test/print_mock_render_thread.cc

@@ -53,8 +53,6 @@ bool PrintMockRenderThread::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintMockRenderThread, msg)
 #if BUILDFLAG(ENABLE_PRINTING)
-    IPC_MESSAGE_HANDLER(PrintHostMsg_GetDefaultPrintSettings,
-                        OnGetDefaultPrintSettings)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrint, OnScriptedPrint)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_UpdatePrintSettings,
                                     OnUpdatePrintSettings)
@@ -73,11 +71,6 @@ bool PrintMockRenderThread::OnMessageReceived(const IPC::Message& msg) {
 
 #if BUILDFLAG(ENABLE_PRINTING)
 
-void PrintMockRenderThread::OnGetDefaultPrintSettings(
-    printing::mojom::PrintParams* params) {
-  printer_->GetDefaultPrintSettings(params);
-}
-
 void PrintMockRenderThread::OnScriptedPrint(
     const printing::mojom::ScriptedPrintParams& params,
     IPC::Message* reply_msg) {

components/printing/test/print_mock_render_thread.h

@@ -68,9 +68,6 @@ class PrintMockRenderThread : public content::MockRenderThread {
   bool OnMessageReceived(const IPC::Message& msg) override;
 
 #if BUILDFLAG(ENABLE_PRINTING)
-  // PrintRenderFrameHelper expects default print settings.
-  void OnGetDefaultPrintSettings(printing::mojom::PrintParams* setting);
-
   // PrintRenderFrameHelper expects final print settings from the user.
   void OnScriptedPrint(const printing::mojom::ScriptedPrintParams& params,
                        IPC::Message* reply_msg);

components/printing/test/print_render_frame_helper_browsertest.cc

@@ -215,9 +215,9 @@ class FakePrintPreviewUI : public mojom::PrintPreviewUI {
 class TestPrintManagerHost
     : public mojom::PrintManagerHostInterceptorForTesting {
  public:
-  TestPrintManagerHost(content::RenderView* view, MockPrinter* printer)
+  TestPrintManagerHost(content::RenderFrame* frame, MockPrinter* printer)
       : printer_(printer) {
-    Init(view);
+    Init(frame);
   }
   ~TestPrintManagerHost() override = default;
 
@@ -229,16 +229,28 @@ class TestPrintManagerHost
     printer_->SetPrintedPagesCount(cookie, number_pages);
   }
   void DidGetDocumentCookie(int32_t cookie) override {}
+  void GetDefaultPrintSettings(
+      GetDefaultPrintSettingsCallback callback) override {
+    printing::mojom::PrintParamsPtr params =
+        printer_->GetDefaultPrintSettings();
+    std::move(callback).Run(std::move(params));
+  }
   void DidShowPrintDialog() override {}
 
   void SetExpectedPagesCount(uint32_t number_pages) {
     number_pages_ = number_pages;
   }
+  void WaitUntilBinding() {
+    if (receiver_.is_bound())
+      return;
+    base::RunLoop run_loop;
+    quit_closure_ = run_loop.QuitClosure();
+    run_loop.Run();
+  }
 
  private:
-  void Init(content::RenderView* view) {
-    content::RenderFrame* main_frame = view->GetMainRenderFrame();
-    main_frame->GetRemoteAssociatedInterfaces()->OverrideBinderForTesting(
+  void Init(content::RenderFrame* frame) {
+    frame->GetRemoteAssociatedInterfaces()->OverrideBinderForTesting(
         mojom::PrintManagerHost::Name_,
         base::BindRepeating(&TestPrintManagerHost::BindPrintManagerReceiver,
                             base::Unretained(this)));
@@ -247,10 +259,15 @@ class TestPrintManagerHost
   void BindPrintManagerReceiver(mojo::ScopedInterfaceEndpointHandle handle) {
     receiver_.Bind(mojo::PendingAssociatedReceiver<mojom::PrintManagerHost>(
         std::move(handle)));
+
+    if (!quit_closure_)
+      return;
+    std::move(quit_closure_).Run();
   }
 
   uint32_t number_pages_ = 0;
   MockPrinter* printer_;
+  base::OnceClosure quit_closure_;
   mojo::AssociatedReceiver<mojom::PrintManagerHost> receiver_{this};
 };
 
@@ -277,8 +294,7 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
         static_cast<PrintMockRenderThread*>(render_thread_.get());
 
     content::RenderViewTest::SetUp();
-    print_manager_ = std::make_unique<TestPrintManagerHost>(
-        view_, print_render_thread_->GetPrinter());
+    BindPrintManagerHost(content::RenderFrame::FromWebFrame(GetMainFrame()));
   }
 
   void TearDown() override {
@@ -291,6 +307,16 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
     content::RenderViewTest::TearDown();
   }
 
+  void BindPrintManagerHost(content::RenderFrame* frame) {
+    auto print_manager = std::make_unique<TestPrintManagerHost>(
+        frame, print_render_thread_->GetPrinter());
+    GetPrintRenderFrameHelperForFrame(frame)->GetPrintManagerHost();
+    print_manager->WaitUntilBinding();
+    frame_to_print_manager_map_.emplace(frame, std::move(print_manager));
+  }
+
+  void ClearPrintManagerHost() { frame_to_print_manager_map_.clear(); }
+
   void PrintWithJavaScript() {
     ExecuteJavaScriptForTests("window.print();");
     base::RunLoop().RunUntilIdle();
@@ -335,8 +361,14 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
   }
 
   void OnPrintPagesInFrame(base::StringPiece frame_name) {
+    blink::WebFrame* frame = GetMainFrame()->FindFrameByName(
+        blink::WebString::FromUTF8(frame_name.data(), frame_name.size()));
+    ASSERT_TRUE(frame);
+    content::RenderFrame* render_frame =
+        content::RenderFrame::FromWebFrame(frame->ToWebLocalFrame());
+    BindPrintManagerHost(render_frame);
     PrintRenderFrameHelper* helper =
-        GetPrintRenderFrameHelperForFrame(frame_name);
+        GetPrintRenderFrameHelperForFrame(render_frame);
     ASSERT_TRUE(helper);
     helper->PrintRequestedPages();
     base::RunLoop().RunUntilIdle();
@@ -376,13 +408,8 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
   }
 
   PrintRenderFrameHelper* GetPrintRenderFrameHelperForFrame(
-      base::StringPiece frame_name) {
-    blink::WebFrame* frame = GetMainFrame()->FindFrameByName(
-        blink::WebString::FromUTF8(frame_name.data(), frame_name.size()));
-    if (!frame)
-      return nullptr;
-    return PrintRenderFrameHelper::Get(
-        content::RenderFrame::FromWebFrame(frame->ToWebLocalFrame()));
+      content::RenderFrame* frame) {
+    return PrintRenderFrameHelper::Get(frame);
   }
 
   void ClickMouseButton(const gfx::Rect& bounds) {
@@ -432,7 +459,11 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
   }
 
   PrintMockRenderThread* print_render_thread() { return print_render_thread_; }
-  TestPrintManagerHost* print_manager() { return print_manager_.get(); }
+  TestPrintManagerHost* print_manager() {
+    auto it = frame_to_print_manager_map_.find(
+        content::RenderFrame::FromWebFrame(GetMainFrame()));
+    return it->second.get();
+  }
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   FakePrintPreviewUI* preview_ui() { return &preview_ui_; }
 #endif
@@ -444,7 +475,8 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
   // Naked pointer as ownership is with
   // |content::RenderViewTest::render_thread_|.
   PrintMockRenderThread* print_render_thread_ = nullptr;
-  std::unique_ptr<TestPrintManagerHost> print_manager_ = nullptr;
+  std::map<content::RenderFrame*, std::unique_ptr<TestPrintManagerHost>>
+      frame_to_print_manager_map_;
 };
 
 // RenderViewTest-based tests crash on Android
@@ -577,6 +609,8 @@ TEST_F(MAYBE_PrintRenderFrameHelperTest, BasicBeforePrintAfterPrintSubFrame) {
   EXPECT_EQ(nullptr, GetMainFrame()->FindFrameByName("sub"));
   VerifyPagesPrinted(false);
 
+  ClearPrintManagerHost();
+
   static const char kCloseOnAfterHtml[] =
       "<body>Hello"
       "<iframe name=sub srcdoc='<script>"

headless/lib/browser/headless_print_manager.cc

@@ -189,14 +189,9 @@ HeadlessPrintManager::GetPrintParamsFromSettings(
 bool HeadlessPrintManager::OnMessageReceived(
     const IPC::Message& message,
     content::RenderFrameHost* render_frame_host) {
-  if (!printing_rfh_ &&
-      (message.type() == PrintHostMsg_GetDefaultPrintSettings::ID ||
-       message.type() == PrintHostMsg_ScriptedPrint::ID)) {
+  if (!printing_rfh_ && message.type() == PrintHostMsg_ScriptedPrint::ID) {
     std::string type;
     switch (message.type()) {
-      case PrintHostMsg_GetDefaultPrintSettings::ID:
-        type = "GetDefaultPrintSettings";
-        break;
       case PrintHostMsg_ScriptedPrint::ID:
         type = "ScriptedPrint";
         break;
@@ -217,14 +212,15 @@ bool HeadlessPrintManager::OnMessageReceived(
   return PrintManager::OnMessageReceived(message, render_frame_host);
 }
 
-void HeadlessPrintManager::OnGetDefaultPrintSettings(
-    content::RenderFrameHost* render_frame_host,
-    IPC::Message* reply_msg) {
-  PrintHostMsg_GetDefaultPrintSettings::WriteReplyParams(
-      reply_msg, *print_params_->params);
-  // Intentionally using |printing_rfh_| instead of |render_frame_host|
-  // parameter.
-  printing_rfh_->Send(reply_msg);
+void HeadlessPrintManager::GetDefaultPrintSettings(
+    GetDefaultPrintSettingsCallback callback) {
+  if (!printing_rfh_) {
+    DLOG(ERROR) << "Unexpected message received before GetPDFContents is "
+                   "called: GetDefaultPrintSettings";
+    std::move(callback).Run(printing::mojom::PrintParams::New());
+    return;
+  }
+  std::move(callback).Run(print_params_->params->Clone());
 }
 
 void HeadlessPrintManager::OnScriptedPrint(

headless/lib/browser/headless_print_manager.h

@@ -68,10 +68,6 @@ class HeadlessPrintManager
 
   ~HeadlessPrintManager() override;
 
-  // printing::mojom::PrintManagerHost:
-  void ShowInvalidPrinterSettingsError() override;
-  void PrintingFailed(int32_t cookie) override;
-
   static std::string PrintResultToString(PrintResult result);
   // Exported for tests.
   HEADLESS_EXPORT static PageRangeStatus PageRangeTextToPages(
@@ -103,12 +99,15 @@ class HeadlessPrintManager
       content::RenderFrameHost* render_frame_host,
       const printing::mojom::DidPrintDocumentParams& params,
       std::unique_ptr<DelayedFrameDispatchHelper> helper) override;
-  void OnGetDefaultPrintSettings(content::RenderFrameHost* render_frame_host,
-                                 IPC::Message* reply_msg) override;
   void OnScriptedPrint(content::RenderFrameHost* render_frame_host,
                        const printing::mojom::ScriptedPrintParams& params,
                        IPC::Message* reply_msg) override;
 
+  // printing::mojom::PrintManagerHost:
+  void GetDefaultPrintSettings(
+      GetDefaultPrintSettingsCallback callback) override;
+  void ShowInvalidPrinterSettingsError() override;
+  void PrintingFailed(int32_t cookie) override;
 
   void Reset();
   void ReleaseJob(PrintResult result);