Convert printing IPCs to Mojo

chrome/service/service_utility_process_host.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/service/service_utility_process_host.h"
 
 #include <stdint.h>
 
 #include <queue>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/process/launch.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/win/win_util.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/chrome_utility_printing_messages.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandbox_init.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/named_platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 #include "printing/emf_win.h"
 #include "sandbox/win/src/sandbox_policy.h"
 #include "sandbox/win/src/sandbox_types.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "ui/base/ui_base_switches.h"
 
 namespace {
 
 using content::ChildProcessHost;
 
 enum ServiceUtilityProcessHostEvent {
   SERVICE_UTILITY_STARTED,
   SERVICE_UTILITY_DISCONNECTED,
   SERVICE_UTILITY_METAFILE_REQUEST,
@@ skipping 37 matching lines @@
 class ServiceUtilityProcessHost::PdfToEmfState {
  public:
   explicit PdfToEmfState(ServiceUtilityProcessHost* host)
       : host_(host), page_count_(0), current_page_(0), pages_in_progress_(0) {}
   ~PdfToEmfState() { Stop(); }
 
   bool Start(base::File pdf_file,
              const printing::PdfRenderSettings& conversion_settings) {
     if (!temp_dir_.CreateUniqueTempDir())
       return false;
-    return host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles(
-        IPC::TakePlatformFileForTransit(std::move(pdf_file)),
-        conversion_settings, false /* print_text_with_gdi */));
+    host_->printing()->RenderPDFPagesToMetafiles(
+        mojo::WrapPlatformFile(pdf_file.TakePlatformFile()),
+        conversion_settings, false /* print_text_with_gdi */,
+        base::Bind(
+            &ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesPageCount,
+            base::Unretained(host_)));
+    return true;
   }
 
   void GetMorePages() {
     const int kMaxNumberOfTempFilesPerDocument = 3;
     while (pages_in_progress_ < kMaxNumberOfTempFilesPerDocument &&
            current_page_ < page_count_) {
       ++pages_in_progress_;
       emf_files_.push(CreateTempFile());
-      host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(
+      host_->printing()->RenderPDFPagesToMetafilesGetPage(
           current_page_++,
-          IPC::GetPlatformFileForTransit(
-              emf_files_.back().GetPlatformFile(), false)));
+          mojo::WrapPlatformFile(emf_files_.back().GetPlatformFile()),
+          base::Bind(
+              &ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesPageDone,
+              base::Unretained(host_)));
     }
   }
 
   // Returns true if all pages processed and client should not expect more
   // results.
   bool OnPageProcessed() {
     --pages_in_progress_;
     GetMorePages();
     if (pages_in_progress_ || current_page_ < page_count_)
       return false;
     Stop();
     return true;
   }
 
   base::File TakeNextFile() {
     DCHECK(!emf_files_.empty());
     base::File file;
     if (!emf_files_.empty())
       file = std::move(emf_files_.front());
     emf_files_.pop();
     return file;
   }
 
   void set_page_count(int page_count) { page_count_ = page_count; }
   bool has_page_count() { return page_count_ > 0; }
 
  private:
-  void Stop() {
-    host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_Stop());
-  }
+  void Stop() { host_->printing()->RenderPDFPagesToMetafilesStop(); }
 
   base::File CreateTempFile() {
     base::FilePath path;
     if (!base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &path))
       return base::File();
     return base::File(path,
                       base::File::FLAG_CREATE_ALWAYS |
                       base::File::FLAG_WRITE |
                       base::File::FLAG_READ |
                       base::File::FLAG_DELETE_ON_CLOSE |
@@ skipping 42 matching lines @@
 }
 
 bool ServiceUtilityProcessHost::StartGetPrinterCapsAndDefaults(
     const std::string& printer_name) {
   ReportUmaEvent(SERVICE_UTILITY_CAPS_REQUEST);
   start_time_ = base::Time::Now();
   if (!StartProcess(true))
     return false;
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
-  return Send(new ChromeUtilityMsg_GetPrinterCapsAndDefaults(printer_name));
+  printing()->GetPrinterCapsAndDefaults(
+      printer_name,
+      base::Bind(&ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaults,
+                 base::Unretained(this), printer_name));
+  return true;
 }
 
 bool ServiceUtilityProcessHost::StartGetPrinterSemanticCapsAndDefaults(
     const std::string& printer_name) {
   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_REQUEST);
   start_time_ = base::Time::Now();
   if (!StartProcess(true))
     return false;
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
-  return Send(
-      new ChromeUtilityMsg_GetPrinterSemanticCapsAndDefaults(printer_name));
+  printing()->GetPrinterSemanticCapsAndDefaults(
+      printer_name,
+      base::Bind(
+          &ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaults,
+          base::Unretained(this), printer_name));
+  return true;
 }
 
 bool ServiceUtilityProcessHost::StartProcess(bool no_sandbox) {
   std::string mojo_channel_token =
       child_process_host_->CreateChannelMojo(mojo_child_token_);
   if (mojo_channel_token.empty())
     return false;
 
   base::FilePath exe_path = GetUtilityProcessCmd();
   if (exe_path.empty()) {
@@ skipping 51 matching lines @@
   if (success) {
     mojo::edk::ChildProcessLaunched(process_.Handle(),
                                     std::move(parent_handle),
                                     mojo_child_token_);
   } else {
     mojo::edk::ChildProcessLaunchFailed(mojo_child_token_);
   }
   return success;
 }
 
-bool ServiceUtilityProcessHost::Send(IPC::Message* msg) {
-  if (child_process_host_)
-    return child_process_host_->Send(msg);
-  delete msg;
-  return false;
-}
-
 base::FilePath ServiceUtilityProcessHost::GetUtilityProcessCmd() {
   return ChildProcessHost::GetChildPath(ChildProcessHost::CHILD_NORMAL);
 }
 
 void ServiceUtilityProcessHost::OnChildDisconnected() {
   if (waiting_for_reply_) {
     // If we are yet to receive a reply then notify the client that the
     // child died.
     client_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Client::OnChildDied, client_.get()));
     ReportUmaEvent(SERVICE_UTILITY_DISCONNECTED);
     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityDisconnectTime",
                         base::Time::Now() - start_time_);
   }
   delete this;
 }
 
 bool ServiceUtilityProcessHost::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ServiceUtilityProcessHost, message)
-    IPC_MESSAGE_HANDLER(
-        ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageCount,
-        OnRenderPDFPagesToMetafilesPageCount)
-    IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageDone,
-                        OnRenderPDFPagesToMetafilesPageDone)
-    IPC_MESSAGE_HANDLER(
-        ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Succeeded,
-        OnGetPrinterCapsAndDefaultsSucceeded)
-    IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Failed,
-                        OnGetPrinterCapsAndDefaultsFailed)
-    IPC_MESSAGE_HANDLER(
-        ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Succeeded,
-        OnGetPrinterSemanticCapsAndDefaultsSucceeded)
-    IPC_MESSAGE_HANDLER(
-        ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Failed,
-        OnGetPrinterSemanticCapsAndDefaultsFailed)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
+  return false;
 }
 
 const base::Process& ServiceUtilityProcessHost::GetProcess() const {
   return process_;
 }
 
 void ServiceUtilityProcessHost::OnMetafileSpooled(bool success) {
   if (!success || pdf_to_emf_state_->OnPageProcessed())
     OnPDFToEmfFinished(success);
 }
@@ skipping 36 matching lines @@
     ReportUmaEvent(SERVICE_UTILITY_METAFILE_FAILED);
     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileFailTime",
                         base::Time::Now() - start_time_);
   }
   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::OnRenderPDFPagesToMetafileDone,
                             client_.get(), success));
   pdf_to_emf_state_.reset();
 }
 
-void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsSucceeded(
+void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaults(
     const std::string& printer_name,
-    const printing::PrinterCapsAndDefaults& caps_and_defaults) {
+    const base::Optional<printing::PrinterCapsAndDefaults>& caps_and_defaults) {
   DCHECK(waiting_for_reply_);
-  ReportUmaEvent(SERVICE_UTILITY_CAPS_SUCCEEDED);
-  UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsTime",
-                      base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
-  client_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(),
-                            true, printer_name, caps_and_defaults));
+  if (caps_and_defaults) {
+    ReportUmaEvent(SERVICE_UTILITY_CAPS_SUCCEEDED);
+    UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsTime",
+                        base::Time::Now() - start_time_);
+    client_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(), true,
+                   printer_name, caps_and_defaults.value()));
+  } else {
+    ReportUmaEvent(SERVICE_UTILITY_CAPS_FAILED);
+    UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsFailTime",
+                        base::Time::Now() - start_time_);
+    client_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(), false,
+                   printer_name, printing::PrinterCapsAndDefaults()));
+  }
 }
 
-void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaultsSucceeded(
+void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaults(
     const std::string& printer_name,
-    const printing::PrinterSemanticCapsAndDefaults& caps_and_defaults) {
+    const base::Optional<printing::PrinterSemanticCapsAndDefaults>&
+        caps_and_defaults) {
   DCHECK(waiting_for_reply_);
-  ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED);
-  UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsTime",
-                      base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
-  client_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults, client_.get(),
-                 true, printer_name, caps_and_defaults));
-}
-
-void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsFailed(
-    const std::string& printer_name) {
-  DCHECK(waiting_for_reply_);
-  ReportUmaEvent(SERVICE_UTILITY_CAPS_FAILED);
-  UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsFailTime",
-                      base::Time::Now() - start_time_);
-  waiting_for_reply_ = false;
-  client_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(), false,
-                 printer_name, printing::PrinterCapsAndDefaults()));
-}
-
-void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaultsFailed(
-    const std::string& printer_name) {
-  DCHECK(waiting_for_reply_);
-  ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_FAILED);
-  UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsFailTime",
-                      base::Time::Now() - start_time_);
-  waiting_for_reply_ = false;
-  client_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults,
-                            client_.get(), false, printer_name,
-                            printing::PrinterSemanticCapsAndDefaults()));
+  if (caps_and_defaults) {
+    ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED);
+    UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsTime",
+                        base::Time::Now() - start_time_);
+    client_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults, client_.get(),
+                   true, printer_name, caps_and_defaults.value()));
+  } else {
+    ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_FAILED);
+    UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsFailTime",
+                        base::Time::Now() - start_time_);
+    client_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults,
+                              client_.get(), false, printer_name,
+                              printing::PrinterSemanticCapsAndDefaults()));
+  }
 }
 
 bool ServiceUtilityProcessHost::Client::MetafileAvailable(float scale_factor,
                                                           base::File file) {
   file.Seek(base::File::FROM_BEGIN, 0);
   int64_t size = file.GetLength();
   if (size <= 0) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   std::vector<char> data(size);
   if (file.ReadAtCurrentPos(data.data(), data.size()) != size) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   printing::Emf emf;
   if (!emf.InitFromData(data.data(), data.size())) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   OnRenderPDFPagesToMetafilePageDone(scale_factor, emf);
   return true;
 }
+
+printing::mojom::Printing* ServiceUtilityProcessHost::printing() {
+  if (!printing_) {
+    printing::mojom::PrintingFactoryPtr printing_factory;
+    child_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::GetProxy(&printing_),
+                                   printing::mojom::FontPreCachingPtr());
+  }
+  return printing_.get();
+}