Change base::LaunchProcess API slightly

base/process_util.h

 // 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.
 
 // This file/namespace contains utility functions for enumerating, ending and
 // computing statistics of processes.
 
 #ifndef BASE_PROCESS_UTIL_H_
 #define BASE_PROCESS_UTIL_H_
 #pragma once
@@ skipping 177 matching lines @@
 // given multimap. Only call this function in a child process where you know
 // that there aren't any other threads.
 BASE_API void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
 #endif
 
 // TODO(evan): rename these to use StudlyCaps.
 typedef std::vector<std::pair<std::string, std::string> > environment_vector;
 typedef std::vector<std::pair<int, int> > file_handle_mapping_vector;
 
 // Options for launching a subprocess that are passed to LaunchApp().
+// The default constructor constructs the object with default options.
 struct LaunchOptions {
-  LaunchOptions() : wait(false), process_handle(NULL),
+  LaunchOptions() : wait(false),
 #if defined(OS_WIN)
                     start_hidden(false), inherit_handles(false), as_user(NULL),
                     empty_desktop_name(false)
 #else
                     environ(NULL), fds_to_remap(NULL), new_process_group(false)
 #endif
       {}
 
   // If true, wait for the process to complete.
   bool wait;
 
-  // If non-NULL, will be filled in with the handle of the launched process.
-  // NOTE: In this case, the caller is responsible for closing the handle so
-  //       that it doesn't leak!  Otherwise, the handle will be implicitly
-  //       closed.
-  // Not especially useful unless |wait| is false.
-  ProcessHandle* process_handle;
-
 #if defined(OS_WIN)
   bool start_hidden;
 
   // If true, the new process inherits handles from the parent.
   bool inherit_handles;
 
   // If non-NULL, runs as if the user represented by the token had launched it.
   // Whether the application is visible on the interactive desktop depends on
   // the token belonging to an interactive logon session.
   //
@@ skipping 18 matching lines @@
   const file_handle_mapping_vector* fds_to_remap;
 
   // If true, start the process in a new process group, instead of
   // inheriting the parent's process group.  The pgid of the child process
   // will be the same as its pid.
   bool new_process_group;
 #endif
 };
 
 // Launch a process via the command line |cmdline|.
-// See the documentation of LaunchOptions for details on launching options.
+// See the documentation of LaunchOptions for details on |options|.
+//
+// If |process_handle| is non-NULL, it will be filled in with the
+// handle of the launched process.  NOTE: In this case, the caller is
+// responsible for closing the handle so that it doesn't leak!
+// Otherwise, the process handle will be implicitly closed.
 //
 // Unix-specific notes:
 // - Before launching, all FDs open in the parent process will be marked as
 //   close-on-exec.
 // - If the first argument on the command line does not contain a slash,
 //   PATH will be searched.  (See man execvp.)
 BASE_API bool LaunchProcess(const CommandLine& cmdline,
-                            const LaunchOptions& options);
+                            const LaunchOptions& options,
+                            ProcessHandle* process_handle);
 
 #if defined(OS_WIN)
 
 enum IntegrityLevel {
   INTEGRITY_UNKNOWN,
   LOW_INTEGRITY,
   MEDIUM_INTEGRITY,
   HIGH_INTEGRITY,
 };
 // Determine the integrity level of the specified process. Returns false
 // if the system does not support integrity levels (pre-Vista) or in the case
 // of an underlying system failure.
 BASE_API bool GetProcessIntegrityLevel(ProcessHandle process,
                                        IntegrityLevel *level);
 
 // Windows-specific LaunchProcess that takes the command line as a
 // string.  Useful for situations where you need to control the
 // command line arguments directly, but prefer the CommandLine version
 // if launching Chrome itself.
 //
 // The first command line argument should be the path to the process,
 // and don't forget to quote it.
 //
 // Example (including literal quotes)
 //  cmdline = "c:\windows\explorer.exe" -foo "c:\bar\"
 BASE_API bool LaunchProcess(const string16& cmdline,
-                            const LaunchOptions& options);
+                            const LaunchOptions& options,
+                            ProcessHandle* process_handle);
 
 // TODO(evan): deprecated; change callers to use LaunchProcess, remove.
 inline bool LaunchApp(const std::wstring& cmdline,
                       bool wait, bool start_hidden,
                       ProcessHandle* process_handle) {
   LaunchOptions options;
   options.wait = wait;
   options.start_hidden = start_hidden;
-  options.process_handle = process_handle;
-  return LaunchProcess(cmdline, options);
+  return LaunchProcess(cmdline, options, process_handle);
 }
 
 // TODO(evan): deprecated; change callers to use LaunchProcess, remove.
 inline bool LaunchAppWithHandleInheritance(const std::wstring& cmdline,
                                            bool wait, bool start_hidden,
                                            ProcessHandle* process_handle) {
   LaunchOptions options;
   options.wait = wait;
   options.start_hidden = start_hidden;
-  options.process_handle = process_handle;
   options.inherit_handles = true;
-  return LaunchProcess(cmdline, options);
+  return LaunchProcess(cmdline, options, process_handle);
 }
 
 // TODO(evan): deprecated; change callers to use LaunchProcess, remove.
 inline bool LaunchAppAsUser(UserTokenHandle token,
                             const std::wstring& cmdline,
                             bool start_hidden,
                             ProcessHandle* process_handle) {
   LaunchOptions options;
   options.start_hidden = start_hidden;
-  options.process_handle = process_handle;
   options.as_user = token;
-  return LaunchProcess(cmdline, options);
+  return LaunchProcess(cmdline, options, process_handle);
 }
 
 // TODO(evan): deprecated; change callers to use LaunchProcess, remove.
 inline bool LaunchAppAsUser(UserTokenHandle token,
                             const std::wstring& cmdline,
                             bool start_hidden, ProcessHandle* process_handle,
                             bool empty_desktop_name, bool inherit_handles) {
   LaunchOptions options;
   options.start_hidden = start_hidden;
-  options.process_handle = process_handle;
   options.as_user = token;
   options.empty_desktop_name = empty_desktop_name;
   options.inherit_handles = inherit_handles;
-  return LaunchProcess(cmdline, options);
+  return LaunchProcess(cmdline, options, process_handle);
 }
 
 #elif defined(OS_POSIX)
 // A POSIX-specific version of LaunchProcess that takes an argv array
 // instead of a CommandLine.  Useful for situations where you need to
 // control the command line arguments directly, but prefer the
 // CommandLine version if launching Chrome itself.
 BASE_API bool LaunchProcess(const std::vector<std::string>& argv,
-                            const LaunchOptions& options);
+                            const LaunchOptions& options,
+                            ProcessHandle* process_handle);
 
 // AlterEnvironment returns a modified environment vector, constructed from the
 // given environment and the list of changes given in |changes|. Each key in
 // the environment is matched against the first element of the pairs. In the
 // event of a match, the value is replaced by the second of the pair, unless
 // the second is empty, in which case the key-value is removed.
 //
 // The returned array is allocated using new[] and must be freed by the caller.
 BASE_API char** AlterEnvironment(const environment_vector& changes,
                                  const char* const* const env);
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_WIN)
 // TODO(evan): deprecated; change callers to use LaunchProcess, remove.
 // Successfully deprecated on non-Windows.
 inline bool LaunchApp(const CommandLine& cl, bool wait, bool start_hidden,
                       ProcessHandle* process_handle) {
   LaunchOptions options;
   options.wait = wait;
-  options.process_handle = process_handle;
-
-  return LaunchProcess(cl, options);
+  options.start_hidden = start_hidden;
+  return LaunchProcess(cl, options, process_handle);
 }
 #endif
 
 // Executes the application specified by |cl| and wait for it to exit. Stores
 // the output (stdout) in |output|. Redirects stderr to /dev/null. Returns true
 // on success (application launched and exited cleanly, with exit code
 // indicating success).
 BASE_API bool GetAppOutput(const CommandLine& cl, std::string* output);
 
 #if defined(OS_POSIX)
@@ skipping 370 matching lines @@
 // instance running inside the parent.  The parent's Breakpad instance should
 // not handle the child's exceptions.  Calling RestoreDefaultExceptionHandler
 // in the child after forking will restore the standard exception handler.
 // See http://crbug.com/20371/ for more details.
 void RestoreDefaultExceptionHandler();
 #endif  // defined(OS_MACOSX)
 
 }  // namespace base
 
 #endif  // BASE_PROCESS_UTIL_H_