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

mojo/edk/system/handle_table.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_HANDLE_TABLE_H_
 #define MOJO_EDK_SYSTEM_HANDLE_TABLE_H_
 
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
-#include "base/memory/ref_counted.h"
+#include "mojo/edk/system/ref_ptr.h"
 #include "mojo/public/c/system/types.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace system {
 
 class Core;
 class Dispatcher;
 class DispatcherTransport;
 
-using DispatcherVector = std::vector<scoped_refptr<Dispatcher>>;
+using DispatcherVector = std::vector<RefPtr<Dispatcher>>;
 
 // Test-only function (defined/used in embedder/test_embedder.cc). Declared here
 // so it can be friended.
 namespace internal {
 bool ShutdownCheckNoLeaks(Core*);
 }
 
 // This class provides the (global) handle table (owned by |Core|), which maps
 // (valid) |MojoHandle|s to |Dispatcher|s. This is abstracted so that, e.g.,
 // caching may be added.
 //
 // This class is NOT thread-safe; locking is left to |Core| (since it may need
 // to make several changes -- "atomically" or in rapid successsion, in which
 // case the extra locking/unlocking would be unnecessary overhead).
 
 class HandleTable {
  public:
   HandleTable();
   ~HandleTable();
 
   // Gets the dispatcher for a given handle (which should not be
   // |MOJO_HANDLE_INVALID|). Returns null if there's no dispatcher for the given
   // handle.
   // WARNING: For efficiency, this returns a dumb pointer. If you're going to
   // use the result outside |Core|'s lock, you MUST take a reference (e.g., by
-  // storing the result inside a |scoped_refptr|).
+  // storing the result inside a |RefPtr|).
   Dispatcher* GetDispatcher(MojoHandle handle);
 
   // On success, gets the dispatcher for a given handle (which should not be
   // |MOJO_HANDLE_INVALID|) and removes it. (On failure, returns an appropriate
   // result (and leaves |dispatcher| alone), namely
   // |MOJO_RESULT_INVALID_ARGUMENT| if there's no dispatcher for the given
   // handle or |MOJO_RESULT_BUSY| if the handle is marked as busy.)
   MojoResult GetAndRemoveDispatcher(MojoHandle handle,
-                                    scoped_refptr<Dispatcher>* dispatcher);
+                                    RefPtr<Dispatcher>* dispatcher);
 
   // Adds a dispatcher (which must be valid), returning the handle for it.
   // Returns |MOJO_HANDLE_INVALID| on failure (if the handle table is full).
-  MojoHandle AddDispatcher(const scoped_refptr<Dispatcher>& dispatcher);
+  MojoHandle AddDispatcher(Dispatcher* dispatcher);
 
   // Adds a pair of dispatchers (which must be valid), return a pair of handles
   // for them. On failure (if the handle table is full), the first (and second)
   // handles will be |MOJO_HANDLE_INVALID|, and neither dispatcher will be
   // added.
-  std::pair<MojoHandle, MojoHandle> AddDispatcherPair(
-      const scoped_refptr<Dispatcher>& dispatcher0,
-      const scoped_refptr<Dispatcher>& dispatcher1);
+  std::pair<MojoHandle, MojoHandle> AddDispatcherPair(Dispatcher* dispatcher0,
+                                                      Dispatcher* dispatcher1);
 
   // Adds the given vector of dispatchers (of size at most
   // |kMaxMessageNumHandles|). |handles| must point to an array of size at least
   // |dispatchers.size()|. Unlike the other |AddDispatcher...()| functions, some
   // of the dispatchers may be invalid (null). Returns true on success and false
   // on failure (if the handle table is full), in which case it leaves
   // |handles[...]| untouched (and all dispatchers unadded).
   bool AddDispatcherVector(const DispatcherVector& dispatchers,
                            MojoHandle* handles);
 
@@ skipping 31 matching lines @@
   // all the dispatchers for the handles that it is sending (and fail with
   // |MOJO_RESULT_BUSY| if the attempt fails). At this point, it can release the
   // handle table lock.
   //
   // If |Core::Close()| is simultaneously called on that handle, it too checks
   // if the handle is marked busy. If it is, it fails (with |MOJO_RESULT_BUSY|).
   // This prevents |Core::WriteMessage()| from sending a handle that has been
   // closed (or learning about this too late).
   struct Entry {
     Entry();
-    explicit Entry(const scoped_refptr<Dispatcher>& dispatcher);
+    explicit Entry(RefPtr<Dispatcher>&& dispatcher);
     ~Entry();
 
-    scoped_refptr<Dispatcher> dispatcher;
+    RefPtr<Dispatcher> dispatcher;
     bool busy;
   };
   using HandleToEntryMap = std::unordered_map<MojoHandle, Entry>;
 
   // Adds the given dispatcher to the handle table, not doing any size checks.
-  MojoHandle AddDispatcherNoSizeCheck(
-      const scoped_refptr<Dispatcher>& dispatcher);
+  MojoHandle AddDispatcherNoSizeCheck(RefPtr<Dispatcher>&& dispatcher);
 
   HandleToEntryMap handle_to_entry_map_;
   MojoHandle next_handle_;  // Invariant: never |MOJO_HANDLE_INVALID|.
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(HandleTable);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_HANDLE_TABLE_H_