Stop linking in the old Mojo EDK.

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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/base_paths.h"
+#include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/location.h"
 #include "base/path_service.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_channel_listener.h"
 #include "ipc/mojo/ipc_mojo_handle_attachment.h"
 #include "ipc/mojo/ipc_mojo_message_helper.h"
 #include "ipc/mojo/ipc_mojo_param_traits.h"
 #include "ipc/mojo/scoped_ipc_support.h"
+#include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/embedder_internal.h"
+#include "mojo/edk/embedder/platform_channel_pair.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #include "ipc/ipc_platform_file_attachment_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(main_message_loop_.task_runner(),
-                                        IPCTestBase::GetChannelName(name),
-                                        IPC::Channel::MODE_CLIENT, listener);
+    channel_ = IPC::ChannelMojo::Create(
+        mojo::edk::internal::g_io_thread_task_runner,
+        IPCTestBase::GetChannelName(name),
+        IPC::Channel::MODE_CLIENT, listener);
   }
 
   void Connect() {
     CHECK(channel_->Connect());
   }
 
   void Close() {
     channel_->Close();
 
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   run_loop.QuitClosure());
     run_loop.Run();
   }
 
   IPC::ChannelMojo* channel() const { return channel_.get(); }
 
  private:
   base::MessageLoopForIO main_message_loop_;
   scoped_ptr<IPC::ChannelMojo> channel_;
 };
 
 class IPCChannelMojoTestBase : public IPCTestBase {
  public:
   void InitWithMojo(const std::string& test_client_name) {
     Init(test_client_name);
   }
 
-  void TearDown() override {
-    // Make sure Mojo IPC support is properly shutdown on the I/O loop before
-    // TearDown continues.
-    base::RunLoop run_loop;
-    task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
-    run_loop.Run();
+  // IPCTestBase:
+  scoped_refptr<base::TaskRunner> io_task_runner() override {
+    return make_scoped_refptr(mojo::edk::internal::g_io_thread_task_runner);
+  }
 
-    IPCTestBase::TearDown();
+  void AboutToSpawnChild(base::LaunchOptions* options) override {
+#if defined(OS_POSIX)
+    base::FileHandleMappingVector* handles =
+        const_cast<base::FileHandleMappingVector*>(options->fds_to_remap);
+#else
+    base::HandlesToInheritVector* handles =
+        const_cast<base::HandlesToInheritVector*>(options->handles_to_inherit);
+#endif
+    broker_handle_ = broker_platform_channel_pair_.
+        PrepareToPassClientHandleToChildProcessAsString(handles);
   }
+
+  bool DidStartClient() override {
+    broker_platform_channel_pair_.ChildProcessLaunched();
+    ChildProcessLaunched(client_process().Handle(),
+                         broker_platform_channel_pair_.PassServerHandle());
+    return IPCTestBase::DidStartClient();
+  }
+
+  // MultiProcessTest:
+  base::CommandLine MakeCmdLine(const std::string& procname) override {
+    base::CommandLine command_line = MultiProcessTest::MakeCmdLine(procname);
+    command_line.AppendSwitchASCII("broker-handle", broker_handle_);
+    return command_line;
+  }
+
+ private:
+  // Used by the broker.
+  mojo::edk::PlatformChannelPair broker_platform_channel_pair_;
+  std::string broker_handle_;
 };
 
 class IPCChannelMojoTest : public IPCChannelMojoTestBase {
  protected:
   scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
-      base::SequencedTaskRunner* runner) override {
-    return IPC::ChannelMojo::CreateServerFactory(task_runner(), handle);
+      base::TaskRunner* runner) override {
+    return IPC::ChannelMojo::CreateServerFactory(io_task_runner(), handle);
   }
 
   bool DidStartClient() override {
-    bool ok = IPCTestBase::DidStartClient();
+    bool ok = IPCChannelMojoTestBase::DidStartClient();
     DCHECK(ok);
     return ok;
   }
 };
 
 
 class TestChannelListenerWithExtraExpectations
     : public IPC::TestChannelListener {
  public:
   TestChannelListenerWithExtraExpectations()
@@ skipping 82 matching lines @@
 
  private:
   bool has_error_;
 };
 
 
 class IPCChannelMojoErrorTest : public IPCChannelMojoTestBase {
  protected:
   scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
-      base::SequencedTaskRunner* runner) override {
-    return IPC::ChannelMojo::CreateServerFactory(task_runner(), handle);
+      base::TaskRunner* runner) override {
+    return IPC::ChannelMojo::CreateServerFactory(io_task_runner(), handle);
   }
 
   bool DidStartClient() override {
-    bool ok = IPCTestBase::DidStartClient();
+    bool ok = IPCChannelMojoTestBase::DidStartClient();
     DCHECK(ok);
     return ok;
   }
 };
 
 class ListenerThatQuits : public IPC::Listener {
  public:
   ListenerThatQuits() {
   }
 
@@ skipping 198 matching lines @@
   base::MessageLoop::current()->Run();
 
   client.Close();
 
   return 0;
 }
 
 void ReadOK(mojo::MessagePipeHandle pipe) {
   std::string should_be_ok("xx");
   uint32_t num_bytes = static_cast<uint32_t>(should_be_ok.size());
+  EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(pipe, MOJO_HANDLE_SIGNAL_READABLE,
+                                       MOJO_DEADLINE_INDEFINITE, nullptr));
   CHECK_EQ(MOJO_RESULT_OK,
            mojo::ReadMessageRaw(pipe, &should_be_ok[0], &num_bytes, nullptr,
                                 nullptr, 0));
   EXPECT_EQ(should_be_ok, std::string("OK"));
 }
 
 void WriteOK(mojo::MessagePipeHandle pipe) {
   std::string ok("OK");
   CHECK_EQ(MOJO_RESULT_OK,
            mojo::WriteMessageRaw(pipe, &ok[0], static_cast<uint32_t>(ok.size()),
@@ skipping 157 matching lines @@
   client.Close();
 
   return 0;
 }
 
 #if defined(OS_WIN)
 class IPCChannelMojoDeadHandleTest : public IPCChannelMojoTestBase {
  protected:
   scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
-      base::SequencedTaskRunner* runner) override {
-    return IPC::ChannelMojo::CreateServerFactory(task_runner(), handle);
+      base::TaskRunner* runner) override {
+    return IPC::ChannelMojo::CreateServerFactory(io_task_runner(), handle);
   }
 
   bool DidStartClient() override {
-    IPCTestBase::DidStartClient();
+    IPCChannelMojoTestBase::DidStartClient();
     // const base::ProcessHandle client = client_process().Handle();
     // Forces GetFileHandleForProcess() fail. It happens occasionally
     // in production, so we should exercise it somehow.
     // TODO(morrita): figure out how to safely test this. See crbug.com/464109.
     // ::CloseHandle(client);
     return true;
   }
 };
 
 TEST_F(IPCChannelMojoDeadHandleTest, InvalidClientHandle) {
@@ skipping 207 matching lines @@
   base::MessageLoop::current()->Run();
 
   client.Close();
 
   return 0;
 }
 
 #endif // OS_LINUX
 
 }  // namespace