Use pdf compositor service for printing when OOPIF is enabled

chrome/browser/printing/print_view_manager_base.cc

 // Copyright 2013 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_view_manager_base.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/shared_memory.h"
+#include "base/memory/shared_memory_handle.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #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/printer_query.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.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/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "printing/features/features.h"
 #include "printing/pdf_metafile_skia.h"
+#include "printing/print_settings.h"
 #include "printing/printed_document.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
 #include "chrome/browser/printing/print_error_dialog.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/command_line.h"
 #include "chrome/common/chrome_features.h"
@@ skipping 69 matching lines @@
     name = l10n_util::GetStringUTF16(IDS_DEFAULT_PRINT_DOCUMENT_TITLE);
   return name;
 }
 
 void PrintViewManagerBase::OnDidGetPrintedPagesCount(int cookie,
                                                      int number_pages) {
   PrintManager::OnDidGetPrintedPagesCount(cookie, number_pages);
   OpportunisticallyCreatePrintJob(cookie);
 }
 
+void PrintViewManagerBase::OnComposePdfDone(
+    const PrintHostMsg_DidPrintPage_Params& params,
+    mojom::PdfCompositor::Status status,
+    mojo::ScopedSharedBufferHandle handle) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (status != mojom::PdfCompositor::Status::SUCCESS) {
+    NOTREACHED() << "Compositing pdf failed";
+    return;
+  }
+
+  UpdateForPrintedPage(
+      params, true,
+      PrintCompositeClient::GetShmFromMojoHandle(std::move(handle)));
+}
+
 void PrintViewManagerBase::OnDidPrintPage(
-  const PrintHostMsg_DidPrintPage_Params& params) {
+    const PrintHostMsg_DidPrintPage_Params& params) {
+  // Ready to composite. Starting a print job.
   if (!OpportunisticallyCreatePrintJob(params.document_cookie))
     return;
 
   PrintedDocument* document = print_job_->document();
   if (!document || params.document_cookie != document->cookie()) {
     // Out of sync. It may happen since we are completely asynchronous. Old
     // spurious messages can be received if one of the processes is overloaded.
     return;
   }
 
 #if defined(OS_MACOSX)
   const bool metafile_must_be_valid = true;
 #else
   const bool metafile_must_be_valid = expecting_first_page_;
   expecting_first_page_ = false;
 #endif
 
   // Only used when |metafile_must_be_valid| is true.
   std::unique_ptr<base::SharedMemory> shared_buf;
   if (metafile_must_be_valid) {
     if (!base::SharedMemory::IsHandleValid(params.metafile_data_handle)) {
       NOTREACHED() << "invalid memory handle";
       web_contents()->Stop();
       return;
     }
-    shared_buf =
-        base::MakeUnique<base::SharedMemory>(params.metafile_data_handle, true);
-    if (!shared_buf->Map(params.data_size)) {
-      NOTREACHED() << "couldn't map";
-      web_contents()->Stop();
-      return;
+
+    if (IsOopifEnabled()) {
+      if (auto* client =
+              PrintCompositeClient::FromWebContents(web_contents())) {
+        client->DoComposite(
+            params.metafile_data_handle, params.data_size,
+            base::BindOnce(&PrintViewManagerBase::OnComposePdfDone,
+                           base::Unretained(this), params),
+            base::ThreadTaskRunnerHandle::Get());
+      }
+    } else {
+      shared_buf = base::MakeUnique<base::SharedMemory>(
+          params.metafile_data_handle, true);
+      if (!shared_buf->Map(params.data_size)) {
+        NOTREACHED() << "couldn't map";
+        web_contents()->Stop();
+        return;
+      }
     }
   } else {
     if (base::SharedMemory::IsHandleValid(params.metafile_data_handle)) {
       NOTREACHED() << "unexpected valid memory handle";
       web_contents()->Stop();
       base::SharedMemory::CloseHandle(params.metafile_data_handle);
       return;
     }
   }
 
-  std::unique_ptr<PdfMetafileSkia> metafile(
-      new PdfMetafileSkia(SkiaDocumentType::PDF));
-  if (metafile_must_be_valid) {
-    if (!metafile->InitFromData(shared_buf->memory(), params.data_size)) {
-      NOTREACHED() << "Invalid metafile header";
-      web_contents()->Stop();
-      return;
-    }
-  }
+  if (!IsOopifEnabled())
+    UpdateForPrintedPage(params, metafile_must_be_valid, std::move(shared_buf));
+}
+
+void PrintViewManagerBase::UpdateForPrintedPage(
+    const PrintHostMsg_DidPrintPage_Params& params,
+    bool has_valid_page_data,
+    std::unique_ptr<base::SharedMemory> shared_buf) {
+  PrintedDocument* document = print_job_->document();
+  if (!document)
+    return;
 
 #if defined(OS_WIN)
   print_job_->AppendPrintedPage(params.page_number);
-  if (metafile_must_be_valid) {
-    scoped_refptr<base::RefCountedBytes> bytes = new base::RefCountedBytes(
+  if (has_valid_page_data) {
+    scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(
         reinterpret_cast<const unsigned char*>(shared_buf->memory()),
-        params.data_size);
+        shared_buf->mapped_size()));
+
     document->DebugDumpData(bytes.get(), FILE_PATH_LITERAL(".pdf"));
 
     const auto& settings = document->settings();
     if (settings.printer_is_textonly()) {
       print_job_->StartPdfToTextConversion(bytes, params.page_size);
     } else if ((settings.printer_is_ps2() || settings.printer_is_ps3()) &&
                !base::FeatureList::IsEnabled(
                    features::kDisablePostScriptPrinting)) {
       print_job_->StartPdfToPostScriptConversion(bytes, params.content_area,
                                                  params.physical_offsets,
                                                  settings.printer_is_ps2());
     } else {
       // TODO(thestig): Figure out why rendering text with GDI results in random
       // missing characters for some users. https://crbug.com/658606
       // Update : The missing letters seem to have been caused by the same
       // problem as https://crbug.com/659604 which was resolved. GDI printing
       // seems to work with the fix for this bug applied.
-      bool print_text_with_gdi = settings.print_text_with_gdi() &&
-                                 !settings.printer_is_xps() &&
-                                 base::FeatureList::IsEnabled(
-                                     features::kGdiTextPrinting);
+      bool print_text_with_gdi =
+          settings.print_text_with_gdi() && !settings.printer_is_xps() &&
+          base::FeatureList::IsEnabled(features::kGdiTextPrinting);
       print_job_->StartPdfToEmfConversion(
           bytes, params.page_size, params.content_area, print_text_with_gdi);
     }
   }
 #else
+  std::unique_ptr<PdfMetafileSkia> metafile =
+      base::MakeUnique<PdfMetafileSkia>(SkiaDocumentType::PDF);
+  if (has_valid_page_data) {
+    if (!metafile->InitFromData(shared_buf->memory(),
+                                shared_buf->mapped_size())) {
+      NOTREACHED() << "Invalid metafile header";
+      web_contents()->Stop();
+      return;
+    }
+  }
+
   // Update the rendered document. It will send notifications to the listener.
-  document->SetPage(params.page_number,
-                    std::move(metafile),
-#if defined(OS_WIN)
-                    0.0f /* dummy shrink_factor */,
-#endif
-                    params.page_size,
+  document->SetPage(params.page_number, std::move(metafile), params.page_size,
                     params.content_area);
 
   ShouldQuitFromInnerMessageLoop();
 #endif
 }
 
 void PrintViewManagerBase::OnPrintingFailed(int cookie) {
   PrintManager::OnPrintingFailed(cookie);
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
@@ skipping 363 matching lines @@
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&PrinterQuery::StopWorker, printer_query));
 }
 
 void PrintViewManagerBase::SendPrintingEnabled(bool enabled,
                                                content::RenderFrameHost* rfh) {
   rfh->Send(new PrintMsg_SetPrintingEnabled(rfh->GetRoutingID(), enabled));
 }
 
 }  // namespace printing