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

mojo/edk/system/remote_data_pipe_impl_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.
 
 // This file tests both |RemoteProducerDataPipeImpl| and
 // |RemoteConsumerDataPipeImpl|.
 
 #include <stdint.h>
 
 #include <utility>
@@ skipping 46 matching lines @@
 
   void TearDown() override {
     EnsureMessagePipeClosed(0);
     EnsureMessagePipeClosed(1);
     io_thread_.PostTaskAndWait(
         FROM_HERE, base::Bind(&RemoteDataPipeImplTest::TearDownOnIOThread,
                               base::Unretained(this)));
   }
 
  protected:
-  static DataPipe* CreateLocal(size_t element_size, size_t num_elements) {
+  static RefPtr<DataPipe> CreateLocal(size_t element_size,
+                                      size_t num_elements) {
     const MojoCreateDataPipeOptions options = {
         static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)),
         MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
         static_cast<uint32_t>(element_size),
         static_cast<uint32_t>(num_elements * element_size)};
     MojoCreateDataPipeOptions validated_options = {};
     CHECK_EQ(DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
                                              &validated_options),
              MOJO_RESULT_OK);
     return DataPipe::CreateLocal(validated_options);
   }
 
-  scoped_refptr<MessagePipe> message_pipe(size_t i) {
-    return message_pipes_[i];
-  }
+  RefPtr<MessagePipe> message_pipe(size_t i) { return message_pipes_[i]; }
 
   void EnsureMessagePipeClosed(size_t i) {
     if (!message_pipes_[i])
       return;
     message_pipes_[i]->Close(0);
     message_pipes_[i] = nullptr;
   }
 
  private:
   // TODO(vtl): The arguments should be rvalue references, but that doesn't
@@ skipping 20 matching lines @@
     }
     if (channels_[1]) {
       channels_[1]->Shutdown();
       channels_[1] = nullptr;
     }
   }
 
   embedder::SimplePlatformSupport platform_support_;
   mojo::test::TestIOThread io_thread_;
   RefPtr<Channel> channels_[2];
-  scoped_refptr<MessagePipe> message_pipes_[2];
+  RefPtr<MessagePipe> message_pipes_[2];
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RemoteDataPipeImplTest);
 };
 
 // These tests are heavier-weight than ideal. They test remote data pipes by
 // passing data pipe (producer/consumer) dispatchers over remote message pipes.
 // Make sure that the test fixture works properly (i.e., that the message pipe
 // works properly, and that things are shut down correctly).
 // TODO(vtl): Make lighter-weight tests. Ideally, we'd have tests for remote
 // data pipes which don't involve message pipes (or even data pipe dispatchers).
@@ skipping 32 matching lines @@
 
 TEST_F(RemoteDataPipeImplTest, SendConsumerWithClosedProducer) {
   char read_buffer[100] = {};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
-  scoped_refptr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
+  RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
   scoped_refptr<DataPipeConsumerDispatcher> consumer =
       DataPipeConsumerDispatcher::Create();
-  consumer->Init(dp);
+  consumer->Init(dp.Clone());
 
   // Write to the producer and close it, before sending the consumer.
   int32_t elements[10] = {123};
   uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
                                   MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   dp->ProducerClose();
 
@@ skipping 93 matching lines @@
 
 TEST_F(RemoteDataPipeImplTest, SendConsumerDuringTwoPhaseWrite) {
   char read_buffer[100] = {};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
-  scoped_refptr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
+  RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
   scoped_refptr<DataPipeConsumerDispatcher> consumer =
       DataPipeConsumerDispatcher::Create();
-  consumer->Init(dp);
+  consumer->Init(dp.Clone());
 
   void* write_ptr = nullptr;
   uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                        MakeUserPointer(&num_bytes)));
   ASSERT_GE(num_bytes, 1u * sizeof(int32_t));
 
   // Write the consumer to MP 0 (port 0). Wait and receive on MP 1 (port 0).
   // (Add the waiter first, to avoid any handling the case where it's already
@@ skipping 85 matching lines @@
 // properly preserved).
 TEST_F(RemoteDataPipeImplTest, SendConsumerDuringSecondTwoPhaseWrite) {
   char read_buffer[100] = {};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
-  scoped_refptr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
+  RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
   scoped_refptr<DataPipeConsumerDispatcher> consumer =
       DataPipeConsumerDispatcher::Create();
-  consumer->Init(dp);
+  consumer->Init(dp.Clone());
 
   void* write_ptr = nullptr;
   uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                        MakeUserPointer(&num_bytes)));
   ASSERT_GE(num_bytes, 1u * sizeof(int32_t));
   *static_cast<int32_t*>(write_ptr) = 123456;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(
                                 static_cast<uint32_t>(1u * sizeof(int32_t))));
@@ skipping 88 matching lines @@
   EXPECT_EQ(123456, elements[0]);
   EXPECT_EQ(789012, elements[1]);
   EXPECT_EQ(0, elements[2]);
 
   consumer->Close();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo