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

mojo/edk/system/channel.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_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_CHANNEL_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <unordered_map>
 
-#include "base/memory/ref_counted.h"
 #include "base/threading/thread_checker.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/channel_endpoint_id.h"
 #include "mojo/edk/system/incoming_endpoint.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/mutex.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/system/ref_counted.h"
 #include "mojo/edk/system/ref_ptr.h"
@@ skipping 122 matching lines @@
   // Case 3: The endpoint's peer is remote (i.e., it has a peer
   // |ChannelEndpoint|). (This has two subcases: the peer endpoint may be on
   // this |Channel| or another |Channel|.)
   void SerializeEndpointWithClosedPeer(void* destination,
                                        MessageInTransitQueue* message_queue);
   // This one returns the |ChannelEndpoint| for the serialized endpoint (which
   // can be used by, e.g., a |ProxyMessagePipeEndpoint|.
   RefPtr<ChannelEndpoint> SerializeEndpointWithLocalPeer(
       void* destination,
       MessageInTransitQueue* message_queue,
-      ChannelEndpointClient* endpoint_client,
+      RefPtr<ChannelEndpointClient>&& endpoint_client,
       unsigned endpoint_client_port);
   void SerializeEndpointWithRemotePeer(void* destination,
                                        MessageInTransitQueue* message_queue,
                                        RefPtr<ChannelEndpoint>&& peer_endpoint);
 
   // Deserializes an endpoint that was sent from the peer |Channel| (using
   // |SerializeEndpoint...()|. |source| should be (a copy of) the data that
   // |SerializeEndpoint...()| wrote, and must be (at least)
   // |GetSerializedEndpointSize()| bytes. This returns the deserialized
   // |IncomingEndpoint| (which can be converted into a |MessagePipe|) or null on
   // error.
-  scoped_refptr<IncomingEndpoint> DeserializeEndpoint(const void* source);
+  RefPtr<IncomingEndpoint> DeserializeEndpoint(const void* source);
 
   // See |RawChannel::GetSerializedPlatformHandleSize()|.
   size_t GetSerializedPlatformHandleSize() const;
 
   embedder::PlatformSupport* platform_support() const {
     return platform_support_;
   }
 
  private:
   FRIEND_REF_COUNTED_THREAD_SAFE(Channel);
@@ skipping 80 matching lines @@
 
   using IdToEndpointMap =
       std::unordered_map<ChannelEndpointId, RefPtr<ChannelEndpoint>>;
   // Map from local IDs to endpoints. If the endpoint is null, this means that
   // we're just waiting for the remove ack before removing the entry.
   IdToEndpointMap local_id_to_endpoint_map_ MOJO_GUARDED_BY(mutex_);
   // Note: The IDs generated by this should be checked for existence before use.
   LocalChannelEndpointIdGenerator local_id_generator_ MOJO_GUARDED_BY(mutex_);
 
   using IdToIncomingEndpointMap =
-      std::unordered_map<ChannelEndpointId, scoped_refptr<IncomingEndpoint>>;
+      std::unordered_map<ChannelEndpointId, RefPtr<IncomingEndpoint>>;
   // Map from local IDs to incoming endpoints (i.e., those received inside other
   // messages, but not yet claimed via |DeserializeEndpoint()|).
   IdToIncomingEndpointMap incoming_endpoints_ MOJO_GUARDED_BY(mutex_);
   // TODO(vtl): We need to keep track of remote IDs (so that we don't collide
   // if/when we wrap).
   RemoteChannelEndpointIdGenerator remote_id_generator_ MOJO_GUARDED_BY(mutex_);
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(Channel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CHANNEL_H_