Add a thread-safe CreateChannel method to ChannelManager.

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/atomicops.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 29 matching lines @@
   // Don't allow the counter to wrap. Note that any (strictly) positive value is
   // a valid |ChannelId| (and |NoBarrier_AtomicIncrement()| returns the value
   // post-increment).
   CHECK_GT(new_counter_value, 0);
   // Use "negative" values for these IDs, so that we'll also be able to use
   // "positive" "process identifiers" (see connection_manager.h) as IDs (and
   // they won't conflict).
   return static_cast<system::ChannelId>(-new_counter_value);
 }
 
-// Helper for |CreateChannel()|. Called on the channel creation thread.
-void CreateChannelHelper(
-    ScopedPlatformHandle platform_handle,
-    scoped_ptr<ChannelInfo> channel_info,
-    scoped_refptr<system::ChannelEndpoint> channel_endpoint,
-    DidCreateChannelCallback callback,
-    scoped_refptr<base::TaskRunner> callback_thread_task_runner) {
-  channel_info->channel_id = MakeChannelId();
-  internal::g_channel_manager->CreateChannelOnIOThread(
-      channel_info->channel_id, platform_handle.Pass(), channel_endpoint);
-
-  // 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());
-  }
-}
-
 }  // namespace
 
 namespace internal {
 
 // Declared in embedder_internal.h.
 PlatformSupport* g_platform_support = nullptr;
 system::Core* g_core = nullptr;
 system::ChannelManager* g_channel_manager = nullptr;
 
 }  // namespace internal
@@ skipping 52 matching lines @@
       system::MessagePipeDispatcher::CreateRemoteMessagePipe(&channel_endpoint);
 
   DCHECK(internal::g_core);
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher)));
 
   // We'll have to set |channel_info->channel_id| on the I/O thread.
   scoped_ptr<ChannelInfo> channel_info(new ChannelInfo());
 
   if (rv.is_valid()) {
-    io_thread_task_runner->PostTask(
-        FROM_HERE,
-        base::Bind(&CreateChannelHelper, base::Passed(&platform_handle),
-                   base::Passed(&channel_info), channel_endpoint, callback,
-                   callback_thread_task_runner));
+    channel_info->channel_id = MakeChannelId();
+    internal::g_channel_manager->CreateChannel(
+        channel_info->channel_id, platform_handle.Pass(), channel_endpoint,
+        io_thread_task_runner,
+        base::Bind(callback, base::Unretained(channel_info.release())),
+        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()));
   }
 
   return rv.Pass();
 }
 
 // TODO(vtl): Write tests for this.
@@ skipping 54 matching lines @@
 }
 
 MojoResult AsyncWait(MojoHandle handle,
                      MojoHandleSignals signals,
                      base::Callback<void(MojoResult)> callback) {
   return internal::g_core->AsyncWait(handle, signals, callback);
 }
 
 }  // namespace embedder
 }  // namespace mojo