IPC::ChannelMojo: Introduce IPC::MojoBootstrap for Windows

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 "build/build_config.h"
 
 #include "ipc/ipc_test_base.h"
 
 #include "base/command_line.h"
 #include "base/process/kill.h"
@@ skipping 34 matching lines @@
     scoped_ptr<base::MessageLoop> message_loop) {
   DCHECK(!test_client_name.empty());
   DCHECK(test_client_name_.empty());
   DCHECK(!message_loop_);
 
   test_client_name_ = test_client_name;
   message_loop_ = message_loop.Pass();
 }
 
 void IPCTestBase::CreateChannel(IPC::Listener* listener) {
-  CreateChannelFromChannelHandle(
-      GetChannelName(test_client_name_), listener);
+  CreateChannelFromChannelHandle(GetTestChannelHandle(), listener);
 }
 
 bool IPCTestBase::ConnectChannel() {
   CHECK(channel_.get());
   return channel_->Connect();
 }
 
 scoped_ptr<IPC::Channel> IPCTestBase::ReleaseChannel() {
   return channel_.Pass();
 }
@@ skipping 16 matching lines @@
   channel_ = CreateChannelFactory(
       channel_handle, task_runner().get())->BuildChannel(listener);
 }
 
 void IPCTestBase::CreateChannelProxy(
     IPC::Listener* listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   CHECK(!channel_.get());
   CHECK(!channel_proxy_.get());
   channel_proxy_ = IPC::ChannelProxy::Create(
-      CreateChannelFactory(GetChannelName(test_client_name_),
-                           ipc_task_runner.get()),
+      CreateChannelFactory(GetTestChannelHandle(), ipc_task_runner.get()),
       listener,
       ipc_task_runner);
 }
 
 void IPCTestBase::DestroyChannelProxy() {
   CHECK(channel_proxy_.get());
   channel_proxy_.reset();
 }
 
 bool IPCTestBase::StartClient() {
+  CHECK(channel_ || channel_proxy_);
+#if defined(OS_WIN)
+  return StartClientInternal(0);

[viettrungluu, 2014/09/15 22:37:27]

I don't know if I'm a huge fan of this.

I'd like something like:

#if defined(OS_WIN)
// definition for StartClient()
#elif define(OS_POSIX)
// definition for StartClient, just calling StartClientWithFD
// definition for StartClientWithFD
#endif

The only question is how to reasonably share code between the Windows and POSIX
cases.

I suppose this is just test code, so I'm not going to get to hung up about it
though.

[Hajime Morrita, 2014/09/15 23:51:32]

Tried this and now looks simpler. Thanks for the suggestion! 

+#elif defined(OS_POSIX)
+  return StartClientInternal(
+      channel_
+      ? channel_->GetClientFileDescriptor()
+      : channel_proxy_->GetClientFileDescriptor());
+#else
+  NOTREACHED();
+  return false;
+#endif
+}
+
+#if defined(OS_POSIX)
+bool IPCTestBase::StartClientWithFD(int ipcfd) {
+  return StartClientInternal(ipcfd);
+}
+#endif
+
+bool IPCTestBase::StartClientInternal(int ipcfd) {
   DCHECK(client_process_ == base::kNullProcessHandle);

[viettrungluu, 2014/09/15 22:37:27]

DCHECK_EQ here too

[Hajime Morrita, 2014/09/15 23:51:32]

Done.

 
   std::string test_main = test_client_name_ + "TestClientMain";
 
 #if defined(OS_WIN)
   client_process_ = SpawnChild(test_main);
 #elif defined(OS_POSIX)
   base::FileHandleMappingVector fds_to_map;
-  const int ipcfd = channel_.get()
-      ? channel_->GetClientFileDescriptor()
-      : channel_proxy_->GetClientFileDescriptor();
   if (ipcfd > -1)
     fds_to_map.push_back(std::pair<int, int>(ipcfd,
         kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
   base::LaunchOptions options;
   options.fds_to_remap = &fds_to_map;
   client_process_ = SpawnChildWithOptions(test_main, options);
 #endif
 
+  if (channel_)
+    channel_->OnClientLaunched(client_process_);

[viettrungluu, 2014/09/15 22:37:27]

It seems dubious to call these even when client_process_ is the null process
handle, no?

[Hajime Morrita, 2014/09/15 23:51:32]

True. Added DCHECK() as there are no cases where the handle should be null.

+  if (channel_proxy_)
+    channel_proxy_->OnClientLaunched(client_process_);
+
   return client_process_ != base::kNullProcessHandle;
 }
 
 bool IPCTestBase::WaitForClientShutdown() {
   DCHECK(client_process_ != base::kNullProcessHandle);
 
   bool rv = base::WaitForSingleProcess(client_process_,
                                        base::TimeDelta::FromSeconds(5));
   base::CloseProcessHandle(client_process_);
   client_process_ = base::kNullProcessHandle;
   return rv;
 }
 
+IPC::ChannelHandle IPCTestBase::GetTestChannelHandle() {
+  return GetChannelName(test_client_name_);
+}
+
 scoped_refptr<base::TaskRunner> IPCTestBase::task_runner() {
   return message_loop_->message_loop_proxy();
 }
 
 scoped_ptr<IPC::ChannelFactory> IPCTestBase::CreateChannelFactory(
     const IPC::ChannelHandle& handle,
     base::TaskRunner* runner) {
   return IPC::ChannelFactory::Create(handle, IPC::Channel::MODE_SERVER);
 }