ipc/ipc_test_base.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "build/build_config.h"
   6
   7 #include "ipc/ipc_test_base.h"
   8
   9 #include "base/command_line.h"
  10 #include "base/debug/debug_on_start_win.h"
  11 #include "base/process/kill.h"
  12 #include "base/threading/thread.h"
  13 #include "base/time/time.h"
  14 #include "ipc/ipc_descriptors.h"
  15 #include "ipc/ipc_switches.h"
  16
  17 // static
  18 std::string IPCTestBase::GetChannelName(const std::string& test_client_name) {
  19   DCHECK(!test_client_name.empty());
  20   return test_client_name + "__Channel";
  21 }
  22
  23 IPCTestBase::IPCTestBase()
  24     : client_process_(base::kNullProcessHandle) {
  25 }
  26
  27 IPCTestBase::~IPCTestBase() {
  28 }
  29
  30 void IPCTestBase::SetUp() {
  31   MultiProcessTest::SetUp();
  32
  33   // Construct a fresh IO Message loop for the duration of each test.
  34   DCHECK(!message_loop_.get());
  35   message_loop_.reset(new base::MessageLoopForIO());
  36 }
  37
  38 void IPCTestBase::TearDown() {
  39   DCHECK(message_loop_.get());
  40   message_loop_.reset();
  41   MultiProcessTest::TearDown();
  42 }
  43
  44 void IPCTestBase::Init(const std::string& test_client_name) {
  45   DCHECK(!test_client_name.empty());
  46   DCHECK(test_client_name_.empty());
  47   test_client_name_ = test_client_name;
  48 }
  49
  50 void IPCTestBase::CreateChannel(IPC::Listener* listener) {
  51   return CreateChannelFromChannelHandle(GetChannelName(test_client_name_),
  52                                         listener);
  53 }
  54
  55 bool IPCTestBase::ConnectChannel() {
  56   CHECK(channel_.get());
  57   return channel_->Connect();
  58 }
  59
  60 void IPCTestBase::DestroyChannel() {
  61   DCHECK(channel_.get());
  62   channel_.reset();
  63 }
  64
  65 void IPCTestBase::CreateChannelFromChannelHandle(
  66     const IPC::ChannelHandle& channel_handle,
  67     IPC::Listener* listener) {
  68   CHECK(!channel_.get());
  69   CHECK(!channel_proxy_.get());
  70   channel_.reset(new IPC::Channel(channel_handle,
  71                                   IPC::Channel::MODE_SERVER,
  72                                   listener));
  73 }
  74
  75 void IPCTestBase::CreateChannelProxy(
  76     IPC::Listener* listener,
  77     base::SingleThreadTaskRunner* ipc_task_runner) {
  78   CHECK(!channel_.get());
  79   CHECK(!channel_proxy_.get());
  80   channel_proxy_.reset(new IPC::ChannelProxy(GetChannelName(test_client_name_),
  81                                              IPC::Channel::MODE_SERVER,
  82                                              listener,
  83                                              ipc_task_runner));
  84 }
  85
  86 void IPCTestBase::DestroyChannelProxy() {
  87   CHECK(channel_proxy_.get());
  88   channel_proxy_.reset();
  89 }
  90
  91 bool IPCTestBase::StartClient() {
  92   DCHECK(client_process_ == base::kNullProcessHandle);
  93
  94   std::string test_main = test_client_name_ + "TestClientMain";
  95   bool debug_on_start =
  96       CommandLine::ForCurrentProcess()->HasSwitch(switches::kDebugChildren);
  97
  98 #if defined(OS_WIN)
  99   client_process_ = MultiProcessTest::SpawnChild(test_main, debug_on_start);
 100 #elif defined(OS_POSIX)
 101   base::FileHandleMappingVector fds_to_map;
 102   const int ipcfd = channel_.get() ? channel_->GetClientFileDescriptor() :
 103                                      channel_proxy_->GetClientFileDescriptor();
 104   if (ipcfd > -1)
 105     fds_to_map.push_back(std::pair<int, int>(ipcfd, kPrimaryIPCChannel + 3));
 106
 107   client_process_ = MultiProcessTest::SpawnChild(test_main,
 108                                                  fds_to_map,
 109                                                  debug_on_start);
 110 #endif
 111
 112   return client_process_ != base::kNullProcessHandle;
 113 }
 114
 115 bool IPCTestBase::WaitForClientShutdown() {
 116   DCHECK(client_process_ != base::kNullProcessHandle);
 117
 118   bool rv = base::WaitForSingleProcess(client_process_,
 119                                        base::TimeDelta::FromSeconds(5));
 120   base::CloseProcessHandle(client_process_);
 121   client_process_ = base::kNullProcessHandle;
 122   return rv;
 123 }