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

mojo/edk/system/message_pipe_dispatcher_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.
 
 // NOTE(vtl): Some of these tests are inherently flaky (e.g., if run on a
 // heavily-loaded system). Sorry. |test::EpsilonDeadline()| may be increased to
 // increase tolerance and reduce observed flakiness (though doing so reduces the
 // meaningfulness of the test).
 
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 
 #include <string.h>
 
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
-#include "base/memory/ref_counted.h"
 #include "mojo/edk/system/message_pipe.h"
+#include "mojo/edk/system/ref_ptr.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/system/waiter_test_utils.h"
 #include "mojo/edk/test/simple_test_thread.h"
 #include "mojo/edk/util/make_unique.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
 const MojoHandleSignals kAllSignals = MOJO_HANDLE_SIGNAL_READABLE |
                                       MOJO_HANDLE_SIGNAL_WRITABLE |
                                       MOJO_HANDLE_SIGNAL_PEER_CLOSED;
 
 TEST(MessagePipeDispatcherTest, Basic) {
   test::Stopwatch stopwatch;
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
-    scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
+    auto d0 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     EXPECT_EQ(Dispatcher::Type::MESSAGE_PIPE, d0->GetType());
-    scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
+    auto d1 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     {
       auto mp = MessagePipe::CreateLocalLocal();
       d0->Init(mp.Clone(), i);         // 0, 1.
       d1->Init(std::move(mp), i ^ 1);  // 1, 0.
     }
     Waiter w;
     uint32_t context = 0;
     HandleSignalsState hss;
 
@@ skipping 88 matching lines @@
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
     EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
   }
 }
 
 TEST(MessagePipeDispatcherTest, InvalidParams) {
   char buffer[1];
 
-  scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
+  auto d0 = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
-  scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
+  auto d1 = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   {
     auto mp = MessagePipe::CreateLocalLocal();
     d0->Init(mp.Clone(), 0);
     d1->Init(std::move(mp), 1);
   }
 
   // |WriteMessage|:
   // Huge buffer size.
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             d0->WriteMessage(UserPointer<const void>(buffer),
                              std::numeric_limits<uint32_t>::max(), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
 }
 
 // These test invalid arguments that should cause death if we're being paranoid
 // about checking arguments (which we would want to do if, e.g., we were in a
 // true "kernel" situation, but we might not want to do otherwise for
 // performance reasons). Probably blatant errors like passing in null pointers
 // (for required pointer arguments) will still cause death, but perhaps not
 // predictably.
 TEST(MessagePipeDispatcherTest, InvalidParamsDeath) {
   const char kMemoryCheckFailedRegex[] = "Check failed";
 
-  scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
+  auto d0 = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
-  scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
+  auto d1 = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   {
     auto mp = MessagePipe::CreateLocalLocal();
     d0->Init(mp.Clone(), 0);
     d1->Init(std::move(mp), 1);
   }
 
   // |WriteMessage|:
   // Null buffer with nonzero buffer size.
   EXPECT_DEATH_IF_SUPPORTED(d0->WriteMessage(NullUserPointer(), 1, nullptr,
@@ skipping 17 matching lines @@
 }
 
 // Test what happens when one end is closed (single-threaded test).
 TEST(MessagePipeDispatcherTest, BasicClosed) {
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
-    scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
+    auto d0 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
-    scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
+    auto d1 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     {
       auto mp = MessagePipe::CreateLocalLocal();
       d0->Init(mp.Clone(), i);         // 0, 1.
       d1->Init(std::move(mp), i ^ 1);  // 1, 0.
     }
     Waiter w;
     HandleSignalsState hss;
 
     // Write (twice) to |d1|.
@@ skipping 107 matching lines @@
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
   MojoDeadline elapsed;
   bool did_wait;
   MojoResult result;
   uint32_t context;
   HandleSignalsState hss;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
-    scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
+    auto d0 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
-    scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
+    auto d1 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     {
       auto mp = MessagePipe::CreateLocalLocal();
       d0->Init(mp.Clone(), i);         // 0, 1.
       d1->Init(std::move(mp), i ^ 1);  // 1, 0.
     }
 
     // Wait for readable on |d1|, which will become readable after some time.
     {
       test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
@@ skipping 60 matching lines @@
     EXPECT_TRUE(did_wait);
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
     EXPECT_EQ(3u, context);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
     EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
   }
 
   for (unsigned i = 0; i < 2; i++) {
-    scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
+    auto d0 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
-    scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
+    auto d1 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     {
       auto mp = MessagePipe::CreateLocalLocal();
       d0->Init(mp.Clone(), i);         // 0, 1.
       d1->Init(std::move(mp), i ^ 1);  // 1, 0.
     }
 
     // Wait for readable on |d1| and close |d1| after some time, which should
     // cancel that wait.
     {
@@ skipping 19 matching lines @@
 }
 
 // Stress test -----------------------------------------------------------------
 
 const size_t kMaxMessageSize = 2000;
 
 class WriterThread : public mojo::test::SimpleTestThread {
  public:
   // |*messages_written| and |*bytes_written| belong to the thread while it's
   // alive.
-  WriterThread(scoped_refptr<Dispatcher> write_dispatcher,
+  WriterThread(RefPtr<Dispatcher> write_dispatcher,
                size_t* messages_written,
                size_t* bytes_written)
       : write_dispatcher_(write_dispatcher),
         messages_written_(messages_written),
         bytes_written_(bytes_written) {
     *messages_written_ = 0;
     *bytes_written_ = 0;
   }
 
   ~WriterThread() override { Join(); }
@@ skipping 18 matching lines @@
                                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
       *bytes_written_ += bytes_to_write;
     }
 
     // Write one last "quit" message.
     EXPECT_EQ(MOJO_RESULT_OK, write_dispatcher_->WriteMessage(
                                   UserPointer<const void>("quit"), 4, nullptr,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
 
-  const scoped_refptr<Dispatcher> write_dispatcher_;
+  const RefPtr<Dispatcher> write_dispatcher_;
   size_t* const messages_written_;
   size_t* const bytes_written_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(WriterThread);
 };
 
 class ReaderThread : public mojo::test::SimpleTestThread {
  public:
   // |*messages_read| and |*bytes_read| belong to the thread while it's alive.
-  ReaderThread(scoped_refptr<Dispatcher> read_dispatcher,
+  ReaderThread(RefPtr<Dispatcher> read_dispatcher,
                size_t* messages_read,
                size_t* bytes_read)
       : read_dispatcher_(read_dispatcher),
         messages_read_(messages_read),
         bytes_read_(bytes_read) {
     *messages_read_ = 0;
     *bytes_read_ = 0;
   }
 
   ~ReaderThread() override { Join(); }
@@ skipping 55 matching lines @@
         return false;
     }
     // Check that the remaining bytes weren't stomped on.
     for (; i < kMaxMessageSize; i++) {
       if (buffer[i] != 0)
         return false;
     }
     return true;
   }
 
-  const scoped_refptr<Dispatcher> read_dispatcher_;
+  const RefPtr<Dispatcher> read_dispatcher_;
   size_t* const messages_read_;
   size_t* const bytes_read_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ReaderThread);
 };
 
 TEST(MessagePipeDispatcherTest, Stress) {
   static const size_t kNumWriters = 30;
   static const size_t kNumReaders = kNumWriters;
 
-  scoped_refptr<MessagePipeDispatcher> d_write = MessagePipeDispatcher::Create(
+  auto d_write = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
-  scoped_refptr<MessagePipeDispatcher> d_read = MessagePipeDispatcher::Create(
+  auto d_read = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   {
     auto mp = MessagePipe::CreateLocalLocal();
     d_write->Init(mp.Clone(), 0);
     d_read->Init(std::move(mp), 1);
   }
 
   size_t messages_written[kNumWriters];
   size_t bytes_written[kNumWriters];
   size_t messages_read[kNumReaders];
@@ skipping 44 matching lines @@
   EXPECT_EQ(total_messages_written, total_messages_read);
   EXPECT_EQ(total_bytes_written, total_bytes_read);
 
   EXPECT_EQ(MOJO_RESULT_OK, d_write->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d_read->Close());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo