Use ChannelMojo between browser and service processes.

chrome/browser/printing/cloud_print/test/cloud_print_proxy_process_browsertest.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.
 
 // Create a service process that uses a Mock to respond to the browser in order
 // to test launching the browser using the cloud print policy check command
 // line switch.
 
 #include <stdint.h>
 
@@ skipping 31 matching lines @@
 #include "chrome/test/base/test_launcher_utils.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_io_thread_state.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
+#include "ipc/ipc_channel_mojo.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_multiprocess_test.h"
 #include "ipc/ipc_switches.h"
 #include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/named_platform_handle.h"
+#include "mojo/edk/embedder/named_platform_handle_utils.h"
+#include "mojo/edk/embedder/scoped_ipc_support.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/common/mac/mock_launchd.h"
 #endif
 #if defined(OS_POSIX)
 #include "base/posix/global_descriptors.h"
 #endif
@@ skipping 28 matching lines @@
 void ShutdownTask() {
   g_good_shutdown = true;
   g_service_process->Shutdown();
 }
 
 class TestStartupClientChannelListener : public IPC::Listener {
  public:
   bool OnMessageReceived(const IPC::Message& message) override { return false; }
 };
 
+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
 
 class TestServiceProcess : public ServiceProcess {
  public:
   TestServiceProcess() { }
   ~TestServiceProcess() override {}
 
   bool Initialize(base::MessageLoopForUI* message_loop,
                   ServiceProcessState* state);
 };
@@ skipping 11 matching lines @@
 
 // This mocks the service side IPC message handler, allowing us to have a
 // minimal service process.
 class MockServiceIPCServer : public ServiceIPCServer {
  public:
   static std::string EnabledUserId();
 
   MockServiceIPCServer(
       ServiceIPCServer::Client* client,
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-      const IPC::ChannelHandle& handle,
       base::WaitableEvent* shutdown_event)
-      : ServiceIPCServer(client, io_task_runner, handle, shutdown_event),
-        enabled_(true) { }
+      : ServiceIPCServer(client, io_task_runner, shutdown_event),
+        enabled_(true) {}
 
   MOCK_METHOD1(OnMessageReceived, bool(const IPC::Message& message));
   MOCK_METHOD1(OnChannelConnected, void(int32_t peer_pid));
   MOCK_METHOD0(OnChannelError, void());
 
   void SetServiceEnabledExpectations();
   void SetWillBeDisabledExpectations();
 
   void CallServiceOnChannelConnected(int32_t peer_pid) {
     ServiceIPCServer::OnChannelConnected(peer_pid);
@@ skipping 97 matching lines @@
 
   TestServiceProcess service_process;
   EXPECT_EQ(&service_process, g_service_process);
 
   // Takes ownership of the pointer, but we can use it since we have the same
   // lifetime.
   EXPECT_TRUE(service_process.Initialize(&main_message_loop, state));
 
   // Needed for IPC.
   mojo::edk::Init();
+  mojo::edk::ScopedIPCSupport ipc_support(service_process.io_task_runner());
 
   MockServiceIPCServer server(&service_process,
                               service_process.io_task_runner(),
-                              state->GetServiceProcessChannel(),
                               service_process.GetShutdownEventForTesting());
 
   // Here is where the expectations/mock responses need to be set up.
   set_expectations.Run(&server);
 
   EXPECT_TRUE(server.Init());
   EXPECT_TRUE(state->SignalReady(service_process.io_task_runner().get(),
                                  base::Bind(&ShutdownTask)));
 #if defined(OS_MACOSX)
   mock_launchd.SignalReady();
@@ skipping 198 matching lines @@
   base::Process process = SpawnChild(name);
 #endif
   EXPECT_TRUE(process.IsValid());
   return process;
 }
 
 void CloudPrintProxyPolicyStartupTest::WaitForConnect() {
   observer_.Wait();
   EXPECT_TRUE(CheckServiceProcessReady());
   EXPECT_TRUE(base::ThreadTaskRunnerHandle::Get().get());
+
+  mojo::MessagePipe pipe;
+  BrowserThread::PostBlockingPoolTask(
+      FROM_HERE, base::Bind(&ConnectOnBlockingPool, base::Passed(&pipe.handle1),
+                            mojo::edk::NamedPlatformHandle(
+                                GetServiceProcessChannel().name)));
   ServiceProcessControl::GetInstance()->SetChannel(
-      IPC::ChannelProxy::Create(GetServiceProcessChannel(),
-                                IPC::Channel::MODE_NAMED_CLIENT,
-                                ServiceProcessControl::GetInstance(),
-                                IOTaskRunner()));
+      IPC::ChannelProxy::Create(IPC::ChannelMojo::CreateClientFactory(
+                                    std::move(pipe.handle0), IOTaskRunner()),
+                                this, IOTaskRunner()));
 }
 
 bool CloudPrintProxyPolicyStartupTest::Send(IPC::Message* message) {
   return ServiceProcessControl::GetInstance()->Send(message);
 }
 
 void CloudPrintProxyPolicyStartupTest::ShutdownAndWaitForExitWithTimeout(
     base::Process process) {
   ASSERT_TRUE(Send(new ServiceMsg_Shutdown()));
 
@@ skipping 12 matching lines @@
     const std::string& procname) {
   base::CommandLine cl = MultiProcessTest::MakeCmdLine(procname);
   cl.AppendSwitchASCII(switches::kProcessChannelID, startup_channel_id_);
 #if defined(OS_MACOSX)
   cl.AppendSwitchASCII(kTestExecutablePath, executable_path_.value());
 #endif
   return cl;
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartAndShutdown) {
+  mojo::edk::Init();
+  mojo::edk::ScopedIPCSupport ipc_support(
+      BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::IO)
+          ->task_runner());
+
   TestingBrowserProcess* browser_process =
       TestingBrowserProcess::GetGlobal();
   TestingProfileManager profile_manager(browser_process);
   ASSERT_TRUE(profile_manager.SetUp());
 
   // Must be created after the TestingProfileManager since that creates the
   // LocalState for the BrowserProcess.  Must be created before profiles are
   // constructed.
   chrome::TestingIOThreadState testing_io_thread_state;
 
   base::Process process =
       Launch("CloudPrintMockService_StartEnabledWaitForQuit");
   WaitForConnect();
   ShutdownAndWaitForExitWithTimeout(std::move(process));
+  ServiceProcessControl::GetInstance()->Disconnect();
   content::RunAllPendingInMessageLoop();
 }