Update browser/service_process to use the new version of LaunchProcess.

chrome/browser/service_process/service_process_control.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/browser/service_process/service_process_control.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 302 matching lines @@
 }
 
 // static
 ServiceProcessControl* ServiceProcessControl::GetInstance() {
   return Singleton<ServiceProcessControl>::get();
 }
 
 ServiceProcessControl::Launcher::Launcher(
     ServiceProcessControl* process,
     scoped_ptr<base::CommandLine> cmd_line)
-    : process_(process),
+    : process_control_(process),
       cmd_line_(cmd_line.Pass()),
       launched_(false),
-      retry_count_(0),
-      process_handle_(base::kNullProcessHandle) {
+      retry_count_(0) {
 }
 
 // Execute the command line to start the process asynchronously.
 // After the command is executed, |task| is called with the process handle on
 // the UI thread.
 void ServiceProcessControl::Launcher::Run(const base::Closure& task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   notify_task_ = task;
   BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
                           base::Bind(&Launcher::DoRun, this));
 }
 
 ServiceProcessControl::Launcher::~Launcher() {
-  CloseProcessHandle();
 }
 
 
 void ServiceProcessControl::Launcher::Notify() {
   DCHECK(!notify_task_.is_null());
   notify_task_.Run();
   notify_task_.Reset();
 }
 
-void ServiceProcessControl::Launcher::CloseProcessHandle() {
-  if (process_handle_ != base::kNullProcessHandle) {
-    base::CloseProcessHandle(process_handle_);
-    process_handle_ = base::kNullProcessHandle;
-  }
-}
-
 #if !defined(OS_MACOSX)
 void ServiceProcessControl::Launcher::DoDetectLaunched() {
   DCHECK(!notify_task_.is_null());
 
   const uint32 kMaxLaunchDetectRetries = 10;
   launched_ = CheckServiceProcessReady();
 
   int exit_code = 0;
   if (launched_ || (retry_count_ >= kMaxLaunchDetectRetries) ||
-      base::WaitForExitCodeWithTimeout(process_handle_, &exit_code,
-                                       base::TimeDelta())) {
-    CloseProcessHandle();
+      process_.WaitForExitWithTimeout(base::TimeDelta(), &exit_code)) {
+    process_.Close();
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(&Launcher::Notify, this));
     return;
   }
   retry_count_++;
 
   // If the service process is not launched yet then check again in 2 seconds.
   const base::TimeDelta kDetectLaunchRetry = base::TimeDelta::FromSeconds(2);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&Launcher::DoDetectLaunched, this),
       kDetectLaunchRetry);
 }
 
 void ServiceProcessControl::Launcher::DoRun() {
   DCHECK(!notify_task_.is_null());
 
   base::LaunchOptions options;
 #if defined(OS_WIN)
   options.start_hidden = true;
 #endif
-  if (base::LaunchProcess(*cmd_line_, options, &process_handle_)) {
+  process_ = base::LaunchProcess(*cmd_line_, options);
+  if (process_.IsValid()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&Launcher::DoDetectLaunched, this));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(&Launcher::Notify, this));
   }
 }
 #endif  // !OS_MACOSX