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_;
 };
 
-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_;
-};
+using IPCChannelMojoTest = IPCChannelMojoTestBase;
 
 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) {
-  InitWithMojo("IPCChannelMojoTestClient");
+  Init("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, ChannelClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestClient) {
   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,
-                                    ChannelClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoErraticTestClient) {
   ListenerThatQuits listener;
   Connect(&listener);
 
   base::RunLoop().Run();
 
   Close();
 }
 
 TEST_F(IPCChannelMojoTest, SendFailWithPendingMessages) {
-  InitWithMojo("IPCChannelMojoErraticTestClient");
+  Init("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) {
-  InitWithMojo("IPCChannelMojoTestSendMessagePipeClient");
+  Init("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,
-                                    ChannelClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestSendMessagePipeClient) {
   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 ChannelClient {
+class ParamTraitMessagePipeClient : public IpcChannelMojoTestClient {
  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) {
-  InitWithMojo("ParamTraitValidMessagePipeClient");
+  Init("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(ParamTraitValidMessagePipeClient,
-                                    ParamTraitMessagePipeClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
+    ParamTraitValidMessagePipeClient,
+    ParamTraitMessagePipeClient) {
   RunTest(true);
 }
 
 TEST_F(IPCChannelMojoTest, ParamTraitInvalidMessagePipe) {
-  InitWithMojo("ParamTraitInvalidMessagePipeClient");
+  Init("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(ParamTraitInvalidMessagePipeClient,
-                                    ParamTraitMessagePipeClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
+    ParamTraitInvalidMessagePipeClient,
+    ParamTraitMessagePipeClient) {
   RunTest(false);
 }
 
 TEST_F(IPCChannelMojoTest, SendFailAfterClose) {
-  InitWithMojo("IPCChannelMojoTestSendOkClient");
+  Init("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,
-                                    ChannelClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestSendOkClient) {
   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) {
-  InitWithMojo("SimpleAssociatedInterfaceClient");
+  Init("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,
-                                    ChannelClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(SimpleAssociatedInterfaceClient) {
   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 InitWithMojo(const std::string& client_name) {
-    IPCChannelMojoTestBase::InitWithMojo(client_name);
+  void Init(const std::string& client_name) {
+    IPCChannelMojoTestBase::Init(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) {
-  InitWithMojo("ProxyThreadAssociatedInterfaceClient");
+  Init("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(ProxyThreadAssociatedInterfaceClient,
-                                    ChannelProxyClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
+    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.
 
-  InitWithMojo("ProxyThreadAssociatedInterfaceIndirectClient");
+  Init("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(
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
     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) {
-  InitWithMojo("SyncAssociatedInterface");
+  Init("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(SyncAssociatedInterface,
-                                    ChannelProxyClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(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.
-  InitWithMojo("CreatePausedClient");
+  Init("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(CreatePausedClient, ChannelProxyClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(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) {
-  InitWithMojo("IPCChannelMojoTestSendPlatformHandleClient");
+  Init("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,
-                                    ChannelClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(
+    IPCChannelMojoTestSendPlatformHandleClient) {
   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) {
-  InitWithMojo("IPCChannelMojoTestSendPlatformHandleAndPipeClient");
+  Init("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,
-    ChannelClient) {
+    IPCChannelMojoTestSendPlatformHandleAndPipeClient) {
   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) {
-  InitWithMojo("IPCChannelMojoTestVerifyGlobalPidClient");
+  Init("IPCChannelMojoTestVerifyGlobalPidClient");
 
   ListenerThatVerifiesPeerPid listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   base::RunLoop().Run();
   channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestVerifyGlobalPidClient,
-                                    ChannelClient) {
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(IPCChannelMojoTestVerifyGlobalPidClient) {
   IPC::Channel::SetGlobalPid(kMagicChildId);
   ListenerThatQuits listener;
   Connect(&listener);
 
   base::RunLoop().Run();
 
   Close();
 }
 
 #endif  // OS_LINUX
 
 }  // namespace