EDK: Change Awakable::Awake()'s context, etc., to be a uint64_t.

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::EpsilonTimeout()| 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"
@@ skipping 21 matching lines @@
 
 namespace mojo {
 namespace system {
 namespace {
 
 TEST(SimpleDispatcherTest, Basic) {
   Stopwatch stopwatch;
 
   auto d = MakeRefCounted<test::MockSimpleDispatcher>();
   Waiter w;
-  uint32_t context = 0;
+  uint64_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));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ skipping 81 matching lines @@
             hss.satisfiable_signals);
 
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
 }
 
 TEST(SimpleDispatcherTest, BasicUnsatisfiable) {
   Stopwatch stopwatch;
 
   auto d = MakeRefCounted<test::MockSimpleDispatcher>();
   Waiter w;
-  uint32_t context = 0;
+  uint64_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,
             d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
@@ skipping 52 matching lines @@
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
 }
 
 TEST(SimpleDispatcherTest, BasicClosed) {
   Stopwatch stopwatch;
 
   RefPtr<test::MockSimpleDispatcher> d;
   Waiter w;
-  uint32_t context = 0;
+  uint64_t context = 0;
   HandleSignalsState hss;
 
   // Try adding a writable waiter when the dispatcher has been closed.
   d = MakeRefCounted<test::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);
@@ skipping 36 matching lines @@
             w.Wait(2 * test::EpsilonTimeout(), &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   EXPECT_EQ(4u, context);
   // Don't need to remove waiters from closed dispatchers.
 }
 
 TEST(SimpleDispatcherTest, BasicThreaded) {
   Stopwatch stopwatch;
   bool did_wait;
   MojoResult result;
-  uint32_t context;
+  uint64_t context;
   HandleSignalsState hss;
 
   // Wait for readable (already readable).
   {
     auto d = MakeRefCounted<test::MockSimpleDispatcher>();
     {
       d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
       test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result,
                                 &context, &hss);
@@ skipping 101 matching lines @@
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 }
 
 TEST(SimpleDispatcherTest, MultipleWaiters) {
   static const uint32_t kNumWaiters = 20;
 
   bool did_wait[kNumWaiters];
   MojoResult result[kNumWaiters];
-  uint32_t context[kNumWaiters];
+  uint64_t context[kNumWaiters];
   HandleSignalsState hss[kNumWaiters];
 
   // All wait for readable and becomes readable after some time.
   {
     auto d = MakeRefCounted<test::MockSimpleDispatcher>();
     std::vector<std::unique_ptr<test::WaiterThread>> threads;
     for (uint32_t i = 0; i < kNumWaiters; i++) {
       threads.push_back(MakeUnique<test::WaiterThread>(
           d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
           &did_wait[i], &result[i], &context[i], &hss[i]));
@@ skipping 121 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