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

mojo/system/remote_message_pipe_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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <vector>
 
@@ skipping 76 matching lines @@
                    mp));
   }
 
   void RestoreInitialState() {
     io_thread_.PostTaskAndWait(
         FROM_HERE,
         base::Bind(&RemoteMessagePipeTest::RestoreInitialStateOnIOThread,
                    base::Unretained(this)));
   }
 
+  embedder::PlatformSupport* platform_support() { return &platform_support_; }
   test::TestIOThread* io_thread() { return &io_thread_; }
 
  private:
   void SetUpOnIOThread() {
     CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop());
 
     embedder::PlatformChannelPair channel_pair;
     platform_handles_[0] = channel_pair.PassServerHandle();
     platform_handles_[1] = channel_pair.PassClientHandle();
   }
 
   void TearDownOnIOThread() {
     CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop());
 
     if (channels_[0]) {
       channels_[0]->Shutdown();
       channels_[0] = NULL;
     }
     if (channels_[1]) {
       channels_[1]->Shutdown();
       channels_[1] = NULL;
     }
   }
 
   void CreateAndInitChannel(unsigned channel_index) {
     CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop());
     CHECK(channel_index == 0 || channel_index == 1);
     CHECK(!channels_[channel_index]);
 
-    channels_[channel_index] = new Channel();
+    channels_[channel_index] = new Channel(&platform_support_);
     CHECK(channels_[channel_index]->Init(
         RawChannel::Create(platform_handles_[channel_index].Pass())));
   }
 
   void ConnectMessagePipesOnIOThread(scoped_refptr<MessagePipe> mp0,
                                      scoped_refptr<MessagePipe> mp1) {
     CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop());
 
     if (!channels_[0])
       CreateAndInitChannel(0);
@@ skipping 27 matching lines @@
         Channel::kBootstrapEndpointId, Channel::kBootstrapEndpointId));
   }
 
   void RestoreInitialStateOnIOThread() {
     CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop());
 
     TearDownOnIOThread();
     SetUpOnIOThread();
   }
 
+  embedder::SimplePlatformSupport platform_support_;
   test::TestIOThread io_thread_;
   embedder::ScopedPlatformHandle platform_handles_[2];
   scoped_refptr<Channel> channels_[2];
 
   DISALLOW_COPY_AND_ASSIGN(RemoteMessagePipeTest);
 };
 
 TEST_F(RemoteMessagePipeTest, Basic) {
   static const char kHello[] = "hello";
   static const char kWorld[] = "world!!!1!!!1!";
@@ skipping 511 matching lines @@
 
   scoped_refptr<MessagePipe> mp0(new MessagePipe(
       scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
   scoped_refptr<MessagePipe> mp1(new MessagePipe(
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
       scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
   ConnectMessagePipes(mp0, mp1);
 
   // We'll try to pass this dispatcher.
-  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> mapping0;
   EXPECT_EQ(
       MOJO_RESULT_OK,
       dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
@@ skipping 247 matching lines @@
 
     mp1->Close(1);
 
     RestoreInitialState();
   }
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo