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

mojo/edk/system/dispatcher.h

 // Copyright 2013 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.
 
 #ifndef MOJO_EDK_SYSTEM_DISPATCHER_H_
 #define MOJO_EDK_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <ostream>
 #include <vector>
 
-#include "base/memory/ref_counted.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/mutex.h"
+#include "mojo/edk/system/ref_counted.h"
+#include "mojo/edk/system/ref_ptr.h"
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/message_pipe.h"
 #include "mojo/public/c/system/types.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 namespace embedder {
 class PlatformSharedBufferMapping;
 }
 
 namespace system {
 
 class Channel;
 class Core;
 class Dispatcher;
 class DispatcherTransport;
 class HandleTable;
 class LocalMessagePipeEndpoint;
 class ProxyMessagePipeEndpoint;
 class TransportData;
 class Awakable;
 
-using DispatcherVector = std::vector<scoped_refptr<Dispatcher>>;
+using DispatcherVector = std::vector<RefPtr<Dispatcher>>;
 
 namespace test {
 
 // Test helper. We need to declare it here so we can friend it.
 DispatcherTransport DispatcherTryStartTransport(Dispatcher* dispatcher);
 
 }  // namespace test
 
 // A |Dispatcher| implements Mojo primitives that are "attached" to a particular
 // handle. This includes most (all?) primitives except for |MojoWait...()|. This
 // object is thread-safe, with its state being protected by a single mutex
 // |mutex_|, which is also made available to implementation subclasses (via the
 // |mutex()| method).
-class Dispatcher : public base::RefCountedThreadSafe<Dispatcher> {
+class Dispatcher : public RefCountedThreadSafe<Dispatcher> {
  public:
   enum class Type {
     UNKNOWN = 0,
     MESSAGE_PIPE,
     DATA_PIPE_PRODUCER,
     DATA_PIPE_CONSUMER,
     SHARED_BUFFER,
 
     // "Private" types (not exposed via the public interface):
     PLATFORM_HANDLE = -1
@@ skipping 37 matching lines @@
                       MojoReadDataFlags flags);
   MojoResult BeginReadData(UserPointer<const void*> buffer,
                            UserPointer<uint32_t> buffer_num_bytes,
                            MojoReadDataFlags flags);
   MojoResult EndReadData(uint32_t num_bytes_read);
   // |options| may be null. |new_dispatcher| must not be null, but
   // |*new_dispatcher| should be null (and will contain the dispatcher for the
   // new handle on success).
   MojoResult DuplicateBufferHandle(
       UserPointer<const MojoDuplicateBufferHandleOptions> options,
-      scoped_refptr<Dispatcher>* new_dispatcher);
+      RefPtr<Dispatcher>* new_dispatcher);
   MojoResult MapBuffer(
       uint64_t offset,
       uint64_t num_bytes,
       MojoMapBufferFlags flags,
       std::unique_ptr<embedder::PlatformSharedBufferMapping>* mapping);
 
   // Gets the current handle signals state. (The default implementation simply
   // returns a default-constructed |HandleSignalsState|, i.e., no signals
   // satisfied or satisfiable.) Note: The state is subject to change from other
   // threads.
@@ skipping 69 matching lines @@
     static bool EndSerializeAndClose(
         Dispatcher* dispatcher,
         Channel* channel,
         void* destination,
         size_t* actual_size,
         embedder::PlatformHandleVector* platform_handles);
 
     // Deserialization API.
     // Note: This "clears" (i.e., reset to the invalid handle) any platform
     // handles that it takes ownership of.
-    static scoped_refptr<Dispatcher> Deserialize(
+    static RefPtr<Dispatcher> Deserialize(
         Channel* channel,
         int32_t type,
         const void* source,
         size_t size,
         embedder::PlatformHandleVector* platform_handles);
   };
 
  protected:
-  friend class base::RefCountedThreadSafe<Dispatcher>;
-
   Dispatcher();
   virtual ~Dispatcher();
 
   // These are to be overridden by subclasses (if necessary). They are called
   // exactly once (first |CancelAllAwakablesNoLock()|, then |CloseImplNoLock()|)
   // when the dispatcher is being closed.
   virtual void CancelAllAwakablesNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual void CloseImplNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
-  virtual scoped_refptr<Dispatcher>
-  CreateEquivalentDispatcherAndCloseImplNoLock()
+  virtual RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock()
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_) = 0;
 
   // These are to be overridden by subclasses (if necessary). They are never
   // called after the dispatcher has been closed. See the descriptions of the
   // methods without the "ImplNoLock" for more information.
   virtual MojoResult WriteMessageImplNoLock(
       UserPointer<const void> bytes,
       uint32_t num_bytes,
       std::vector<DispatcherTransport>* transports,
       MojoWriteMessageFlags flags) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
@@ skipping 18 matching lines @@
                                         MojoReadDataFlags flags)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult BeginReadDataImplNoLock(
       UserPointer<const void*> buffer,
       UserPointer<uint32_t> buffer_num_bytes,
       MojoReadDataFlags flags) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult EndReadDataImplNoLock(uint32_t num_bytes_read)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult DuplicateBufferHandleImplNoLock(
       UserPointer<const MojoDuplicateBufferHandleOptions> options,
-      scoped_refptr<Dispatcher>* new_dispatcher)
-      MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+      RefPtr<Dispatcher>* new_dispatcher) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult MapBufferImplNoLock(
       uint64_t offset,
       uint64_t num_bytes,
       MojoMapBufferFlags flags,
       std::unique_ptr<embedder::PlatformSharedBufferMapping>* mapping)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual HandleSignalsState GetHandleSignalsStateImplNoLock() const
       MOJO_SHARED_LOCKS_REQUIRED(mutex_);
   virtual MojoResult AddAwakableImplNoLock(Awakable* awakable,
                                            MojoHandleSignals signals,
@@ skipping 29 matching lines @@
       embedder::PlatformHandleVector* platform_handles) MOJO_NOT_THREAD_SAFE;
 
   // This should be overridden to return true if/when there's an ongoing
   // operation (e.g., two-phase read/writes on data pipes) that should prevent a
   // handle from being sent over a message pipe (with status "busy").
   virtual bool IsBusyNoLock() const MOJO_SHARED_LOCKS_REQUIRED(mutex_);
 
   Mutex& mutex() const MOJO_LOCK_RETURNED(mutex_) { return mutex_; }
 
  private:
+  FRIEND_REF_COUNTED_THREAD_SAFE(Dispatcher);
   friend class DispatcherTransport;
 
   // Closes the dispatcher. This must be done under lock, and unlike |Close()|,
   // the dispatcher must not be closed already. (This is the "equivalent" of
   // |CreateEquivalentDispatcherAndCloseNoLock()|, for situations where the
   // dispatcher must be disposed of instead of "transferred".)
   void CloseNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   // Creates an equivalent dispatcher -- representing the same resource as this
   // dispatcher -- and close (i.e., disable) this dispatcher. I.e., this
   // dispatcher will look as though it was closed, but the resource it
   // represents will be assigned to the new dispatcher. This must be called
   // under the dispatcher's lock.
-  scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseNoLock()
+  RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseNoLock()
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   // API to serialize dispatchers to a |Channel|, exposed to only
   // |TransportData| (via |TransportData|). They may only be called on a
   // dispatcher attached to a |MessageInTransit| (and in particular not in
   // |CoreImpl|'s handle table).
   //
   // TODO(vtl): The serialization API (and related implementation methods,
   // including |DispatcherTransport|'s methods) is marked
   // |MOJO_NOT_THREAD_SAFE|. This is because the threading requirements are
@@ skipping 50 matching lines @@
  public:
   DispatcherTransport() : dispatcher_(nullptr) {}
 
   void End() MOJO_NOT_THREAD_SAFE;
 
   Dispatcher::Type GetType() const { return dispatcher_->GetType(); }
   bool IsBusy() const MOJO_NOT_THREAD_SAFE {
     return dispatcher_->IsBusyNoLock();
   }
   void Close() MOJO_NOT_THREAD_SAFE { dispatcher_->CloseNoLock(); }
-  scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndClose()
-      MOJO_NOT_THREAD_SAFE {
+  RefPtr<Dispatcher> CreateEquivalentDispatcherAndClose() MOJO_NOT_THREAD_SAFE {
     return dispatcher_->CreateEquivalentDispatcherAndCloseNoLock();
   }
 
   bool is_valid() const { return !!dispatcher_; }
 
  protected:
   Dispatcher* dispatcher() { return dispatcher_; }
 
  private:
   friend class Dispatcher::HandleTableAccess;
 
   explicit DispatcherTransport(Dispatcher* dispatcher)
       : dispatcher_(dispatcher) {}
 
   Dispatcher* dispatcher_;
 
   // Copy and assign allowed.
 };
 
 // So logging macros and |DCHECK_EQ()|, etc. work.
 inline std::ostream& operator<<(std::ostream& out, Dispatcher::Type type) {
   return out << static_cast<int>(type);
 }
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_DISPATCHER_H_