Revert of 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 IPCChannelMojoTestBase {
+class IPCChannelProxyTest : public IPCTestBase {
  public:
   IPCChannelProxyTest() {}
   ~IPCChannelProxyTest() override {}
 
   void SetUp() override {
-    IPCChannelMojoTestBase::SetUp();
+    IPCTestBase::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());
-    channel_proxy_ = IPC::ChannelProxy::Create(
-        TakeHandle().release(), IPC::Channel::MODE_SERVER, listener_.get(),
-        thread_->task_runner());
+    CreateChannelProxy(listener_.get(), thread_->task_runner().get());
+
+    ASSERT_TRUE(StartClient());
   }
 
   void TearDown() override {
-    channel_proxy_.reset();
+    DestroyChannelProxy();
     thread_.reset();
     listener_.reset();
-    IPCChannelMojoTestBase::TearDown();
+    IPCTestBase::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 132 matching lines @@
   // 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
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(ChannelProxyClient) {
+MULTIPROCESS_IPC_TEST_CLIENT_MAIN(ChannelProxyClient) {
+  base::MessageLoopForIO main_message_loop;
   ChannelReflectorListener listener;
-  Connect(&listener);
-  listener.Init(channel());
+  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());
 
   base::RunLoop().Run();
-  Close();
+  return 0;
 }
 
 }  // namespace