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

mojo/edk/system/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 contains tests that are shared between different implementations of
 // |DataPipeImpl|.
 
 #include "mojo/edk/system/data_pipe_impl.h"
 
 #include <stdint.h>
@@ skipping 237 matching lines @@
 
   void Create(const MojoCreateDataPipeOptions& validated_options) override {
     CHECK(!dp_);
     dp_ = DataPipe::CreateLocal(validated_options);
   }
 
   bool IsStrictCircularBuffer() const override { return false; }
 
  protected:
   void SendDispatcher(size_t source_i,
-                      scoped_refptr<Dispatcher> to_send,
-                      scoped_refptr<Dispatcher>* to_receive) {
+                      RefPtr<Dispatcher> to_send,
+                      RefPtr<Dispatcher>* to_receive) {
     DCHECK(source_i == 0 || source_i == 1);
     size_t dest_i = source_i ^ 1;
 
     // Write the dispatcher to MP |source_i| (port 0). Wait and receive on MP
     // |dest_i| (port 0). (Add the waiter first, to avoid any handling the case
     // where it's already readable.)
     Waiter waiter;
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
               message_pipe(dest_i)->AddAwakable(
@@ skipping 24 matching lines @@
     uint32_t read_num_dispatchers = 10;  // Maximum to get.
     ASSERT_EQ(MOJO_RESULT_OK,
               message_pipe(dest_i)->ReadMessage(
                   0, UserPointer<void>(read_buffer),
                   MakeUserPointer(&read_buffer_size), &read_dispatchers,
                   &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(0u, static_cast<size_t>(read_buffer_size));
     ASSERT_EQ(1u, read_dispatchers.size());
     ASSERT_EQ(1u, read_num_dispatchers);
     ASSERT_TRUE(read_dispatchers[0]);
-    EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
+    read_dispatchers[0]->AssertHasOneRef();
 
     *to_receive = read_dispatchers[0];
   }
 
   RefPtr<MessagePipe> message_pipe(size_t i) { return message_pipes_[i]; }
   RefPtr<DataPipe> dp() { return dp_; }
 
  private:
   void EnsureMessagePipeClosed(size_t i) {
     if (!message_pipes_[i])
@@ skipping 46 matching lines @@
 // i.e., |dp_| will have a |RemoteProducerDataPipeImpl|. The remote side, of
 // course, will have a |RemoteConsumerDataPipeImpl|.
 class RemoteProducerDataPipeImplTestHelper
     : public RemoteDataPipeImplTestHelper {
  public:
   RemoteProducerDataPipeImplTestHelper() {}
   ~RemoteProducerDataPipeImplTestHelper() override {}
 
   void DoTransfer() override {
     // This is the producer dispatcher we'll send.
-    scoped_refptr<DataPipeProducerDispatcher> to_send =
-        DataPipeProducerDispatcher::Create();
+    auto to_send = DataPipeProducerDispatcher::Create();
     to_send->Init(dp());
-    scoped_refptr<Dispatcher> to_receive;
+    RefPtr<Dispatcher> to_receive;
     SendDispatcher(0, to_send, &to_receive);
     // |to_send| should have been closed. This is |DCHECK()|ed when it is
     // destroyed.
-    EXPECT_TRUE(to_send->HasOneRef());
+    to_send->AssertHasOneRef();
     to_send = nullptr;
 
     ASSERT_EQ(Dispatcher::Type::DATA_PIPE_PRODUCER, to_receive->GetType());
-    producer_dispatcher_ =
-        static_cast<DataPipeProducerDispatcher*>(to_receive.get());
+    producer_dispatcher_ = RefPtr<DataPipeProducerDispatcher>(
+        static_cast<DataPipeProducerDispatcher*>(to_receive.get()));
   }
 
   DataPipe* DataPipeForProducer() override {
     if (producer_dispatcher_)
       return producer_dispatcher_->GetDataPipeForTest();
     return dp().get();
   }
   DataPipe* DataPipeForConsumer() override { return dp().get(); }
 
   void ProducerClose() override {
     if (producer_dispatcher_)
       ASSERT_EQ(MOJO_RESULT_OK, producer_dispatcher_->Close());
     else
       dp()->ProducerClose();
   }
   void ConsumerClose() override { dp()->ConsumerClose(); }
 
  protected:
-  scoped_refptr<DataPipeProducerDispatcher> producer_dispatcher_;
+  RefPtr<DataPipeProducerDispatcher> producer_dispatcher_;
 
  private:
   MOJO_DISALLOW_COPY_AND_ASSIGN(RemoteProducerDataPipeImplTestHelper);
 };
 
 // RemoteConsumerDataPipeImplTestHelper ----------------------------------------
 
 // Note about naming confusion: This class is named after the "local" class,
 // i.e., |dp_| will have a |RemoteConsumerDataPipeImpl|. The remote side, of
 // course, will have a |RemoteProducerDataPipeImpl|.
 class RemoteConsumerDataPipeImplTestHelper
     : public RemoteDataPipeImplTestHelper {
  public:
   RemoteConsumerDataPipeImplTestHelper() {}
   ~RemoteConsumerDataPipeImplTestHelper() override {}
 
   void DoTransfer() override {
     // This is the consumer dispatcher we'll send.
-    scoped_refptr<DataPipeConsumerDispatcher> to_send =
-        DataPipeConsumerDispatcher::Create();
+    auto to_send = DataPipeConsumerDispatcher::Create();
     to_send->Init(dp());
-    scoped_refptr<Dispatcher> to_receive;
+    RefPtr<Dispatcher> to_receive;
     SendDispatcher(0, to_send, &to_receive);
     // |to_send| should have been closed. This is |DCHECK()|ed when it is
     // destroyed.
-    EXPECT_TRUE(to_send->HasOneRef());
+    to_send->AssertHasOneRef();
     to_send = nullptr;
 
     ASSERT_EQ(Dispatcher::Type::DATA_PIPE_CONSUMER, to_receive->GetType());
-    consumer_dispatcher_ =
-        static_cast<DataPipeConsumerDispatcher*>(to_receive.get());
+    consumer_dispatcher_ = RefPtr<DataPipeConsumerDispatcher>(
+        static_cast<DataPipeConsumerDispatcher*>(to_receive.get()));
   }
 
   DataPipe* DataPipeForProducer() override { return dp().get(); }
   DataPipe* DataPipeForConsumer() override {
     if (consumer_dispatcher_)
       return consumer_dispatcher_->GetDataPipeForTest();
     return dp().get();
   }
 
   void ProducerClose() override { dp()->ProducerClose(); }
   void ConsumerClose() override {
     if (consumer_dispatcher_)
       ASSERT_EQ(MOJO_RESULT_OK, consumer_dispatcher_->Close());
     else
       dp()->ConsumerClose();
   }
 
  protected:
-  scoped_refptr<DataPipeConsumerDispatcher> consumer_dispatcher_;
+  RefPtr<DataPipeConsumerDispatcher> consumer_dispatcher_;
 
  private:
   MOJO_DISALLOW_COPY_AND_ASSIGN(RemoteConsumerDataPipeImplTestHelper);
 };
 
 // RemoteProducerDataPipeImplTestHelper2 ---------------------------------------
 
 // This is like |RemoteProducerDataPipeImplTestHelper|, but |DoTransfer()| does
 // a second transfer. This thus tests passing a producer handle twice, and in
 // particular tests (some of) |RemoteConsumerDataPipeImpl|'s
 // |ProducerEndSerialize()| (instead of |LocalDataPipeImpl|'s).
 //
 // Note about naming confusion: This class is named after the "local" class,
 // i.e., |dp_| will have a |RemoteProducerDataPipeImpl|. The remote side, of
 // course, will have a |RemoteConsumerDataPipeImpl|.
 class RemoteProducerDataPipeImplTestHelper2
     : public RemoteProducerDataPipeImplTestHelper {
  public:
   RemoteProducerDataPipeImplTestHelper2() {}
   ~RemoteProducerDataPipeImplTestHelper2() override {}
 
   void DoTransfer() override {
     // This is the producer dispatcher we'll send.
-    scoped_refptr<DataPipeProducerDispatcher> to_send =
-        DataPipeProducerDispatcher::Create();
+    auto to_send = DataPipeProducerDispatcher::Create();
     to_send->Init(dp());
-    scoped_refptr<Dispatcher> to_receive;
+    RefPtr<Dispatcher> to_receive;
     SendDispatcher(0, to_send, &to_receive);
     // |to_send| should have been closed. This is |DCHECK()|ed when it is
     // destroyed.
-    EXPECT_TRUE(to_send->HasOneRef());
+    to_send->AssertHasOneRef();
     to_send = nullptr;
     ASSERT_EQ(Dispatcher::Type::DATA_PIPE_PRODUCER, to_receive->GetType());
-    to_send = static_cast<DataPipeProducerDispatcher*>(to_receive.get());
+    to_send = RefPtr<DataPipeProducerDispatcher>(
+        static_cast<DataPipeProducerDispatcher*>(to_receive.get()));
     to_receive = nullptr;
 
     // Now send it back the other way.
     SendDispatcher(1, to_send, &to_receive);
     // |producer_dispatcher_| should have been closed. This is |DCHECK()|ed when
     // it is destroyed.
-    EXPECT_TRUE(to_send->HasOneRef());
+    to_send->AssertHasOneRef();
     to_send = nullptr;
 
     ASSERT_EQ(Dispatcher::Type::DATA_PIPE_PRODUCER, to_receive->GetType());
-    producer_dispatcher_ =
-        static_cast<DataPipeProducerDispatcher*>(to_receive.get());
+    producer_dispatcher_ = RefPtr<DataPipeProducerDispatcher>(
+        static_cast<DataPipeProducerDispatcher*>(to_receive.get()));
   }
 
  private:
   MOJO_DISALLOW_COPY_AND_ASSIGN(RemoteProducerDataPipeImplTestHelper2);
 };
 
 // RemoteConsumerDataPipeImplTestHelper2 ---------------------------------------
 
 // This is like |RemoteConsumerDataPipeImplTestHelper|, but |DoTransfer()| does
 // a second transfer. This thus tests passing a consumer handle twice, and in
 // particular tests (some of) |RemoteProducerDataPipeImpl|'s
 // |ConsumerEndSerialize()| (instead of |LocalDataPipeImpl|'s).
 //
 // Note about naming confusion: This class is named after the "local" class,
 // i.e., |dp_| will have a |RemoteConsumerDataPipeImpl|. The remote side, of
 // course, will have a |RemoteProducerDataPipeImpl|.
 class RemoteConsumerDataPipeImplTestHelper2
     : public RemoteConsumerDataPipeImplTestHelper {
  public:
   RemoteConsumerDataPipeImplTestHelper2() {}
   ~RemoteConsumerDataPipeImplTestHelper2() override {}
 
   void DoTransfer() override {
     // This is the consumer dispatcher we'll send.
-    scoped_refptr<DataPipeConsumerDispatcher> to_send =
-        DataPipeConsumerDispatcher::Create();
+    auto to_send = DataPipeConsumerDispatcher::Create();
     to_send->Init(dp());
-    scoped_refptr<Dispatcher> to_receive;
+    RefPtr<Dispatcher> to_receive;
     SendDispatcher(0, to_send, &to_receive);
     // |to_send| should have been closed. This is |DCHECK()|ed when it is
     // destroyed.
-    EXPECT_TRUE(to_send->HasOneRef());
+    to_send->AssertHasOneRef();
     to_send = nullptr;
     ASSERT_EQ(Dispatcher::Type::DATA_PIPE_CONSUMER, to_receive->GetType());
-    to_send = static_cast<DataPipeConsumerDispatcher*>(to_receive.get());
+    to_send = RefPtr<DataPipeConsumerDispatcher>(
+        static_cast<DataPipeConsumerDispatcher*>(to_receive.get()));
     to_receive = nullptr;
 
     // Now send it back the other way.
     SendDispatcher(1, to_send, &to_receive);
     // |consumer_dispatcher_| should have been closed. This is |DCHECK()|ed when
     // it is destroyed.
-    EXPECT_TRUE(to_send->HasOneRef());
+    to_send->AssertHasOneRef();
     to_send = nullptr;
 
     ASSERT_EQ(Dispatcher::Type::DATA_PIPE_CONSUMER, to_receive->GetType());
-    consumer_dispatcher_ =
-        static_cast<DataPipeConsumerDispatcher*>(to_receive.get());
+    consumer_dispatcher_ = RefPtr<DataPipeConsumerDispatcher>(
+        static_cast<DataPipeConsumerDispatcher*>(to_receive.get()));
   }
 
  private:
   MOJO_DISALLOW_COPY_AND_ASSIGN(RemoteConsumerDataPipeImplTestHelper2);
 };
 
 // Test case instantiation -----------------------------------------------------
 
 using HelperTypes = testing::Types<LocalDataPipeImplTestHelper,
                                    RemoteProducerDataPipeImplTestHelper,
@@ skipping 1939 matching lines @@
   test::Sleep(10u);
 
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(num_bytes));
 
   this->ConsumerClose();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo