Unifying ChildProcessLauncher across platforms.

content/browser/child_process_launcher_helper.cc

+// Copyright 2017 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_helper.h"
+
+#include "base/metrics/histogram_macros.h"
+#include "content/browser/child_process_launcher.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/common/sandboxed_process_launcher_delegate.h"
+#include "mojo/edk/embedder/platform_channel_pair.h"
+
+namespace content {
+namespace internal {
+
+namespace {
+
+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;
+  }
+}
+
+}  // namespace
+
+ChildProcessLauncherHelper::Process::Process(Process&& other)
+  : process(std::move(other.process))
+#if defined(OS_LINUX)
+   , zygote(other.zygote)
+#endif
+{
+}
+
+ChildProcessLauncherHelper::Process&
+ChildProcessLauncherHelper::Process::Process::operator=(
+    ChildProcessLauncherHelper::Process&& other) {
+  DCHECK_NE(this, &other);
+  process = std::move(other.process);
+#if defined(OS_LINUX)
+  zygote = other.zygote;
+#endif
+  return *this;
+}
+
+ChildProcessLauncherHelper::ChildProcessLauncherHelper(
+    int child_process_id,
+    BrowserThread::ID client_thread_id,
+    std::unique_ptr<base::CommandLine> command_line,
+    std::unique_ptr<SandboxedProcessLauncherDelegate> delegate,
+    const base::WeakPtr<ChildProcessLauncher>& child_process_launcher,
+    bool terminate_on_shutdown)
+    : child_process_id_(child_process_id),
+      client_thread_id_(client_thread_id),
+      command_line_(std::move(command_line)),
+      delegate_(std::move(delegate)),
+      child_process_launcher_(child_process_launcher),
+      terminate_on_shutdown_(terminate_on_shutdown) {
+}
+
+ChildProcessLauncherHelper::~ChildProcessLauncherHelper() {
+}
+
+void ChildProcessLauncherHelper::StartLaunchOnClientThread() {
+  DCHECK_CURRENTLY_ON(client_thread_id_);
+
+  BeforeLaunchOnClientThread();
+
+  mojo_server_handle_ = PrepareMojoPipeHandlesOnClientThread();
+  if (!mojo_server_handle_.is_valid()) {
+    mojo::edk::PlatformChannelPair channel_pair;
+    mojo_server_handle_ = channel_pair.PassServerHandle();
+    mojo_client_handle_ = channel_pair.PassClientHandle();
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
+      base::Bind(&ChildProcessLauncherHelper::LaunchOnLauncherThread, this));
+}
+
+void ChildProcessLauncherHelper::LaunchOnLauncherThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
+
+  begin_launch_time_ = base::TimeTicks::Now();
+
+  std::unique_ptr<FileMappedForLaunch> files_to_register = GetFilesToMap();
+
+  bool is_synchronous_launch = true;
+  int launch_result = LAUNCH_RESULT_FAILURE;
+  base::LaunchOptions options;
+  BeforeLaunchOnLauncherThread(*files_to_register, &options);
+
+  Process process = LaunchProcessOnLauncherThread(options,
+                                                  std::move(files_to_register),
+                                                  &is_synchronous_launch,
+                                                  &launch_result);
+
+  AfterLaunchOnLauncherThread(process, options);
+
+  if (is_synchronous_launch) {
+    PostLaunchOnLauncherThread(std::move(process), launch_result, false);
+  }
+}
+
+void ChildProcessLauncherHelper::PostLaunchOnLauncherThread(
+    ChildProcessLauncherHelper::Process process,
+    int launch_result,
+    bool post_launch_on_client_thread_called) {
+  // Release the client handle now that the process has been started (the pipe
+  // may not signal when the process dies otherwise and we would not detect the
+  // child process died).
+  mojo_client_handle_.reset();
+
+  if (process.process.IsValid()) {
+    RecordHistogramsOnLauncherThread(
+        base::TimeTicks::Now() - begin_launch_time_);
+  }
+
+  if (!post_launch_on_client_thread_called) {
+    BrowserThread::PostTask(
+        client_thread_id_, FROM_HERE,
+        base::Bind(&ChildProcessLauncherHelper::PostLaunchOnClientThread,
+            this, base::Passed(&process), launch_result));
+  }
+}
+
+void ChildProcessLauncherHelper::PostLaunchOnClientThread(
+    ChildProcessLauncherHelper::Process process,
+    int error_code) {
+  if (child_process_launcher_) {
+    child_process_launcher_->Notify(
+        std::move(process), std::move(mojo_server_handle_), error_code);
+  } else if (process.process.IsValid() && terminate_on_shutdown_) {
+    // Client is gone, terminate the process.
+    ForceNormalProcessTerminationAsync(std::move(process));
+  }
+}
+
+std::string ChildProcessLauncherHelper::GetProcessType() {
+  return command_line()->GetSwitchValueASCII(switches::kProcessType);
+}
+
+// static
+void ChildProcessLauncherHelper::ForceNormalProcessTerminationAsync(
+    ChildProcessLauncherHelper::Process process) {
+  if (BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER)) {
+    ForceNormalProcessTerminationSync(std::move(process));
+    return;
+  }
+  // On Posix, EnsureProcessTerminated can lead to 2 seconds of sleep!
+  // So don't do this on the UI/IO threads.
+  BrowserThread::PostTask(
+      BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
+      base::Bind(&ChildProcessLauncherHelper::ForceNormalProcessTerminationSync,
+                 base::Passed(&process)));
+}
+
+}  // namespace internal
+}  // namespace content