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

mojo/edk/system/remote_message_pipe_unittest.cc

 // Copyright 2014 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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <memory>
 #include <utility>
@@ skipping 603 matching lines @@
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<ChannelEndpoint> ep0;
   auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // We'll try to pass this dispatcher.
-  scoped_refptr<MessagePipeDispatcher> dispatcher =
-      MessagePipeDispatcher::Create(
-          MessagePipeDispatcher::kDefaultCreateOptions);
+  auto dispatcher = MessagePipeDispatcher::Create(
+      MessagePipeDispatcher::kDefaultCreateOptions);
   auto local_mp = MessagePipe::CreateLocalLocal();
   dispatcher->Init(local_mp.Clone(), 0);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
-    EXPECT_TRUE(dispatcher->HasOneRef());
+    dispatcher->AssertHasOneRef();
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp1->ReadMessage(1, UserPointer<void>(read_buffer),
                        MakeUserPointer(&read_buffer_size), &read_dispatchers,
                        &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   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::MESSAGE_PIPE, read_dispatchers[0]->GetType());
-  dispatcher = static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get());
+  dispatcher = RefPtr<MessagePipeDispatcher>(
+      static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get()));
 
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             dispatcher->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456,
                                     nullptr));
 
   // Write to "local_mp", port 1.
   EXPECT_EQ(
       MOJO_RESULT_OK,
@@ skipping 64 matching lines @@
 }
 
 TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) {
   static const char kHello[] = "hello";
   static const char kWorld[] = "world!";
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // We'll try to pass this dispatcher.
-  scoped_refptr<MessagePipeDispatcher> dispatcher =
-      MessagePipeDispatcher::Create(
-          MessagePipeDispatcher::kDefaultCreateOptions);
+  auto dispatcher = MessagePipeDispatcher::Create(
+      MessagePipeDispatcher::kDefaultCreateOptions);
   auto local_mp = MessagePipe::CreateLocalLocal();
   dispatcher->Init(local_mp.Clone(), 0);
 
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   // Write to the other end (|local_mp|, port 1), and then close it.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
@@ skipping 36 matching lines @@
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
-    EXPECT_TRUE(dispatcher->HasOneRef());
+    dispatcher->AssertHasOneRef();
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp1->ReadMessage(1, UserPointer<void>(read_buffer),
                        MakeUserPointer(&read_buffer_size), &read_dispatchers,
                        &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   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::MESSAGE_PIPE, read_dispatchers[0]->GetType());
-  dispatcher = static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get());
+  dispatcher = RefPtr<MessagePipeDispatcher>(
+      static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get()));
 
   // |dispatcher| should already be readable and not writable.
   hss = dispatcher->GetHandleSignalsState();
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
   // So read from it.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
@@ skipping 35 matching lines @@
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<ChannelEndpoint> ep0;
   auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // We'll try to pass this dispatcher.
-  scoped_refptr<SharedBufferDispatcher> dispatcher;
-  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
-                                platform_support(),
-                                SharedBufferDispatcher::kDefaultCreateOptions,
-                                100, &dispatcher));
+  MojoResult result = MOJO_RESULT_INTERNAL;
+  auto dispatcher = SharedBufferDispatcher::Create(
+      platform_support(), SharedBufferDispatcher::kDefaultCreateOptions, 100,
+      &result);
+  EXPECT_EQ(MOJO_RESULT_OK, result);
   ASSERT_TRUE(dispatcher);
 
   // Make a mapping.
   std::unique_ptr<embedder::PlatformSharedBufferMapping> mapping0;
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
                                 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
   ASSERT_TRUE(mapping0);
   ASSERT_TRUE(mapping0->GetBase());
   ASSERT_EQ(100u, mapping0->GetLength());
   static_cast<char*>(mapping0->GetBase())[0] = 'A';
@@ skipping 16 matching lines @@
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
-    EXPECT_TRUE(dispatcher->HasOneRef());
+    dispatcher->AssertHasOneRef();
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp1->ReadMessage(1, UserPointer<void>(read_buffer),
                        MakeUserPointer(&read_buffer_size), &read_dispatchers,
                        &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   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::SHARED_BUFFER, read_dispatchers[0]->GetType());
-  dispatcher = static_cast<SharedBufferDispatcher*>(read_dispatchers[0].get());
+  dispatcher = RefPtr<SharedBufferDispatcher>(
+      static_cast<SharedBufferDispatcher*>(read_dispatchers[0].get()));
 
   // Make another mapping.
   std::unique_ptr<embedder::PlatformSharedBufferMapping> mapping1;
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
                                 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
   ASSERT_TRUE(mapping1);
   ASSERT_TRUE(mapping1->GetBase());
   ASSERT_EQ(100u, mapping1->GetLength());
   EXPECT_NE(mapping1->GetBase(), mapping0->GetBase());
   EXPECT_EQ('A', static_cast<char*>(mapping1->GetBase())[0]);
@@ skipping 31 matching lines @@
   RefPtr<ChannelEndpoint> ep0;
   auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   util::ScopedFILE fp(test_dir.CreateFile());
   EXPECT_EQ(sizeof(kHello), fwrite(kHello, 1, sizeof(kHello), fp.get()));
   // We'll try to pass this dispatcher, which will cause a |PlatformHandle| to
   // be passed.
-  scoped_refptr<PlatformHandleDispatcher> dispatcher =
-      PlatformHandleDispatcher::Create(
-          mojo::test::PlatformHandleFromFILE(fp.Pass()));
+  auto dispatcher = PlatformHandleDispatcher::Create(
+      mojo::test::PlatformHandleFromFILE(fp.Pass()));
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
-    EXPECT_TRUE(dispatcher->HasOneRef());
+    dispatcher->AssertHasOneRef();
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp1->ReadMessage(1, UserPointer<void>(read_buffer),
                        MakeUserPointer(&read_buffer_size), &read_dispatchers,
                        &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   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::PLATFORM_HANDLE, read_dispatchers[0]->GetType());
-  dispatcher =
-      static_cast<PlatformHandleDispatcher*>(read_dispatchers[0].get());
+  dispatcher = RefPtr<PlatformHandleDispatcher>(
+      static_cast<PlatformHandleDispatcher*>(read_dispatchers[0].get()));
 
   embedder::ScopedPlatformHandle h = dispatcher->PassPlatformHandle().Pass();
   EXPECT_TRUE(h.is_valid());
 
   fp = mojo::test::FILEFromPlatformHandle(h.Pass(), "rb").Pass();
   EXPECT_FALSE(h.is_valid());
   EXPECT_TRUE(fp);
 
   rewind(fp.get());
   memset(read_buffer, 0, sizeof(read_buffer));
@@ skipping 56 matching lines @@
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<ChannelEndpoint> ep0;
   auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // We'll try to pass this dispatcher.
-  scoped_refptr<MessagePipeDispatcher> dispatcher =
-      MessagePipeDispatcher::Create(
-          MessagePipeDispatcher::kDefaultCreateOptions);
+  auto dispatcher = MessagePipeDispatcher::Create(
+      MessagePipeDispatcher::kDefaultCreateOptions);
   auto local_mp = MessagePipe::CreateLocalLocal();
   dispatcher->Init(local_mp.Clone(), 0);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
-    EXPECT_TRUE(dispatcher->HasOneRef());
+    dispatcher->AssertHasOneRef();
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp1->ReadMessage(1, UserPointer<void>(read_buffer),
                        MakeUserPointer(&read_buffer_size), &read_dispatchers,
                        &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   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::MESSAGE_PIPE, read_dispatchers[0]->GetType());
-  dispatcher = static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get());
+  dispatcher = RefPtr<MessagePipeDispatcher>(
+      static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get()));
   read_dispatchers.clear();
 
   // Now pass it back.
 
   // Prepare to wait on MP 0, port 0. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
 
   // Write to MP 1, port 1.
   {
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
     // |dispatcher| is destroyed.
-    EXPECT_TRUE(dispatcher->HasOneRef());
+    dispatcher->AssertHasOneRef();
     dispatcher = nullptr;
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
   mp0->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
   // Read from MP 0, port 0.
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   read_num_dispatchers = 10;  // Maximum to get.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp0->ReadMessage(0, UserPointer<void>(read_buffer),
                        MakeUserPointer(&read_buffer_size), &read_dispatchers,
                        &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   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::MESSAGE_PIPE, read_dispatchers[0]->GetType());
-  dispatcher = static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get());
+  dispatcher = RefPtr<MessagePipeDispatcher>(
+      static_cast<MessagePipeDispatcher*>(read_dispatchers[0].get()));
   read_dispatchers.clear();
 
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             dispatcher->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
                                     nullptr));
 
   // Write to "local_mp", port 1.
   EXPECT_EQ(
@@ skipping 57 matching lines @@
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
   // Note that |local_mp|'s port 0 belong to |dispatcher|, which was closed.
   local_mp->Close(1);
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo