Convert mojo::system::Dispatcher 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 156 matching lines @@
   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;
 
   RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
-  scoped_refptr<DataPipeConsumerDispatcher> consumer =
-      DataPipeConsumerDispatcher::Create();
+  auto consumer = DataPipeConsumerDispatcher::Create();
   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 12 matching lines @@
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |consumer| should have been closed. This is |DCHECK()|ed when it is
     // destroyed.
-    EXPECT_TRUE(consumer->HasOneRef());
+    consumer->AssertHasOneRef();
     consumer = nullptr;
   }
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::ActionDeadline(), &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   EXPECT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->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));
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0]);
-  EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
+  read_dispatchers[0]->AssertHasOneRef();
 
   EXPECT_EQ(Dispatcher::Type::DATA_PIPE_CONSUMER,
             read_dispatchers[0]->GetType());
-  consumer =
-      static_cast<DataPipeConsumerDispatcher*>(read_dispatchers[0].get());
+  consumer = RefPtr<DataPipeConsumerDispatcher>(
+      static_cast<DataPipeConsumerDispatcher*>(read_dispatchers[0].get()));
   read_dispatchers.clear();
 
   waiter.Init();
   hss = HandleSignalsState();
   MojoResult result =
       consumer->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, &hss);
   if (result == MOJO_RESULT_OK) {
     context = 0;
     EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::ActionDeadline(), &context));
     EXPECT_EQ(456u, context);
@@ skipping 39 matching lines @@
   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;
 
   RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
-  scoped_refptr<DataPipeConsumerDispatcher> consumer =
-      DataPipeConsumerDispatcher::Create();
+  auto consumer = DataPipeConsumerDispatcher::Create();
   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).
@@ skipping 10 matching lines @@
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |consumer| should have been closed. This is |DCHECK()|ed when it is
     // destroyed.
-    EXPECT_TRUE(consumer->HasOneRef());
+    consumer->AssertHasOneRef();
     consumer = nullptr;
   }
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::ActionDeadline(), &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   EXPECT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->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));
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0]);
-  EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
+  read_dispatchers[0]->AssertHasOneRef();
 
   EXPECT_EQ(Dispatcher::Type::DATA_PIPE_CONSUMER,
             read_dispatchers[0]->GetType());
-  consumer =
-      static_cast<DataPipeConsumerDispatcher*>(read_dispatchers[0].get());
+  consumer = RefPtr<DataPipeConsumerDispatcher>(
+      static_cast<DataPipeConsumerDispatcher*>(read_dispatchers[0].get()));
   read_dispatchers.clear();
 
   // Now actually write the data, complete the two-phase write, and close the
   // producer.
   *static_cast<int32_t*>(write_ptr) = 123456;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(
                                 static_cast<uint32_t>(1u * sizeof(int32_t))));
   dp->ProducerClose();
 
   // Wait for the consumer to be readable.
@@ skipping 33 matching lines @@
   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;
 
   RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
-  scoped_refptr<DataPipeConsumerDispatcher> consumer =
-      DataPipeConsumerDispatcher::Create();
+  auto consumer = DataPipeConsumerDispatcher::Create();
   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(
@@ skipping 20 matching lines @@
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |consumer| should have been closed. This is |DCHECK()|ed when it is
     // destroyed.
-    EXPECT_TRUE(consumer->HasOneRef());
+    consumer->AssertHasOneRef();
     consumer = nullptr;
   }
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::ActionDeadline(), &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   EXPECT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->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));
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0]);
-  EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
+  read_dispatchers[0]->AssertHasOneRef();
 
   EXPECT_EQ(Dispatcher::Type::DATA_PIPE_CONSUMER,
             read_dispatchers[0]->GetType());
-  consumer =
-      static_cast<DataPipeConsumerDispatcher*>(read_dispatchers[0].get());
+  consumer = RefPtr<DataPipeConsumerDispatcher>(
+      static_cast<DataPipeConsumerDispatcher*>(read_dispatchers[0].get()));
   read_dispatchers.clear();
 
   // Now actually write the data, complete the two-phase write, and close the
   // producer.
   *static_cast<int32_t*>(write_ptr) = 789012;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(
                                 static_cast<uint32_t>(1u * sizeof(int32_t))));
   dp->ProducerClose();
 
   // Wait for the consumer to know that the producer is closed.
@@ skipping 24 matching lines @@
   EXPECT_EQ(123456, elements[0]);
   EXPECT_EQ(789012, elements[1]);
   EXPECT_EQ(0, elements[2]);
 
   consumer->Close();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo