Cleanup orphaned testserver processes on posix.

base/process_util_posix.cc

 // Copyright (c) 2010 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 177 matching lines @@
     if (!exited)
       result = kill(process_id, SIGKILL) == 0;
   }
 
   if (!result)
     DPLOG(ERROR) << "Unable to terminate process " << process_id;
 
   return result;
 }
 
+bool KillProcessGroup(ProcessHandle process_group_id) {
+  bool result = kill(-1 * process_group_id, SIGKILL) == 0;
+  if (!result)
+    PLOG(ERROR) << "Unable to terminate process group " << process_group_id;
+  return result;
+}
+
 // A class to handle auto-closing of DIR*'s.
 class ScopedDIRClose {
  public:
   inline void operator()(DIR* x) const {
     if (x) {
       closedir(x);
     }
   }
 };
 typedef scoped_ptr_malloc<DIR, ScopedDIRClose> ScopedDIR;
@@ skipping 205 matching lines @@
       *scratch++ = '=';
       memcpy(scratch, j->second.c_str(), j->second.size() + 1);
       scratch += j->second.size() + 1;
      }
   }
 
   ret[k] = NULL;
   return ret;
 }
 
-bool LaunchApp(
+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) {
+    ProcessHandle* process_handle,
+    bool start_new_process_group) {
   pid_t pid;
   InjectiveMultimap fd_shuffle1, fd_shuffle2;
   fd_shuffle1.reserve(fds_to_remap.size());
   fd_shuffle2.reserve(fds_to_remap.size());
   scoped_array<char*> argv_cstr(new char*[argv.size() + 1]);
   scoped_array<char*> new_environ(AlterEnvironment(env_changes, environ));
 
   pid = fork();
   if (pid < 0)
     return false;
 
   if (pid == 0) {
     // Child process
+
+    if (start_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)
+        return false;
+    }
 #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 =
@@ skipping 39 matching lines @@
       DPCHECK(ret > 0);
     }
 
     if (process_handle)
       *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) {
@@ skipping 298 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