Simplify ChildProcessLauncher

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"
 #include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.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/sandboxed_process_launcher_delegate.h"
 
 #if defined(OS_WIN)
 #include "base/files/file_path.h"
 #include "content/common/sandbox_win.h"
 #include "content/public/common/sandbox_init.h"
@@ skipping 12 matching lines @@
 #include "content/common/child_process_sandbox_support_impl_linux.h"
 #endif
 
 #if defined(OS_POSIX)
 #include "base/posix/global_descriptors.h"
 #include "content/browser/file_descriptor_info_impl.h"
 #endif
 
 namespace content {
 
-// Having the functionality of ChildProcessLauncher be in an internal
-// ref counted object allows us to automatically terminate the process when the
-// parent class destructs, while still holding on to state that we need.
-class ChildProcessLauncher::Context
-    : public base::RefCountedThreadSafe<ChildProcessLauncher::Context> {
- public:
-  Context();
+namespace {
 
-  // Posts a task to a dedicated thread to do the actual work.
-  // Must be called on the UI thread.
-  void Launch(SandboxedProcessLauncherDelegate* delegate,
-              base::CommandLine* cmd_line,
-              int child_process_id,
-              Client* client);
+typedef base::Callback<void(bool,
+#if defined(OS_ANDROID)
+                            base::ScopedFD,
+#endif
+                            base::Process)> NotifyCallback;
 
-#if defined(OS_ANDROID)
-  // Called on the UI thread with the operation result. Calls Notify().
-  static void OnChildProcessStarted(
-      // |this_object| is NOT thread safe. Only use it to post a task back.
-      scoped_refptr<Context> this_object,
-      BrowserThread::ID client_thread_id,
-      const base::TimeTicks begin_launch_time,
-      base::ProcessHandle handle);
-#endif
-
-  // Resets the client (the client is going away).
-  void ResetClient();
-
-  bool starting() const { return starting_; }
-
-  const base::Process& process() const { return process_; }
-
-  int exit_code() const { return exit_code_; }
-
-  base::TerminationStatus termination_status() const {
-    return termination_status_;
-  }
-
-  void set_terminate_child_on_shutdown(bool terminate_on_shutdown) {
-    terminate_child_on_shutdown_ = terminate_on_shutdown;
-  }
-
-  void UpdateTerminationStatus(bool known_dead);
-
-  void Close() { process_.Close(); }
-
-  void SetProcessBackgrounded(bool background);
-
-  Client* ReplaceClientForTest(Client* client) {
-    Client* ret = client_;
-    client_ = client;
-    return ret;
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<ChildProcessLauncher::Context>;
-
-  ~Context() {
-    Terminate();
-  }
-
-  static void RecordHistograms(base::TimeTicks begin_launch_time);
-  static void RecordLaunchHistograms(base::TimeDelta launch_time);
-
-  // Performs the actual work of launching the process.
-  // Runs on the PROCESS_LAUNCHER thread.
-  static void LaunchInternal(
-      // |this_object| is NOT thread safe. Only use it to post a task back.
-      scoped_refptr<Context> this_object,
-      BrowserThread::ID client_thread_id,
-      int child_process_id,
-      SandboxedProcessLauncherDelegate* delegate,
-      base::CommandLine* cmd_line);
-
-  // Notifies the client about the result of the operation.
-  // Runs on the UI thread.
-  void Notify(
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-      bool zygote,
-#endif
-      base::Process process);
-
-  void Terminate();
-
-  static void SetProcessBackgroundedInternal(base::Process process,
-                                             bool background);
-
-  static void TerminateInternal(
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-      bool zygote,
-#endif
-      base::Process process);
-
-  Client* client_;
-  BrowserThread::ID client_thread_id_;
-  base::Process process_;
-  base::TerminationStatus termination_status_;
-  int exit_code_;
-#if defined(OS_ANDROID)
-  // The fd to close after creating the process.
-  base::ScopedFD ipcfd_;
-#elif defined(OS_POSIX) && !defined(OS_MACOSX)
-  bool zygote_;
-#endif
-  bool starting_;
-  // Controls whether the child process should be terminated on browser
-  // shutdown. Default behavior is to terminate the child.
-  bool terminate_child_on_shutdown_;
-};
-
-ChildProcessLauncher::Context::Context()
-    : client_(NULL),
-      client_thread_id_(BrowserThread::UI),
-      termination_status_(base::TERMINATION_STATUS_NORMAL_TERMINATION),
-      exit_code_(RESULT_CODE_NORMAL_EXIT),
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-      zygote_(false),
-#endif
-      starting_(true),
-#if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || \
-    defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \
-    defined(UNDEFINED_SANITIZER)
-      terminate_child_on_shutdown_(false) {
-#else
-      terminate_child_on_shutdown_(true) {
-#endif
-}
-
-void ChildProcessLauncher::Context::Launch(
-    SandboxedProcessLauncherDelegate* delegate,
-    base::CommandLine* cmd_line,
-    int child_process_id,
-    Client* client) {
-  CHECK(BrowserThread::GetCurrentThreadIdentifier(&client_thread_id_));
-  client_ = client;
-
-#if defined(OS_ANDROID)
-  // Android only supports renderer, sandboxed utility and gpu.
-  std::string process_type =
-      cmd_line->GetSwitchValueASCII(switches::kProcessType);
-  CHECK(process_type == switches::kGpuProcess ||
-        process_type == switches::kRendererProcess ||
-        process_type == switches::kUtilityProcess)
-      << "Unsupported process type: " << process_type;
-
-  // Non-sandboxed utility or renderer process are currently not supported.
-  DCHECK(process_type == switches::kGpuProcess ||
-         !cmd_line->HasSwitch(switches::kNoSandbox));
-
-  // We need to close the client end of the IPC channel to reliably detect
-  // child termination. We will close this fd after we create the child
-  // process which is asynchronous on Android.
-  ipcfd_.reset(delegate->TakeIpcFd().release());
-#endif
-  BrowserThread::PostTask(
-      BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
-      base::Bind(&Context::LaunchInternal,
-                 make_scoped_refptr(this),
-                 client_thread_id_,
-                 child_process_id,
-                 delegate,
-                 cmd_line));
-}
-
-#if defined(OS_ANDROID)
-// static
-void ChildProcessLauncher::Context::OnChildProcessStarted(
-    // |this_object| is NOT thread safe. Only use it to post a task back.
-    scoped_refptr<Context> this_object,
-    BrowserThread::ID client_thread_id,
-    const base::TimeTicks begin_launch_time,
-    base::ProcessHandle handle) {
-  RecordHistograms(begin_launch_time);
-  if (BrowserThread::CurrentlyOn(client_thread_id)) {
-    // This is always invoked on the UI thread which is commonly the
-    // |client_thread_id| so we can shortcut one PostTask.
-    this_object->Notify(base::Process(handle));
-  } else {
-    BrowserThread::PostTask(
-        client_thread_id, FROM_HERE,
-        base::Bind(&ChildProcessLauncher::Context::Notify,
-                   this_object,
-                   base::Passed(base::Process(handle))));
-  }
-}
-#endif
-
-void ChildProcessLauncher::Context::ResetClient() {
-  // No need for locking as this function gets called on the same thread that
-  // client_ would be used.
-  CHECK(BrowserThread::CurrentlyOn(client_thread_id_));
-  client_ = NULL;
-}
-
-void ChildProcessLauncher::Context::UpdateTerminationStatus(bool known_dead) {
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-  if (zygote_) {
-    termination_status_ = ZygoteHostImpl::GetInstance()->
-        GetTerminationStatus(process_.Handle(), known_dead, &exit_code_);
-  } else if (known_dead) {
-    termination_status_ =
-        base::GetKnownDeadTerminationStatus(process_.Handle(), &exit_code_);
-  } else {
-#elif defined(OS_MACOSX)
-  if (known_dead) {
-    termination_status_ =
-        base::GetKnownDeadTerminationStatus(process_.Handle(), &exit_code_);
-  } else {
-#elif defined(OS_ANDROID)
-  if (IsChildProcessOomProtected(process_.Handle())) {
-    termination_status_ = base::TERMINATION_STATUS_OOM_PROTECTED;
-  } else {
-#else
-  {
-#endif
-    termination_status_ =
-      base::GetTerminationStatus(process_.Handle(), &exit_code_);
-  }
-}
-
-void ChildProcessLauncher::Context::SetProcessBackgrounded(bool background) {
-  base::Process to_pass = process_.Duplicate();
-  BrowserThread::PostTask(
-      BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
-      base::Bind(&Context::SetProcessBackgroundedInternal,
-                 base::Passed(&to_pass), background));
-}
-
-// static
-void ChildProcessLauncher::Context::RecordHistograms(
-    base::TimeTicks begin_launch_time) {
-  base::TimeDelta launch_time = base::TimeTicks::Now() - begin_launch_time;
-  if (BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER)) {
-    RecordLaunchHistograms(launch_time);
-  } else {
-    BrowserThread::PostTask(
-        BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
-        base::Bind(&ChildProcessLauncher::Context::RecordLaunchHistograms,
-                   launch_time));
-  }
-}
-
-// static
-void ChildProcessLauncher::Context::RecordLaunchHistograms(
-    base::TimeDelta launch_time) {
+void RecordHistogramsOnLauncherThread(base::TimeDelta launch_time) {
+  DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
   // Log the launch time, separating out the first one (which will likely be
   // slower due to the rest of the browser initializing at the same time).
   static bool done_first_launch = false;
   if (done_first_launch) {
     UMA_HISTOGRAM_TIMES("MPArch.ChildProcessLaunchSubsequent", launch_time);
   } else {
     UMA_HISTOGRAM_TIMES("MPArch.ChildProcessLaunchFirst", launch_time);
     done_first_launch = true;
   }
 }
 
-// static
-void ChildProcessLauncher::Context::LaunchInternal(
-    // |this_object| is NOT thread safe. Only use it to post a task back.
-    scoped_refptr<Context> this_object,
-    BrowserThread::ID client_thread_id,
-    int child_process_id,
-    SandboxedProcessLauncherDelegate* delegate,
-    base::CommandLine* cmd_line) {
+#if defined(OS_ANDROID)
+// TODO(sievers): Remove this by defining better what happens on what
+// thread in the corresponding Java code.
+void OnChildProcessStartedAndroid(const NotifyCallback& callback,
+                                  BrowserThread::ID client_thread_id,
+                                  const base::TimeTicks begin_launch_time,
+                                  base::ScopedFD ipcfd,
+                                  base::ProcessHandle handle) {
+  // This can be called on the launcher thread or UI thread.
+  base::TimeDelta launch_time = base::TimeTicks::Now() - begin_launch_time;
+  BrowserThread::PostTask(
+      BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
+      base::Bind(&RecordHistogramsOnLauncherThread, launch_time));
+
+  base::Closure callback_on_client_thread(
+      base::Bind(callback, false, base::Passed(&ipcfd),
+                 base::Passed(base::Process(handle))));
+  if (BrowserThread::CurrentlyOn(client_thread_id)) {
+    callback_on_client_thread.Run();
+  } else {
+    BrowserThread::PostTask(
+        client_thread_id, FROM_HERE, callback_on_client_thread);
+ }
+}
+#endif
+
+void LaunchOnLauncherThread(const NotifyCallback& callback,
+                            BrowserThread::ID client_thread_id,
+                            int child_process_id,
+                            SandboxedProcessLauncherDelegate* delegate,
+#if defined(OS_ANDROID)
+                            base::ScopedFD ipcfd,
+#endif
+                            base::CommandLine* cmd_line) {
+  DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
   scoped_ptr<SandboxedProcessLauncherDelegate> delegate_deleter(delegate);
 #if defined(OS_WIN)
+  bool use_zygote = false;
   bool launch_elevated = delegate->ShouldLaunchElevated();
-#elif defined(OS_ANDROID)
-  // Uses |ipcfd_| instead of |ipcfd| on Android.
 #elif defined(OS_MACOSX)
+  bool use_zygote = false;
   base::EnvironmentMap env = delegate->GetEnvironment();
   base::ScopedFD ipcfd = delegate->TakeIpcFd();
-#elif defined(OS_POSIX)
+#elif defined(OS_POSIX) && !defined(OS_ANDROID)
   bool use_zygote = delegate->ShouldUseZygote();
   base::EnvironmentMap env = delegate->GetEnvironment();
   base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #endif
   scoped_ptr<base::CommandLine> cmd_line_deleter(cmd_line);
   base::TimeTicks begin_launch_time = base::TimeTicks::Now();
 
   base::Process process;
 #if defined(OS_WIN)
   if (launch_elevated) {
     base::LaunchOptions options;
     options.start_hidden = true;
     process = base::LaunchElevatedProcess(*cmd_line, options);
   } else {
     process = StartSandboxedProcess(delegate, cmd_line);
   }
 #elif defined(OS_POSIX)
   std::string process_type =
       cmd_line->GetSwitchValueASCII(switches::kProcessType);
   scoped_ptr<FileDescriptorInfo> files_to_register(
       FileDescriptorInfoImpl::Create());
 
 #if defined(OS_ANDROID)
-  files_to_register->Share(kPrimaryIPCChannel, this_object->ipcfd_.get());
+  files_to_register->Share(kPrimaryIPCChannel, ipcfd.get());
 #else
   files_to_register->Transfer(kPrimaryIPCChannel, ipcfd.Pass());
 #endif
 #endif
 
 #if defined(OS_ANDROID)
   // Android WebView runs in single process, ensure that we never get here
   // when running in single process mode.
   CHECK(!cmd_line->HasSwitch(switches::kSingleProcess));
 
   GetContentClient()->browser()->GetAdditionalMappedFilesForChildProcess(
       *cmd_line, child_process_id, files_to_register.get());
 
   StartChildProcess(
-      cmd_line->argv(),
-      child_process_id,
-      files_to_register.Pass(),
-      base::Bind(&ChildProcessLauncher::Context::OnChildProcessStarted,
-                 this_object,
-                 client_thread_id,
-                 begin_launch_time));
+      cmd_line->argv(), child_process_id, files_to_register.Pass(),
+      base::Bind(&OnChildProcessStartedAndroid, callback, client_thread_id,
+                 begin_launch_time, base::Passed(&ipcfd)));
 
 #elif defined(OS_POSIX)
   // We need to close the client end of the IPC channel to reliably detect
   // child termination.
 
 #if !defined(OS_MACOSX)
   GetContentClient()->browser()->GetAdditionalMappedFilesForChildProcess(
       *cmd_line, child_process_id, files_to_register.get());
   if (use_zygote) {
     base::ProcessHandle handle = ZygoteHostImpl::GetInstance()->ForkRequest(
@@ skipping 59 matching lines @@
     if (process.IsValid())
       broker->AddPlaceholderForPid(process.Pid(), child_process_id);
 
     // After updating the broker, release the lock and let the child's
     // messasge be processed on the broker's thread.
     broker->GetLock().Release();
 #endif  // defined(OS_MACOSX)
   }
 #endif  // else defined(OS_POSIX)
 #if !defined(OS_ANDROID)
-  if (process.IsValid())
-    RecordHistograms(begin_launch_time);
-  BrowserThread::PostTask(
-      client_thread_id, FROM_HERE,
-      base::Bind(&Context::Notify,
-                 this_object.get(),
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
-                 use_zygote,
-#endif
-                 base::Passed(&process)));
+  if (process.IsValid()) {
+    RecordHistogramsOnLauncherThread(base::TimeTicks::Now() -
+                                     begin_launch_time);
+  }
+  BrowserThread::PostTask(client_thread_id, FROM_HERE,
+                          base::Bind(callback,
+                                     use_zygote,
+                                     base::Passed(&process)));
 #endif  // !defined(OS_ANDROID)
 }
 
-void ChildProcessLauncher::Context::Notify(
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-    bool zygote,
-#endif
-    base::Process process) {
-  // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
-  // is fixed.
-  tracked_objects::ScopedTracker tracking_profile1(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "465841 ChildProcessLauncher::Context::Notify::Start"));
-
-#if defined(OS_ANDROID)
-  // Finally close the ipcfd
-  base::ScopedFD ipcfd_closer = ipcfd_.Pass();
-#endif
-  starting_ = false;
-  process_ = process.Pass();
-  if (!process_.IsValid())
-    LOG(ERROR) << "Failed to launch child process";
-
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-  zygote_ = zygote;
-#endif
-  if (client_) {
-    if (process_.IsValid()) {
-      // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
-      // is fixed.
-      tracked_objects::ScopedTracker tracking_profile2(
-          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-              "465841 ChildProcessLauncher::Context::Notify::ProcessLaunched"));
-      client_->OnProcessLaunched();
-    } else {
-      // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
-      // is fixed.
-      tracked_objects::ScopedTracker tracking_profile3(
-          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-              "465841 ChildProcessLauncher::Context::Notify::ProcessFailed"));
-      client_->OnProcessLaunchFailed();
-    }
-  } else {
-    // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
-    // is fixed.
-    tracked_objects::ScopedTracker tracking_profile4(
-        FROM_HERE_WITH_EXPLICIT_FUNCTION(
-            "465841 ChildProcessLauncher::Context::Notify::ProcessTerminate"));
-    Terminate();
-  }
-}
-
-void ChildProcessLauncher::Context::Terminate() {
-  if (!process_.IsValid())
-    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
-                base::Passed(&process_)));
-}
-
-// static
-void ChildProcessLauncher::Context::SetProcessBackgroundedInternal(
-    base::Process process,
-    bool background) {
-  process.SetProcessBackgrounded(background);
-#if defined(OS_ANDROID)
-  SetChildProcessInForeground(process.Handle(), !background);
-#endif
-}
-
-// static
-void ChildProcessLauncher::Context::TerminateInternal(
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-    bool zygote,
-#endif
-    base::Process process) {
+void TerminateOnLauncherThread(bool zygote, base::Process process) {
+  DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
 #if defined(OS_ANDROID)
   VLOG(1) << "ChromeProcess: Stopping process with handle "
           << process.Handle();
   StopChildProcess(process.Handle());
 #else
   // 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, false);
   // 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(process.Handle());
   } else
 #endif  // !OS_MACOSX
   base::EnsureProcessTerminated(process.Pass());
 #endif  // OS_POSIX
 #endif  // defined(OS_ANDROID)
 }
 
-// -----------------------------------------------------------------------------
+void SetProcessBackgroundedOnLauncherThread(base::Process process,
+                                            bool background) {
+  DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
+  process.SetProcessBackgrounded(background);
+#if defined(OS_ANDROID)
+  SetChildProcessInForeground(process.Handle(), !background);
+#endif
+}
+
+}  // anonymous namespace
 
 ChildProcessLauncher::ChildProcessLauncher(
     SandboxedProcessLauncherDelegate* delegate,
     base::CommandLine* cmd_line,
     int child_process_id,
-    Client* client) {
-  context_ = new Context();
-  context_->Launch(
-      delegate,
-      cmd_line,
-      child_process_id,
-      client);
+    Client* client,
+    bool terminate_on_shutdown)
+    : client_(client),
+      termination_status_(base::TERMINATION_STATUS_NORMAL_TERMINATION),
+      exit_code_(RESULT_CODE_NORMAL_EXIT),
+      zygote_(false),
+      starting_(true),
+#if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) ||  \
+    defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \
+    defined(UNDEFINED_SANITIZER)
+      terminate_child_on_shutdown_(false),
+#else
+      terminate_child_on_shutdown_(terminate_on_shutdown),
+#endif
+      weak_factory_(this) {
+  DCHECK(CalledOnValidThread());
+  CHECK(BrowserThread::GetCurrentThreadIdentifier(&client_thread_id_));
+  Launch(delegate, cmd_line, child_process_id);
 }
 
 ChildProcessLauncher::~ChildProcessLauncher() {
-  context_->ResetClient();
+  DCHECK(CalledOnValidThread());
+  if (process_.IsValid() && terminate_child_on_shutdown_) {
+    // 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(&TerminateOnLauncherThread, zygote_,
+                                       base::Passed(&process_)));
+  }
+}
+
+void ChildProcessLauncher::Launch(
+    SandboxedProcessLauncherDelegate* delegate,
+    base::CommandLine* cmd_line,
+    int child_process_id) {
+  DCHECK(CalledOnValidThread());
+
+#if defined(OS_ANDROID)
+  // Android only supports renderer, sandboxed utility and gpu.
+  std::string process_type =
+      cmd_line->GetSwitchValueASCII(switches::kProcessType);
+  CHECK(process_type == switches::kGpuProcess ||
+        process_type == switches::kRendererProcess ||
+        process_type == switches::kUtilityProcess)
+      << "Unsupported process type: " << process_type;
+
+  // Non-sandboxed utility or renderer process are currently not supported.
+  DCHECK(process_type == switches::kGpuProcess ||
+         !cmd_line->HasSwitch(switches::kNoSandbox));
+
+  // We need to close the client end of the IPC channel to reliably detect
+  // child termination. We will close this fd after we create the child
+  // process which is asynchronous on Android.
+  base::ScopedFD ipcfd(delegate->TakeIpcFd().release());
+#endif
+  NotifyCallback reply_callback(base::Bind(&ChildProcessLauncher::DidLaunch,
+                                           weak_factory_.GetWeakPtr(),
+                                           terminate_child_on_shutdown_));
+  BrowserThread::PostTask(
+      BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
+      base::Bind(&LaunchOnLauncherThread, reply_callback, client_thread_id_,
+                 child_process_id, delegate,
+#if defined(OS_ANDROID)
+                 base::Passed(&ipcfd),
+#endif
+                 cmd_line));
+}
+
+void ChildProcessLauncher::UpdateTerminationStatus(bool known_dead) {
+  DCHECK(CalledOnValidThread());
+#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
+  if (zygote_) {
+    termination_status_ = ZygoteHostImpl::GetInstance()->
+        GetTerminationStatus(process_.Handle(), known_dead, &exit_code_);
+  } else if (known_dead) {
+    termination_status_ =
+        base::GetKnownDeadTerminationStatus(process_.Handle(), &exit_code_);
+  } else {
+#elif defined(OS_MACOSX)
+  if (known_dead) {
+    termination_status_ =
+        base::GetKnownDeadTerminationStatus(process_.Handle(), &exit_code_);
+  } else {
+#elif defined(OS_ANDROID)
+  if (IsChildProcessOomProtected(process_.Handle())) {
+    termination_status_ = base::TERMINATION_STATUS_OOM_PROTECTED;
+  } else {
+#else
+  {
+#endif
+    termination_status_ =
+      base::GetTerminationStatus(process_.Handle(), &exit_code_);
+  }
+}
+
+void ChildProcessLauncher::SetProcessBackgrounded(bool background) {
+  DCHECK(CalledOnValidThread());
+  base::Process to_pass = process_.Duplicate();
+  BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
+                          base::Bind(&SetProcessBackgroundedOnLauncherThread,
+                                     base::Passed(&to_pass), background));
+}
+
+void ChildProcessLauncher::DidLaunch(
+    base::WeakPtr<ChildProcessLauncher> instance,
+    bool terminate_on_shutdown,
+    bool zygote,
+#if defined(OS_ANDROID)
+    base::ScopedFD ipcfd,
+#endif
+    base::Process process) {
+  if (!process.IsValid())
+    LOG(ERROR) << "Failed to launch child process";
+
+  // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
+  // is fixed.
+  tracked_objects::ScopedTracker tracking_profile1(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "465841 ChildProcessLauncher::Context::Notify::Start"));
+
+  if (instance.get()) {
+    instance->Notify(zygote,
+#if defined(OS_ANDROID)
+                     ipcfd.Pass(),
+#endif
+                     process.Pass());
+  } else {
+    // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
+    // is fixed.
+    tracked_objects::ScopedTracker tracking_profile4(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "465841 ChildProcessLauncher::Context::Notify::ProcessTerminate"));
+    if (process.IsValid() && terminate_on_shutdown) {
+      // 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(&TerminateOnLauncherThread, zygote,
+                                         base::Passed(&process)));
+    }
+  }
+}
+
+void ChildProcessLauncher::Notify(
+    bool zygote,
+#if defined(OS_ANDROID)
+    base::ScopedFD ipcfd,
+#endif
+    base::Process process) {
+  DCHECK(CalledOnValidThread());
+  starting_ = false;
+  process_ = process.Pass();
+
+#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
+  zygote_ = zygote;
+#endif
+  if (process_.IsValid()) {
+    // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
+    // is fixed.
+    tracked_objects::ScopedTracker tracking_profile2(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "465841 ChildProcessLauncher::Context::Notify::ProcessLaunched"));
+    client_->OnProcessLaunched();
+  } else {
+    // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
+    // is fixed.
+    tracked_objects::ScopedTracker tracking_profile3(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "465841 ChildProcessLauncher::Context::Notify::ProcessFailed"));
+    client_->OnProcessLaunchFailed();
+  }
 }
 
 bool ChildProcessLauncher::IsStarting() {
-  return context_->starting();
+  // TODO(crbug.com/469248): This fails in some tests.
+  // DCHECK(CalledOnValidThread());
+  return starting_;
 }
 
 const base::Process& ChildProcessLauncher::GetProcess() const {
-  DCHECK(!context_->starting());
-  return context_->process();
+  // TODO(crbug.com/469248): This fails in some tests.
+  // DCHECK(CalledOnValidThread());
+  return process_;
 }
 
 base::TerminationStatus ChildProcessLauncher::GetChildTerminationStatus(
     bool known_dead,
     int* exit_code) {
-  if (!context_->process().IsValid()) {
+  DCHECK(CalledOnValidThread());
+  if (!process_.IsValid()) {
     // Process is already gone, so return the cached termination status.
     if (exit_code)
-      *exit_code = context_->exit_code();
-    return context_->termination_status();
-  }
-
-  context_->UpdateTerminationStatus(known_dead);
+      *exit_code = exit_code_;
+    return termination_status_;
+  }
+
+  UpdateTerminationStatus(known_dead);
   if (exit_code)
-    *exit_code = context_->exit_code();
+    *exit_code = exit_code_;
 
   // POSIX: If the process crashed, then the kernel closed the socket
   // for it and so the child has already died by the time we get
   // here. Since GetTerminationStatus called waitpid with WNOHANG,
   // it'll reap the process.  However, if GetTerminationStatus didn't
   // reap the child (because it was still running), we'll need to
   // Terminate via ProcessWatcher. So we can't close the handle here.
-  if (context_->termination_status() != base::TERMINATION_STATUS_STILL_RUNNING)
-    context_->Close();
+  if (termination_status_ != base::TERMINATION_STATUS_STILL_RUNNING)
+    process_.Close();
 
-  return context_->termination_status();
-}
-
-void ChildProcessLauncher::SetProcessBackgrounded(bool background) {
-  context_->SetProcessBackgrounded(background);
-}
-
-void ChildProcessLauncher::SetTerminateChildOnShutdown(
-    bool terminate_on_shutdown) {
-  if (context_.get())
-    context_->set_terminate_child_on_shutdown(terminate_on_shutdown);
+  return termination_status_;
 }
 
 ChildProcessLauncher::Client* ChildProcessLauncher::ReplaceClientForTest(
     Client* client) {
-  return context_->ReplaceClientForTest(client);
+  Client* ret = client_;
+  client_ = client;
+  return ret;
 }
 
 }  // namespace content