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 "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_->GetPrinting()->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_->GetPrinting()->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));
+  GetPrinting()->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));
+  GetPrinting()->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::GetPrinting() {
+  if (!printing_) {
+    printing::mojom::PrintingFactoryPtr printing_factory;
+    child_process_host_->GetRemoteInterfaces()->GetInterface(&printing_factory);

[leonhsl(Using Gerrit), 2017/01/18 03:35:29]

Hi, I came across here while checking some issue around service utility process,
would you please help to clarify my confusion: 
I found service utility process is launched without service manager connection,
it's launched via ChildProcessHostImpl but not BrowserChildProcessHostImpl, this
is different with normal utility process. That is to say, there has no interface
provider/registry pair established between ServiceUtilityProcessHost and
ServiceUtilityProcess, here seems child_process_host_->GetRemoteInterfaces()
would return nullptr?

Thanks!

[leonhsl(Using Gerrit), 2017/01/18 03:38:11]

The issue I'm investigating is
https://bugs.chromium.org/p/chromium/issues/detail?id=680400, CL is
https://codereview.chromium.org/2629873002/, that bug's root cause is service
utility process has no service manager connection.

+    // We don't care about calls to FontPreCaching so we pass a null pointer
+    // (FontPreCachingPtr no-arg constructor creates a null InterfacePtr) as the
+    // second argument.
+    printing_factory->MakePrinting(mojo::MakeRequest(&printing_),
+                                   printing::mojom::FontPreCachingPtr());
+  }
+  return printing_.get();
+}