Change most IPC tests to use ChannelMojo.

ipc/ipc_test_base.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.
 
 #include "ipc/ipc_test_base.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/kill.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "ipc/ipc_channel_mojo.h"
 #include "ipc/ipc_descriptors.h"
 
 #if defined(OS_POSIX)
 #include "base/posix/global_descriptors.h"
 #endif
 
 // static
 std::string IPCTestBase::GetChannelName(const std::string& test_client_name) {
   DCHECK(!test_client_name.empty());
   return test_client_name + "__Channel";
@@ skipping 135 matching lines @@
 
 scoped_refptr<base::SingleThreadTaskRunner> IPCTestBase::task_runner() {
   return message_loop_->task_runner();
 }
 
 std::unique_ptr<IPC::ChannelFactory> IPCTestBase::CreateChannelFactory(
     const IPC::ChannelHandle& handle,
     base::SingleThreadTaskRunner* runner) {
   return IPC::ChannelFactory::Create(handle, IPC::Channel::MODE_SERVER, runner);
 }
+IPCChannelMojoTestBase::IPCChannelMojoTestBase() = default;
+IPCChannelMojoTestBase::~IPCChannelMojoTestBase() = default;
+
+void IPCChannelMojoTestBase::Init(const std::string& test_client_name) {
+  handle_ = helper_.StartChild(test_client_name);
+}
+
+bool IPCChannelMojoTestBase::WaitForClientShutdown() {
+  return helper_.WaitForChildTestShutdown();
+}
+
+void IPCChannelMojoTestBase::TearDown() {
+  base::RunLoop().RunUntilIdle();
+}
+
+void IPCChannelMojoTestBase::CreateChannel(IPC::Listener* listener) {
+  channel_ =
+      IPC::ChannelMojo::Create(TakeHandle(), IPC::Channel::MODE_SERVER,
+                               listener, base::ThreadTaskRunnerHandle::Get());
+}
+
+bool IPCChannelMojoTestBase::ConnectChannel() {
+  return channel_->Connect();
+}
+
+void IPCChannelMojoTestBase::DestroyChannel() {
+  channel_.reset();
+}
+
+mojo::ScopedMessagePipeHandle IPCChannelMojoTestBase::TakeHandle() {
+  return std::move(handle_);
+}
+
+IpcChannelMojoTestClient::IpcChannelMojoTestClient() = default;
+
+IpcChannelMojoTestClient::~IpcChannelMojoTestClient() = default;
+
+void IpcChannelMojoTestClient::Init(mojo::ScopedMessagePipeHandle handle) {
+  handle_ = std::move(handle);
+}
+
+void IpcChannelMojoTestClient::Connect(IPC::Listener* listener) {
+  channel_ =
+      IPC::ChannelMojo::Create(std::move(handle_), IPC::Channel::MODE_CLIENT,
+                               listener, base::ThreadTaskRunnerHandle::Get());
+  CHECK(channel_->Connect());
+}
+
+void IpcChannelMojoTestClient::Close() {
+  channel_->Close();
+
+  base::RunLoop run_loop;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                run_loop.QuitClosure());
+  run_loop.Run();
+}