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

mojo/edk/system/simple_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/simple_dispatcher.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/logging.h"
-#include "base/memory/ref_counted.h"
+#include "mojo/edk/system/ref_ptr.h"
 #include "mojo/edk/system/test_utils.h"
+#include "mojo/edk/system/thread_annotations.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/system/waiter_test_utils.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 {
 
 class MockSimpleDispatcher final : public SimpleDispatcher {
  public:
-  MockSimpleDispatcher()
-      : state_(MOJO_HANDLE_SIGNAL_NONE,
-               MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE) {}
-  explicit MockSimpleDispatcher(const HandleSignalsState& state)
-      : state_(state) {}
+  // Note: Use |MakeRefCounted<MockSimpleDispatcher>()|.
 
   void SetSatisfiedSignals(MojoHandleSignals new_satisfied_signals) {
     MutexLocker locker(&mutex());
 
     // Any new signals that are set should be satisfiable.
     CHECK_EQ(new_satisfied_signals & ~state_.satisfied_signals,
              new_satisfied_signals & ~state_.satisfied_signals &
                  state_.satisfiable_signals);
 
     if (new_satisfied_signals == state_.satisfied_signals)
@@ skipping 13 matching lines @@
     if (new_satisfiable_signals == state_.satisfiable_signals)
       return;
 
     state_.satisfiable_signals = new_satisfiable_signals;
     HandleSignalsStateChangedNoLock();
   }
 
   Type GetType() const override { return Type::UNKNOWN; }
 
  private:
+  FRIEND_MAKE_REF_COUNTED(MockSimpleDispatcher);
+
+  MockSimpleDispatcher()
+      : state_(MOJO_HANDLE_SIGNAL_NONE,
+               MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE) {}
+  explicit MockSimpleDispatcher(const HandleSignalsState& state)
+      : state_(state) {}
   ~MockSimpleDispatcher() override {}
 
-  scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock()
-      override {
-    scoped_refptr<MockSimpleDispatcher> rv(new MockSimpleDispatcher(state_));
-    return scoped_refptr<Dispatcher>(rv.get());
+  RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock() override
+      MOJO_NO_THREAD_SAFETY_ANALYSIS {
+    return MakeRefCounted<MockSimpleDispatcher>(state_);
   }
 
   // |Dispatcher| override:
   HandleSignalsState GetHandleSignalsStateImplNoLock() const override {
     mutex().AssertHeld();
     return state_;
   }
 
   HandleSignalsState state_ MOJO_GUARDED_BY(mutex());
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(MockSimpleDispatcher);
 };
 
 TEST(SimpleDispatcherTest, Basic) {
   test::Stopwatch stopwatch;
 
-  scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+  auto d = MakeRefCounted<MockSimpleDispatcher>();
   Waiter w;
   uint32_t context = 0;
   HandleSignalsState hss;
 
   // Try adding a readable waiter when already readable.
   w.Init();
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
@@ skipping 81 matching lines @@
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
 }
 
 TEST(SimpleDispatcherTest, BasicUnsatisfiable) {
   test::Stopwatch stopwatch;
 
-  scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+  auto d = MakeRefCounted<MockSimpleDispatcher>();
   Waiter w;
   uint32_t context = 0;
   HandleSignalsState hss;
 
   // Try adding a writable waiter when it can never be writable.
   w.Init();
   d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE);
   d->SetSatisfiedSignals(0);
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ skipping 52 matching lines @@
   d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
 }
 
 TEST(SimpleDispatcherTest, BasicClosed) {
   test::Stopwatch stopwatch;
 
-  scoped_refptr<MockSimpleDispatcher> d;
+  RefPtr<MockSimpleDispatcher> d;
   Waiter w;
   uint32_t context = 0;
   HandleSignalsState hss;
 
   // Try adding a writable waiter when the dispatcher has been closed.
-  d = new MockSimpleDispatcher();
+  d = MakeRefCounted<MockSimpleDispatcher>();
   w.Init();
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   // Shouldn't need to remove the waiter (it was not added).
 
   // Wait (forever) for writable and then the dispatcher is closed.
-  d = new MockSimpleDispatcher();
+  d = MakeRefCounted<MockSimpleDispatcher>();
   w.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_CANCELLED, w.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonDeadline());
   EXPECT_EQ(2u, context);
   // Don't need to remove waiters from closed dispatchers.
 
   // Wait for zero time for writable and then the dispatcher is closed.
-  d = new MockSimpleDispatcher();
+  d = MakeRefCounted<MockSimpleDispatcher>();
   w.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_CANCELLED, w.Wait(0, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonDeadline());
   EXPECT_EQ(3u, context);
   // Don't need to remove waiters from closed dispatchers.
 
   // Wait for non-zero, finite time for writable and then the dispatcher is
   // closed.
-  d = new MockSimpleDispatcher();
+  d = MakeRefCounted<MockSimpleDispatcher>();
   w.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_CANCELLED,
             w.Wait(2 * test::EpsilonDeadline(), &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonDeadline());
   EXPECT_EQ(4u, context);
   // Don't need to remove waiters from closed dispatchers.
 }
 
 TEST(SimpleDispatcherTest, BasicThreaded) {
   test::Stopwatch stopwatch;
   bool did_wait;
   MojoResult result;
   uint32_t context;
   HandleSignalsState hss;
 
   // Wait for readable (already readable).
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     {
       d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
       test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result,
                                 &context, &hss);
       stopwatch.Start();
       thread.Start();
     }  // Joins the thread.
     // If we closed earlier, then probably we'd get a |MOJO_RESULT_CANCELLED|.
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonDeadline());
   EXPECT_FALSE(did_wait);
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, result);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Wait for readable and becomes readable after some time.
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     {
       test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE, 2, &did_wait, &result,
                                 &context, &hss);
       stopwatch.Start();
       thread.Start();
       test::Sleep(2 * test::EpsilonDeadline());
       d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
     }  // Joins the thread.
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }
   MojoDeadline elapsed = stopwatch.Elapsed();
   EXPECT_GT(elapsed, (2 - 1) * test::EpsilonDeadline());
   EXPECT_LT(elapsed, (2 + 1) * test::EpsilonDeadline());
   EXPECT_TRUE(did_wait);
   EXPECT_EQ(MOJO_RESULT_OK, result);
   EXPECT_EQ(2u, context);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 
   // Wait for readable and becomes never-readable after some time.
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     {
       test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE, 3, &did_wait, &result,
                                 &context, &hss);
       stopwatch.Start();
       thread.Start();
       test::Sleep(2 * test::EpsilonDeadline());
       d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_NONE);
     }  // Joins the thread.
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }
   elapsed = stopwatch.Elapsed();
   EXPECT_GT(elapsed, (2 - 1) * test::EpsilonDeadline());
   EXPECT_LT(elapsed, (2 + 1) * test::EpsilonDeadline());
   EXPECT_TRUE(did_wait);
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
   EXPECT_EQ(3u, context);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   // Wait for readable and dispatcher gets closed.
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
                               MOJO_DEADLINE_INDEFINITE, 4, &did_wait, &result,
                               &context, &hss);
     stopwatch.Start();
     thread.Start();
     test::Sleep(2 * test::EpsilonDeadline());
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }  // Joins the thread.
   elapsed = stopwatch.Elapsed();
   EXPECT_GT(elapsed, (2 - 1) * test::EpsilonDeadline());
   EXPECT_LT(elapsed, (2 + 1) * test::EpsilonDeadline());
   EXPECT_TRUE(did_wait);
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
   EXPECT_EQ(4u, context);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   // Wait for readable and times out.
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     {
       test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
                                 2 * test::EpsilonDeadline(), 5, &did_wait,
                                 &result, &context, &hss);
       stopwatch.Start();
       thread.Start();
       test::Sleep(1 * test::EpsilonDeadline());
       // Not what we're waiting for.
       d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_WRITABLE);
     }  // Joins the thread (after its wait times out).
@@ skipping 13 matching lines @@
 TEST(SimpleDispatcherTest, MultipleWaiters) {
   static const uint32_t kNumWaiters = 20;
 
   bool did_wait[kNumWaiters];
   MojoResult result[kNumWaiters];
   uint32_t context[kNumWaiters];
   HandleSignalsState hss[kNumWaiters];
 
   // All wait for readable and becomes readable after some time.
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     std::vector<std::unique_ptr<test::WaiterThread>> threads;
     for (uint32_t i = 0; i < kNumWaiters; i++) {
       threads.push_back(util::MakeUnique<test::WaiterThread>(
           d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
           &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     test::Sleep(2 * test::EpsilonDeadline());
     d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }  // Joins the threads.
   for (uint32_t i = 0; i < kNumWaiters; i++) {
     EXPECT_TRUE(did_wait[i]) << i;
     EXPECT_EQ(MOJO_RESULT_OK, result[i]) << i;
     EXPECT_EQ(i, context[i]) << i;
     // Since we closed before joining, we can't say much about what each thread
     // saw as the state.
   }
 
   // Some wait for readable, some for writable, and becomes readable after some
   // time.
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     std::vector<std::unique_ptr<test::WaiterThread>> threads;
     for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
       threads.push_back(util::MakeUnique<test::WaiterThread>(
           d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
           &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
       threads.push_back(util::MakeUnique<test::WaiterThread>(
           d, MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE, i,
@@ skipping 16 matching lines @@
     EXPECT_TRUE(did_wait[i]) << i;
     EXPECT_EQ(MOJO_RESULT_CANCELLED, result[i]) << i;
     EXPECT_EQ(i, context[i]) << i;
     // Since we closed before joining, we can't say much about what each thread
     // saw as the state.
   }
 
   // Some wait for readable, some for writable, and becomes readable and
   // never-writable after some time.
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     std::vector<std::unique_ptr<test::WaiterThread>> threads;
     for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
       threads.push_back(util::MakeUnique<test::WaiterThread>(
           d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
           &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
       threads.push_back(util::MakeUnique<test::WaiterThread>(
           d, MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE, i,
@@ skipping 17 matching lines @@
     EXPECT_TRUE(did_wait[i]) << i;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result[i]) << i;
     EXPECT_EQ(i, context[i]) << i;
     // Since we closed before joining, we can't say much about what each thread
     // saw as the state.
   }
 
   // Some wait for readable, some for writable, and becomes readable after some
   // time.
   {
-    scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
+    auto d = MakeRefCounted<MockSimpleDispatcher>();
     std::vector<std::unique_ptr<test::WaiterThread>> threads;
     for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
       threads.push_back(util::MakeUnique<test::WaiterThread>(
           d, MOJO_HANDLE_SIGNAL_READABLE, 3 * test::EpsilonDeadline(), i,
           &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
       threads.push_back(util::MakeUnique<test::WaiterThread>(
           d, MOJO_HANDLE_SIGNAL_WRITABLE, 1 * test::EpsilonDeadline(), i,
@@ skipping 18 matching lines @@
     // Since we closed before joining, we can't say much about what each thread
     // saw as the state.
   }
 }
 
 // TODO(vtl): Stress test?
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo