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

mojo/edk/system/endpoint_relayer_unittest.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/system/endpoint_relayer.h"
 
 #include "base/logging.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "mojo/edk/system/channel_endpoint_id.h"
 #include "mojo/edk/system/channel_test_base.h"
 #include "mojo/edk/system/message_in_transit_queue.h"
 #include "mojo/edk/system/message_in_transit_test_utils.h"
+#include "mojo/edk/system/ref_ptr.h"
 #include "mojo/edk/system/test_channel_endpoint_client.h"
 #include "mojo/edk/util/make_unique.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
 class EndpointRelayerTest : public test::ChannelTestBase {
  public:
@@ skipping 12 matching lines @@
     // * Across the pair of channels, we'll have a pair of connections (call
     //   them "a" and "b").
     // * On channel 0, we'll have a pair of endpoints ("0a" and "0b") hooked up
     //   to an |EndpointRelayer|.
     // * On channel 1, we'll have a pair of endpoints hooked up to test endpoint
     //   clients ("1a" and "1b").
     LocalChannelEndpointIdGenerator id_generator;
     ChannelEndpointId ida = id_generator.GetNext();
     ChannelEndpointId idb = id_generator.GetNext();
 
-    relayer_ = new EndpointRelayer();
-    endpoint0a_ = MakeRefCounted<ChannelEndpoint>(relayer_.get(), 0);
-    endpoint0b_ = MakeRefCounted<ChannelEndpoint>(relayer_.get(), 1);
+    relayer_ = MakeRefCounted<EndpointRelayer>();
+    endpoint0a_ = MakeRefCounted<ChannelEndpoint>(relayer_.Clone(), 0);
+    endpoint0b_ = MakeRefCounted<ChannelEndpoint>(relayer_.Clone(), 1);
     relayer_->Init(endpoint0a_.Clone(), endpoint0b_.Clone());
     channel(0)->SetBootstrapEndpointWithIds(endpoint0a_.Clone(), ida, ida);
     channel(0)->SetBootstrapEndpointWithIds(endpoint0b_.Clone(), idb, idb);
 
-    client1a_ = new test::TestChannelEndpointClient();
-    client1b_ = new test::TestChannelEndpointClient();
-    endpoint1a_ = MakeRefCounted<ChannelEndpoint>(client1a_.get(), 0);
-    endpoint1b_ = MakeRefCounted<ChannelEndpoint>(client1b_.get(), 0);
+    client1a_ = MakeRefCounted<test::TestChannelEndpointClient>();
+    client1b_ = MakeRefCounted<test::TestChannelEndpointClient>();
+    endpoint1a_ = MakeRefCounted<ChannelEndpoint>(client1a_.Clone(), 0);
+    endpoint1b_ = MakeRefCounted<ChannelEndpoint>(client1b_.Clone(), 0);
     client1a_->Init(0, endpoint1a_.Clone());
     client1b_->Init(0, endpoint1b_.Clone());
     channel(1)->SetBootstrapEndpointWithIds(endpoint1a_.Clone(), ida, ida);
     channel(1)->SetBootstrapEndpointWithIds(endpoint1b_.Clone(), idb, idb);
   }
 
   void TearDown() override {
     PostMethodToIOThreadAndWait(
         FROM_HERE, &EndpointRelayerTest::ShutdownChannelOnIOThread, 0);
     PostMethodToIOThreadAndWait(
         FROM_HERE, &EndpointRelayerTest::ShutdownChannelOnIOThread, 1);
 
     test::ChannelTestBase::TearDown();
   }
 
  protected:
   EndpointRelayer* relayer() { return relayer_.get(); }
   test::TestChannelEndpointClient* client1a() { return client1a_.get(); }
   test::TestChannelEndpointClient* client1b() { return client1b_.get(); }
   ChannelEndpoint* endpoint1a() { return endpoint1a_.get(); }
   ChannelEndpoint* endpoint1b() { return endpoint1b_.get(); }
 
  private:
-  scoped_refptr<EndpointRelayer> relayer_;
+  RefPtr<EndpointRelayer> relayer_;
   RefPtr<ChannelEndpoint> endpoint0a_;
   RefPtr<ChannelEndpoint> endpoint0b_;
-  scoped_refptr<test::TestChannelEndpointClient> client1a_;
-  scoped_refptr<test::TestChannelEndpointClient> client1b_;
+  RefPtr<test::TestChannelEndpointClient> client1a_;
+  RefPtr<test::TestChannelEndpointClient> client1b_;
   RefPtr<ChannelEndpoint> endpoint1a_;
   RefPtr<ChannelEndpoint> endpoint1b_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(EndpointRelayerTest);
 };
 
 TEST_F(EndpointRelayerTest, Basic) {
   base::WaitableEvent read_event(true, false);
   client1b()->SetReadEvent(&read_event);
   EXPECT_EQ(0u, client1b()->NumMessages());
@@ skipping 129 matching lines @@
     ASSERT_TRUE(message);
     test::VerifyTestMessage(message.get(), message_id);
   }
 }
 
 // TODO(vtl): Add some "shutdown" tests.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo