EDK: Remove Core::AddDispatcher().

mojo/edk/embedder/multiprocess_embedder.cc

 // Copyright 2015 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/multiprocess_embedder.h"
 
 #include <atomic>
 #include <utility>
 
 #include "base/logging.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/process_delegate.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_manager.h"
 #include "mojo/edk/system/core.h"
+#include "mojo/edk/system/handle.h"
 #include "mojo/edk/system/ipc_support.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/util/ref_ptr.h"
 
 using mojo::platform::PlatformHandleWatcher;
 using mojo::platform::ScopedPlatformHandle;
 using mojo::platform::TaskRunner;
 using mojo::util::RefPtr;
 
@@ skipping 93 matching lines @@
       internal::g_ipc_support->GenerateConnectionIdentifier();
   *platform_connection_id = connection_id.ToString();
   system::ChannelId channel_id = system::kInvalidChannelId;
   RefPtr<system::MessagePipeDispatcher> dispatcher =
       internal::g_ipc_support->ConnectToSlave(
           connection_id, slave_info, platform_handle.Pass(),
           std::move(did_connect_to_slave_callback),
           std::move(did_connect_to_slave_runner), &channel_id);
   *channel_info = new ChannelInfo(channel_id);
 
-  ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
+  ScopedMessagePipeHandle rv(MessagePipeHandle(internal::g_core->AddHandle(
+      system::Handle(std::move(dispatcher),
+                     system::MessagePipeDispatcher::kDefaultHandleRights))));
   CHECK(rv.is_valid());
   return rv;
 }
 
 ScopedMessagePipeHandle ConnectToMaster(
     const std::string& platform_connection_id,
     std::function<void()>&& did_connect_to_master_callback,
     RefPtr<TaskRunner>&& did_connect_to_master_runner,
     ChannelInfo** channel_info) {
   DCHECK(channel_info);
   DCHECK(internal::g_ipc_support);
 
   bool ok = false;
   system::ConnectionIdentifier connection_id =
       system::ConnectionIdentifier::FromString(platform_connection_id, &ok);
   CHECK(ok);
 
   system::ChannelId channel_id = system::kInvalidChannelId;
   RefPtr<system::MessagePipeDispatcher> dispatcher =
       internal::g_ipc_support->ConnectToMaster(
           connection_id, std::move(did_connect_to_master_callback),
           std::move(did_connect_to_master_runner), &channel_id);
   *channel_info = new ChannelInfo(channel_id);
 
-  ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
+  ScopedMessagePipeHandle rv(MessagePipeHandle(internal::g_core->AddHandle(
+      system::Handle(std::move(dispatcher),
+                     system::MessagePipeDispatcher::kDefaultHandleRights))));
   CHECK(rv.is_valid());
   return rv;
 }
 
 // TODO(vtl): Write tests for this.
 ScopedMessagePipeHandle CreateChannelOnIOThread(
     ScopedPlatformHandle platform_handle,
     ChannelInfo** channel_info) {
   DCHECK(platform_handle.is_valid());
   DCHECK(channel_info);
   DCHECK(internal::g_ipc_support);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
 
   *channel_info = new ChannelInfo(MakeChannelId());
   RefPtr<system::MessagePipeDispatcher> dispatcher =
       channel_manager->CreateChannelOnIOThread((*channel_info)->channel_id,
                                                platform_handle.Pass());
 
-  ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
+  ScopedMessagePipeHandle rv(MessagePipeHandle(internal::g_core->AddHandle(
+      system::Handle(std::move(dispatcher),
+                     system::MessagePipeDispatcher::kDefaultHandleRights))));
   CHECK(rv.is_valid());
   return rv;
 }
 
 ScopedMessagePipeHandle CreateChannel(
     ScopedPlatformHandle platform_handle,
     std::function<void(ChannelInfo*)>&& did_create_channel_callback,
     RefPtr<TaskRunner>&& did_create_channel_runner) {
   DCHECK(platform_handle.is_valid());
   DCHECK(did_create_channel_callback);
   DCHECK(internal::g_ipc_support);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
 
   system::ChannelId channel_id = MakeChannelId();
   // Ownership gets passed back to the caller via |did_create_channel_callback|.
   ChannelInfo* channel_info = new ChannelInfo(channel_id);
   RefPtr<system::MessagePipeDispatcher> dispatcher =
       channel_manager->CreateChannel(
           channel_id, platform_handle.Pass(),
           [did_create_channel_callback, channel_info]() {
             did_create_channel_callback(channel_info);
           },
           std::move(did_create_channel_runner));
 
-  ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
+  ScopedMessagePipeHandle rv(MessagePipeHandle(internal::g_core->AddHandle(
+      system::Handle(std::move(dispatcher),
+                     system::MessagePipeDispatcher::kDefaultHandleRights))));
   CHECK(rv.is_valid());
   return rv;
 }
 
 // TODO(vtl): Write tests for this.
 void DestroyChannelOnIOThread(ChannelInfo* channel_info) {
   DCHECK(channel_info);
   DCHECK(channel_info->channel_id);
   DCHECK(internal::g_ipc_support);
 
@@ skipping 24 matching lines @@
   DCHECK(channel_info);
   DCHECK(internal::g_ipc_support);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
   channel_manager->WillShutdownChannel(channel_info->channel_id);
 }
 
 }  // namespace embedder
 }  // namespace mojo