Use ChannelMojo in CloudPrintProxyPolicyStartupTest.StartAndShutdown.

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 32 matching lines @@
 #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 "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
 
 using ::testing::AnyNumber;
 using ::testing::Assign;
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::Property;
 using ::testing::Return;
 using ::testing::WithoutArgs;
@@ skipping 207 matching lines @@
 #endif
 
   // Connect up the parent/child IPC channel to signal that the test can
   // continue.
   TestStartupClientChannelListener listener;
   EXPECT_TRUE(base::CommandLine::ForCurrentProcess()->HasSwitch(
       kProcessChannelID));
   std::string startup_channel_name =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           kProcessChannelID);
-  std::unique_ptr<IPC::ChannelProxy> startup_channel;
-  startup_channel =
-      IPC::ChannelProxy::Create(startup_channel_name,
-                                IPC::Channel::MODE_CLIENT,
-                                &listener,
-                                service_process.io_task_runner());
+  std::unique_ptr<IPC::ChannelProxy> startup_channel =
+      IPC::ChannelProxy::Create(
+          mojo::edk::ConnectToPeerProcess(
+              mojo::edk::CreateClientHandle(
+                  mojo::edk::NamedPlatformHandle(startup_channel_name)))
+              .release(),
+          IPC::Channel::MODE_CLIENT, &listener,
+          service_process.io_task_runner());
 
   base::RunLoop().Run();
   if (!Mock::VerifyAndClearExpectations(&server))
     return kExpectationsNotMet;
   if (!g_good_shutdown)
     return kShutdownNotGood;
   return 0;
 }
 
 void SetServiceEnabledExpectations(MockServiceIPCServer* server) {
   server->SetServiceEnabledExpectations();
 }
 
-MULTIPROCESS_IPC_TEST_MAIN(CloudPrintMockService_StartEnabledWaitForQuit) {
+MULTIPROCESS_TEST_MAIN(CloudPrintMockService_StartEnabledWaitForQuit) {
   return CloudPrintMockService_Main(
       base::Bind(&SetServiceEnabledExpectations));
 }
 
 void SetServiceWillBeDisabledExpectations(MockServiceIPCServer* server) {
   server->SetWillBeDisabledExpectations();
 }
 
-MULTIPROCESS_IPC_TEST_MAIN(CloudPrintMockService_StartEnabledExpectDisabled) {
+MULTIPROCESS_TEST_MAIN(CloudPrintMockService_StartEnabledExpectDisabled) {
   return CloudPrintMockService_Main(
       base::Bind(&SetServiceWillBeDisabledExpectations));
 }
 
 class CloudPrintProxyPolicyStartupTest : public base::MultiProcessTest,
                                          public IPC::Listener {
  public:
   CloudPrintProxyPolicyStartupTest();
   ~CloudPrintProxyPolicyStartupTest() override;
 
@@ skipping 19 matching lines @@
     StartupBrowserCreator browser_creator;
     return browser_creator.ProcessCmdLineImpl(
         command_line, base::FilePath(), false, profile,
         StartupBrowserCreator::Profiles());
   }
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_user_data_dir_;
 
-  std::string startup_channel_id_;
+  mojo::edk::NamedPlatformHandle startup_channel_handle_;
   std::unique_ptr<IPC::ChannelProxy> startup_channel_;
   std::unique_ptr<ChromeContentClient> content_client_;
   std::unique_ptr<ChromeContentBrowserClient> browser_content_client_;
 
 #if defined(OS_MACOSX)
   base::ScopedTempDir temp_dir_;
   base::FilePath executable_path_, bundle_path_;
   std::unique_ptr<MockLaunchd> mock_launchd_;
   std::unique_ptr<Launchd::ScopedInstance> scoped_launchd_instance_;
 #endif
@@ skipping 80 matching lines @@
   content_client_.reset();
   content::SetContentClient(NULL);
 
   TestingBrowserProcess::DeleteInstance();
 }
 
 base::Process CloudPrintProxyPolicyStartupTest::Launch(
     const std::string& name) {
   EXPECT_FALSE(CheckServiceProcessReady());
 
-  startup_channel_id_ =
-      base::StringPrintf("%d.%p.%d",
-                         base::GetCurrentProcId(), this,
-                         base::RandInt(0, std::numeric_limits<int>::max()));
-  startup_channel_ = IPC::ChannelProxy::Create(startup_channel_id_,
-                                               IPC::Channel::MODE_SERVER,
-                                               this,
-                                               IOTaskRunner());
+  startup_channel_handle_ = mojo::edk::NamedPlatformHandle(
+      base::StringPrintf("%d.%p.%d", base::GetCurrentProcId(), this,
+                         base::RandInt(0, std::numeric_limits<int>::max())));
+  startup_channel_ = IPC::ChannelProxy::Create(
+      mojo::edk::ConnectToPeerProcess(
+          mojo::edk::CreateServerHandle(startup_channel_handle_, false))
+          .release(),
+      IPC::Channel::MODE_SERVER, this, IOTaskRunner());
 
-#if defined(OS_POSIX)
-  base::FileHandleMappingVector ipc_file_list;
-  ipc_file_list.push_back(std::make_pair(
-      startup_channel_->TakeClientFileDescriptor().release(),
-      kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
-  base::LaunchOptions options;
-  options.fds_to_remap = &ipc_file_list;
-  base::Process process = SpawnChildWithOptions(name, options);
-#else
   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;
@@ skipping 22 matching lines @@
   EXPECT_EQ(exit_code, 0);
 }
 
 void CloudPrintProxyPolicyStartupTest::OnChannelConnected(int32_t peer_pid) {
   observer_.Notify();
 }
 
 base::CommandLine CloudPrintProxyPolicyStartupTest::MakeCmdLine(
     const std::string& procname) {
   base::CommandLine cl = MultiProcessTest::MakeCmdLine(procname);
-  cl.AppendSwitchASCII(kProcessChannelID, startup_channel_id_);
+  cl.AppendSwitchNative(kProcessChannelID, startup_channel_handle_.name);
 #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();
 }