base: refactor LaunchApp variants into a single function

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 484 matching lines @@
       *scratch++ = '=';
       memcpy(scratch, j->second.c_str(), j->second.size() + 1);
       scratch += j->second.size() + 1;
      }
   }
 
   ret[k] = NULL;
   return ret;
 }
 
-bool LaunchAppImpl(
-    const std::vector<std::string>& argv,
-    const environment_vector& env_changes,
-    const file_handle_mapping_vector& fds_to_remap,
-    bool wait,
-    ProcessHandle* process_handle,
-    bool start_new_process_group) {
+bool LaunchProcess(const std::vector<std::string>& argv,
+                   const LaunchOptions& options) {
   pid_t pid;
   InjectiveMultimap fd_shuffle1, fd_shuffle2;
-  fd_shuffle1.reserve(fds_to_remap.size());
-  fd_shuffle2.reserve(fds_to_remap.size());
+  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(AlterEnvironment(env_changes, environ));
+  scoped_array<char*> new_environ;
+  if (options.environ)
+    new_environ.reset(AlterEnvironment(*options.environ, environ));
 
   pid = fork();
   if (pid < 0) {
     PLOG(ERROR) << "fork";
     return false;
   }
   if (pid == 0) {
     // Child process
 
     // DANGER: fork() rule: in the child, if you don't end up doing exec*(),
@@ skipping 11 matching lines @@
       _exit(127);
     }
 
     file_util::ScopedFD null_fd_closer(&null_fd);
     int new_fd = HANDLE_EINTR(dup2(null_fd, STDIN_FILENO));
     if (new_fd != STDIN_FILENO) {
       RAW_LOG(ERROR, "Failed to dup /dev/null for stdin");
       _exit(127);
     }
 
-    if (start_new_process_group) {
+    if (options.new_process_group) {
       // Instead of inheriting the process group ID of the parent, the child
       // starts off a new process group with pgid equal to its process ID.
       if (setpgid(0, 0) < 0) {
         RAW_LOG(ERROR, "setpgid failed");
         _exit(127);
       }
     }
 #if defined(OS_MACOSX)
     RestoreDefaultExceptionHandler();
 #endif
 
     ResetChildSignalHandlersToDefaults();
 
 #if 0
     // When debugging it can be helpful to check that we really aren't making
     // any hidden calls to malloc.
     void *malloc_thunk =
         reinterpret_cast<void*>(reinterpret_cast<intptr_t>(malloc) & ~4095);
     mprotect(malloc_thunk, 4096, PROT_READ | PROT_WRITE | PROT_EXEC);
     memset(reinterpret_cast<void*>(malloc), 0xff, 8);
 #endif
 
     // DANGER: no calls to malloc are allowed from now on:
     // http://crbug.com/36678
 
-    for (file_handle_mapping_vector::const_iterator
-        it = fds_to_remap.begin(); it != fds_to_remap.end(); ++it) {
-      fd_shuffle1.push_back(InjectionArc(it->first, it->second, false));
-      fd_shuffle2.push_back(InjectionArc(it->first, it->second, false));
+    if (options.fds_to_remap) {
+      for (file_handle_mapping_vector::const_iterator
+               it = options.fds_to_remap->begin();
+           it != options.fds_to_remap->end(); ++it) {
+        fd_shuffle1.push_back(InjectionArc(it->first, it->second, false));
+        fd_shuffle2.push_back(InjectionArc(it->first, it->second, false));
+      }
     }
 
-    environ = new_environ.get();
+    if (options.environ)
+      environ = new_environ.get();
 
     // fd_shuffle1 is mutated by this call because it cannot malloc.
     if (!ShuffleFileDescriptors(&fd_shuffle1))
       _exit(127);
 
     CloseSuperfluousFds(fd_shuffle2);
 
     for (size_t i = 0; i < argv.size(); i++)
       argv_cstr[i] = const_cast<char*>(argv[i].c_str());
     argv_cstr[argv.size()] = NULL;
     execvp(argv_cstr[0], argv_cstr.get());
     RAW_LOG(ERROR, "LaunchApp: failed to execvp:");
     RAW_LOG(ERROR, argv_cstr[0]);
     _exit(127);
   } else {
     // Parent process
-    if (wait) {
+    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 (process_handle)
-      *process_handle = pid;
+    if (options.process_handle)
+      *options.process_handle = pid;
   }
 
   return true;
 }
 
-bool LaunchApp(
-    const std::vector<std::string>& argv,
-    const environment_vector& env_changes,
-    const file_handle_mapping_vector& fds_to_remap,
-    bool wait,
-    ProcessHandle* process_handle) {
-  return LaunchAppImpl(argv, env_changes, fds_to_remap,
-                       wait, process_handle, false);
-}
-
-bool LaunchAppInNewProcessGroup(
-    const std::vector<std::string>& argv,
-    const environment_vector& env_changes,
-    const file_handle_mapping_vector& fds_to_remap,
-    bool wait,
-    ProcessHandle* process_handle) {
-  return LaunchAppImpl(argv, env_changes, fds_to_remap, wait,
-                       process_handle, true);
-}
-
-bool LaunchApp(const std::vector<std::string>& argv,
-               const file_handle_mapping_vector& fds_to_remap,
-               bool wait, ProcessHandle* process_handle) {
-  base::environment_vector no_env;
-  return LaunchApp(argv, no_env, fds_to_remap, wait, process_handle);
-}
-
-bool LaunchApp(const CommandLine& cl,
-               bool wait, bool start_hidden,
-               ProcessHandle* process_handle) {
-  file_handle_mapping_vector no_files;
-  return LaunchApp(cl.argv(), no_files, wait, process_handle);
+bool LaunchProcess(const CommandLine& cmdline,
+                   const LaunchOptions& options) {
+  return LaunchProcess(cl.argv(), options);
 }
 
 ProcessMetrics::~ProcessMetrics() { }
 
 void EnableTerminationOnHeapCorruption() {
   // On POSIX, there nothing to do AFAIK.
 }
 
 bool EnableInProcessStackDumping() {
   // When running in an application, our code typically expects SIGPIPE
@@ skipping 350 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