Revert of Update mojo sdk to rev 8af2ccff2eee4bfca1043015abee30482a030b30

third_party/mojo/src/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"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "mojo/edk/embedder/embedder_internal.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_manager.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/core.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 {
 
@@ skipping 21 matching lines @@
 }
 
 }  // namespace
 
 namespace internal {
 
 // Declared in embedder_internal.h.
 PlatformSupport* g_platform_support = nullptr;
 system::Core* g_core = nullptr;
 system::ChannelManager* g_channel_manager = nullptr;
-MasterProcessDelegate* g_master_process_delegate = nullptr;
-SlaveProcessDelegate* g_slave_process_delegate = nullptr;
 
 }  // namespace internal
 
-Configuration* GetConfiguration() {
-  return system::GetMutableConfiguration();
-}
-
 void Init(scoped_ptr<PlatformSupport> platform_support) {
   DCHECK(platform_support);
 
   DCHECK(!internal::g_platform_support);
   internal::g_platform_support = platform_support.release();
 
   DCHECK(!internal::g_core);
   internal::g_core = new system::Core(internal::g_platform_support);
 
   DCHECK(!internal::g_channel_manager);
   internal::g_channel_manager =
       new system::ChannelManager(internal::g_platform_support);
 }
 
-void InitMaster(scoped_refptr<base::TaskRunner> delegate_thread_task_runner,
-                MasterProcessDelegate* master_process_delegate,
-                scoped_refptr<base::TaskRunner> io_thread_task_runner) {
-  // |Init()| must have already been called.
-  DCHECK(internal::g_core);
-
-  // TODO(vtl): This is temporary. We really want to construct a
-  // |MasterConnectionManager| here, which will in turn hold on to the delegate.
-  internal::g_master_process_delegate = master_process_delegate;
-}
-
-void InitSlave(scoped_refptr<base::TaskRunner> delegate_thread_task_runner,
-               SlaveProcessDelegate* slave_process_delegate,
-               scoped_refptr<base::TaskRunner> io_thread_task_runner,
-               ScopedPlatformHandle platform_handle) {
-  // |Init()| must have already been called.
-  DCHECK(internal::g_core);
-
-  // TODO(vtl): This is temporary. We really want to construct a
-  // |SlaveConnectionManager| here, which will in turn hold on to the delegate.
-  internal::g_slave_process_delegate = slave_process_delegate;
+Configuration* GetConfiguration() {
+  return system::GetMutableConfiguration();
 }
 
 // TODO(vtl): Write tests for this.
 ScopedMessagePipeHandle CreateChannelOnIOThread(
     ScopedPlatformHandle platform_handle,
     ChannelInfo** channel_info) {
   DCHECK(platform_handle.is_valid());
   DCHECK(channel_info);
 
-  *channel_info = new ChannelInfo(MakeChannelId());
+  scoped_refptr<system::ChannelEndpoint> channel_endpoint;
   scoped_refptr<system::MessagePipeDispatcher> dispatcher =
-      internal::g_channel_manager->CreateChannelOnIOThread(
-          (*channel_info)->channel_id, platform_handle.Pass());
+      system::MessagePipeDispatcher::CreateRemoteMessagePipe(&channel_endpoint);
 
+  DCHECK(internal::g_core);
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher)));
-  CHECK(rv.is_valid());
-  // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
-  // once that's fixed.
+
+  *channel_info = new ChannelInfo(MakeChannelId());
+  internal::g_channel_manager->CreateChannelOnIOThread(
+      (*channel_info)->channel_id, platform_handle.Pass(), channel_endpoint);
+
   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);
   DCHECK(!callback.is_null());
 
-  system::ChannelId channel_id = MakeChannelId();
-  scoped_ptr<ChannelInfo> channel_info(new ChannelInfo(channel_id));
+  scoped_refptr<system::ChannelEndpoint> channel_endpoint;
   scoped_refptr<system::MessagePipeDispatcher> dispatcher =
-      internal::g_channel_manager->CreateChannel(
-          channel_id, platform_handle.Pass(), io_thread_task_runner,
-          base::Bind(callback, base::Unretained(channel_info.release())),
-          callback_thread_task_runner);
+      system::MessagePipeDispatcher::CreateRemoteMessagePipe(&channel_endpoint);
 
+  DCHECK(internal::g_core);
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher)));
-  CHECK(rv.is_valid());
-  // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
-  // once that's fixed.
+
+  // 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()) {
+    system::ChannelId channel_id = MakeChannelId();
+    channel_info->channel_id = channel_id;
+    internal::g_channel_manager->CreateChannel(
+        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.
 void DestroyChannel(ChannelInfo* channel_info) {
   DCHECK(channel_info);
   DCHECK(channel_info->channel_id);
   DCHECK(internal::g_channel_manager);
   // This will destroy the channel synchronously if called from the channel
   // thread.
@@ skipping 48 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