Eliminate the ChannelMojo channel for renderers

content/child/child_thread_impl.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/child/child_thread_impl.h"
 
 #include <signal.h>
 #include <string>
 #include <utility>
 
@@ skipping 336 matching lines @@
     return browser_process_io_runner_;
   return ChildProcess::current()->io_task_runner();
 }
 
 void ChildThreadImpl::ConnectChannel(bool use_mojo_channel,
                                      const std::string& ipc_token) {
   bool create_pipe_now = true;
   if (use_mojo_channel) {
     VLOG(1) << "Mojo is enabled on child";
     mojo::ScopedMessagePipeHandle handle;
-    if (!IsInBrowserProcess()) {
-      DCHECK(!handle.is_valid());
-      handle = mojo::edk::CreateChildMessagePipe(
-          base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-              switches::kMojoChannelToken));
+    std::string token = IsInBrowserProcess() ? ipc_token :
+        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            switches::kMojoChannelToken);
+    if (token.empty()) {
+      IPC::mojom::BootstrapRequest request = GetProxy(&pending_bootstrap_);
+      handle = request.PassMessagePipe();
     } else {
-      handle = mojo::edk::CreateChildMessagePipe(ipc_token);
+      handle = mojo::edk::CreateChildMessagePipe(token);
     }
     DCHECK(handle.is_valid());
     channel_->Init(IPC::ChannelMojo::CreateClientFactory(std::move(handle)),
                    create_pipe_now);
     return;
   }
 
   VLOG(1) << "Mojo is disabled on child";
   channel_->Init(channel_name_, IPC::Channel::MODE_CLIENT, create_pipe_now);
 }
@@ skipping 215 matching lines @@
 }
 
 void ChildThreadImpl::RecordComputedAction(const std::string& action) {
     NOTREACHED();
 }
 
 MojoShellConnection* ChildThreadImpl::GetMojoShellConnection() {
   return mojo_shell_connection_.get();
 }
 
+bool ChildThreadImpl::AcceptConnection(shell::Connection* connection) {
+  connection->GetInterfaceRegistry()->AddInterface(
+      IPC::mojom::Bootstrap::Name_,
+      base::Bind(&ChildThreadImpl::BindBootstrapRequest,
+                 base::Unretained(this)));
+  return true;
+}
+
 shell::InterfaceRegistry* ChildThreadImpl::GetInterfaceRegistry() {
   if (!interface_registry_.get())
     interface_registry_.reset(new shell::InterfaceRegistry(nullptr));
   return interface_registry_.get();
 }
 
 shell::InterfaceProvider* ChildThreadImpl::GetRemoteInterfaces() {
   if (!remote_interfaces_.get())
     remote_interfaces_.reset(new shell::InterfaceProvider);
   return remote_interfaces_.get();
@@ skipping 152 matching lines @@
   // race conditions if the process refcount is 0 but there's an IPC message
   // inflight that would addref it.
   Send(new ChildProcessHostMsg_ShutdownRequest);
 }
 
 void ChildThreadImpl::EnsureConnected() {
   VLOG(0) << "ChildThreadImpl::EnsureConnected()";
   base::Process::Current().Terminate(0, false);
 }
 
+void ChildThreadImpl::BindBootstrapRequest(
+    mojo::ScopedMessagePipeHandle handle) {
+  IPC::mojom::BootstrapRequest request =
+      mojo::MakeRequest<IPC::mojom::Bootstrap>(std::move(handle));
+  mojo::FuseInterface(std::move(request), pending_bootstrap_.PassInterface());
+}
+
 bool ChildThreadImpl::IsInBrowserProcess() const {
   return static_cast<bool>(browser_process_io_runner_);
 }
 
 }  // namespace content