Add Core methods for wait set.

mojo/edk/system/wait_set_dispatcher_unittest.cc

 // Copyright 2016 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::EpsilonTimeout()| may be increased to
 // increase tolerance and reduce observed flakiness (though doing so reduces the
 // meaningfulness of the test).
 
 #include "mojo/edk/system/wait_set_dispatcher.h"
@@ skipping 76 matching lines @@
 
   auto d = WaitSetDispatcher::Create(WaitSetDispatcher::kDefaultCreateOptions);
 
   // These will be members of our wait set.
   auto d_member0 = MakeRefCounted<test::MockSimpleDispatcher>(kW, kR | kW);
   auto d_member1 = MakeRefCounted<test::MockSimpleDispatcher>(kR, kR);
 
   // Add |d_member0|, for something not satisfied, but satisfiable.
   static constexpr uint64_t kCookie0 = 0x123456789abcdef0ULL;
   static constexpr auto kSignals0 = kR;
-  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(NullUserPointer(), d_member0.Clone(),
-                                          kSignals0, kCookie0));
+  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member0.Clone(), kSignals0,
+                                          kCookie0, NullUserPointer()));
 
   // Add |d_member1|, for something satisfied.
   static constexpr uint64_t kCookie1 = 0x23456789abcdef01ULL;
   static constexpr auto kSignals1 = kR;
-  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(NullUserPointer(), d_member1.Clone(),
-                                          kSignals1, kCookie1));
+  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member1.Clone(), kSignals1,
+                                          kCookie1, NullUserPointer()));
 
   // Can add |d_member0| again (satisfied), with a different cookie.
   static constexpr uint64_t kCookie2 = 0x3456789abcdef012ULL;
   static constexpr auto kSignals2 = kW;
-  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(NullUserPointer(), d_member0.Clone(),
-                                          kSignals2, kCookie2));
+  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member0.Clone(), kSignals2,
+                                          kCookie2, NullUserPointer()));
 
   // Adding something with the same cookie yields "already exists".
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            d->WaitSetAdd(NullUserPointer(), d_member1.Clone(), kR, kCookie2));
+            d->WaitSetAdd(d_member1.Clone(), kR, kCookie2, NullUserPointer()));
 
   // Can remove something based on a cookie.
   EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetRemove(kCookie0));
 
   // Trying to remove the same cookie again should fail.
   EXPECT_EQ(MOJO_RESULT_NOT_FOUND, d->WaitSetRemove(kCookie0));
 
   // Can re-add it (still not satisfied, but satisfiable).
   EXPECT_EQ(MOJO_RESULT_OK,
-            d->WaitSetAdd(NullUserPointer(), d_member0.Clone(), kR, kCookie0));
+            d->WaitSetAdd(d_member0.Clone(), kR, kCookie0, NullUserPointer()));
 
   // Wait. Recall:
   //   - |kCookie0| is for |d_member0| and is not satisfied (but satisfiable).
   //   - |kCookie1| is for |d_member1| and is satisfied.
   //   - |kCookie2| is for |d_member0| and is satisfied.
   {
     uint32_t num_results = 10u;
     MojoWaitSetResult results[10] = {};
     uint32_t max_results = static_cast<uint32_t>(-1);
     EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 150 matching lines @@
     EXPECT_GT(elapsed, test::EpsilonTimeout());
     EXPECT_LT(elapsed, 3 * test::EpsilonTimeout());
     // The inputs should be untouched.
     EXPECT_EQ(1u, num_results);
     EXPECT_EQ(456u, results[0].cookie);
     EXPECT_EQ(789u, max_results);
   }
 
   auto d_member = MakeRefCounted<test::MockSimpleDispatcher>(
       MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE);
-  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(NullUserPointer(), d_member.Clone(),
-                                          MOJO_HANDLE_SIGNAL_READABLE, 123u));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            d->WaitSetAdd(d_member.Clone(), MOJO_HANDLE_SIGNAL_READABLE, 123u,
+                          NullUserPointer()));
 
   // Wait with timeout with an unsatisfied (but satisfiable) entry.
   {
     uint32_t num_results = 1u;
     MojoWaitSetResult results[1] = {{456u}};
     uint32_t max_results = 789u;
     stopwatch.Start();
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
               d->WaitSetWait(
                   2 * test::EpsilonTimeout(), MakeUserPointer(&num_results),
@@ skipping 20 matching lines @@
 
   auto d = WaitSetDispatcher::Create(WaitSetDispatcher::kDefaultCreateOptions);
 
   // These will be members of our wait set.
   auto d_member0 = MakeRefCounted<test::MockSimpleDispatcher>(kNone, kR | kW);
   auto d_member1 = MakeRefCounted<test::MockSimpleDispatcher>(kNone, kR);
 
   // Add |d_member0|.
   static constexpr uint64_t kCookie0 = 123u;
   static constexpr auto kSignals0 = kR;
-  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(NullUserPointer(), d_member0.Clone(),
-                                          kSignals0, kCookie0));
+  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member0.Clone(), kSignals0,
+                                          kCookie0, NullUserPointer()));
 
   // Add |d_member1|.
   static constexpr uint64_t kCookie1 = 456u;
   static constexpr auto kSignals1 = kR;
-  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(NullUserPointer(), d_member1.Clone(),
-                                          kSignals1, kCookie1));
+  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member1.Clone(), kSignals1,
+                                          kCookie1, NullUserPointer()));
 
   // Can add |d_member0| again with a different cookie.
   static constexpr uint64_t kCookie2 = 789u;
   static constexpr auto kSignals2 = kW;
-  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(NullUserPointer(), d_member0.Clone(),
-                                          kSignals2, kCookie2));
+  EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member0.Clone(), kSignals2,
+                                          kCookie2, NullUserPointer()));
 
   // We'll wait on the main thread, and do stuff on another thread.
 
   {
     // Trigger |kCookie0|.
     std::thread t([epsilon, d_member0]() {
       // Sleep to try to ensure that waiting has started.
       ThreadSleep(epsilon);
       d_member0->SetSatisfiedSignals(kR);
     });
@@ skipping 118 matching lines @@
   static constexpr uint64_t kCookie2 = 789u;
   static constexpr auto kSignals2 = kR | kW;
 
   // We'll wait on the main thread, and do stuff on another thread.
 
   {
     // Add |kCookie0|.
     std::thread t0([epsilon, d, d_member]() {
       // Sleep to try to ensure that waiting has started.
       ThreadSleep(epsilon);
-      EXPECT_EQ(MOJO_RESULT_OK,
-                d->WaitSetAdd(NullUserPointer(), d_member.Clone(), kSignals0,
-                              kCookie0));
+      EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member.Clone(), kSignals0,
+                                              kCookie0, NullUserPointer()));
     });
     // Trigger |kCookie0| after |2 * epsilon| on another thread.
     stopwatch.Start();
     std::thread t1([epsilon, d_member]() {
       ThreadSleep(2 * epsilon);
       d_member->SetSatisfiedSignals(kR);
     });
 
     uint32_t num_results = 10u;
     MojoWaitSetResult results[10] = {};
@@ skipping 22 matching lines @@
     // Remove |kCookie0|.
     std::thread t0([epsilon, d]() {
       // Sleep to try to ensure that waiting has started.
       ThreadSleep(epsilon);
       EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetRemove(kCookie0));
     });
     // Add |kCookie1|.
     std::thread t1([epsilon, d, d_member]() {
       // Sleep to try to ensure that waiting has started.
       ThreadSleep(epsilon);
-      EXPECT_EQ(MOJO_RESULT_OK,
-                d->WaitSetAdd(NullUserPointer(), d_member.Clone(), kSignals1,
-                              kCookie1));
+      EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member.Clone(), kSignals1,
+                                              kCookie1, NullUserPointer()));
     });
     // Add |kCookie2|.
     std::thread t2([epsilon, d, d_member]() {
       // Sleep to try to ensure that waiting has started.
       ThreadSleep(epsilon);
-      EXPECT_EQ(MOJO_RESULT_OK,
-                d->WaitSetAdd(NullUserPointer(), d_member.Clone(), kSignals2,
-                              kCookie2));
+      EXPECT_EQ(MOJO_RESULT_OK, d->WaitSetAdd(d_member.Clone(), kSignals2,
+                                              kCookie2, NullUserPointer()));
     });
     // Trigger |kCookie1| and |kCookie2| after |2 * epsilon| on another thread.
     stopwatch.Start();
     std::thread t3([epsilon, d_member]() {
       ThreadSleep(2 * epsilon);
       d_member->SetSatisfiedSignals(kW);
     });
 
     uint32_t num_results = 10u;
     MojoWaitSetResult results[10] = {};
@@ skipping 53 matching lines @@
   const auto epsilon = test::EpsilonTimeout();
 
   Stopwatch stopwatch;
 
   auto d = WaitSetDispatcher::Create(WaitSetDispatcher::kDefaultCreateOptions);
   auto d_member = MakeRefCounted<test::MockSimpleDispatcher>(kNone, kR);
 
   {
     // Add an entry.
     EXPECT_EQ(MOJO_RESULT_OK,
-              d->WaitSetAdd(NullUserPointer(), d_member.Clone(), kR, 123u));
+              d->WaitSetAdd(d_member.Clone(), kR, 123u, NullUserPointer()));
 
     // Wait on a bunch of threads. We'll trigger on the main thread.
     std::vector<std::thread> threads;
     for (size_t i = 0; i < 4; i++) {
       threads.push_back(std::thread([epsilon, d, d_member]() {
         uint32_t num_results = 10u;
         MojoWaitSetResult results[10] = {};
         EXPECT_EQ(MOJO_RESULT_OK,
                   d->WaitSetWait(5 * epsilon, MakeUserPointer(&num_results),
                                  MakeUserPointer(results), NullUserPointer()));
@@ skipping 52 matching lines @@
   uint64_t next_cookie = kQuitCookie + 1;
   // Cookie -> dispatcher map. Guarded by |mu|.
   std::map<uint64_t, RefPtr<test::MockSimpleDispatcher>>
       cookie_to_dispatcher_map;
 
   auto wait_set =
       WaitSetDispatcher::Create(WaitSetDispatcher::kDefaultCreateOptions);
   // The quit dispatcher and entry.
   auto quit = MakeRefCounted<test::MockSimpleDispatcher>(kNone, kSignal);
   EXPECT_EQ(MOJO_RESULT_OK,
-            wait_set->WaitSetAdd(NullUserPointer(), quit.Clone(), kSignal,
-                                 kQuitCookie));
+            wait_set->WaitSetAdd(quit.Clone(), kSignal, kQuitCookie,
+                                 NullUserPointer()));
 
   std::vector<std::thread> threads;
 
   // Add waiter threads.
   for (size_t i = 0; i < kNumWaiters; i++) {
     threads.push_back(std::thread([&mu, &cookie_to_dispatcher_map, &wait_set,
                                    i]() {
       uint64_t total_wakeups = 0;
 
       for (;;) {
@@ skipping 57 matching lines @@
               MakeRefCounted<test::MockSimpleDispatcher>(kNone, kSignal);
           uint64_t new_cookie;
           {
             MutexLocker locker(&mu);
             new_cookie = next_cookie++;
             cookie_to_dispatcher_map[new_cookie] = new_dispatcher;
             dispatchers.push_back(new_dispatcher);
             cookies.push_back(new_cookie);
           }
           EXPECT_NE(new_cookie, kQuitCookie);
-          EXPECT_EQ(
-              MOJO_RESULT_OK,
-              wait_set->WaitSetAdd(NullUserPointer(), std::move(new_dispatcher),
-                                   kSignal, new_cookie));
+          EXPECT_EQ(MOJO_RESULT_OK,
+                    wait_set->WaitSetAdd(std::move(new_dispatcher), kSignal,
+                                         new_cookie, NullUserPointer()));
         }
 
         // Should we trigger an entry? Make the probability be (current number)
         // / (maximum number).
         int j = test::RandomInt(0, static_cast<int>(kMaxEntriesPerWorker - 1));
         if (j < static_cast<int>(dispatchers.size())) {
           total_triggers++;
 
           // Just use |j| as an index into |dispatchers|/|cookies|.
           dispatchers[j]->SetSatisfiedSignals(kSignal);
@@ skipping 41 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, quit->Close());
   EXPECT_EQ(MOJO_RESULT_OK, wait_set->Close());
 }
 
 // TODO(vtl): Test options validation for "create" and "add" (not that there's
 // much to test).
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo