Use pdf compositor service for printing when OOPIF is enabled

chrome/browser/printing/print_preview_message_handler.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/print_preview_message_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/shared_memory.h"
+#include "base/memory/shared_memory_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/printing/print_job_manager.h"
 #include "chrome/browser/printing/print_preview_dialog_controller.h"
 #include "chrome/browser/printing/print_view_manager.h"
 #include "chrome/browser/printing/printer_query.h"
 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
+#include "components/printing/browser/print_composite_client.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/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "printing/page_size_margins.h"
 #include "printing/print_job_constants.h"
+#include "printing/print_settings.h"
 
 using content::BrowserThread;
 using content::WebContents;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(printing::PrintPreviewMessageHandler);
 
 namespace printing {
 
 namespace {
 
@@ skipping 23 matching lines @@
 
   unsigned char* data_begin = static_cast<unsigned char*>(shared_buf->memory());
   std::vector<unsigned char> data(data_begin, data_begin + data_size);
   return base::RefCountedBytes::TakeVector(&data);
 }
 
 }  // namespace
 
 PrintPreviewMessageHandler::PrintPreviewMessageHandler(
     WebContents* web_contents)
-    : content::WebContentsObserver(web_contents) {
+    : content::WebContentsObserver(web_contents), weak_ptr_factory_(this) {
   DCHECK(web_contents);
 }
 
 PrintPreviewMessageHandler::~PrintPreviewMessageHandler() {
 }
 
 WebContents* PrintPreviewMessageHandler::GetPrintPreviewDialog() {
   PrintPreviewDialogController* dialog_controller =
       PrintPreviewDialogController::GetInstance();
   if (!dialog_controller)
@@ skipping 35 matching lines @@
 
   print_preview_ui->OnDidGetPreviewPageCount(params);
 }
 
 void PrintPreviewMessageHandler::OnDidPreviewPage(
     const PrintHostMsg_DidPreviewPage_Params& params) {
   int page_number = params.page_number;
   if (page_number < FIRST_PAGE_INDEX || !params.data_size)
     return;
 
-  PrintPreviewUI* print_preview_ui = GetPrintPreviewUI();
-  if (!print_preview_ui)
+  if (!GetPrintPreviewUI())
     return;
 
-  scoped_refptr<base::RefCountedBytes> data_bytes =
-      GetDataFromHandle(params.metafile_data_handle, params.data_size);
-  DCHECK(data_bytes);
+  if (IsOopifEnabled()) {
+    auto* client = PrintCompositeClient::FromWebContents(web_contents());
+    DCHECK(client);
 
-  print_preview_ui->SetPrintPreviewDataForIndex(page_number,
-                                                std::move(data_bytes));
-  print_preview_ui->OnDidPreviewPage(page_number, params.preview_request_id);
+    // Use utility process to convert skia metafile to pdf.
+    client->DoComposite(
+        params.metafile_data_handle, params.data_size,
+        base::BindOnce(&PrintPreviewMessageHandler::OnCompositePdfPageDone,
+                       weak_ptr_factory_.GetWeakPtr(), params.page_number,
+                       params.preview_request_id));
+  } else {
+    NotifyUIPreviewPageReady(
+        page_number, params.preview_request_id,
+        GetDataFromHandle(params.metafile_data_handle, params.data_size));
+  }
 }
 
 void PrintPreviewMessageHandler::OnMetafileReadyForPrinting(
     const PrintHostMsg_DidPreviewDocument_Params& params) {
   // Always try to stop the worker.
   StopWorker(params.document_cookie);
 
   if (params.expected_pages_count <= 0) {
     NOTREACHED();
     return;
   }
 
-  PrintPreviewUI* print_preview_ui = GetPrintPreviewUI();
-  if (!print_preview_ui)
+  if (!GetPrintPreviewUI())
     return;
 
-  // TODO(joth): This seems like a good match for using RefCountedStaticMemory
-  // to avoid the memory copy, but the SetPrintPreviewData call chain below
-  // needs updating to accept the RefCountedMemory* base class.
-  scoped_refptr<base::RefCountedBytes> data_bytes =
-      GetDataFromHandle(params.metafile_data_handle, params.data_size);
-  if (!data_bytes || !data_bytes->size())
+  if (IsOopifEnabled()) {
+    auto* client = PrintCompositeClient::FromWebContents(web_contents());
+    DCHECK(client);
+
+    client->DoComposite(
+        params.metafile_data_handle, params.data_size,
+        base::BindOnce(&PrintPreviewMessageHandler::OnCompositePdfDocumentDone,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       params.expected_pages_count, params.preview_request_id));
+  } else {
+    NotifyUIPreviewDocumentReady(
+        params.expected_pages_count, params.preview_request_id,
+        GetDataFromHandle(params.metafile_data_handle, params.data_size));
+  }
+}
+
+void PrintPreviewMessageHandler::OnCompositePdfPageDone(
+    int page_number,
+    int request_id,
+    mojom::PdfCompositor::Status status,
+    mojo::ScopedSharedBufferHandle handle) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (status != mojom::PdfCompositor::Status::SUCCESS) {
+    NOTREACHED() << "Compositing pdf failed";

[Lei Zhang, 2017/09/08 07:50:53]

You shouldn't use NOTREACHED() here, because the compositor can fail. Switch to
some form of logging instead?

[Wei Li, 2017/09/08 22:57:47]

Compositor only fails on unable to map memory or invalid buffer format which
should not happen in our current use, so should be safe to use NOTREACHED. For
the next steps (adding the logic into compositor), I will have to think ways to
handle errors as compositor may fail for some legit reasons. 

[Lei Zhang, 2017/09/09 00:44:59]

But on the compositor side, a Map() failure isn't treated as NOTREACHED.
Shouldn't the two sides be consistent?

     return;
+  }
+  NotifyUIPreviewPageReady(
+      page_number, request_id,
+      PrintCompositeClient::GetDataFromMojoHandle(std::move(handle)));
+}
 
-  print_preview_ui->SetPrintPreviewDataForIndex(COMPLETE_PREVIEW_DOCUMENT_INDEX,
-                                                std::move(data_bytes));
-  print_preview_ui->OnPreviewDataIsAvailable(
-      params.expected_pages_count, params.preview_request_id);
+void PrintPreviewMessageHandler::OnCompositePdfDocumentDone(
+    int page_count,
+    int request_id,
+    mojom::PdfCompositor::Status status,
+    mojo::ScopedSharedBufferHandle handle) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (status != mojom::PdfCompositor::Status::SUCCESS) {
+    NOTREACHED() << "Compositing pdf failed";
+    return;
+  }
+  NotifyUIPreviewDocumentReady(
+      page_count, request_id,
+      PrintCompositeClient::GetDataFromMojoHandle(std::move(handle)));
 }
 
 void PrintPreviewMessageHandler::OnPrintPreviewFailed(int document_cookie) {
   StopWorker(document_cookie);
 
   PrintPreviewUI* print_preview_ui = GetPrintPreviewUI();
   if (!print_preview_ui)
     return;
   print_preview_ui->OnPrintPreviewFailed();
 }
@@ skipping 30 matching lines @@
 }
 
 void PrintPreviewMessageHandler::OnSetOptionsFromDocument(
     const PrintHostMsg_SetOptionsFromDocument_Params& params) {
   PrintPreviewUI* print_preview_ui = GetPrintPreviewUI();
   if (!print_preview_ui)
     return;
   print_preview_ui->OnSetOptionsFromDocument(params);
 }
 
+void PrintPreviewMessageHandler::NotifyUIPreviewPageReady(
+    int page_number,
+    int request_id,
+    scoped_refptr<base::RefCountedBytes> data_bytes) {
+  DCHECK(data_bytes);
+
+  PrintPreviewUI* print_preview_ui = GetPrintPreviewUI();
+  if (!print_preview_ui)
+    return;
+  print_preview_ui->SetPrintPreviewDataForIndex(page_number,
+                                                std::move(data_bytes));
+  print_preview_ui->OnDidPreviewPage(page_number, request_id);
+}
+
+void PrintPreviewMessageHandler::NotifyUIPreviewDocumentReady(
+    int page_count,
+    int request_id,
+    scoped_refptr<base::RefCountedBytes> data_bytes) {
+  if (!data_bytes || !data_bytes->size())
+    return;
+
+  PrintPreviewUI* print_preview_ui = GetPrintPreviewUI();
+  if (!print_preview_ui)
+    return;
+  print_preview_ui->SetPrintPreviewDataForIndex(COMPLETE_PREVIEW_DOCUMENT_INDEX,
+                                                std::move(data_bytes));
+  print_preview_ui->OnPreviewDataIsAvailable(page_count, request_id);
+}
+
 bool PrintPreviewMessageHandler::OnMessageReceived(
     const IPC::Message& message,
     content::RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(PrintPreviewMessageHandler, message,
                                    render_frame_host)
     IPC_MESSAGE_HANDLER(PrintHostMsg_RequestPrintPreview,
                         OnRequestPrintPreview)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   if (handled)
     return true;
 
   IPC_BEGIN_MESSAGE_MAP(PrintPreviewMessageHandler, message)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetPreviewPageCount,
                         OnDidGetPreviewPageCount)
-    IPC_MESSAGE_HANDLER(PrintHostMsg_DidPreviewPage,
-                        OnDidPreviewPage)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_DidPreviewPage, OnDidPreviewPage)
     IPC_MESSAGE_HANDLER(PrintHostMsg_MetafileReadyForPrinting,
                         OnMetafileReadyForPrinting)
     IPC_MESSAGE_HANDLER(PrintHostMsg_PrintPreviewFailed,
                         OnPrintPreviewFailed)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetDefaultPageLayout,
                         OnDidGetDefaultPageLayout)
     IPC_MESSAGE_HANDLER(PrintHostMsg_PrintPreviewCancelled,
                         OnPrintPreviewCancelled)
     IPC_MESSAGE_HANDLER(PrintHostMsg_PrintPreviewInvalidPrinterSettings,
                         OnInvalidPrinterSettings)
     IPC_MESSAGE_HANDLER(PrintHostMsg_SetOptionsFromDocument,
                         OnSetOptionsFromDocument)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 }  // namespace printing