Don't pass ProcessHandle through ChildProcessHostDelegate.

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 <queue>
 
 #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/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
+#include "base/process/process_handle.h"
 #include "base/task_runner_util.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/result_codes.h"
 #include "content/public/common/sandbox_init.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "ipc/ipc_switches.h"
 #include "printing/emf_win.h"
 #include "sandbox/win/src/sandbox_policy_base.h"
@@ skipping 116 matching lines @@
   ServiceUtilityProcessHost* host_;
   std::queue<base::File> emf_files_;
   int page_count_;
   int current_page_;
   int pages_in_progress_;
 };
 
 ServiceUtilityProcessHost::ServiceUtilityProcessHost(
     Client* client,
     base::MessageLoopProxy* client_message_loop_proxy)
-    : handle_(base::kNullProcessHandle),
-      client_(client),
+    : client_(client),
       client_message_loop_proxy_(client_message_loop_proxy),
       waiting_for_reply_(false),
       weak_ptr_factory_(this) {
   child_process_host_.reset(ChildProcessHost::Create(this));
 }
 
 ServiceUtilityProcessHost::~ServiceUtilityProcessHost() {
   // We need to kill the child process when the host dies.
-  base::KillProcess(handle_, content::RESULT_CODE_NORMAL_EXIT, false);
+  base::KillProcess(process_.Handle(), content::RESULT_CODE_NORMAL_EXIT, false);
 }
 
 bool ServiceUtilityProcessHost::StartRenderPDFPagesToMetafile(
     const base::FilePath& pdf_path,
     const printing::PdfRenderSettings& render_settings) {
   ReportUmaEvent(SERVICE_UTILITY_METAFILE_REQUEST);
   start_time_ = base::Time::Now();
   base::File pdf_file(pdf_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   if (!pdf_file.IsValid() || !StartProcess(false))
     return false;
@@ skipping 49 matching lines @@
     return true;
   }
   ReportUmaEvent(SERVICE_UTILITY_FAILED_TO_START);
   return false;
 }
 
 bool ServiceUtilityProcessHost::Launch(base::CommandLine* cmd_line,
                                        bool no_sandbox) {
   if (no_sandbox) {
     cmd_line->AppendSwitch(switches::kNoSandbox);
-    base::LaunchProcess(*cmd_line, base::LaunchOptions(), &handle_);
+    base::ProcessHandle handle;
+    if (base::LaunchProcess(*cmd_line, base::LaunchOptions(), &handle))
+      process_ = base::Process(handle);
   } else {
     ServiceSandboxedProcessLauncherDelegate delegate;
-    handle_ = content::StartSandboxedProcess(&delegate, cmd_line);
+    process_ =
+        base::Process(content::StartSandboxedProcess(&delegate, cmd_line));
   }
-  return (handle_ != base::kNullProcessHandle);
+  return process_.IsValid();
 }
 
 bool ServiceUtilityProcessHost::Send(IPC::Message* msg) {
   if (child_process_host_)
     return child_process_host_->Send(msg);
   delete msg;
   return false;
 }
 
 base::FilePath ServiceUtilityProcessHost::GetUtilityProcessCmd() {
@@ skipping 35 matching lines @@
         ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Succeeded,
         OnGetPrinterSemanticCapsAndDefaultsSucceeded)
     IPC_MESSAGE_HANDLER(
         ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Failed,
         OnGetPrinterSemanticCapsAndDefaultsFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-base::ProcessHandle ServiceUtilityProcessHost::GetHandle() const {
-  return handle_;
+const base::Process& ServiceUtilityProcessHost::GetProcess() const {
+  return process_;
 }
 
 void ServiceUtilityProcessHost::OnMetafileSpooled(bool success) {
   if (!success || pdf_to_emf_state_->OnPageProcessed())
     OnPDFToEmfFinished(success);
 }
 
 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesPageCount(
     int page_count) {
   DCHECK(waiting_for_reply_);
@@ skipping 112 matching lines @@
     return false;
   }
   printing::Emf emf;
   if (!emf.InitFromData(data.data(), data.size())) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   OnRenderPDFPagesToMetafilePageDone(scale_factor, emf);
   return true;
 }