Update mojo sdk to rev 04a510fb37db10642e156957f9b2c11c2f6442ac

mojo/edk/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/edk/embedder/embedder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
+#include "mojo/edk/system/channel_info.h"
 #include "mojo/edk/system/core.h"
 #include "mojo/edk/system/entrypoints.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/raw_channel.h"
 
 namespace mojo {
 namespace embedder {
 
-// This is defined here (instead of a header file), since it's opaque to the
-// outside world. But we need to define it before our (internal-only) functions
-// that use it.
-struct ChannelInfo {
-  ChannelInfo() {}
-  ~ChannelInfo() {}
-
-  scoped_refptr<system::Channel> channel;
-
-  // 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::ChannelEndpoint> channel_endpoint) {
   DCHECK(platform_handle.is_valid());
 
   // Create and initialize a |system::Channel|.
@@ skipping 47 matching lines @@
 
   scoped_refptr<system::ChannelEndpoint> channel_endpoint;
   scoped_refptr<system::MessagePipeDispatcher> dispatcher =
       system::MessagePipeDispatcher::CreateRemoteMessagePipe(&channel_endpoint);
 
   system::Core* core = system::entrypoints::GetCore();
   DCHECK(core);
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(core->AddDispatcher(dispatcher)));
 
-  *channel_info = new ChannelInfo();
-  (*channel_info)->channel =
-      MakeChannel(core, platform_handle.Pass(), channel_endpoint);
+  *channel_info = new ChannelInfo(
+      MakeChannel(core, platform_handle.Pass(), channel_endpoint),
+      base::MessageLoopProxy::current());
 
   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());
+  DCHECK(io_thread_task_runner.get());
+  DCHECK(!callback.is_null());
 
   scoped_refptr<system::ChannelEndpoint> channel_endpoint;
   scoped_refptr<system::MessagePipeDispatcher> dispatcher =
       system::MessagePipeDispatcher::CreateRemoteMessagePipe(&channel_endpoint);
 
   system::Core* core = system::entrypoints::GetCore();
   DCHECK(core);
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(core->AddDispatcher(dispatcher)));
 
   scoped_ptr<ChannelInfo> channel_info(new ChannelInfo());
-  channel_info->io_thread_task_runner = io_thread_task_runner;
+  // We'll have to set |channel_info->channel| on the I/O thread.
+  channel_info->channel_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),
                                                channel_endpoint,
                                                callback,
                                                callback_thread_task_runner));
@@ skipping 13 matching lines @@
     return;
   }
 
   channel_info->channel->Shutdown();
   delete channel_info;
 }
 
 // TODO(vtl): Write tests for this.
 void DestroyChannel(ChannelInfo* channel_info) {
   DCHECK(channel_info);
-  DCHECK(channel_info->io_thread_task_runner.get());
+  DCHECK(channel_info->channel_thread_task_runner.get());
 
   if (!channel_info->channel.get()) {
     // Presumably, |Init()| on the channel failed.
     return;
   }
 
   channel_info->channel->WillShutdownSoon();
-  channel_info->io_thread_task_runner->PostTask(
+  channel_info->channel_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(&DestroyChannelOnIOThread, channel_info));
 }
 
 void WillDestroyChannelSoon(ChannelInfo* channel_info) {
   DCHECK(channel_info);
   channel_info->channel->WillShutdownSoon();
 }
 
 MojoResult CreatePlatformHandleWrapper(
     ScopedPlatformHandle platform_handle,
@@ skipping 32 matching lines @@
 
   *platform_handle =
       static_cast<system::PlatformHandleDispatcher*>(dispatcher.get())
           ->PassPlatformHandle()
           .Pass();
   return MOJO_RESULT_OK;
 }
 
 }  // namespace embedder
 }  // namespace mojo