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

mojo/edk/system/awakable_list_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/awakable_list.h"
 
 #include "mojo/edk/platform/thread_utils.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/test/timeouts.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/system/waiter_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using mojo::platform::ThreadSleep;
 
 namespace mojo {
 namespace system {
 namespace {
 
 TEST(AwakableListTest, BasicCancel) {
   MojoResult result;
-  uint32_t context;
+  uint64_t context;
 
   // Cancel immediately after thread start.
   {
     AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
     awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread.Start();
     awakable_list.CancelAll();
     // Double-remove okay:
     awakable_list.Remove(thread.waiter());
@@ skipping 20 matching lines @@
     thread.Start();
     ThreadSleep(2 * test::EpsilonTimeout());
     awakable_list.CancelAll();
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
   EXPECT_EQ(3u, context);
 }
 
 TEST(AwakableListTest, BasicAwakeSatisfied) {
   MojoResult result;
-  uint32_t context;
+  uint64_t context;
 
   // Awake immediately after thread start.
   {
     AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
     awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread.Start();
     awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_READABLE,
         MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE));
@@ skipping 29 matching lines @@
         MOJO_HANDLE_SIGNAL_READABLE,
         MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE));
     awakable_list.Remove(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_OK, result);
   EXPECT_EQ(3u, context);
 }
 
 TEST(AwakableListTest, BasicAwakeUnsatisfiable) {
   MojoResult result;
-  uint32_t context;
+  uint64_t context;
 
   // Awake (for unsatisfiability) immediately after thread start.
   {
     AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
     awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread.Start();
     awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE));
     awakable_list.Remove(thread.waiter());
@@ skipping 29 matching lines @@
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
   EXPECT_EQ(3u, context);
 }
 
 TEST(AwakableListTest, MultipleAwakables) {
   MojoResult result1;
   MojoResult result2;
   MojoResult result3;
   MojoResult result4;
-  uint32_t context1;
-  uint32_t context2;
-  uint32_t context3;
-  uint32_t context4;
+  uint64_t context1;
+  uint64_t context2;
+  uint64_t context3;
+  uint64_t context4;
 
   // Cancel two awakables.
   {
     AwakableList awakable_list;
     test::SimpleWaiterThread thread1(&result1, &context1);
     awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread1.Start();
     test::SimpleWaiterThread thread2(&result2, &context2);
     awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
     thread2.Start();
@@ skipping 100 matching lines @@
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result3);
   EXPECT_EQ(9u, context3);
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result4);
   EXPECT_EQ(10u, context4);
 }
 
 class KeepAwakable : public Awakable {
  public:
   KeepAwakable() : awake_count(0) {}
 
-  bool Awake(MojoResult result, uintptr_t context) override {
+  bool Awake(MojoResult result, uint64_t context) override {
     awake_count++;
     return true;
   }
 
   int awake_count;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(KeepAwakable);
 };
 
 class RemoveAwakable : public Awakable {
  public:
   RemoveAwakable() : awake_count(0) {}
 
-  bool Awake(MojoResult result, uintptr_t context) override {
+  bool Awake(MojoResult result, uint64_t context) override {
     awake_count++;
     return false;
   }
 
   int awake_count;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveAwakable);
 };
 
 TEST(AwakableListTest, KeepAwakablesReturningTrue) {
@@ skipping 33 matching lines @@
   EXPECT_EQ(keep1.awake_count, 2);
   EXPECT_EQ(remove2.awake_count, 1);
 
   remove_first.Remove(&keep0);
   remove_first.Remove(&keep1);
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo