Change base::LaunchProcess API slightly

base/process_util_posix.cc

 // Copyright (c) 2011 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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 510 matching lines @@
       memcpy(scratch, j->second.c_str(), j->second.size() + 1);
       scratch += j->second.size() + 1;
      }
   }
 
   ret[k] = NULL;
   return ret;
 }
 
 bool LaunchProcess(const std::vector<std::string>& argv,
-                   const LaunchOptions& options) {
+                   const LaunchOptions& options,
+                   ProcessHandle* process_handle) {
   pid_t pid;
   InjectiveMultimap fd_shuffle1, fd_shuffle2;
   if (options.fds_to_remap) {
     fd_shuffle1.reserve(options.fds_to_remap->size());
     fd_shuffle2.reserve(options.fds_to_remap->size());
   }
   scoped_array<char*> argv_cstr(new char*[argv.size() + 1]);
   scoped_array<char*> new_environ;
   if (options.environ)
     new_environ.reset(AlterEnvironment(*options.environ, GetEnvironment()));
@@ skipping 82 matching lines @@
   } else {
     // Parent process
     if (options.wait) {
       // While this isn't strictly disk IO, waiting for another process to
       // finish is the sort of thing ThreadRestrictions is trying to prevent.
       base::ThreadRestrictions::AssertIOAllowed();
       pid_t ret = HANDLE_EINTR(waitpid(pid, 0, 0));
       DPCHECK(ret > 0);
     }
 
-    if (options.process_handle)
-      *options.process_handle = pid;
+    if (process_handle)
+      *process_handle = pid;
   }
 
   return true;
 }
 
 bool LaunchProcess(const CommandLine& cmdline,
-                   const LaunchOptions& options) {
-  return LaunchProcess(cmdline.argv(), options);
+                   const LaunchOptions& options,
+                   ProcessHandle* process_handle) {
+  return LaunchProcess(cmdline.argv(), options, process_handle);
 }
 
 ProcessMetrics::~ProcessMetrics() { }
 
 void EnableTerminationOnHeapCorruption() {
   // On POSIX, there nothing to do AFAIK.
 }
 
 bool EnableInProcessStackDumping() {
   // When running in an application, our code typically expects SIGPIPE
@@ skipping 392 matching lines @@
                       const ProcessFilter* filter) {
   bool exited_cleanly =
       WaitForProcessesToExit(executable_name, wait_milliseconds,
                              filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
 }
 
 }  // namespace base