[printing] Convert PrintHostMsg_DidPrintDocument to Mojo

This CL converts PrintHostMsg_DidPrintDocument message to
DidPrintDocument() in mojom::PrintManagerHost.

Bug: 1008939
Change-Id: I80a7dddda4226c6158ffae505b0368ec2a0a4d69
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2544295
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Rebekah Potter <rbpotter@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Wei Li <weili@chromium.org>
Reviewed-by: Bo <boliu@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Commit-Queue: Julie Kim <jkim@igalia.com>
Cr-Commit-Position: refs/heads/master@{#833180}

android_webview/browser/aw_print_manager.cc

@@ -92,18 +92,20 @@ void AwPrintManager::OnScriptedPrint(
   render_frame_host->Send(reply_msg);
 }
 
-void AwPrintManager::OnDidPrintDocument(
-    content::RenderFrameHost* render_frame_host,
-    const printing::mojom::DidPrintDocumentParams& params,
-    std::unique_ptr<DelayedFrameDispatchHelper> helper) {
-  if (params.document_cookie != cookie_)
+void AwPrintManager::DidPrintDocument(
+    printing::mojom::DidPrintDocumentParamsPtr params,
+    DidPrintDocumentCallback callback) {
+  if (params->document_cookie != cookie_) {
+    std::move(callback).Run(false);
     return;
+  }
 
-  const printing::mojom::DidPrintContentParams& content = *params.content;
+  const printing::mojom::DidPrintContentParams& content = *params->content;
   if (!content.metafile_data_region.IsValid()) {
     NOTREACHED() << "invalid memory handle";
     web_contents()->Stop();
     PdfWritingDone(0);
+    std::move(callback).Run(false);
     return;
   }
 
@@ -113,12 +115,14 @@ void AwPrintManager::OnDidPrintDocument(
     NOTREACHED() << "couldn't map";
     web_contents()->Stop();
     PdfWritingDone(0);
+    std::move(callback).Run(false);
     return;
   }
 
   if (number_pages_ > printing::kMaxPageCount) {
     web_contents()->Stop();
     PdfWritingDone(0);
+    std::move(callback).Run(false);
     return;
   }
 
@@ -130,18 +134,18 @@ void AwPrintManager::OnDidPrintDocument(
           .get(),
       FROM_HERE, base::BindOnce(&SaveDataToFd, fd_, number_pages_, data),
       base::BindOnce(&AwPrintManager::OnDidPrintDocumentWritingDone,
-                     pdf_writing_done_callback_, std::move(helper)));
+                     pdf_writing_done_callback_, std::move(callback)));
 }
 
 // static
 void AwPrintManager::OnDidPrintDocumentWritingDone(
     const PdfWritingDoneCallback& callback,
-    std::unique_ptr<DelayedFrameDispatchHelper> helper,
+    DidPrintDocumentCallback did_print_document_cb,
     uint32_t page_count) {
   DCHECK_LE(page_count, printing::kMaxPageCount);
   if (callback)
     callback.Run(base::checked_cast<int>(page_count));
-  helper->SendCompleted();
+  std::move(did_print_document_cb).Run(true);
 }
 
 WEB_CONTENTS_USER_DATA_KEY_IMPL(AwPrintManager)

android_webview/browser/aw_print_manager.h

@@ -22,6 +22,8 @@ class AwPrintManager : public printing::PrintManager,
   ~AwPrintManager() override;
 
   // mojom::PrintManagerHost:
+  void DidPrintDocument(printing::mojom::DidPrintDocumentParamsPtr params,
+                        DidPrintDocumentCallback callback) override;
   void GetDefaultPrintSettings(
       GetDefaultPrintSettingsCallback callback) override;
 
@@ -41,17 +43,13 @@ class AwPrintManager : public printing::PrintManager,
   explicit AwPrintManager(content::WebContents* contents);
 
   // printing::PrintManager:
-  void OnDidPrintDocument(
-      content::RenderFrameHost* render_frame_host,
-      const printing::mojom::DidPrintDocumentParams& params,
-      std::unique_ptr<DelayedFrameDispatchHelper> helper) override;
   void OnScriptedPrint(content::RenderFrameHost* render_frame_host,
                        const printing::mojom::ScriptedPrintParams& params,
                        IPC::Message* reply_msg) override;
 
   static void OnDidPrintDocumentWritingDone(
       const PdfWritingDoneCallback& callback,
-      std::unique_ptr<DelayedFrameDispatchHelper> helper,
+      DidPrintDocumentCallback did_print_document_cb,
       uint32_t page_count);
 
   std::unique_ptr<printing::PrintSettings> settings_;

chrome/browser/printing/print_view_manager_base.cc

@@ -460,49 +460,59 @@ void PrintViewManagerBase::OnComposePdfDone(
     const gfx::Size& page_size,
     const gfx::Rect& content_area,
     const gfx::Point& physical_offsets,
-    std::unique_ptr<DelayedFrameDispatchHelper> helper,
+    DidPrintDocumentCallback callback,
     mojom::PrintCompositor::Status status,
     base::ReadOnlySharedMemoryRegion region) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (status != mojom::PrintCompositor::Status::kSuccess) {
     DLOG(ERROR) << "Compositing pdf failed with error " << status;
+    std::move(callback).Run(false);
     return;
   }
 
-  if (!print_job_->document())
+  if (!print_job_->document()) {
+    std::move(callback).Run(false);
     return;
+  }
 
   scoped_refptr<base::RefCountedSharedMemoryMapping> data =
       base::RefCountedSharedMemoryMapping::CreateFromWholeRegion(region);
-  if (!data)
+  if (!data) {
+    std::move(callback).Run(false);
     return;
+  }
 
   PrintDocument(data, page_size, content_area, physical_offsets);
-  helper->SendCompleted();
+  std::move(callback).Run(true);
 }
 
-void PrintViewManagerBase::OnDidPrintDocument(
-    content::RenderFrameHost* render_frame_host,
-    const mojom::DidPrintDocumentParams& params,
-    std::unique_ptr<DelayedFrameDispatchHelper> helper) {
-  if (!PrintJobHasDocument(params.document_cookie))
+void PrintViewManagerBase::DidPrintDocument(
+    mojom::DidPrintDocumentParamsPtr params,
+    DidPrintDocumentCallback callback) {
+  if (!PrintJobHasDocument(params->document_cookie)) {
+    std::move(callback).Run(false);
     return;
+  }
 
-  const mojom::DidPrintContentParams& content = *params.content;
+  const mojom::DidPrintContentParams& content = *params->content;
   if (!content.metafile_data_region.IsValid()) {
     NOTREACHED() << "invalid memory handle";
     web_contents()->Stop();
+    std::move(callback).Run(false);
     return;
   }
 
   auto* client = PrintCompositeClient::FromWebContents(web_contents());
+  content::RenderFrameHost* render_frame_host =
+      print_manager_host_receivers_.GetCurrentTargetFrame();
+
   if (IsOopifEnabled() && print_job_->document()->settings().is_modifiable()) {
     client->DoCompositeDocumentToPdf(
-        params.document_cookie, render_frame_host, content,
+        params->document_cookie, render_frame_host, content,
         base::BindOnce(&PrintViewManagerBase::OnComposePdfDone,
-                       weak_ptr_factory_.GetWeakPtr(), params.page_size,
-                       params.content_area, params.physical_offsets,
-                       std::move(helper)));
+                       weak_ptr_factory_.GetWeakPtr(), params->page_size,
+                       params->content_area, params->physical_offsets,
+                       std::move(callback)));
     return;
   }
   auto data = base::RefCountedSharedMemoryMapping::CreateFromWholeRegion(
@@ -510,12 +520,13 @@ void PrintViewManagerBase::OnDidPrintDocument(
   if (!data) {
     NOTREACHED() << "couldn't map";
     web_contents()->Stop();
+    std::move(callback).Run(false);
     return;
   }
 
-  PrintDocument(data, params.page_size, params.content_area,
-                params.physical_offsets);
-  helper->SendCompleted();
+  PrintDocument(data, params->page_size, params->content_area,
+                params->physical_offsets);
+  std::move(callback).Run(true);
 }
 
 void PrintViewManagerBase::GetDefaultPrintSettings(

chrome/browser/printing/print_view_manager_base.h

@@ -77,6 +77,8 @@ class PrintViewManagerBase : public content::NotificationObserver,
 
   // mojom::PrintManagerHost:
   void DidGetPrintedPagesCount(int32_t cookie, uint32_t number_pages) override;
+  void DidPrintDocument(mojom::DidPrintDocumentParamsPtr params,
+                        DidPrintDocumentCallback callback) override;
 #if BUILDFLAG(ENABLE_TAGGED_PDF)
   void SetAccessibilityTree(
       int32_t cookie,
@@ -133,10 +135,6 @@ class PrintViewManagerBase : public content::NotificationObserver,
   void NavigationStopped() override;
 
   // printing::PrintManager:
-  void OnDidPrintDocument(
-      content::RenderFrameHost* render_frame_host,
-      const mojom::DidPrintDocumentParams& params,
-      std::unique_ptr<DelayedFrameDispatchHelper> helper) override;
   void OnScriptedPrint(content::RenderFrameHost* render_frame_host,
                        const mojom::ScriptedPrintParams& params,
                        IPC::Message* reply_msg) override;
@@ -145,7 +143,7 @@ class PrintViewManagerBase : public content::NotificationObserver,
   void OnComposePdfDone(const gfx::Size& page_size,
                         const gfx::Rect& content_area,
                         const gfx::Point& physical_offsets,
-                        std::unique_ptr<DelayedFrameDispatchHelper> helper,
+                        DidPrintDocumentCallback callback,
                         mojom::PrintCompositor::Status status,
                         base::ReadOnlySharedMemoryRegion region);
 

components/printing/browser/print_manager.cc

@@ -22,53 +22,8 @@ struct PrintManager::FrameDispatchHelper {
                        IPC::Message* reply_msg) {
     manager->OnScriptedPrint(render_frame_host, scripted_params, reply_msg);
   }
-
-  void OnDidPrintDocument(const mojom::DidPrintDocumentParams& params,
-                          IPC::Message* reply_msg) {
-    // If DidPrintDocument message was received then need to transition from
-    // a variable allocated on stack (which has efficient memory management
-    // when dealing with any other incoming message) to a persistent variable
-    // on the heap that can be referenced by the asynchronous processing which
-    // occurs beyond the scope of PrintViewManagerBase::OnMessageReceived().
-    manager->OnDidPrintDocument(
-        render_frame_host, params,
-        std::make_unique<DelayedFrameDispatchHelper>(
-            manager->web_contents(), render_frame_host, reply_msg));
-  }
 };
 
-PrintManager::DelayedFrameDispatchHelper::DelayedFrameDispatchHelper(
-    content::WebContents* contents,
-    content::RenderFrameHost* render_frame_host,
-    IPC::Message* reply_msg)
-    : content::WebContentsObserver(contents),
-      render_frame_host_(render_frame_host),
-      reply_msg_(reply_msg) {}
-
-PrintManager::DelayedFrameDispatchHelper::~DelayedFrameDispatchHelper() {
-  if (reply_msg_) {
-    PrintHostMsg_DidPrintDocument::WriteReplyParams(reply_msg_, false);
-    render_frame_host_->Send(reply_msg_);
-  }
-}
-
-void PrintManager::DelayedFrameDispatchHelper::SendCompleted() {
-  if (!reply_msg_)
-    return;
-
-  PrintHostMsg_DidPrintDocument::WriteReplyParams(reply_msg_, true);
-  render_frame_host_->Send(reply_msg_);
-
-  // This wraps up the one allowed reply for the message.
-  reply_msg_ = nullptr;
-}
-
-void PrintManager::DelayedFrameDispatchHelper::RenderFrameDeleted(
-    content::RenderFrameHost* render_frame_host) {
-  if (render_frame_host == render_frame_host_)
-    reply_msg_ = nullptr;
-}
-
 PrintManager::PrintManager(content::WebContents* contents)
     : content::WebContentsObserver(contents),
       print_manager_host_receivers_(contents, this) {}
@@ -83,8 +38,6 @@ bool PrintManager::OnMessageReceived(
   IPC_BEGIN_MESSAGE_MAP(PrintManager, message)
     IPC_MESSAGE_FORWARD_DELAY_REPLY(PrintHostMsg_ScriptedPrint, &helper,
                                     FrameDispatchHelper::OnScriptedPrint)
-    IPC_MESSAGE_FORWARD_DELAY_REPLY(PrintHostMsg_DidPrintDocument, &helper,
-                                    FrameDispatchHelper::OnDidPrintDocument);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -122,6 +75,11 @@ void PrintManager::UpdatePrintSettings(int32_t cookie,
 
 void PrintManager::DidShowPrintDialog() {}
 
+void PrintManager::DidPrintDocument(mojom::DidPrintDocumentParamsPtr params,
+                                    DidPrintDocumentCallback callback) {
+  std::move(callback).Run(false);
+}
+
 void PrintManager::ShowInvalidPrinterSettingsError() {}
 
 void PrintManager::PrintingFailed(int32_t cookie) {

components/printing/browser/print_manager.h

@@ -47,6 +47,8 @@ class PrintManager : public content::WebContentsObserver,
   // printing::mojom::PrintManagerHost:
   void DidGetPrintedPagesCount(int32_t cookie, uint32_t number_pages) override;
   void DidGetDocumentCookie(int32_t cookie) override;
+  void DidPrintDocument(mojom::DidPrintDocumentParamsPtr params,
+                        DidPrintDocumentCallback callback) override;
 #if BUILDFLAG(ENABLE_TAGGED_PDF)
   void SetAccessibilityTree(
       int32_t cookie,
@@ -78,38 +80,7 @@ class PrintManager : public content::WebContentsObserver,
   // IPC handling support
   struct FrameDispatchHelper;
 
-  // IPC message PrintHostMsg_DidPrintDocument can require handling in other
-  // processes beyond the rendering process running OnMessageReceived(),
-  // requiring that the renderer needs to wait.
-  class DelayedFrameDispatchHelper : public content::WebContentsObserver {
-   public:
-    DelayedFrameDispatchHelper(content::WebContents* contents,
-                               content::RenderFrameHost* render_frame_host,
-                               IPC::Message* reply_msg);
-    DelayedFrameDispatchHelper(const DelayedFrameDispatchHelper&) = delete;
-    ~DelayedFrameDispatchHelper() override;
-    DelayedFrameDispatchHelper& operator=(const DelayedFrameDispatchHelper&) =
-        delete;
-
-    // content::WebContentsObserver
-    void RenderFrameDeleted(
-        content::RenderFrameHost* render_frame_host) override;
-
-    // SendCompleted() can be called at most once, since it provides the success
-    // reply for a message. A failure reply for the message is automatically
-    // sent if this is never called.
-    void SendCompleted();
-
-   private:
-    content::RenderFrameHost* const render_frame_host_;
-    IPC::Message* reply_msg_;
-  };
-
   // IPC handlers
-  virtual void OnDidPrintDocument(
-      content::RenderFrameHost* render_frame_host,
-      const mojom::DidPrintDocumentParams& params,
-      std::unique_ptr<DelayedFrameDispatchHelper> helper) = 0;
   virtual void OnScriptedPrint(content::RenderFrameHost* render_frame_host,
                                const mojom::ScriptedPrintParams& params,
                                IPC::Message* reply_msg) = 0;

components/printing/common/print.mojom

@@ -302,6 +302,12 @@ interface PrintManagerHost {
   // Tells the browser that the print dialog has been shown.
   DidShowPrintDialog();
 
+  // Sends back to the browser the rendered document that was requested by a
+  // PrintRequestedPages() or from scripted printing. Waits until the document
+  // is ready before replying.
+  [Sync]
+  DidPrintDocument(DidPrintDocumentParams params) => (bool completed);
+
   // Tells the browser that there are invalid printer settings.
   ShowInvalidPrinterSettingsError();
 

components/printing/common/print_messages.h

@@ -267,15 +267,6 @@ IPC_STRUCT_TRAITS_END()
 
 // Messages sent from the renderer to the browser.
 
-// Sends back to the browser the rendered document that was requested by a
-// PrintMsg_PrintPages message or from scripted printing. The memory handle in
-// this message is already valid in the browser process. Waits until the
-// document is complete ready before replying.
-IPC_SYNC_MESSAGE_ROUTED1_1(PrintHostMsg_DidPrintDocument,
-                           printing::mojom::DidPrintDocumentParams
-                           /* page content */,
-                           bool /* completed */)
-
 // 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

@@ -2010,13 +2010,14 @@ bool PrintRenderFrameHelper::PrintPagesNative(blink::WebLocalFrame* frame,
     snapshotter->Snapshot(ui::AXMode::kPDF, 0, &metafile.accessibility_tree());
   }
 
-  mojom::DidPrintDocumentParams page_params;
-  page_params.content = mojom::DidPrintContentParams::New();
+  mojom::DidPrintDocumentParamsPtr page_params =
+      mojom::DidPrintDocumentParams::New();
+  page_params->content = mojom::DidPrintContentParams::New();
   gfx::Size* page_size_in_dpi;
   gfx::Rect* content_area_in_dpi;
 #if defined(OS_APPLE) || defined(OS_WIN)
-  page_size_in_dpi = &page_params.page_size;
-  content_area_in_dpi = &page_params.content_area;
+  page_size_in_dpi = &page_params->page_size;
+  content_area_in_dpi = &page_params->content_area;
 #else
   page_size_in_dpi = nullptr;
   content_area_in_dpi = nullptr;
@@ -2036,17 +2037,16 @@ bool PrintRenderFrameHelper::PrintPagesNative(blink::WebLocalFrame* frame,
   metafile.FinishDocument();
 
   if (!CopyMetafileDataToReadOnlySharedMem(metafile,
-                                           page_params.content.get())) {
+                                           page_params->content.get())) {
     return false;
   }
 
-  page_params.document_cookie = print_params.document_cookie;
+  page_params->document_cookie = print_params.document_cookie;
 #if defined(OS_WIN)
-  page_params.physical_offsets = printer_printable_area_.origin();
+  page_params->physical_offsets = printer_printable_area_.origin();
 #endif
   bool completed = false;
-  Send(
-      new PrintHostMsg_DidPrintDocument(routing_id(), page_params, &completed));
+  GetPrintManagerHost()->DidPrintDocument(std::move(page_params), &completed);
   return completed;
 }
 

components/printing/test/mock_printer.cc

@@ -204,18 +204,17 @@ void MockPrinter::SetPrintedPagesCount(int cookie, uint32_t number_pages) {
   pages_.clear();
 }
 
-void MockPrinter::PrintPage(
-    const printing::mojom::DidPrintDocumentParams& params) {
+void MockPrinter::PrintPage(printing::mojom::DidPrintDocumentParamsPtr params) {
   // Verify the input parameter and update the printer status so that the
   // RenderViewTest class can verify the this function finishes without errors.
   EXPECT_EQ(PRINTER_PRINTING, printer_status_);
-  EXPECT_EQ(document_cookie_, params.document_cookie);
+  EXPECT_EQ(document_cookie_, params->document_cookie);
 
 #if defined(OS_WIN) || defined(OS_APPLE)
   // Load the data sent from a RenderView object and create a PageData object.
-  ASSERT_TRUE(params.content->metafile_data_region.IsValid());
+  ASSERT_TRUE(params->content->metafile_data_region.IsValid());
   base::ReadOnlySharedMemoryMapping mapping =
-      params.content->metafile_data_region.Map();
+      params->content->metafile_data_region.Map();
   ASSERT_TRUE(mapping.IsValid());
   EXPECT_GT(mapping.size(), 0U);
 

components/printing/test/mock_printer.h

@@ -89,7 +89,7 @@ class MockPrinter {
                       int margins_type,
                       const gfx::Size& page_size,
                       int scale_factor);
-  void PrintPage(const printing::mojom::DidPrintDocumentParams& params);
+  void PrintPage(printing::mojom::DidPrintDocumentParamsPtr params);
 
   // Functions that retrieve the output pages.
   Status GetPrinterStatus() const { return printer_status_; }

components/printing/test/print_mock_render_thread.cc

@@ -51,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_DidPrintDocument,
-                                    OnDidPrintDocument)
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidStartPreview, OnDidStartPreview)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidPreviewPage, OnDidPreviewPage)
@@ -79,14 +77,6 @@ void PrintMockRenderThread::OnScriptedPrint(
   Send(reply_msg);
 }
 
-void PrintMockRenderThread::OnDidPrintDocument(
-    const printing::mojom::DidPrintDocumentParams& params,
-    IPC::Message* reply_msg) {
-  printer_->PrintPage(params);
-  PrintHostMsg_DidPrintDocument::WriteReplyParams(reply_msg, true);
-  Send(reply_msg);
-}
-
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
 void PrintMockRenderThread::OnDidStartPreview(
     const printing::mojom::DidStartPreviewParams& params,

components/printing/test/print_mock_render_thread.h

@@ -67,9 +67,6 @@ class PrintMockRenderThread : public content::MockRenderThread {
   // PrintRenderFrameHelper expects final print settings from the user.
   void OnScriptedPrint(const printing::mojom::ScriptedPrintParams& params,
                        IPC::Message* reply_msg);
-
-  void OnDidPrintDocument(const printing::mojom::DidPrintDocumentParams& params,
-                          IPC::Message* reply_msg);
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   void OnDidStartPreview(const printing::mojom::DidStartPreviewParams& params,
                          const printing::mojom::PreviewIds& ids);

components/printing/test/print_render_frame_helper_browsertest.cc

@@ -230,6 +230,13 @@ class TestPrintManagerHost
     printer_->SetPrintedPagesCount(cookie, number_pages);
   }
   void DidGetDocumentCookie(int32_t cookie) override {}
+  void DidPrintDocument(mojom::DidPrintDocumentParamsPtr params,
+                        DidPrintDocumentCallback callback) override {
+    base::RunLoop().RunUntilIdle();
+    printer_->PrintPage(std::move(params));
+    std::move(callback).Run(true);
+    is_printed_ = true;
+  }
   void GetDefaultPrintSettings(
       GetDefaultPrintSettingsCallback callback) override {
     printing::mojom::PrintParamsPtr params =
@@ -325,6 +332,7 @@ class TestPrintManagerHost
 
   void DidShowPrintDialog() override {}
 
+  bool IsPrinted() { return is_printed_; }
   void SetExpectedPagesCount(uint32_t number_pages) {
     number_pages_ = number_pages;
   }
@@ -354,6 +362,7 @@ class TestPrintManagerHost
   }
 
   uint32_t number_pages_ = 0;
+  bool is_printed_ = false;
   MockPrinter* printer_;
   base::OnceClosure quit_closure_;
   mojo::AssociatedReceiver<mojom::PrintManagerHost> receiver_{this};
@@ -435,12 +444,11 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
   // Verifies whether the pages printed or not.
-  void VerifyPagesPrinted(bool expect_printed) {
-    const IPC::Message* print_msg =
-        render_thread_->sink().GetUniqueMessageMatching(
-            PrintHostMsg_DidPrintDocument::ID);
-    bool did_print = !!print_msg;
-    ASSERT_EQ(expect_printed, did_print);
+  void VerifyPagesPrinted(bool expect_printed,
+                          content::RenderFrame* render_frame = nullptr) {
+    if (!render_frame)
+      render_frame = content::RenderFrame::FromWebFrame(GetMainFrame());
+    ASSERT_EQ(expect_printed, print_manager(render_frame)->IsPrinted());
   }
 
   void OnPrintPages() {
@@ -547,9 +555,10 @@ class PrintRenderFrameHelperTestBase : public content::RenderViewTest {
   }
 
   PrintMockRenderThread* print_render_thread() { return print_render_thread_; }
-  TestPrintManagerHost* print_manager() {
-    auto it = frame_to_print_manager_map_.find(
-        content::RenderFrame::FromWebFrame(GetMainFrame()));
+  TestPrintManagerHost* print_manager(content::RenderFrame* frame = nullptr) {
+    if (!frame)
+      frame = content::RenderFrame::FromWebFrame(GetMainFrame());
+    auto it = frame_to_print_manager_map_.find(frame);
     return it->second.get();
   }
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
@@ -693,9 +702,11 @@ TEST_F(MAYBE_PrintRenderFrameHelperTest, BasicBeforePrintAfterPrintSubFrame) {
       "</body>";
 
   LoadHTML(kCloseOnBeforeHtml);
+  content::RenderFrame* sub_render_frame = content::RenderFrame::FromWebFrame(
+      GetMainFrame()->FindFrameByName("sub")->ToWebLocalFrame());
   OnPrintPagesInFrame("sub");
   EXPECT_EQ(nullptr, GetMainFrame()->FindFrameByName("sub"));
-  VerifyPagesPrinted(false);
+  VerifyPagesPrinted(false, sub_render_frame);
 
   ClearPrintManagerHost();
 
@@ -707,9 +718,11 @@ TEST_F(MAYBE_PrintRenderFrameHelperTest, BasicBeforePrintAfterPrintSubFrame) {
       "</body>";
 
   LoadHTML(kCloseOnAfterHtml);
+  sub_render_frame = content::RenderFrame::FromWebFrame(
+      GetMainFrame()->FindFrameByName("sub")->ToWebLocalFrame());
   OnPrintPagesInFrame("sub");
   EXPECT_EQ(nullptr, GetMainFrame()->FindFrameByName("sub"));
-  VerifyPagesPrinted(true);
+  VerifyPagesPrinted(true, sub_render_frame);
 }
 
 #if defined(OS_APPLE)

headless/lib/browser/headless_print_manager.cc

@@ -259,22 +259,23 @@ void HeadlessPrintManager::PrintingFailed(int32_t cookie) {
   ReleaseJob(PRINTING_FAILED);
 }
 
-void HeadlessPrintManager::OnDidPrintDocument(
-    content::RenderFrameHost* render_frame_host,
-    const printing::mojom::DidPrintDocumentParams& params,
-    std::unique_ptr<DelayedFrameDispatchHelper> helper) {
-  auto& content = *params.content;
+void HeadlessPrintManager::DidPrintDocument(
+    printing::mojom::DidPrintDocumentParamsPtr params,
+    DidPrintDocumentCallback callback) {
+  auto& content = *params->content;
   if (!content.metafile_data_region.IsValid()) {
     ReleaseJob(INVALID_MEMORY_HANDLE);
+    std::move(callback).Run(false);
     return;
   }
   base::ReadOnlySharedMemoryMapping map = content.metafile_data_region.Map();
   if (!map.IsValid()) {
     ReleaseJob(METAFILE_MAP_ERROR);
+    std::move(callback).Run(false);
     return;
   }
   data_ = std::string(static_cast<const char*>(map.memory()), map.size());
-  helper->SendCompleted();
+  std::move(callback).Run(true);
   ReleaseJob(PRINT_SUCCESS);
 }
 

headless/lib/browser/headless_print_manager.h

@@ -95,15 +95,13 @@ class HeadlessPrintManager
                          content::RenderFrameHost* render_frame_host) override;
 
   // printing::PrintManager:
-  void OnDidPrintDocument(
-      content::RenderFrameHost* render_frame_host,
-      const printing::mojom::DidPrintDocumentParams& params,
-      std::unique_ptr<DelayedFrameDispatchHelper> helper) override;
   void OnScriptedPrint(content::RenderFrameHost* render_frame_host,
                        const printing::mojom::ScriptedPrintParams& params,
                        IPC::Message* reply_msg) override;
 
   // printing::mojom::PrintManagerHost:
+  void DidPrintDocument(printing::mojom::DidPrintDocumentParamsPtr params,
+                        DidPrintDocumentCallback callback) override;
   void GetDefaultPrintSettings(
       GetDefaultPrintSettingsCallback callback) override;
   void ShowInvalidPrinterSettingsError() override;