Change most IPC tests to use ChannelMojo.

ipc/ipc_channel_proxy_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 "build/build_config.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 
@@ skipping 214 matching lines @@
   ~MessageCountFilter() override {}
 
   size_t messages_received_;
   uint32_t supported_message_class_;
   bool is_global_filter_;
 
   FilterEvent last_filter_event_;
   bool message_filtering_enabled_;
 };
 
-class IPCChannelProxyTest : public IPCTestBase {
+class IPCChannelProxyTest : public IPCChannelMojoTestBase {
  public:
   IPCChannelProxyTest() {}
   ~IPCChannelProxyTest() override {}
 
   void SetUp() override {
-    IPCTestBase::SetUp();
+    IPCChannelMojoTestBase::SetUp();
 
     Init("ChannelProxyClient");
 
     thread_.reset(new base::Thread("ChannelProxyTestServerThread"));
     base::Thread::Options options;
     options.message_loop_type = base::MessageLoop::TYPE_IO;
     thread_->StartWithOptions(options);
 
     listener_.reset(new QuitListener());
-    CreateChannelProxy(listener_.get(), thread_->task_runner().get());
-
-    ASSERT_TRUE(StartClient());
+    channel_proxy_ = IPC::ChannelProxy::Create(
+        TakeHandle().release(), IPC::Channel::MODE_SERVER, listener_.get(),
+        thread_->task_runner());
   }
 
   void TearDown() override {
-    DestroyChannelProxy();
+    channel_proxy_.reset();
     thread_.reset();
     listener_.reset();
-    IPCTestBase::TearDown();
+    IPCChannelMojoTestBase::TearDown();
   }
 
   void SendQuitMessageAndWaitForIdle() {
     sender()->Send(new WorkerMsg_Quit);
     base::RunLoop().Run();
     EXPECT_TRUE(WaitForClientShutdown());
   }
 
   bool DidListenerGetBadMessage() {
     return listener_->bad_message_received_;
   }
 
+  IPC::ChannelProxy* channel_proxy() { return channel_proxy_.get(); }
+  IPC::Sender* sender() { return channel_proxy_.get(); }
+
  private:
   std::unique_ptr<base::Thread> thread_;
   std::unique_ptr<QuitListener> listener_;
+  std::unique_ptr<IPC::ChannelProxy> channel_proxy_;
 };
 
 TEST_F(IPCChannelProxyTest, MessageClassFilters) {
   // Construct a filter per message class.
   std::vector<scoped_refptr<MessageCountFilter> > class_filters;
   class_filters.push_back(make_scoped_refptr(
       new MessageCountFilter(TestMsgStart)));
   class_filters.push_back(make_scoped_refptr(
       new MessageCountFilter(UtilityMsgStart)));
   for (size_t i = 0; i < class_filters.size(); ++i)
@@ skipping 61 matching lines @@
   // Ensure that the filters were removed and did not receive any messages.
   SendQuitMessageAndWaitForIdle();
   EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
             global_filter->last_filter_event());
   EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
             class_filter->last_filter_event());
   EXPECT_EQ(0U, class_filter->messages_received());
   EXPECT_EQ(0U, global_filter->messages_received());
 }
 
-// The test that follow trigger DCHECKS in debug build.
-#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
-
 TEST_F(IPCChannelProxyTest, BadMessageOnListenerThread) {
   scoped_refptr<MessageCountFilter> class_filter(
       new MessageCountFilter(TestMsgStart));
   class_filter->set_message_filtering_enabled(false);
   channel_proxy()->AddFilter(class_filter.get());
 
   sender()->Send(new TestMsg_SendBadMessage());
 
   SendQuitMessageAndWaitForIdle();
   EXPECT_TRUE(DidListenerGetBadMessage());
 }
 
 TEST_F(IPCChannelProxyTest, BadMessageOnIPCThread) {
   scoped_refptr<MessageCountFilter> class_filter(
       new MessageCountFilter(TestMsgStart));
   class_filter->set_message_filtering_enabled(true);
   channel_proxy()->AddFilter(class_filter.get());
 
   sender()->Send(new TestMsg_SendBadMessage());
 
   SendQuitMessageAndWaitForIdle();
   EXPECT_TRUE(DidListenerGetBadMessage());
 }
 
-class IPCChannelBadMessageTest : public IPCTestBase {
+class IPCChannelBadMessageTest : public IPCChannelMojoTestBase {
  public:
   void SetUp() override {
-    IPCTestBase::SetUp();
+    IPCChannelMojoTestBase::SetUp();
 
     Init("ChannelProxyClient");
 
     listener_.reset(new QuitListener());
     CreateChannel(listener_.get());
     ASSERT_TRUE(ConnectChannel());
-
-    ASSERT_TRUE(StartClient());
   }
 
   void TearDown() override {
+    IPCChannelMojoTestBase::TearDown();
     listener_.reset();
-    IPCTestBase::TearDown();
   }
 
   void SendQuitMessageAndWaitForIdle() {
     sender()->Send(new WorkerMsg_Quit);
     base::RunLoop().Run();
     EXPECT_TRUE(WaitForClientShutdown());
   }
 
   bool DidListenerGetBadMessage() {
     return listener_->bad_message_received_;
   }
 
  private:
   std::unique_ptr<QuitListener> listener_;
 };
 
 #if !defined(OS_WIN)
   // TODO(jam): for some reason this is flaky on win buildbots.
 TEST_F(IPCChannelBadMessageTest, BadMessage) {
   sender()->Send(new TestMsg_SendBadMessage());
   SendQuitMessageAndWaitForIdle();
   EXPECT_TRUE(DidListenerGetBadMessage());
 }
 #endif
 
-#endif
-
-MULTIPROCESS_IPC_TEST_CLIENT_MAIN(ChannelProxyClient) {
-  base::MessageLoopForIO main_message_loop;
+DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(ChannelProxyClient) {
   ChannelReflectorListener listener;
-  std::unique_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
-      IPCTestBase::GetChannelName("ChannelProxyClient"), &listener,
-      main_message_loop.task_runner()));
-  CHECK(channel->Connect());
-  listener.Init(channel.get());
+  Connect(&listener);
+  listener.Init(channel());
 
   base::RunLoop().Run();
-  return 0;
+  Close();
 }
 
 }  // namespace