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

mojo/embedder/embedder.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 "mojo/embedder/embedder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 20 matching lines @@
 
   // May be null, in which case |DestroyChannelOnIOThread()| must be used (from
   // the IO thread), instead of |DestroyChannel()|.
   scoped_refptr<base::TaskRunner> io_thread_task_runner;
 };
 
 namespace {
 
 // Helper for |CreateChannel...()|. (Note: May return null for some failures.)
 scoped_refptr<system::Channel> MakeChannel(
+    system::Core* core,
     ScopedPlatformHandle platform_handle,
     scoped_refptr<system::MessagePipe> message_pipe) {
   DCHECK(platform_handle.is_valid());
 
   // Create and initialize a |system::Channel|.
-  scoped_refptr<system::Channel> channel = new system::Channel();
+  scoped_refptr<system::Channel> channel =
+      new system::Channel(core->platform_support());
   if (!channel->Init(system::RawChannel::Create(platform_handle.Pass()))) {
     // This is very unusual (e.g., maybe |platform_handle| was invalid or we
     // reached some system resource limit).
     LOG(ERROR) << "Channel::Init() failed";
     // Return null, since |Shutdown()| shouldn't be called in this case.
     return scoped_refptr<system::Channel>();
   }
   // Once |Init()| has succeeded, we have to return |channel| (since
   // |Shutdown()| will have to be called on it).
 
@@ skipping 12 matching lines @@
                                        system::Channel::kBootstrapEndpointId)) {
     // Currently, there's no reason for this to fail.
     NOTREACHED() << "Channel::RunMessagePipeEndpoint() failed";
     return channel;
   }
 
   return channel;
 }
 
 void CreateChannelHelper(
+    system::Core* core,
     ScopedPlatformHandle platform_handle,
     scoped_ptr<ChannelInfo> channel_info,
     scoped_refptr<system::MessagePipe> message_pipe,
     DidCreateChannelCallback callback,
     scoped_refptr<base::TaskRunner> callback_thread_task_runner) {
-  channel_info->channel = MakeChannel(platform_handle.Pass(), message_pipe);
+  channel_info->channel =
+      MakeChannel(core, platform_handle.Pass(), message_pipe);
 
   // Hand the channel back to the embedder.
   if (callback_thread_task_runner) {
     callback_thread_task_runner->PostTask(
         FROM_HERE, base::Bind(callback, channel_info.release()));
   } else {
     callback.Run(channel_info.release());
   }
 }
 
@@ skipping 14 matching lines @@
             scoped_refptr<system::MessagePipe> > remote_message_pipe =
       system::MessagePipeDispatcher::CreateRemoteMessagePipe();
 
   system::Core* core = system::entrypoints::GetCore();
   DCHECK(core);
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(core->AddDispatcher(remote_message_pipe.first)));
 
   *channel_info = new ChannelInfo();
   (*channel_info)->channel =
-      MakeChannel(platform_handle.Pass(), remote_message_pipe.second);
+      MakeChannel(core, platform_handle.Pass(), remote_message_pipe.second);
 
   return rv.Pass();
 }
 
 ScopedMessagePipeHandle CreateChannel(
     ScopedPlatformHandle platform_handle,
     scoped_refptr<base::TaskRunner> io_thread_task_runner,
     DidCreateChannelCallback callback,
     scoped_refptr<base::TaskRunner> callback_thread_task_runner) {
   DCHECK(platform_handle.is_valid());
 
   std::pair<scoped_refptr<system::MessagePipeDispatcher>,
             scoped_refptr<system::MessagePipe> > remote_message_pipe =
       system::MessagePipeDispatcher::CreateRemoteMessagePipe();
 
   system::Core* core = system::entrypoints::GetCore();
   DCHECK(core);
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(core->AddDispatcher(remote_message_pipe.first)));
 
   scoped_ptr<ChannelInfo> channel_info(new ChannelInfo());
   channel_info->io_thread_task_runner = io_thread_task_runner;
 
   if (rv.is_valid()) {
     io_thread_task_runner->PostTask(FROM_HERE,
                                     base::Bind(&CreateChannelHelper,
+                                               base::Unretained(core),
                                                base::Passed(&platform_handle),
                                                base::Passed(&channel_info),
                                                remote_message_pipe.second,
                                                callback,
                                                callback_thread_task_runner));
   } else {
     (callback_thread_task_runner ? callback_thread_task_runner
                                  : io_thread_task_runner)
         ->PostTask(FROM_HERE, base::Bind(callback, channel_info.release()));
   }
@@ skipping 69 matching lines @@
 
   *platform_handle =
       static_cast<system::PlatformHandleDispatcher*>(dispatcher.get())
           ->PassPlatformHandle()
           .Pass();
   return MOJO_RESULT_OK;
 }
 
 }  // namespace embedder
 }  // namespace mojo