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(
+        std::move(pdf_file), 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(
-          current_page_++,
-          IPC::GetPlatformFileForTransit(
-              emf_files_.back().GetPlatformFile(), false)));
+      host_->printing()->RenderPDFPagesToMetafilesGetPage(
+          current_page_++, emf_files_.back().Duplicate(),
+          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_.reset(); }
 
   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;
 }
 

[groby-ooo-7-16, 2016/12/14 17:28:29]

Does this still need to be an IPC::Listener?

[tibell, 2016/12/14 23:12:19]

Unfortunately OnMessageReceived is defined pure virtual (by inheritance) in
ChildProcessHostDelegate, which we inherit from since we use other methods from
that class, so we're forced to define it here.

 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

[groby-ooo-7-16, 2016/12/14 17:28:29]

This comment seems out of date?

[tibell, 2016/12/14 23:12:19]

printing::mojom::FontPreCachingPtr() does create a "null" interface pointer. I
have reworded the comment to make that more clear.

+    // the second argument.
+    printing_factory->MakePrinting(mojo::GetProxy(&printing_),
+                                   printing::mojom::FontPreCachingPtr());
+  }
+  return printing_.get();
+}