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

ipc/mojo/ipc_channel_mojo_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 "ipc/mojo/ipc_channel_mojo.h"
 
 #include "base/base_paths.h"
 #include "base/files/file.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_channel_listener.h"
+#include "ipc/mojo/ipc_channel_mojo_host.h"
 #include "ipc/mojo/ipc_channel_mojo_readers.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #endif
 
 namespace {
 
 class ListenerThatExpectsOK : public IPC::Listener {
  public:
@@ skipping 26 matching lines @@
     ASSERT_TRUE(sender->Send(message));
   }
 
  private:
   bool received_ok_;
 };
 
 class ChannelClient {
  public:
   explicit ChannelClient(IPC::Listener* listener, const char* name) {
-    channel_ = IPC::ChannelMojo::Create(
-        IPCTestBase::GetChannelName(name), IPC::Channel::MODE_CLIENT, listener,
-        main_message_loop_.message_loop_proxy());
+    channel_ = IPC::ChannelMojo::Create(NULL,
+                                        IPCTestBase::GetChannelName(name),
+                                        IPC::Channel::MODE_CLIENT,
+                                        listener);
   }
 
   void Connect() {
     CHECK(channel_->Connect());
   }
 
   IPC::ChannelMojo* channel() const { return channel_.get(); }
 
  private:
+  base::MessageLoopForIO main_message_loop_;
   scoped_ptr<IPC::ChannelMojo> channel_;
-  base::MessageLoopForIO main_message_loop_;
 };
 
 class IPCChannelMojoTest : public IPCTestBase {
  protected:
   virtual scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::TaskRunner* runner) OVERRIDE {
-    return IPC::ChannelMojo::CreateFactory(
-        handle, IPC::Channel::MODE_SERVER, runner);
+    host_.reset(new IPC::ChannelMojoHost(task_runner()));
+    return IPC::ChannelMojo::CreateServerFactory(host_.get(), handle);
   }
+
+  virtual bool DidStartClient() OVERRIDE {
+    bool ok = IPCTestBase::DidStartClient();
+    DCHECK(ok);
+    host_->OnClientLaunched(client_process());
+    return ok;
+  }
+
+ private:
+  scoped_ptr<IPC::ChannelMojoHost> host_;
 };
 
 
 class TestChannelListenerWithExtraExpectations
     : public IPC::TestChannelListener {
  public:
   TestChannelListenerWithExtraExpectations()
       : is_connected_called_(false) {
   }
 
@@ skipping 46 matching lines @@
   base::MessageLoop::current()->Run();
   EXPECT_TRUE(listener.is_connected_called());
   EXPECT_TRUE(listener.HasSentAll());
 
   return 0;
 }
 
 // Close given handle before use to simulate an error.
 class ErraticChannelMojo : public IPC::ChannelMojo {
  public:
-  ErraticChannelMojo(
-      const IPC::ChannelHandle& channel_handle,
-      IPC::Channel::Mode mode,
-      IPC::Listener* listener,
-      scoped_refptr<base::TaskRunner> runner)
-      : ChannelMojo(channel_handle, mode, listener, runner) {
-  }
+  ErraticChannelMojo(IPC::ChannelMojoHost* host,
+                     const IPC::ChannelHandle& channel_handle,
+                     IPC::Channel::Mode mode,
+                     IPC::Listener* listener,
+                     scoped_refptr<base::TaskRunner> runner)
+      : ChannelMojo(host, channel_handle, mode, listener) {}
 
   virtual void OnConnected(mojo::ScopedMessagePipeHandle pipe) {
     MojoClose(pipe.get().value());
     OnConnected(pipe.Pass());
   }
 };
 
 // Exists to create ErraticChannelMojo.
 class ErraticChannelFactory : public IPC::ChannelFactory {
  public:
-  explicit ErraticChannelFactory(
-      const IPC::ChannelHandle& handle,
-      base::TaskRunner* runner)
-      : handle_(handle), runner_(runner) {
-  }
+  explicit ErraticChannelFactory(IPC::ChannelMojoHost* host,
+                                 const IPC::ChannelHandle& handle,
+                                 base::TaskRunner* runner)
+      : host_(host), handle_(handle), runner_(runner) {}
 
   virtual std::string GetName() const OVERRIDE {
     return "";
   }
 
   virtual scoped_ptr<IPC::Channel> BuildChannel(
       IPC::Listener* listener) OVERRIDE {
-    return scoped_ptr<IPC::Channel>(
-        new ErraticChannelMojo(
-            handle_, IPC::Channel::MODE_SERVER, listener, runner_));
+    return scoped_ptr<IPC::Channel>(new ErraticChannelMojo(
+        host_, handle_, IPC::Channel::MODE_SERVER, listener, runner_));
   }
 
  private:
+  IPC::ChannelMojoHost* host_;
   IPC::ChannelHandle handle_;
   scoped_refptr<base::TaskRunner> runner_;
 };
 
 class ListenerExpectingErrors : public IPC::Listener {
  public:
   ListenerExpectingErrors()
       : has_error_(false) {
   }
 
@@ skipping 11 matching lines @@
  private:
   bool has_error_;
 };
 
 
 class IPCChannelMojoErrorTest : public IPCTestBase {
  protected:
   virtual scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::TaskRunner* runner) OVERRIDE {
+    host_.reset(new IPC::ChannelMojoHost(task_runner()));
     return scoped_ptr<IPC::ChannelFactory>(
-        new ErraticChannelFactory(handle, runner));
+        new ErraticChannelFactory(host_.get(), handle, runner));
   }
+
+  virtual bool DidStartClient() OVERRIDE {
+    bool ok = IPCTestBase::DidStartClient();
+    DCHECK(ok);
+    host_->OnClientLaunched(client_process());
+    return ok;
+  }
+
+ private:
+  scoped_ptr<IPC::ChannelMojoHost> host_;
 };
 
 class ListenerThatQuits : public IPC::Listener {
  public:
   ListenerThatQuits() {
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     return true;
   }
@@ skipping 121 matching lines @@
   client.Connect();
   listener.set_sender(client.channel());
 
   base::MessageLoop::current()->Run();
 
   return 0;
 }
 #endif
 
 }  // namespace