Update from https://crrev.com/311145

base/test/launcher/test_launcher.cc

 // Copyright 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 "base/test/launcher/test_launcher.h"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #endif
 
@@ skipping 269 matching lines @@
   }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_LINUX)
   // To prevent accidental privilege sharing to an untrusted child, processes
   // are started with PR_SET_NO_NEW_PRIVS. Do not set that here, since this
   // new child will be privileged and trusted.
   new_options.allow_new_privs = true;
 #endif
 
-  ProcessHandle process_handle;
+  Process process;
 
   {
     // Note how we grab the lock before the process possibly gets created.
     // This ensures that when the lock is held, ALL the processes are registered
     // in the set.
     AutoLock lock(g_live_processes_lock.Get());
 
-    if (!LaunchProcess(command_line, new_options, &process_handle))
+    process = LaunchProcess(command_line, new_options);
+    if (!process.IsValid())
       return -1;
 
-    g_live_processes.Get().insert(std::make_pair(process_handle, command_line));
+    // TODO(rvargas) crbug.com/417532: Don't store process handles.
+    g_live_processes.Get().insert(std::make_pair(process.Handle(),
+                                                 command_line));
   }
 
   int exit_code = 0;
-  if (!WaitForExitCodeWithTimeout(process_handle, &exit_code, timeout)) {
+  if (!process.WaitForExitWithTimeout(timeout, &exit_code)) {
     *was_timeout = true;
     exit_code = -1;  // Set a non-zero exit code to signal a failure.
 
     // Ensure that the process terminates.
-    KillProcess(process_handle, -1, true);
+    KillProcess(process.Handle(), -1, true);
   }
 
   {
     // Note how we grab the log before issuing a possibly broad process kill.
     // Other code parts that grab the log kill processes, so avoid trying
     // to do that twice and trigger all kinds of log messages.
     AutoLock lock(g_live_processes_lock.Get());
 
 #if defined(OS_POSIX)
     if (exit_code != 0) {
       // On POSIX, in case the test does not exit cleanly, either due to a crash
       // or due to it timing out, we need to clean up any child processes that
       // it might have created. On Windows, child processes are automatically
       // cleaned up using JobObjects.
-      KillProcessGroup(process_handle);
+      KillProcessGroup(process.Handle());
     }
 #endif
 
-    g_live_processes.Get().erase(process_handle);
+    g_live_processes.Get().erase(process.Handle());
   }
 
-  CloseProcessHandle(process_handle);
-
   return exit_code;
 }
 
 void RunCallback(
     const TestLauncher::LaunchChildGTestProcessCallback& callback,
     int exit_code,
     const TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   callback.Run(exit_code, elapsed_time, was_timeout, output);
@@ skipping 736 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base