Convert printing IPCs to Mojo

chrome/browser/printing/pwg_raster_converter.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/pwg_raster_converter.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/cancelable_callback.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/common/chrome_utility_messages.h"
-#include "chrome/common/chrome_utility_printing_messages.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/cloud_devices/common/cloud_device_description.h"
 #include "components/cloud_devices/common/printer_description.h"
+#include "components/printing/common/printing.mojom.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "printing/pdf_render_settings.h"
 #include "printing/pwg_raster_settings.h"
 #include "printing/units.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace printing {
 
 namespace {
 
 using content::BrowserThread;
 
 class FileHandlers {
  public:
   FileHandlers() {}
 
   ~FileHandlers() {
     DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   }
 
   void Init(base::RefCountedMemory* data);
   bool IsValid();
 
   base::FilePath GetPwgPath() const {
     return temp_dir_.GetPath().AppendASCII("output.pwg");
   }
 
   base::FilePath GetPdfPath() const {
     return temp_dir_.GetPath().AppendASCII("input.pdf");
   }
 
-  IPC::PlatformFileForTransit GetPdfForProcess() {
+  base::File GetPdfForProcess() {
     DCHECK(pdf_file_.IsValid());
-    IPC::PlatformFileForTransit transit =
-        IPC::TakePlatformFileForTransit(std::move(pdf_file_));
-    return transit;
+    return std::move(pdf_file_);
   }
 
-  IPC::PlatformFileForTransit GetPwgForProcess() {
+  base::File GetPwgForProcess() {
     DCHECK(pwg_file_.IsValid());
-    IPC::PlatformFileForTransit transit =
-        IPC::TakePlatformFileForTransit(std::move(pwg_file_));
-    return transit;
+    return std::move(pwg_file_);
   }
 
  private:
   base::ScopedTempDir temp_dir_;
   base::File pdf_file_;
   base::File pwg_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FileHandlers);
 };
 
@@ skipping 40 matching lines @@
   void Convert(base::RefCountedMemory* data,
                const PWGRasterConverter::ResultCallback& callback);
 
   // UtilityProcessHostClient implementation.
   void OnProcessCrashed(int exit_code) override;
   bool OnMessageReceived(const IPC::Message& message) override;
 
  private:
   ~PwgUtilityProcessHostClient() override;
 
-  // Message handlers.
-  void OnSucceeded();
-  void OnFailed();
-
   void RunCallback(bool success);
 
   void StartProcessOnIOThread();
 
   void RunCallbackOnUIThread(bool success);
   void OnFilesReadyOnUIThread();
 
   std::unique_ptr<FileHandlers, BrowserThread::DeleteOnFileThread> files_;
   PdfRenderSettings settings_;
   PwgRasterSettings bitmap_settings_;
   PWGRasterConverter::ResultCallback callback_;
+  mojom::PrintingPtr printing_;
 
   DISALLOW_COPY_AND_ASSIGN(PwgUtilityProcessHostClient);
 };
 
 PwgUtilityProcessHostClient::PwgUtilityProcessHostClient(
     const PdfRenderSettings& settings,
     const PwgRasterSettings& bitmap_settings)
     : settings_(settings), bitmap_settings_(bitmap_settings) {}
 
 PwgUtilityProcessHostClient::~PwgUtilityProcessHostClient() {
 }
 
 void PwgUtilityProcessHostClient::Convert(
     base::RefCountedMemory* data,
     const PWGRasterConverter::ResultCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   callback_ = callback;
   CHECK(!files_);
   files_.reset(new FileHandlers());
 
   BrowserThread::PostTaskAndReply(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&FileHandlers::Init, base::Unretained(files_.get()),
                  base::RetainedRef(data)),
       base::Bind(&PwgUtilityProcessHostClient::OnFilesReadyOnUIThread, this));
 }
 
 void PwgUtilityProcessHostClient::OnProcessCrashed(int exit_code) {
-  OnFailed();
+  RunCallback(false);
 }
 
 bool PwgUtilityProcessHostClient::OnMessageReceived(
   const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PwgUtilityProcessHostClient, message)
-    IPC_MESSAGE_HANDLER(
-        ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Succeeded, OnSucceeded)
-    IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Failed,
-                        OnFailed)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void PwgUtilityProcessHostClient::OnSucceeded() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  RunCallback(true);
-}
-
-void PwgUtilityProcessHostClient::OnFailed() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  RunCallback(false);
+  return false;
 }
 
 void PwgUtilityProcessHostClient::OnFilesReadyOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!files_->IsValid()) {
     RunCallbackOnUIThread(false);
     return;
   }
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PwgUtilityProcessHostClient::StartProcessOnIOThread, this));
 }
 
 void PwgUtilityProcessHostClient::StartProcessOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  // TODO(tibell): Use UtilityProcessMojoClient to manage process lifetime
+  // instead.
   content::UtilityProcessHost* utility_process_host =
       content::UtilityProcessHost::Create(this,
                                           base::ThreadTaskRunnerHandle::Get());
-  utility_process_host->SetName(l10n_util::GetStringUTF16(
-      IDS_UTILITY_PROCESS_PWG_RASTER_CONVERTOR_NAME));
-  utility_process_host->Send(new ChromeUtilityMsg_RenderPDFPagesToPWGRaster(
+  utility_process_host->SetName(
+      l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_PWG_RASTER_CONVERTOR_NAME));
+  utility_process_host->Start();
+
+  mojom::PrintingFactoryPtr printing_factory;
+  utility_process_host->GetRemoteInterfaces()->GetInterface(&printing_factory);
+  // We don't care about calls to FontPreCaching so we pass a null pointer for
+  // the second argument.
+  printing_factory->MakePrinting(mojo::MakeRequest(&printing_),
+                                 mojom::FontPreCachingPtr());
+  printing_->RenderPDFPagesToPWGRaster(
       files_->GetPdfForProcess(), settings_, bitmap_settings_,
-      files_->GetPwgForProcess()));
+      files_->GetPwgForProcess(),
+      base::Bind(&PwgUtilityProcessHostClient::RunCallback, this));
 }
 
 void PwgUtilityProcessHostClient::RunCallback(bool success) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PwgUtilityProcessHostClient::RunCallbackOnUIThread, this,
                  success));
 }
 
 void PwgUtilityProcessHostClient::RunCallbackOnUIThread(bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (callback_.is_null())
     return;
@@ skipping 98 matching lines @@
         result.odd_page_transform = TRANSFORM_FLIP_HORIZONTAL;
       break;
   }
 
   result.rotate_all_pages = raster_capability.value().rotate_all_pages;
   result.reverse_page_order = raster_capability.value().reverse_order_streaming;
   return result;
 }
 
 }  // namespace printing