Revert of Change most IPC tests to use ChannelMojo.

ipc/ipc_channel_mojo_unittest.cc

 // Copyright 2014 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 "ipc/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 19 matching lines @@
 #include "build/build_config.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_mojo_handle_attachment.h"
 #include "ipc/ipc_mojo_message_helper.h"
 #include "ipc/ipc_mojo_param_traits.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message.h"
 #include "ipc/ipc_test.mojom.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_channel_listener.h"
+#include "mojo/edk/test/mojo_test_base.h"
+#include "mojo/edk/test/multiprocess_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
+#define DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(client_name, test_base)           \
+  class client_name##_MainFixture : public test_base {                        \
+   public:                                                                    \
+    void Main();                                                              \
+  };                                                                          \
+  MULTIPROCESS_TEST_MAIN_WITH_SETUP(                                          \
+      client_name##TestChildMain,                                             \
+      ::mojo::edk::test::MultiprocessTestHelper::ChildSetup) {                \
+    client_name##_MainFixture test;                                           \
+    test.Init(                                                                \
+        std::move(mojo::edk::test::MultiprocessTestHelper::primordial_pipe)); \
+    test.Main();                                                              \
+    return (::testing::Test::HasFatalFailure() ||                             \
+            ::testing::Test::HasNonfatalFailure())                            \
+               ? 1                                                            \
+               : 0;                                                           \
+  }                                                                           \
+  void client_name##_MainFixture::Main()
+
 namespace {
 
 void SendString(IPC::Sender* sender, const std::string& str) {
   IPC::Message* message = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
   message->WriteString(str);
   ASSERT_TRUE(sender->Send(message));
 }
 
 void SendValue(IPC::Sender* sender, int32_t value) {
   IPC::Message* message = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
@@ skipping 23 matching lines @@
     // process dies.
     DCHECK(received_ok_);
   }
 
   static void SendOK(IPC::Sender* sender) { SendString(sender, "OK"); }
 
  private:
   bool received_ok_;
 };
 
-using IPCChannelMojoTest = IPCChannelMojoTestBase;
+class ChannelClient {
+ public:
+  void Init(mojo::ScopedMessagePipeHandle handle) {
+    handle_ = std::move(handle);
+  }
+
+  void Connect(IPC::Listener* listener) {
+    channel_ = IPC::ChannelMojo::Create(
+        std::move(handle_), IPC::Channel::MODE_CLIENT, listener,
+        base::ThreadTaskRunnerHandle::Get());
+    CHECK(channel_->Connect());
+  }
+
+  void Close() {
+    channel_->Close();
+
+    base::RunLoop run_loop;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  IPC::ChannelMojo* channel() const { return channel_.get(); }
+
+ private:
+  base::MessageLoopForIO main_message_loop_;
+  mojo::ScopedMessagePipeHandle handle_;
+  std::unique_ptr<IPC::ChannelMojo> channel_;
+};
+
+class IPCChannelMojoTestBase : public testing::Test {
+ public:
+  void InitWithMojo(const std::string& test_client_name) {
+    handle_ = helper_.StartChild(test_client_name);
+  }
+
+  bool WaitForClientShutdown() { return helper_.WaitForChildTestShutdown(); }
+
+ protected:
+  mojo::ScopedMessagePipeHandle TakeHandle() { return std::move(handle_); }
+
+ private:
+  mojo::ScopedMessagePipeHandle handle_;
+  mojo::edk::test::MultiprocessTestHelper helper_;
+};
+
+class IPCChannelMojoTest : public IPCChannelMojoTestBase {
+ public:
+  void TearDown() override { base::RunLoop().RunUntilIdle(); }
+
+  void CreateChannel(IPC::Listener* listener) {
+    channel_ = IPC::ChannelMojo::Create(
+        TakeHandle(), IPC::Channel::MODE_SERVER, listener,
+        base::ThreadTaskRunnerHandle::Get());
+  }
+
+  bool ConnectChannel() { return channel_->Connect(); }
+
+  void DestroyChannel() { channel_.reset(); }
+
+  IPC::Sender* sender() { return channel(); }
+  IPC::Channel* channel() { return channel_.get(); }
+
+ private:
+  base::MessageLoop message_loop_;
+  std::unique_ptr<IPC::Channel> channel_;
+};
 
 class TestChannelListenerWithExtraExpectations
     : public IPC::TestChannelListener {
  public:
   TestChannelListenerWithExtraExpectations() : is_connected_called_(false) {}
 
   void OnChannelConnected(int32_t peer_pid) override {
     IPC::TestChannelListener::OnChannelConnected(peer_pid);
     EXPECT_TRUE(base::kNullProcessId != peer_pid);
     is_connected_called_ = true;
   }
 
   bool is_connected_called() const { return is_connected_called_; }
 
  private:
   bool is_connected_called_;
 };
 
 TEST_F(IPCChannelMojoTest, ConnectedFromClient) {
-  Init("IPCChannelMojoTestClient");
+  InitWithMojo("IPCChannelMojoTestClient");
 
   // Set up IPC channel and start client.
   TestChannelListenerWithExtraExpectations listener;
   CreateChannel(&listener);
   listener.Init(sender());
   ASSERT_TRUE(ConnectChannel());
 
   IPC::TestChannelListener::SendOneMessage(sender(), "hello from parent");
 
   base::RunLoop().Run();
 
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   EXPECT_TRUE(listener.is_connected_called());
   EXPECT_TRUE(listener.HasSentAll());
 
   DestroyChannel();
 }
 
 // A long running process that connects to us
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestClient, ChannelClient) {
   TestChannelListenerWithExtraExpectations listener;
   Connect(&listener);
   listener.Init(channel());
 
   IPC::TestChannelListener::SendOneMessage(channel(), "hello from child");
   base::RunLoop().Run();
   EXPECT_TRUE(listener.is_connected_called());
   EXPECT_TRUE(listener.HasSentAll());
 
   Close();
@@ skipping 21 matching lines @@
   ListenerThatQuits() {}
 
   bool OnMessageReceived(const IPC::Message& message) override { return true; }
 
   void OnChannelConnected(int32_t peer_pid) override {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 };
 
 // A long running process that connects to us.
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoErraticTestClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoErraticTestClient,
+                                    ChannelClient) {
   ListenerThatQuits listener;
   Connect(&listener);
 
   base::RunLoop().Run();
 
   Close();
 }
 
 TEST_F(IPCChannelMojoTest, SendFailWithPendingMessages) {
-  Init("IPCChannelMojoErraticTestClient");
+  InitWithMojo("IPCChannelMojoErraticTestClient");
 
   // Set up IPC channel and start client.
   ListenerExpectingErrors listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   // This matches a value in mojo/edk/system/constants.h
   const int kMaxMessageNumBytes = 4 * 1024 * 1024;
   std::string overly_large_data(kMaxMessageNumBytes, '*');
   // This messages are queued as pending.
@@ skipping 123 matching lines @@
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
 };
 
 TEST_F(IPCChannelMojoTest, SendMessagePipe) {
-  Init("IPCChannelMojoTestSendMessagePipeClient");
+  InitWithMojo("IPCChannelMojoTestSendMessagePipeClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   TestingMessagePipe pipe;
   HandleSendingHelper::WritePipeThenSend(channel(), &pipe);
 
   base::RunLoop().Run();
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestSendMessagePipeClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestSendMessagePipeClient,
+                                    ChannelClient) {
   ListenerThatExpectsMessagePipe listener;
   Connect(&listener);
   listener.set_sender(channel());
 
   base::RunLoop().Run();
 
   Close();
 }
 
 void ReadOK(mojo::MessagePipeHandle pipe) {
@@ skipping 40 matching lines @@
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
   bool receiving_valid_;
 };
 
-class ParamTraitMessagePipeClient : public IpcChannelMojoTestClient {
+class ParamTraitMessagePipeClient : public ChannelClient {
  public:
   void RunTest(bool receiving_valid_handle) {
     ListenerThatExpectsMessagePipeUsingParamTrait listener(
         receiving_valid_handle);
     Connect(&listener);
     listener.set_sender(channel());
 
     base::RunLoop().Run();
 
     Close();
   }
 };
 
 TEST_F(IPCChannelMojoTest, ParamTraitValidMessagePipe) {
-  Init("ParamTraitValidMessagePipeClient");
+  InitWithMojo("ParamTraitValidMessagePipeClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   TestingMessagePipe pipe;
 
   std::unique_ptr<IPC::Message> message(new IPC::Message());
   IPC::ParamTraits<mojo::MessagePipeHandle>::Write(message.get(),
                                                    pipe.peer.release());
   WriteOK(pipe.self.get());
 
   channel()->Send(message.release());
   base::RunLoop().Run();
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
-    ParamTraitValidMessagePipeClient,
-    ParamTraitMessagePipeClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(ParamTraitValidMessagePipeClient,
+                                    ParamTraitMessagePipeClient) {
   RunTest(true);
 }
 
 TEST_F(IPCChannelMojoTest, ParamTraitInvalidMessagePipe) {
-  Init("ParamTraitInvalidMessagePipeClient");
+  InitWithMojo("ParamTraitInvalidMessagePipeClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   mojo::MessagePipeHandle invalid_handle;
   std::unique_ptr<IPC::Message> message(new IPC::Message());
   IPC::ParamTraits<mojo::MessagePipeHandle>::Write(message.get(),
                                                    invalid_handle);
 
   channel()->Send(message.release());
   base::RunLoop().Run();
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
-    ParamTraitInvalidMessagePipeClient,
-    ParamTraitMessagePipeClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(ParamTraitInvalidMessagePipeClient,
+                                    ParamTraitMessagePipeClient) {
   RunTest(false);
 }
 
 TEST_F(IPCChannelMojoTest, SendFailAfterClose) {
-  Init("IPCChannelMojoTestSendOkClient");
+  InitWithMojo("IPCChannelMojoTestSendOkClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   base::RunLoop().Run();
   channel()->Close();
   ASSERT_FALSE(channel()->Send(new IPC::Message()));
 
   EXPECT_TRUE(WaitForClientShutdown());
@@ skipping 10 matching lines @@
     ListenerThatExpectsOK::SendOK(sender_);
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
 };
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestSendOkClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestSendOkClient,
+                                    ChannelClient) {
   ListenerSendingOneOk listener;
   Connect(&listener);
   listener.set_sender(channel());
 
   base::RunLoop().Run();
 
   Close();
 }
 
 class ListenerWithSimpleAssociatedInterface
@@ skipping 84 matching lines @@
   void set_channel(IPC::Channel* channel) { channel_ = channel; }
 
  private:
   static void OnQuitAck() { base::MessageLoop::current()->QuitWhenIdle(); }
 
   IPC::Channel* channel_ = nullptr;
   IPC::mojom::SimpleTestDriverAssociatedPtr driver_;
 };
 
 TEST_F(IPCChannelMojoTest, SimpleAssociatedInterface) {
-  Init("SimpleAssociatedInterfaceClient");
+  InitWithMojo("SimpleAssociatedInterfaceClient");
 
   ListenerWithSimpleAssociatedInterface listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   listener.RegisterInterfaceFactory(channel());
 
   base::RunLoop().Run();
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(SimpleAssociatedInterfaceClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(SimpleAssociatedInterfaceClient,
+                                    ChannelClient) {
   ListenerSendingAssociatedMessages listener;
   Connect(&listener);
   listener.set_channel(channel());
 
   base::RunLoop().Run();
 
   Close();
 }
 
 class ChannelProxyRunner {
@@ skipping 34 matching lines @@
   mojo::ScopedMessagePipeHandle handle_;
   base::Thread io_thread_;
   std::unique_ptr<IPC::ChannelProxy> proxy_;
   base::WaitableEvent never_signaled_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelProxyRunner);
 };
 
 class IPCChannelProxyMojoTest : public IPCChannelMojoTestBase {
  public:
-  void Init(const std::string& client_name) {
-    IPCChannelMojoTestBase::Init(client_name);
+  void InitWithMojo(const std::string& client_name) {
+    IPCChannelMojoTestBase::InitWithMojo(client_name);
     runner_.reset(new ChannelProxyRunner(TakeHandle(), true));
   }
   void CreateProxy(IPC::Listener* listener) { runner_->CreateProxy(listener); }
   void RunProxy() {
     runner_->RunProxy();
   }
   void DestroyProxy() {
     runner_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   IPC::ChannelProxy* proxy() { return runner_->proxy(); }
 
  private:
+  base::MessageLoop message_loop_;
   std::unique_ptr<ChannelProxyRunner> runner_;
 };
 
 class ListenerWithSimpleProxyAssociatedInterface
     : public IPC::Listener,
       public IPC::mojom::SimpleTestDriver {
  public:
   static const int kNumMessages;
 
   ListenerWithSimpleProxyAssociatedInterface() : binding_(this) {}
@@ skipping 55 matching lines @@
   int32_t next_expected_value_ = 0;
   int num_messages_received_ = 0;
   bool received_quit_ = false;
 
   mojo::AssociatedBinding<IPC::mojom::SimpleTestDriver> binding_;
 };
 
 const int ListenerWithSimpleProxyAssociatedInterface::kNumMessages = 1000;
 
 TEST_F(IPCChannelProxyMojoTest, ProxyThreadAssociatedInterface) {
-  Init("ProxyThreadAssociatedInterfaceClient");
+  InitWithMojo("ProxyThreadAssociatedInterfaceClient");
 
   ListenerWithSimpleProxyAssociatedInterface listener;
   CreateProxy(&listener);
   RunProxy();
 
   base::RunLoop().Run();
 
   EXPECT_TRUE(WaitForClientShutdown());
   EXPECT_TRUE(listener.received_all_messages());
 
@@ skipping 27 matching lines @@
   base::MessageLoop message_loop_;
   std::unique_ptr<ChannelProxyRunner> runner_;
 };
 
 class DummyListener : public IPC::Listener {
  public:
   // IPC::Listener
   bool OnMessageReceived(const IPC::Message& message) override { return true; }
 };
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
-    ProxyThreadAssociatedInterfaceClient,
-    ChannelProxyClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(ProxyThreadAssociatedInterfaceClient,
+                                    ChannelProxyClient) {
   DummyListener listener;
   CreateProxy(&listener);
   RunProxy();
 
   // Send a bunch of interleaved messages, alternating between the associated
   // interface and a legacy IPC::Message.
   IPC::mojom::SimpleTestDriverAssociatedPtr driver;
   proxy()->GetRemoteAssociatedInterface(&driver);
   for (int i = 0; i < ListenerWithSimpleProxyAssociatedInterface::kNumMessages;
        ++i) {
@@ skipping 49 matching lines @@
   mojo::AssociatedBinding<IPC::mojom::PingReceiver> ping_receiver_binding_;
 
   base::Closure ping_handler_;
 };
 
 TEST_F(IPCChannelProxyMojoTest, ProxyThreadAssociatedInterfaceIndirect) {
   // Tests that we can pipeline interface requests and subsequent messages
   // targeting proxy thread bindings, and the channel will still dispatch
   // messages appropriately.
 
-  Init("ProxyThreadAssociatedInterfaceIndirectClient");
+  InitWithMojo("ProxyThreadAssociatedInterfaceIndirectClient");
 
   ListenerWithIndirectProxyAssociatedInterface listener;
   CreateProxy(&listener);
   listener.RegisterInterfaceFactory(proxy());
   RunProxy();
 
   base::RunLoop loop;
   listener.set_ping_handler(loop.QuitClosure());
   loop.Run();
 
   EXPECT_TRUE(WaitForClientShutdown());
 
   DestroyProxy();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(
     ProxyThreadAssociatedInterfaceIndirectClient,
     ChannelProxyClient) {
   DummyListener listener;
   CreateProxy(&listener);
   RunProxy();
 
   // Use an interface requested via another interface. On the remote end both
   // interfaces are bound on the proxy thread. This ensures that the Ping
   // message we send will still be dispatched properly even though the remote
   // endpoint may not have been bound yet by the time the message is initially
@@ skipping 96 matching lines @@
       return false;
     return true;
   }
 
   int32_t* storage_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncReplyReader);
 };
 
 TEST_F(IPCChannelProxyMojoTest, SyncAssociatedInterface) {
-  Init("SyncAssociatedInterface");
+  InitWithMojo("SyncAssociatedInterface");
 
   ListenerWithSyncAssociatedInterface listener;
   CreateProxy(&listener);
   listener.set_sync_sender(proxy());
   listener.RegisterInterfaceFactory(proxy());
   RunProxy();
 
   // Run the client's simple sanity check to completion.
   listener.RunUntilQuitRequested();
 
@@ skipping 85 matching lines @@
 
   bool use_sync_sender_ = false;
   mojo::AssociatedBinding<IPC::mojom::SimpleTestClient> binding_;
   IPC::Sender* sync_sender_ = nullptr;
   IPC::mojom::SimpleTestDriver* driver_ = nullptr;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleTestClientImpl);
 };
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(SyncAssociatedInterface,
-                                                        ChannelProxyClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(SyncAssociatedInterface,
+                                    ChannelProxyClient) {
   SimpleTestClientImpl client_impl;
   CreateProxy(&client_impl);
   client_impl.set_sync_sender(proxy());
   proxy()->AddAssociatedInterface(base::Bind(&SimpleTestClientImpl::BindRequest,
                                              base::Unretained(&client_impl)));
   RunProxy();
 
   IPC::mojom::SimpleTestDriverAssociatedPtr driver;
   proxy()->GetRemoteAssociatedInterface(&driver);
   client_impl.set_driver(driver.get());
@@ skipping 38 matching lines @@
   //   Send(E)
   //   Flush()
   //
   // must result in the other end receiving messages A, D, E, B, D; in that
   // order.
   //
   // This behavior is required by some consumers of IPC::Channel, and it is not
   // sufficient to leave this up to the consumer to implement since associated
   // interface requests and messages also need to be queued according to the
   // same policy.
-  Init("CreatePausedClient");
+  InitWithMojo("CreatePausedClient");
 
   DummyListener listener;
   CreateProxy(&listener);
   RunProxy();
 
   // This message must be sent immediately since the channel is unpaused.
   SendValue(proxy(), 1);
 
   proxy()->Pause();
 
@@ skipping 32 matching lines @@
       base::MessageLoop::current()->QuitWhenIdle();
     return true;
   }
 
  private:
   std::queue<int32_t>* expected_values_;
 
   DISALLOW_COPY_AND_ASSIGN(ExpectValueSequenceListener);
 };
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(CreatePausedClient,
-                                                        ChannelProxyClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(CreatePausedClient, ChannelProxyClient) {
   std::queue<int32_t> expected_values;
   ExpectValueSequenceListener listener(&expected_values);
   CreateProxy(&listener);
   expected_values.push(1);
   expected_values.push(4);
   expected_values.push(5);
   expected_values.push(2);
   expected_values.push(3);
   RunProxy();
   base::RunLoop().Run();
@@ skipping 20 matching lines @@
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
 };
 
 TEST_F(IPCChannelMojoTest, SendPlatformHandle) {
-  Init("IPCChannelMojoTestSendPlatformHandleClient");
+  InitWithMojo("IPCChannelMojoTestSendPlatformHandleClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::File file(HandleSendingHelper::GetSendingFilePath(temp_dir.GetPath()),
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
                       base::File::FLAG_READ);
   HandleSendingHelper::WriteFileThenSend(channel(), file);
   base::RunLoop().Run();
 
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(
-    IPCChannelMojoTestSendPlatformHandleClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestSendPlatformHandleClient,
+                                    ChannelClient) {
   ListenerThatExpectsFile listener;
   Connect(&listener);
   listener.set_sender(channel());
 
   base::RunLoop().Run();
 
   Close();
 }
 
 class ListenerThatExpectsFileAndPipe : public IPC::Listener {
@@ skipping 14 matching lines @@
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
 };
 
 TEST_F(IPCChannelMojoTest, SendPlatformHandleAndPipe) {
-  Init("IPCChannelMojoTestSendPlatformHandleAndPipeClient");
+  InitWithMojo("IPCChannelMojoTestSendPlatformHandleAndPipeClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::File file(HandleSendingHelper::GetSendingFilePath(temp_dir.GetPath()),
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
                       base::File::FLAG_READ);
   TestingMessagePipe pipe;
   HandleSendingHelper::WriteFileAndPipeThenSend(channel(), file, &pipe);
 
   base::RunLoop().Run();
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(
-    IPCChannelMojoTestSendPlatformHandleAndPipeClient) {
+    IPCChannelMojoTestSendPlatformHandleAndPipeClient,
+    ChannelClient) {
   ListenerThatExpectsFileAndPipe listener;
   Connect(&listener);
   listener.set_sender(channel());
 
   base::RunLoop().Run();
 
   Close();
 }
 
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_LINUX)
 
 const base::ProcessId kMagicChildId = 54321;
 
 class ListenerThatVerifiesPeerPid : public IPC::Listener {
  public:
   void OnChannelConnected(int32_t peer_pid) override {
     EXPECT_EQ(peer_pid, kMagicChildId);
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   bool OnMessageReceived(const IPC::Message& message) override {
     NOTREACHED();
     return true;
   }
 };
 
 TEST_F(IPCChannelMojoTest, VerifyGlobalPid) {
-  Init("IPCChannelMojoTestVerifyGlobalPidClient");
+  InitWithMojo("IPCChannelMojoTestVerifyGlobalPidClient");
 
   ListenerThatVerifiesPeerPid listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   base::RunLoop().Run();
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestVerifyGlobalPidClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestVerifyGlobalPidClient,
+                                    ChannelClient) {
   IPC::Channel::SetGlobalPid(kMagicChildId);
   ListenerThatQuits listener;
   Connect(&listener);
 
   base::RunLoop().Run();
 
   Close();
 }
 
 #endif  // OS_LINUX
 
 }  // namespace