Use ChannelMojo between browser and service processes.

chrome/browser/service_process/service_process_control.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 "chrome/browser/service_process/service_process_control.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 10 matching lines @@
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/upgrade_detector.h"
 #include "chrome/common/service_messages.h"
 #include "chrome/common/service_process_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
+#include "ipc/ipc_channel_mojo.h"
+#include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/named_platform_handle.h"
+#include "mojo/edk/embedder/named_platform_handle_utils.h"
 
 using content::BrowserThread;
 
+namespace {
+
+void ConnectOnBlockingPool(mojo::ScopedMessagePipeHandle handle,
+                           mojo::edk::NamedPlatformHandle os_pipe) {
+  mojo::edk::ScopedPlatformHandle os_pipe_handle =
+      mojo::edk::CreateClientHandle(os_pipe);
+  if (!os_pipe_handle.is_valid())
+    return;
+
+  mojo::FuseMessagePipes(
+      mojo::edk::ConnectToPeerProcess(std::move(os_pipe_handle)),
+      std::move(handle));
+}
+
+}  // namespace
+
 // ServiceProcessControl implementation.
 ServiceProcessControl::ServiceProcessControl() {
 }
 
 ServiceProcessControl::~ServiceProcessControl() {
 }
 
 void ServiceProcessControl::ConnectInternal() {
   // If the channel has already been established then we run the task
   // and return.
   if (channel_.get()) {
     RunConnectDoneTasks();
     return;
   }
 
   // Actually going to connect.
   DVLOG(1) << "Connecting to Service Process IPC Server";
 
+  mojo::MessagePipe pipe;
+  BrowserThread::PostBlockingPoolTask(
+      FROM_HERE, base::Bind(&ConnectOnBlockingPool, base::Passed(&pipe.handle1),
+                            mojo::edk::NamedPlatformHandle(
+                                GetServiceProcessChannel().name)));
   // TODO(hclam): Handle error connecting to channel.
-  const IPC::ChannelHandle channel_id = GetServiceProcessChannel();
-  SetChannel(IPC::ChannelProxy::Create(
-      channel_id, IPC::Channel::MODE_NAMED_CLIENT, this,
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::IO).get()));
+  auto io_task_runner =
+      BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
+  SetChannel(
+      IPC::ChannelProxy::Create(IPC::ChannelMojo::CreateClientFactory(
+                                    std::move(pipe.handle0), io_task_runner),
+                                this, io_task_runner));
 }
 
 void ServiceProcessControl::SetChannel(
     std::unique_ptr<IPC::ChannelProxy> channel) {
   channel_ = std::move(channel);
 }
 
 void ServiceProcessControl::RunConnectDoneTasks() {
   // The tasks executed here may add more tasks to the vector. So copy
   // them to the stack before executing them. This way recursion is
@@ skipping 314 matching lines @@
   if (process_.IsValid()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&Launcher::DoDetectLaunched, this));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(&Launcher::Notify, this));
   }
 }
 #endif  // !OS_MACOSX