Upgrade the windows specific version of LaunchProcess to avoid raw handles.

win8/delegate_execute/chrome_util.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 "win8/delegate_execute/chrome_util.h"
 
 #include <windows.h>
 #include <atlbase.h>
 #include <shlobj.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/md5.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
-#include "base/process/process_handle.h"
+#include "base/process/process.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "google_update/google_update_idl.h"
@@ skipping 65 matching lines @@
 
 namespace delegate_execute {
 
 void UpdateChromeIfNeeded(const base::FilePath& chrome_exe) {
 #if defined(GOOGLE_CHROME_BUILD)
   // Nothing to do if a browser is already running or if there's no
   // new_chrome.exe.
   if (IsBrowserRunning(chrome_exe) || !NewChromeExeExists(chrome_exe))
     return;
 
-  base::win::ScopedHandle process_handle;
+  base::Process process;
 
   if (InstallUtil::IsPerUserInstall(chrome_exe.value().c_str())) {
     // Read the update command from the registry.
     base::string16 update_command;
     if (!GetUpdateCommand(true, &update_command)) {
       AtlTrace("%hs. Failed to read update command from registry.\n",
                __FUNCTION__);
     } else {
       // Run the update command.
       base::LaunchOptions launch_options;
       launch_options.start_hidden = true;
-      if (!base::LaunchProcess(update_command, launch_options,
-                               &process_handle)) {
+      process = base::LaunchProcess(update_command, launch_options);
+      if (!process.IsValid()) {
         AtlTrace("%hs. Failed to launch command to finalize update; "
                  "error %u.\n", __FUNCTION__, ::GetLastError());
       }
     }
   } else {
     // Run the update command via Google Update.
     HRESULT hr = S_OK;
     base::win::ScopedComPtr<IProcessLauncher> process_launcher;
     hr = process_launcher.CreateInstance(__uuidof(ProcessLauncherClass));
     if (FAILED(hr)) {
       AtlTrace("%hs. Failed to Create ProcessLauncher; hr=0x%X.\n",
                __FUNCTION__, hr);
     } else {
       ULONG_PTR handle = 0;
       BrowserDistribution* dist = BrowserDistribution::GetDistribution();
       hr = process_launcher->LaunchCmdElevated(
           dist->GetAppGuid().c_str(), kRenameCommandValue,
           GetCurrentProcessId(), &handle);
       if (FAILED(hr)) {
         AtlTrace("%hs. Failed to launch command to finalize update; "
                  "hr=0x%X.\n", __FUNCTION__, hr);
       } else {
-        process_handle.Set(reinterpret_cast<base::ProcessHandle>(handle));
+        process = base::Process(reinterpret_cast<base::ProcessHandle>(handle));
       }
     }
   }
 
   // Wait for the update to complete and report the results.
-  if (process_handle.IsValid()) {
+  if (process.IsValid()) {
     int exit_code = 0;
-    // WaitForExitCode will close the handle in all cases.
-    if (!base::WaitForExitCode(process_handle.Take(), &exit_code)) {
+    if (!base::WaitForExitCodeWithTimeout(
+            process.Handle(), &exit_code,
+            base::TimeDelta::FromMilliseconds(INFINITE))) {
       AtlTrace("%hs. Failed to get result when finalizing update.\n",
                __FUNCTION__);
     } else if (exit_code != installer::RENAME_SUCCESSFUL) {
       AtlTrace("%hs. Failed to finalize update with exit code %d.\n",
                __FUNCTION__, exit_code);
     } else {
       AtlTrace("%hs. Finalized pending update.\n", __FUNCTION__);
     }
   }
 #endif
 }
 
 }  // delegate_execute