Avoid a thread hop when initializing IPC to new processes

content/browser/child_process_launcher_helper.h

 // 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.
 
 #ifndef CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_HELPER_H_
 #define CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_HELPER_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/process/kill.h"
 #include "base/process/process.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/result_codes.h"
 #include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/pending_process_connection.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 
 #if defined(OS_WIN)
 #include "sandbox/win/src/sandbox_types.h"
 #else
 #include "content/public/browser/file_descriptor_info.h"
 #endif
 
 #if defined(OS_LINUX)
 #include "content/public/common/zygote_handle.h"
@@ skipping 38 matching lines @@
 #if defined(OS_LINUX)
     ZygoteHandle zygote = nullptr;
 #endif
   };
 
   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);
 
   // The methods below are defined in the order they are called.
 
   // Starts the flow of launching the process.
   void StartLaunchOnClientThread();
 
   // Platform specific.
   void BeforeLaunchOnClientThread();
 
   // Called in to give implementors a chance at creating a server pipe.
   // Platform specific.
   mojo::edk::ScopedPlatformHandle PrepareMojoPipeHandlesOnClientThread();
 
   // Returns the list of files that should be mapped in the child process.
   // Platform specific.
   std::unique_ptr<FileMappedForLaunch> GetFilesToMap();
 
   // Platform specific.
   void BeforeLaunchOnLauncherThread(
       const FileMappedForLaunch& files_to_register,
       base::LaunchOptions* options);
 
   // Does the actual starting of the process.
   // |is_synchronous_launch| is set to false if the starting of the process is
   // asynchonous (this is the case on Android), in which case the returned
   // Process is not valid (and PostLaunchOnLauncherThread() will provide the
-  // process once it is available).
+  // process once it is available). Iff |is_synchronous_launch| is set to false,
+  // the implementation must also take ownership of |*pending_connection| and
+  // |*server_handle| to eventually pass them on to
+  // PostLaunchOnLauncherThread().
   // Platform specific.
   ChildProcessLauncherHelper::Process LaunchProcessOnLauncherThread(
       const base::LaunchOptions& options,
       std::unique_ptr<FileMappedForLaunch> 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);
 
   // Called right after the process has been launched, whether it was created
   // yet or not.
   // Platform specific.
   void AfterLaunchOnLauncherThread(
       const ChildProcessLauncherHelper::Process& process,
       const base::LaunchOptions& options);
 
   // Called once the process has been created, successfully or not.
   // If |post_launch_on_client_thread_called| is false,
   // this calls PostLaunchOnClientThread on the client thread.
-  void PostLaunchOnLauncherThread(ChildProcessLauncherHelper::Process process,
-                                  int launch_result,
-                                  bool post_launch_on_client_thread_called);
+  void PostLaunchOnLauncherThread(
+      ChildProcessLauncherHelper::Process process,
+      int launch_result,
+      bool post_launch_on_client_thread_called,
+      std::unique_ptr<mojo::edk::PendingProcessConnection> pending_connection,
+      mojo::edk::ScopedPlatformHandle server_handle);
 
   // Note that this could be called before PostLaunchOnLauncherThread() is
   // called.
   void PostLaunchOnClientThread(ChildProcessLauncherHelper::Process process,
                                 int error_code);
 
   int client_thread_id() const { return client_thread_id_; }
 
   // Returns the termination status and sets |exit_code| if non null.
   // See ChildProcessLauncher::GetChildTerminationStatus for more info.
@@ skipping 18 matching lines @@
       ChildProcessLauncherHelper::Process process);
 
   static void SetProcessBackgroundedOnLauncherThread(
       base::Process process, bool background);
 
  private:
   friend class base::RefCountedThreadSafe<ChildProcessLauncherHelper>;
 
   ~ChildProcessLauncherHelper();
 
-  void LaunchOnLauncherThread();
+  void LaunchOnLauncherThread(
+      std::unique_ptr<mojo::edk::PendingProcessConnection> pending_connection,
+      mojo::edk::ScopedPlatformHandle server_handle);
 
   const mojo::edk::PlatformHandle& mojo_client_handle() const {
     return mojo_client_handle_.get();
   }
   base::CommandLine* command_line() { return command_line_.get(); }
   int child_process_id() const { return child_process_id_; }
 
   std::string GetProcessType();
 
   static void ForceNormalProcessTerminationSync(
       ChildProcessLauncherHelper::Process process);
 
   const int child_process_id_;
   const BrowserThread::ID client_thread_id_;
   base::TimeTicks begin_launch_time_;
   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_;
   base::WeakPtr<ChildProcessLauncher> child_process_launcher_;
   mojo::edk::ScopedPlatformHandle mojo_client_handle_;
-  mojo::edk::ScopedPlatformHandle mojo_server_handle_;
   bool terminate_on_shutdown_;
 };
 
 }  // namespace internal
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_HELPER_H_