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

mojo/edk/system/multiprocess_message_pipe_unittest.cc

 // Copyright 2013 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 <string>
@@ skipping 224 matching lines @@
   CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
                            MakeUserPointer(&num_bytes), &dispatchers,
                            &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("go 1"));
   CHECK_EQ(num_dispatchers, 1u);
 
   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::Type::SHARED_BUFFER);
 
-  scoped_refptr<SharedBufferDispatcher> dispatcher(
+  RefPtr<SharedBufferDispatcher> dispatcher(
       static_cast<SharedBufferDispatcher*>(dispatchers[0].get()));
 
   // Make a mapping.
   std::unique_ptr<embedder::PlatformSharedBufferMapping> mapping;
   CHECK_EQ(dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping),
            MOJO_RESULT_OK);
   CHECK(mapping);
   CHECK(mapping->GetBase());
   CHECK_EQ(mapping->GetLength(), 100u);
 
@@ skipping 47 matching lines @@
 #define MAYBE_SharedBufferPassing SharedBufferPassing
 #endif
 TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
   helper()->StartChild("CheckSharedBuffer");
 
   RefPtr<ChannelEndpoint> ep;
   auto mp = MessagePipe::CreateLocalProxy(&ep);
   Init(std::move(ep));
 
   // Make a shared buffer.
-  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> mapping;
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
   ASSERT_TRUE(mapping);
   ASSERT_TRUE(mapping->GetBase());
   ASSERT_EQ(100u, mapping->GetLength());
 
   // Send the shared buffer.
   const std::string go1("go 1");
   DispatcherTransport transport(
       test::DispatcherTryStartTransport(dispatcher.get()));
   ASSERT_TRUE(transport.is_valid());
 
   std::vector<DispatcherTransport> transports;
   transports.push_back(transport);
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0, UserPointer<const void>(&go1[0]),
                              static_cast<uint32_t>(go1.size()), &transports,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   transport.End();
 
-  EXPECT_TRUE(dispatcher->HasOneRef());
+  dispatcher->AssertHasOneRef();
   dispatcher = nullptr;
 
   // Wait for a message from the child.
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_OK,
             test::WaitIfNecessary(mp.get(), MOJO_HANDLE_SIGNAL_READABLE, &hss));
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
   std::string read_buffer(100, '\0');
@@ skipping 65 matching lines @@
   read_buffer.resize(num_bytes);
   char hello[32];
   int num_handles = 0;
   sscanf(read_buffer.c_str(), "%s %d", hello, &num_handles);
   CHECK_EQ(std::string("hello"), std::string(hello));
   CHECK_GT(num_handles, 0);
 
   for (int i = 0; i < num_handles; ++i) {
     CHECK_EQ(dispatchers[i]->GetType(), Dispatcher::Type::PLATFORM_HANDLE);
 
-    scoped_refptr<PlatformHandleDispatcher> dispatcher(
+    RefPtr<PlatformHandleDispatcher> dispatcher(
         static_cast<PlatformHandleDispatcher*>(dispatchers[i].get()));
     embedder::ScopedPlatformHandle h = dispatcher->PassPlatformHandle().Pass();
     CHECK(h.is_valid());
     dispatcher->Close();
 
     util::ScopedFILE fp(mojo::test::FILEFromPlatformHandle(h.Pass(), "r"));
     CHECK(fp);
     std::string fread_buffer(100, '\0');
     size_t bytes_read =
         fread(&fread_buffer[0], 1, fread_buffer.size(), fp.get());
@@ skipping 10 matching lines @@
 
 TEST_P(MultiprocessMessagePipeTestWithPipeCount, PlatformHandlePassing) {
   mojo::test::ScopedTestDir test_dir;
 
   helper()->StartChild("CheckPlatformHandleFile");
 
   RefPtr<ChannelEndpoint> ep;
   auto mp = MessagePipe::CreateLocalProxy(&ep);
   Init(std::move(ep));
 
-  std::vector<scoped_refptr<PlatformHandleDispatcher>> dispatchers;
+  std::vector<RefPtr<PlatformHandleDispatcher>> dispatchers;
   std::vector<DispatcherTransport> transports;
 
   size_t pipe_count = GetParam();
   for (size_t i = 0; i < pipe_count; ++i) {
     util::ScopedFILE fp(test_dir.CreateFile());
     const std::string world("world");
     CHECK_EQ(fwrite(&world[0], 1, world.size(), fp.get()), world.size());
     fflush(fp.get());
     rewind(fp.get());
 
-    scoped_refptr<PlatformHandleDispatcher> dispatcher =
+    auto dispatcher =
         PlatformHandleDispatcher::Create(embedder::ScopedPlatformHandle(
             mojo::test::PlatformHandleFromFILE(fp.Pass())));
     dispatchers.push_back(dispatcher);
     DispatcherTransport transport(
         test::DispatcherTryStartTransport(dispatcher.get()));
     ASSERT_TRUE(transport.is_valid());
     transports.push_back(transport);
   }
 
   char message[128];
   sprintf(message, "hello %d", static_cast<int>(pipe_count));
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0, UserPointer<const void>(message),
                              static_cast<uint32_t>(strlen(message)),
                              &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   for (size_t i = 0; i < pipe_count; ++i) {
     transports[i].End();
-    EXPECT_TRUE(dispatchers[i]->HasOneRef());
+    dispatchers[i]->AssertHasOneRef();
   }
 
   dispatchers.clear();
 
   // Wait for it to become readable, which should fail.
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             test::WaitIfNecessary(mp.get(), MOJO_HANDLE_SIGNAL_READABLE, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   mp->Close(0);
 
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 // Android multi-process tests are not executing the new process. This is flaky.
 #if !defined(OS_ANDROID)
 INSTANTIATE_TEST_CASE_P(PipeCount,
                         MultiprocessMessagePipeTestWithPipeCount,
                         testing::Values(1u, 128u, 140u));
 #endif
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo