Convert mojo::system::Dispatcher to use our new refcounting stuff (instead of base's).

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/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/task_runner.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/platform_support.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/configuration.h"
 #include "mojo/edk/system/core.h"
 #include "mojo/edk/system/ipc_support.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/raw_channel.h"
+#include "mojo/edk/system/ref_ptr.h"
 
 namespace mojo {
 namespace embedder {
 
 namespace internal {
 
 // Declared in embedder_internal.h.
 PlatformSupport* g_platform_support = nullptr;
 system::Core* g_core = nullptr;
 system::IPCSupport* g_ipc_support = nullptr;
@@ skipping 59 matching lines @@
                      MojoHandleSignals signals,
                      const base::Callback<void(MojoResult)>& callback) {
   return internal::g_core->AsyncWait(handle, signals, callback);
 }
 
 MojoResult CreatePlatformHandleWrapper(
     ScopedPlatformHandle platform_handle,
     MojoHandle* platform_handle_wrapper_handle) {
   DCHECK(platform_handle_wrapper_handle);
 
-  scoped_refptr<system::Dispatcher> dispatcher =
+  auto dispatcher =
       system::PlatformHandleDispatcher::Create(platform_handle.Pass());
 
   DCHECK(internal::g_core);
-  MojoHandle h = internal::g_core->AddDispatcher(dispatcher);
+  MojoHandle h = internal::g_core->AddDispatcher(dispatcher.get());
   if (h == MOJO_HANDLE_INVALID) {
     LOG(ERROR) << "Handle table full";
     dispatcher->Close();
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   }
 
   *platform_handle_wrapper_handle = h;
   return MOJO_RESULT_OK;
 }
 
 MojoResult PassWrappedPlatformHandle(MojoHandle platform_handle_wrapper_handle,
                                      ScopedPlatformHandle* platform_handle) {
   DCHECK(platform_handle);
 
   DCHECK(internal::g_core);
-  scoped_refptr<system::Dispatcher> dispatcher(
-      internal::g_core->GetDispatcher(platform_handle_wrapper_handle));
+  auto dispatcher =
+      internal::g_core->GetDispatcher(platform_handle_wrapper_handle);
   if (!dispatcher)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (dispatcher->GetType() != system::Dispatcher::Type::PLATFORM_HANDLE)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   *platform_handle =
       static_cast<system::PlatformHandleDispatcher*>(dispatcher.get())
           ->PassPlatformHandle()
           .Pass();
@@ skipping 40 matching lines @@
     std::string* platform_connection_id,
     ChannelInfo** channel_info) {
   DCHECK(platform_connection_id);
   DCHECK(channel_info);
   DCHECK(internal::g_ipc_support);
 
   system::ConnectionIdentifier connection_id =
       internal::g_ipc_support->GenerateConnectionIdentifier();
   *platform_connection_id = connection_id.ToString();
   system::ChannelId channel_id = system::kInvalidChannelId;
-  scoped_refptr<system::MessagePipeDispatcher> dispatcher =
+  system::RefPtr<system::MessagePipeDispatcher> dispatcher =
       internal::g_ipc_support->ConnectToSlave(
           connection_id, slave_info, platform_handle.Pass(),
           did_connect_to_slave_callback, did_connect_to_slave_runner.Pass(),
           &channel_id);
   *channel_info = new ChannelInfo(channel_id);
 
   ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher)));
+      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
   CHECK(rv.is_valid());
-  // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
-  // once that's fixed.
-  return rv.Pass();
+  return rv;
 }
 
 ScopedMessagePipeHandle ConnectToMaster(
     const std::string& platform_connection_id,
     const base::Closure& did_connect_to_master_callback,
     scoped_refptr<base::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;
-  scoped_refptr<system::MessagePipeDispatcher> dispatcher =
+  system::RefPtr<system::MessagePipeDispatcher> dispatcher =
       internal::g_ipc_support->ConnectToMaster(
           connection_id, did_connect_to_master_callback,
           did_connect_to_master_runner.Pass(), &channel_id);
   *channel_info = new ChannelInfo(channel_id);
 
   ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher)));
+      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
   CHECK(rv.is_valid());
-  // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
-  // once that's fixed.
-  return rv.Pass();
+  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());
-  scoped_refptr<system::MessagePipeDispatcher> dispatcher =
+  system::RefPtr<system::MessagePipeDispatcher> dispatcher =
       channel_manager->CreateChannelOnIOThread((*channel_info)->channel_id,
                                                platform_handle.Pass());
 
   ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher)));
+      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
   CHECK(rv.is_valid());
-  // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
-  // once that's fixed.
-  return rv.Pass();
+  return rv;
 }
 
 ScopedMessagePipeHandle CreateChannel(
     ScopedPlatformHandle platform_handle,
     const base::Callback<void(ChannelInfo*)>& did_create_channel_callback,
     scoped_refptr<base::TaskRunner> did_create_channel_runner) {
   DCHECK(platform_handle.is_valid());
   DCHECK(!did_create_channel_callback.is_null());
   DCHECK(internal::g_ipc_support);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
 
   system::ChannelId channel_id = MakeChannelId();
   std::unique_ptr<ChannelInfo> channel_info(new ChannelInfo(channel_id));
-  scoped_refptr<system::MessagePipeDispatcher> dispatcher =
+  system::RefPtr<system::MessagePipeDispatcher> dispatcher =
       channel_manager->CreateChannel(
           channel_id, platform_handle.Pass(),
           base::Bind(did_create_channel_callback,
                      base::Unretained(channel_info.release())),
           did_create_channel_runner);
 
   ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher)));
+      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
   CHECK(rv.is_valid());
-  // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
-  // once that's fixed.
-  return rv.Pass();
+  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);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
@@ skipping 23 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