chrome: respect --child-clean-exit.

content/zygote/zygote_linux.cc

 // Copyright (c) 2012 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 "content/zygote/zygote_linux.h"
 
 #include <fcntl.h>
+#include <pthread.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/linux_util.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/global_descriptors.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "base/process_util.h"
 #include "content/common/sandbox_linux.h"
 #include "content/common/set_process_title.h"
 #include "content/common/zygote_commands_linux.h"
 #include "content/public/common/content_descriptors.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandbox_linux.h"
 #include "content/public/common/zygote_fork_delegate_linux.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_switches.h"
 
 // See http://code.google.com/p/chromium/wiki/LinuxZygote
 
 namespace content {
 
@@ skipping 66 matching lines @@
   return sandbox_flags_ & kSandboxLinuxSUID;
 }
 
 bool Zygote::HandleRequestFromBrowser(int fd) {
   std::vector<int> fds;
   char buf[kZygoteMaxMessageLength];
   const ssize_t len = UnixDomainSocket::RecvMsg(fd, buf, sizeof(buf), &fds);
 
   if (len == 0 || (len == -1 && errno == ECONNRESET)) {
     // EOF from the browser. We should die.
-    _exit(0);
+    if (CommandLine::ForCurrentProcess()->
+        HasSwitch(switches::kChildCleanExit))
+      // Zygote children are reaped in a separate detached thread (see the
+      // implementation of EnsureProcessGetsReaped()). If we _exit() or exit()
+      // here, the reaping wait may not have completed. For this reason, we
+      // only terminate this thread (instead of terminating the whole process).
+      // The zygote will then exit only when all children have exited and have
+      // been reaped.
+      pthread_exit(NULL);
+    else
+      _exit(0);
     return false;
   }
 
   if (len == -1) {
     PLOG(ERROR) << "Error reading message from browser";
     return false;
   }
 
   Pickle pickle(buf, len);
   PickleIterator iter(pickle);
@@ skipping 44 matching lines @@
 
   if (UsingSUIDSandbox()) {
     actual_child = real_pids_to_sandbox_pids[child];
     if (!actual_child)
       return;
     real_pids_to_sandbox_pids.erase(child);
   } else {
     actual_child = child;
   }
 
-  base::EnsureProcessTerminated(actual_child);
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kChildCleanExit))
+    base::EnsureProcessGetsReaped(actual_child);
+  else
+    base::EnsureProcessTerminated(actual_child);
 }
 
 void Zygote::HandleGetTerminationStatus(int fd,
                                         const Pickle& pickle,
                                         PickleIterator iter) {
   bool known_dead;
   base::ProcessHandle child;
 
   if (!pickle.ReadBool(&iter, &known_dead) ||
       !pickle.ReadInt(&iter, &child)) {
@@ skipping 286 matching lines @@
                                     PickleIterator iter) {
   if (HANDLE_EINTR(write(fd, &sandbox_flags_, sizeof(sandbox_flags_))) !=
                    sizeof(sandbox_flags_)) {
     PLOG(ERROR) << "write";
   }
 
   return false;
 }
 
 }  // namespace content