Support generic synchronization against an IPC::Channel

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"
@@ skipping 152 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::ClientHandle::ClientHandle() = default;
+
+IPCChannelMojoTestBase::ClientHandle::~ClientHandle() = default;
+
+void IPCChannelMojoTestBase::ClientHandle::Init(
+    const std::string& test_client_name) {
+  pipe_ = helper_.StartChild(test_client_name);
+}
+
+void IPCChannelMojoTestBase::ClientHandle::CreateChannel(
+    IPC::Listener* listener) {
+  channel_ =
+      IPC::ChannelMojo::Create(TakeHandle(), IPC::Channel::MODE_SERVER,
+                               listener, base::ThreadTaskRunnerHandle::Get());
+}
+
+bool IPCChannelMojoTestBase::ClientHandle::ConnectChannel() {
+  return channel_->Connect();
+}
+
+void IPCChannelMojoTestBase::ClientHandle::DestroyChannel() {
+  channel_.reset();
+}
+
+bool IPCChannelMojoTestBase::ClientHandle::WaitForShutdown() {
+  return helper_.WaitForChildTestShutdown();
+}
+
+mojo::ScopedMessagePipeHandle
+IPCChannelMojoTestBase::ClientHandle::TakeHandle() {
+  return std::move(pipe_);
+}
+
 IPCChannelMojoTestBase::IPCChannelMojoTestBase() = default;
+
 IPCChannelMojoTestBase::~IPCChannelMojoTestBase() = default;
 
 void IPCChannelMojoTestBase::Init(const std::string& test_client_name) {
-  handle_ = helper_.StartChild(test_client_name);
+  primary_client_.Init(test_client_name);
 }
 
 bool IPCChannelMojoTestBase::WaitForClientShutdown() {
-  return helper_.WaitForChildTestShutdown();
+  return primary_client_.WaitForShutdown();
 }
 
 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());
+  primary_client_.CreateChannel(listener);
 }
 
 bool IPCChannelMojoTestBase::ConnectChannel() {
-  return channel_->Connect();
+  return primary_client_.ConnectChannel();
 }
 
 void IPCChannelMojoTestBase::DestroyChannel() {
-  channel_.reset();
+  return primary_client_.DestroyChannel();
 }
 
 mojo::ScopedMessagePipeHandle IPCChannelMojoTestBase::TakeHandle() {
-  return std::move(handle_);
+  return primary_client_.TakeHandle();
 }
 
 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();
 }