Avoid a thread hop when initializing IPC to new processes

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"
@@ skipping 36 matching lines @@
   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,
+    std::unique_ptr<mojo::edk::PendingProcessConnection> pending_connection,
+    const mojo::edk::ProcessErrorCallback& process_error_callback,
     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)),
+      pending_connection_(std::move(pending_connection)),
+      process_error_callback_(process_error_callback),
       child_process_launcher_(child_process_launcher),
-      terminate_on_shutdown_(terminate_on_shutdown) {
-}
+      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::ScopedPlatformHandle server_handle =
+      PrepareMojoPipeHandlesOnClientThread();
+  if (!server_handle.is_valid()) {
     mojo::edk::PlatformChannelPair channel_pair;
-    mojo_server_handle_ = channel_pair.PassServerHandle();
+    server_handle = channel_pair.PassServerHandle();
     mojo_client_handle_ = channel_pair.PassClientHandle();
   }
 
   BrowserThread::PostTask(
       BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
-      base::Bind(&ChildProcessLauncherHelper::LaunchOnLauncherThread, this));
+      base::Bind(&ChildProcessLauncherHelper::LaunchOnLauncherThread, this,
+                 base::Passed(&pending_connection_),
+                 base::Passed(&server_handle)));
 }
 
-void ChildProcessLauncherHelper::LaunchOnLauncherThread() {
+void ChildProcessLauncherHelper::LaunchOnLauncherThread(
+    std::unique_ptr<mojo::edk::PendingProcessConnection> pending_connection,
+    mojo::edk::ScopedPlatformHandle server_handle) {
   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);
+  Process process = LaunchProcessOnLauncherThread(
+      options, std::move(files_to_register), &is_synchronous_launch,
+      &launch_result, &pending_connection, &server_handle);
 
   AfterLaunchOnLauncherThread(process, options);
 
   if (is_synchronous_launch) {
-    PostLaunchOnLauncherThread(std::move(process), launch_result, false);
+    // If launch was synchronous, the helper must not have taken ownership of
+    // |pending_connection| or |server_handle|.
+    DCHECK(pending_connection);
+    DCHECK(server_handle.is_valid());
+    PostLaunchOnLauncherThread(std::move(process), launch_result, false,
+                               std::move(pending_connection),
+                               std::move(server_handle));
   }
 }
 
 void ChildProcessLauncherHelper::PostLaunchOnLauncherThread(
     ChildProcessLauncherHelper::Process process,
     int launch_result,
-    bool post_launch_on_client_thread_called) {
+    bool post_launch_on_client_thread_called,
+    std::unique_ptr<mojo::edk::PendingProcessConnection> pending_connection,
+    mojo::edk::ScopedPlatformHandle server_handle) {
   // 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_);
+
+    DCHECK(pending_connection);
+    DCHECK(server_handle.is_valid());
+    pending_connection->Connect(process.process.Handle(),
+                                std::move(server_handle),
+                                process_error_callback_);
   }
 
   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);
+    child_process_launcher_->Notify(std::move(process), 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