Mojo: Make Core own a PlatformSupport, and plumb it through to Channel.

mojo/system/multiprocess_message_pipe_unittest.cc

 // Copyright 2013 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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
@@ skipping 24 matching lines @@
 #include "mojo/system/test_utils.h"
 #include "mojo/system/waiter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
 class ChannelThread {
  public:
-  ChannelThread() : test_io_thread_(test::TestIOThread::kManualStart) {}
+  explicit ChannelThread(embedder::PlatformSupport* platform_support)
+      : platform_support_(platform_support),
+        test_io_thread_(test::TestIOThread::kManualStart) {}
   ~ChannelThread() { Stop(); }
 
   void Start(embedder::ScopedPlatformHandle platform_handle,
              scoped_refptr<MessagePipe> message_pipe) {
     test_io_thread_.Start();
     test_io_thread_.PostTaskAndWait(
         FROM_HERE,
         base::Bind(&ChannelThread::InitChannelOnIOThread,
                    base::Unretained(this),
                    base::Passed(&platform_handle),
@@ skipping 16 matching lines @@
     test_io_thread_.Stop();
   }
 
  private:
   void InitChannelOnIOThread(embedder::ScopedPlatformHandle platform_handle,
                              scoped_refptr<MessagePipe> message_pipe) {
     CHECK_EQ(base::MessageLoop::current(), test_io_thread_.message_loop());
     CHECK(platform_handle.is_valid());
 
     // Create and initialize |Channel|.
-    channel_ = new Channel();
+    channel_ = new Channel(platform_support_);
     CHECK(channel_->Init(RawChannel::Create(platform_handle.Pass())));
 
     // Attach the message pipe endpoint.
     // Note: On the "server" (parent process) side, we need not attach the
     // message pipe endpoint immediately. However, on the "client" (child
     // process) side, this *must* be done here -- otherwise, the |Channel| may
     // receive/process messages (which it can do as soon as it's hooked up to
     // the IO thread message loop, and that message loop runs) before the
     // message pipe endpoint is attached.
     CHECK_EQ(channel_->AttachMessagePipeEndpoint(message_pipe, 1),
              Channel::kBootstrapEndpointId);
     CHECK(channel_->RunMessagePipeEndpoint(Channel::kBootstrapEndpointId,
                                            Channel::kBootstrapEndpointId));
   }
 
   void ShutdownChannelOnIOThread() {
     CHECK(channel_);
     channel_->Shutdown();
     channel_ = NULL;
   }
 
+  embedder::PlatformSupport* const platform_support_;
   test::TestIOThread test_io_thread_;
   scoped_refptr<Channel> channel_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelThread);
 };
 
 class MultiprocessMessagePipeTest : public testing::Test {
  public:
-  MultiprocessMessagePipeTest() {}
+  MultiprocessMessagePipeTest() : channel_thread_(&platform_support_) {}
   virtual ~MultiprocessMessagePipeTest() {}
 
  protected:
   void Init(scoped_refptr<MessagePipe> mp) {
     channel_thread_.Start(helper_.server_platform_handle.Pass(), mp);
   }
 
+  embedder::PlatformSupport* platform_support() { return &platform_support_; }
   mojo::test::MultiprocessTestHelper* helper() { return &helper_; }
 
  private:
+  embedder::SimplePlatformSupport platform_support_;
   ChannelThread channel_thread_;
   mojo::test::MultiprocessTestHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiprocessMessagePipeTest);
 };
 
 MojoResult WaitIfNecessary(scoped_refptr<MessagePipe> mp,
                            MojoHandleSignals signals,
                            HandleSignalsState* signals_state) {
   Waiter waiter;
   waiter.Init();
 
   MojoResult add_result = mp->AddWaiter(0, &waiter, signals, 0, signals_state);
   if (add_result != MOJO_RESULT_OK) {
     return (add_result == MOJO_RESULT_ALREADY_EXISTS) ? MOJO_RESULT_OK
                                                       : add_result;
   }
 
   MojoResult wait_result = waiter.Wait(MOJO_DEADLINE_INDEFINITE, NULL);
   mp->RemoveWaiter(0, &waiter, signals_state);
   return wait_result;
 }
 
 // For each message received, sends a reply message with the same contents
 // repeated twice, until the other end is closed or it receives "quitquitquit"
 // (which it doesn't reply to). It'll return the number of messages received,
 // not including any "quitquitquit" message, modulo 100.
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
-  ChannelThread channel_thread;
+  embedder::SimplePlatformSupport platform_support;
+  ChannelThread channel_thread(&platform_support);
   embedder::ScopedPlatformHandle client_platform_handle =
       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
   CHECK(client_platform_handle.is_valid());
   scoped_refptr<MessagePipe> mp(new MessagePipe(
       scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
   channel_thread.Start(client_platform_handle.Pass(), mp);
 
   const std::string quitquitquit("quitquitquit");
   int rv = 0;
@@ skipping 148 matching lines @@
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   mp->Close(0);
 
   EXPECT_EQ(static_cast<int>(kNumMessages % 100),
             helper()->WaitForChildShutdown());
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
-  ChannelThread channel_thread;
+  embedder::SimplePlatformSupport platform_support;
+  ChannelThread channel_thread(&platform_support);
   embedder::ScopedPlatformHandle client_platform_handle =
       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
   CHECK(client_platform_handle.is_valid());
   scoped_refptr<MessagePipe> mp(new MessagePipe(
       scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
   channel_thread.Start(client_platform_handle.Pass(), mp);
 
   // Wait for the first message from our parent.
   HandleSignalsState hss;
@@ skipping 90 matching lines @@
 #endif
 TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
   helper()->StartChild("CheckSharedBuffer");
 
   scoped_refptr<MessagePipe> mp(new MessagePipe(
       scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
   Init(mp);
 
   // Make a shared buffer.
-  embedder::SimplePlatformSupport platform_support;
   scoped_refptr<SharedBufferDispatcher> dispatcher;
   EXPECT_EQ(MOJO_RESULT_OK,
             SharedBufferDispatcher::Create(
-                &platform_support,
+                platform_support(),
                 SharedBufferDispatcher::kDefaultCreateOptions,
                 100,
                 &dispatcher));
   ASSERT_TRUE(dispatcher);
 
   // Make a mapping.
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
   ASSERT_TRUE(mapping);
@@ skipping 62 matching lines @@
             WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   mp->Close(0);
 
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) {
-  ChannelThread channel_thread;
+  embedder::SimplePlatformSupport platform_support;
+  ChannelThread channel_thread(&platform_support);
   embedder::ScopedPlatformHandle client_platform_handle =
       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
   CHECK(client_platform_handle.is_valid());
   scoped_refptr<MessagePipe> mp(new MessagePipe(
       scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
   channel_thread.Start(client_platform_handle.Pass(), mp);
 
   HandleSignalsState hss;
   CHECK_EQ(WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
@@ skipping 94 matching lines @@
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   mp->Close(0);
 
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo