Avoid a thread hop when initializing IPC to new processes

content/browser/child_process_launcher_helper_android.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 <memory>
 
 #include "base/i18n/icu_util.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 
 namespace content {
 namespace internal {
 
 namespace {
 
 // Callback invoked from Java once the process has been started.
 void ChildProcessStartedCallback(
     ChildProcessLauncherHelper* helper,
     base::ProcessHandle handle,
-    int launch_result) {
+    int launch_result,
+    std::unique_ptr<mojo::edk::PendingProcessConnection> pending_connection,
+    mojo::edk::ScopedPlatformHandle server_handle) {
   // TODO(jcivelli): Remove this by defining better what happens on what thread
   // in the corresponding Java code.
   ChildProcessLauncherHelper::Process process;
   process.process = base::Process(handle);
   if (BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER)) {
     helper->PostLaunchOnLauncherThread(
         std::move(process),
         launch_result,
         false);  // post_launch_on_client_thread_called
     return;
   }
 
   bool on_client_thread = BrowserThread::CurrentlyOn(
       static_cast<BrowserThread::ID>(helper->client_thread_id()));
   BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
       base::Bind(&ChildProcessLauncherHelper::PostLaunchOnLauncherThread,
                  helper,
                  base::Passed(std::move(process)),
                  launch_result,
                  on_client_thread));
   if (on_client_thread) {
     ChildProcessLauncherHelper::Process process;
     process.process = base::Process(handle);
-    helper->PostLaunchOnClientThread(std::move(process), launch_result);
+    helper->PostLaunchOnClientThread(std::move(process), launch_result,
+                                     std::move(pending_connection),
+                                     std::move(server_handle));
   }
 }
 
 }  // namespace
 
 void ChildProcessLauncherHelper::BeforeLaunchOnClientThread() {
   // Android only supports renderer, sandboxed utility and gpu.
   std::string process_type =
       command_line()->GetSwitchValueASCII(switches::kProcessType);
   CHECK(process_type == switches::kGpuProcess ||
@@ skipping 57 matching lines @@
 void ChildProcessLauncherHelper::BeforeLaunchOnLauncherThread(
     const FileDescriptorInfo& files_to_register,
     base::LaunchOptions* options) {
 }
 
 ChildProcessLauncherHelper::Process
 ChildProcessLauncherHelper::LaunchProcessOnLauncherThread(
     const base::LaunchOptions& options,
     std::unique_ptr<FileDescriptorInfo> files_to_register,
     bool* is_synchronous_launch,
-    int* launch_result) {
+    int* launch_result,
+    std::unique_ptr<mojo::edk::PendingProcessConnection>* pending_connection,
+    mojo::edk::ScopedPlatformHandle* server_handle) {
   *is_synchronous_launch = false;
 
-  StartChildProcess(command_line()->argv(),
-                    child_process_id(),
+  StartChildProcess(command_line()->argv(), child_process_id(),
                     files_to_register.get(),
-                    base::Bind(&ChildProcessStartedCallback,
-                               RetainedRef(this)));
+                    base::Bind(&ChildProcessStartedCallback, RetainedRef(this),
+                               base::Passed(pending_connection),
+                               base::Passed(server_handle)));
 
   return Process();
 }
 
 void ChildProcessLauncherHelper::AfterLaunchOnLauncherThread(
     const ChildProcessLauncherHelper::Process& process,
     const base::LaunchOptions& options) {
 }
 
 // static
@@ skipping 23 matching lines @@
 }
 
 // static
 void ChildProcessLauncherHelper::SetProcessBackgroundedOnLauncherThread(
       base::Process process, bool background) {
   SetChildProcessInForeground(process.Handle(), !background);
 }
 
 }  // namespace internal
 }  // namespace content