chrome: respect --child-clean-exit.

content/browser/child_process_launcher.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/browser/child_process_launcher.h"
 
 #include <utility>  // For std::pair.
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 321 matching lines @@
       client_->OnProcessLaunched();
     } else {
       Terminate();
     }
   }
 
   void Terminate() {
     if (!process_.handle())
       return;
 
-    if (!terminate_child_on_shutdown_)
-      return;
-
     // On Posix, EnsureProcessTerminated can lead to 2 seconds of sleep!  So
     // don't this on the UI/IO threads.
     BrowserThread::PostTask(
         BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
         base::Bind(
             &Context::TerminateInternal,
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
             zygote_,
 #endif
-            process_.handle()));
+            process_.handle(),
+            !terminate_child_on_shutdown_));
     process_.set_handle(base::kNullProcessHandle);
   }
 
   static void SetProcessBackgrounded(base::ProcessHandle handle,
                                      bool background) {
     base::Process process(handle);
     process.SetProcessBackgrounded(background);
   }
 
   static void TerminateInternal(
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
       bool zygote,
 #endif
-      base::ProcessHandle handle) {
+      base::ProcessHandle handle,
+      bool wait_for_child_to_exit_cleanly) {
 #if defined(OS_ANDROID)
     LOG(INFO) << "ChromeProcess: Stopping process with handle " << handle;
     StopChildProcess(handle);
 #else
     base::Process process(handle);
      // Client has gone away, so just kill the process.  Using exit code 0
     // means that UMA won't treat this as a crash.
-    process.Terminate(RESULT_CODE_NORMAL_EXIT);
+    if (!wait_for_child_to_exit_cleanly)
+      process.Terminate(RESULT_CODE_NORMAL_EXIT);
+
     // On POSIX, we must additionally reap the child.
 #if defined(OS_POSIX)
 #if !defined(OS_MACOSX)
     if (zygote) {
       // If the renderer was created via a zygote, we have to proxy the reaping
       // through the zygote process.
       ZygoteHostImpl::GetInstance()->EnsureProcessTerminated(handle);
     } else
 #endif  // !OS_MACOSX
     {
-      base::EnsureProcessTerminated(handle);
+      if (wait_for_child_to_exit_cleanly)
+        base::EnsureProcessGetsReaped(handle);
+      else
+        base::EnsureProcessTerminated(handle);
     }
 #endif  // OS_POSIX
     process.Close();
 #endif  // defined(OS_ANDROID)
   }
 
   Client* client_;
   BrowserThread::ID client_thread_id_;
   base::Process process_;
   base::TerminationStatus termination_status_;
@@ skipping 95 matching lines @@
           GetHandle(), background));
 }
 
 void ChildProcessLauncher::SetTerminateChildOnShutdown(
   bool terminate_on_shutdown) {
   if (context_.get())
     context_->set_terminate_child_on_shutdown(terminate_on_shutdown);
 }
 
 }  // namespace content