Update chromedriver to use the new version of LaunchProcess.

chrome/test/chromedriver/chrome_launcher.cc

 // Copyright (c) 2013 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/test/chromedriver/chrome_launcher.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 334 matching lines @@
   options.stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
   options.inherit_handles = true;
 #endif
 
 #if defined(OS_WIN)
   std::string command_string = base::WideToUTF8(command.GetCommandLineString());
 #else
   std::string command_string = command.GetCommandLineString();
 #endif
   VLOG(0) << "Launching chrome: " << command_string;
-  base::ProcessHandle process;
-  if (!base::LaunchProcess(command, options, &process))
+  base::Process process = base::LaunchProcess(command, options);
+  if (!process.IsValid())
     return Status(kUnknownError, "chrome failed to start");
 
   scoped_ptr<DevToolsHttpClient> devtools_http_client;
   status = WaitForDevToolsAndCheckVersion(
       NetAddress(port), context_getter, socket_factory, &capabilities,
       &devtools_http_client);
 
   if (status.IsError()) {
     int exit_code;
     base::TerminationStatus chrome_status =
-        base::GetTerminationStatus(process, &exit_code);
+        base::GetTerminationStatus(process.Handle(), &exit_code);
     if (chrome_status != base::TERMINATION_STATUS_STILL_RUNNING) {
       std::string termination_reason;
       switch (chrome_status) {
         case base::TERMINATION_STATUS_NORMAL_TERMINATION:
           termination_reason = "exited normally";
           break;
         case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
           termination_reason = "exited abnormally";
           break;
         case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
           termination_reason = "was killed";
           break;
         case base::TERMINATION_STATUS_PROCESS_CRASHED:
           termination_reason = "crashed";
           break;
         default:
           termination_reason = "unknown";
           break;
       }
       return Status(kUnknownError,
                     "Chrome failed to start: " + termination_reason);
     }
-    if (!base::KillProcess(process, 0, true)) {
+    if (!base::KillProcess(process.Handle(), 0, true)) {
       int exit_code;
-      if (base::GetTerminationStatus(process, &exit_code) ==
+      if (base::GetTerminationStatus(process.Handle(), &exit_code) ==
           base::TERMINATION_STATUS_STILL_RUNNING)
         return Status(kUnknownError, "cannot kill Chrome", status);
     }
     return status;
   }
 
   scoped_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
       NetAddress(port), capabilities.perf_logging_prefs, socket_factory,
       *devtools_event_listeners, &devtools_websocket_client);
   if (status.IsError()) {
     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
                  << status.message();
   }
 
   scoped_ptr<ChromeDesktopImpl> chrome_desktop(
       new ChromeDesktopImpl(devtools_http_client.Pass(),
                             devtools_websocket_client.Pass(),
                             *devtools_event_listeners,
                             port_reservation.Pass(),
-                            process,
+                            process.Pass(),
                             command,
                             &user_data_dir,
                             &extension_dir));
   for (size_t i = 0; i < extension_bg_pages.size(); ++i) {
     VLOG(0) << "Waiting for extension bg page load: " << extension_bg_pages[i];
     scoped_ptr<WebView> web_view;
     Status status = chrome_desktop->WaitForPageToLoad(
         extension_bg_pages[i], base::TimeDelta::FromSeconds(10), &web_view);
     if (status.IsError()) {
       return Status(kUnknownError,
@@ skipping 411 matching lines @@
   // Write empty "First Run" file, otherwise Chrome will wipe the default
   // profile that was written.
   if (base::WriteFile(
           user_data_dir.Append(chrome::kFirstRunSentinel), "", 0) != 0) {
     return Status(kUnknownError, "failed to write first run file");
   }
   return Status(kOk);
 }
 
 }  // namespace internal