diff --git a/mojo/edk/mojo_edk_system_impl.gypi b/mojo/edk/mojo_edk_system_impl.gypi
index a0af387..74a8f2d 100644
--- a/mojo/edk/mojo_edk_system_impl.gypi
+++ b/mojo/edk/mojo_edk_system_impl.gypi
@@ -41,6 +41,9 @@
     'embedder/simple_platform_shared_buffer_win.cc',
     'embedder/simple_platform_support.cc',
     'embedder/simple_platform_support.h',
+    'system/awakable.h',
+    'system/awakable_list.cc',
+    'system/awakable_list.h',
     'system/channel.cc',
     'system/channel.h',
     'system/channel_endpoint.cc',
@@ -102,8 +105,6 @@
     'system/transport_data.h',
     'system/waiter.cc',
     'system/waiter.h',
-    'system/waiter_list.cc',
-    'system/waiter_list.h',
     # Test-only code:
     # TODO(vtl): It's a little unfortunate that these end up in the same
     # component as non-test-only code. In the static build, this code
diff --git a/mojo/edk/system/BUILD.gn b/mojo/edk/system/BUILD.gn
index 57eebac..e3c7b37 100644
--- a/mojo/edk/system/BUILD.gn
+++ b/mojo/edk/system/BUILD.gn
@@ -79,8 +79,9 @@
     "transport_data.h",
     "waiter.cc",
     "waiter.h",
-    "waiter_list.cc",
-    "waiter_list.h",
+    "awakable.h",
+    "awakable_list.cc",
+    "awakable_list.h",
   ]
 
   defines = [
@@ -144,7 +145,7 @@
     "run_all_unittests.cc",
     "shared_buffer_dispatcher_unittest.cc",
     "simple_dispatcher_unittest.cc",
-    "waiter_list_unittest.cc",
+    "awakable_list_unittest.cc",
     "waiter_test_utils.cc",
     "waiter_test_utils.h",
     "waiter_unittest.cc",
diff --git a/mojo/edk/system/awakable.h b/mojo/edk/system/awakable.h
new file mode 100644
index 0000000..5f73b35
--- /dev/null
+++ b/mojo/edk/system/awakable.h
@@ -0,0 +1,31 @@
+// 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.
+
+#ifndef MOJO_EDK_SYSTEM_AWAKABLE_H_
+#define MOJO_EDK_SYSTEM_AWAKABLE_H_
+
+#include <stdint.h>
+
+#include "mojo/public/c/system/types.h"
+
+namespace mojo {
+namespace system {
+
+// An interface that may be waited on |AwakableList|.
+class Awakable {
+ public:
+  // |Awake()| must satisfy the following contract:
+  // * As this is called from any thread, this must be thread-safe.
+  // * As this is called inside a lock, this must not call anything that takes
+  //   "non-terminal" locks, i.e., those which are always safe to take.
+  virtual void Awake(MojoResult result, uintptr_t context) = 0;
+
+ protected:
+  Awakable() {}
+};
+
+}  // namespace system
+}  // namespace mojo
+
+#endif  // MOJO_EDK_SYSTEM_AWAKABLE_H_
diff --git a/mojo/edk/system/awakable_list.cc b/mojo/edk/system/awakable_list.cc
new file mode 100644
index 0000000..6af305b
--- /dev/null
+++ b/mojo/edk/system/awakable_list.cc
@@ -0,0 +1,58 @@
+// 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.
+
+#include "mojo/edk/system/awakable_list.h"
+
+#include "base/logging.h"
+#include "mojo/edk/system/awakable.h"
+#include "mojo/edk/system/handle_signals_state.h"
+
+namespace mojo {
+namespace system {
+
+AwakableList::AwakableList() {
+}
+
+AwakableList::~AwakableList() {
+  DCHECK(awakables_.empty());
+}
+
+void AwakableList::AwakeForStateChange(const HandleSignalsState& state) {
+  for (AwakeInfoList::iterator it = awakables_.begin(); it != awakables_.end();
+       ++it) {
+    if (state.satisfies(it->signals))
+      it->awakable->Awake(MOJO_RESULT_OK, it->context);
+    else if (!state.can_satisfy(it->signals))
+      it->awakable->Awake(MOJO_RESULT_FAILED_PRECONDITION, it->context);
+  }
+}
+
+void AwakableList::CancelAll() {
+  for (AwakeInfoList::iterator it = awakables_.begin(); it != awakables_.end();
+       ++it) {
+    it->awakable->Awake(MOJO_RESULT_CANCELLED, it->context);
+  }
+  awakables_.clear();
+}
+
+void AwakableList::Add(Awakable* awakable,
+                       MojoHandleSignals signals,
+                       uint32_t context) {
+  awakables_.push_back(AwakeInfo(awakable, signals, context));
+}
+
+void AwakableList::Remove(Awakable* awakable) {
+  // We allow a thread to wait on the same handle multiple times simultaneously,
+  // so we need to scan the entire list and remove all occurrences of |waiter|.
+  for (AwakeInfoList::iterator it = awakables_.begin();
+       it != awakables_.end();) {
+    AwakeInfoList::iterator maybe_delete = it;
+    ++it;
+    if (maybe_delete->awakable == awakable)
+      awakables_.erase(maybe_delete);
+  }
+}
+
+}  // namespace system
+}  // namespace mojo
diff --git a/mojo/edk/system/awakable_list.h b/mojo/edk/system/awakable_list.h
new file mode 100644
index 0000000..19c03c8
--- /dev/null
+++ b/mojo/edk/system/awakable_list.h
@@ -0,0 +1,58 @@
+// 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.
+
+#ifndef MOJO_EDK_SYSTEM_AWAKABLE_LIST_H_
+#define MOJO_EDK_SYSTEM_AWAKABLE_LIST_H_
+
+#include <stdint.h>
+
+#include <list>
+
+#include "base/macros.h"
+#include "mojo/edk/system/system_impl_export.h"
+#include "mojo/public/c/system/types.h"
+
+namespace mojo {
+namespace system {
+
+class Awakable;
+struct HandleSignalsState;
+
+// |AwakableList| tracks all the |Waiter|s that are waiting on a given
+// handle/|Dispatcher|. There should be a |AwakableList| for each handle that
+// can be waited on (in any way). In the simple case, the |AwakableList| is
+// owned by the |Dispatcher|, whereas in more complex cases it is owned by the
+// secondary object (see simple_dispatcher.* and the explanatory comment in
+// core.cc). This class is thread-unsafe (all concurrent access must be
+// protected by some lock).
+class MOJO_SYSTEM_IMPL_EXPORT AwakableList {
+ public:
+  AwakableList();
+  ~AwakableList();
+
+  void AwakeForStateChange(const HandleSignalsState& state);
+  void CancelAll();
+  void Add(Awakable* awakable, MojoHandleSignals signals, uint32_t context);
+  void Remove(Awakable* awakable);
+
+ private:
+  struct AwakeInfo {
+    AwakeInfo(Awakable* awakable, MojoHandleSignals signals, uint32_t context)
+        : awakable(awakable), signals(signals), context(context) {}
+
+    Awakable* awakable;
+    MojoHandleSignals signals;
+    uint32_t context;
+  };
+  typedef std::list<AwakeInfo> AwakeInfoList;
+
+  AwakeInfoList awakables_;
+
+  DISALLOW_COPY_AND_ASSIGN(AwakableList);
+};
+
+}  // namespace system
+}  // namespace mojo
+
+#endif  // MOJO_EDK_SYSTEM_AWAKABLE_LIST_H_
diff --git a/mojo/edk/system/waiter_list_unittest.cc b/mojo/edk/system/awakable_list_unittest.cc
similarity index 63%
rename from mojo/edk/system/waiter_list_unittest.cc
rename to mojo/edk/system/awakable_list_unittest.cc
index 129df71..201b751 100644
--- a/mojo/edk/system/waiter_list_unittest.cc
+++ b/mojo/edk/system/awakable_list_unittest.cc
@@ -7,7 +7,7 @@
 // increase tolerance and reduce observed flakiness (though doing so reduces the
 // meaningfulness of the test).
 
-#include "mojo/edk/system/waiter_list.h"
+#include "mojo/edk/system/awakable_list.h"
 
 #include "base/threading/platform_thread.h"  // For |Sleep()|.
 #include "base/time/time.h"
@@ -21,29 +21,29 @@
 namespace system {
 namespace {
 
-TEST(WaiterListTest, BasicCancel) {
+TEST(AwakableListTest, BasicCancel) {
   MojoResult result;
   uint32_t context;
 
   // Cancel immediately after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread.Start();
-    waiter_list.CancelAllWaiters();
+    awakable_list.CancelAll();
     // Double-remove okay:
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
   EXPECT_EQ(1u, context);
 
   // Cancel before after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
-    waiter_list.CancelAllWaiters();
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
+    awakable_list.CancelAll();
     thread.Start();
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
@@ -51,46 +51,46 @@
 
   // Cancel some time after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3);
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3);
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
-    waiter_list.CancelAllWaiters();
+    awakable_list.CancelAll();
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
   EXPECT_EQ(3u, context);
 }
 
-TEST(WaiterListTest, BasicAwakeSatisfied) {
+TEST(AwakableListTest, BasicAwakeSatisfied) {
   MojoResult result;
   uint32_t context;
 
   // Awake immediately after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread.Start();
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_READABLE,
         MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE));
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_OK, result);
   EXPECT_EQ(1u, context);
 
   // Awake before after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_WRITABLE,
         MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE));
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
     // Double-remove okay:
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
     thread.Start();
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_OK, result);
@@ -98,45 +98,45 @@
 
   // Awake some time after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3);
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3);
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_READABLE,
         MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE));
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_OK, result);
   EXPECT_EQ(3u, context);
 }
 
-TEST(WaiterListTest, BasicAwakeUnsatisfiable) {
+TEST(AwakableListTest, BasicAwakeUnsatisfiable) {
   MojoResult result;
   uint32_t context;
 
   // Awake (for unsatisfiability) immediately after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread.Start();
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE));
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
   EXPECT_EQ(1u, context);
 
   // Awake (for unsatisfiability) before after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_READABLE, MOJO_HANDLE_SIGNAL_READABLE));
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
     thread.Start();
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
@@ -144,22 +144,22 @@
 
   // Awake (for unsatisfiability) some time after thread start.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread(&result, &context);
-    waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3);
+    awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3);
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE));
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
     // Double-remove okay:
-    waiter_list.RemoveWaiter(thread.waiter());
+    awakable_list.Remove(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
   EXPECT_EQ(3u, context);
 }
 
-TEST(WaiterListTest, MultipleWaiters) {
+TEST(AwakableListTest, MultipleAwakables) {
   MojoResult result1;
   MojoResult result2;
   MojoResult result3;
@@ -169,110 +169,110 @@
   uint32_t context3;
   uint32_t context4;
 
-  // Cancel two waiters.
+  // Cancel two awakables.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread1(&result1, &context1);
-    waiter_list.AddWaiter(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
+    awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread1.Start();
     test::SimpleWaiterThread thread2(&result2, &context2);
-    waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
+    awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
     thread2.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
-    waiter_list.CancelAllWaiters();
+    awakable_list.CancelAll();
   }  // Join threads.
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result1);
   EXPECT_EQ(1u, context1);
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result2);
   EXPECT_EQ(2u, context2);
 
-  // Awake one waiter, cancel other.
+  // Awake one awakable, cancel other.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread1(&result1, &context1);
-    waiter_list.AddWaiter(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3);
+    awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3);
     thread1.Start();
     test::SimpleWaiterThread thread2(&result2, &context2);
-    waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 4);
+    awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 4);
     thread2.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_READABLE,
         MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE));
-    waiter_list.RemoveWaiter(thread1.waiter());
-    waiter_list.CancelAllWaiters();
+    awakable_list.Remove(thread1.waiter());
+    awakable_list.CancelAll();
   }  // Join threads.
   EXPECT_EQ(MOJO_RESULT_OK, result1);
   EXPECT_EQ(3u, context1);
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result2);
   EXPECT_EQ(4u, context2);
 
-  // Cancel one waiter, awake other for unsatisfiability.
+  // Cancel one awakable, awake other for unsatisfiability.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread1(&result1, &context1);
-    waiter_list.AddWaiter(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 5);
+    awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 5);
     thread1.Start();
     test::SimpleWaiterThread thread2(&result2, &context2);
-    waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 6);
+    awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 6);
     thread2.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE));
-    waiter_list.RemoveWaiter(thread2.waiter());
-    waiter_list.CancelAllWaiters();
+    awakable_list.Remove(thread2.waiter());
+    awakable_list.CancelAll();
   }  // Join threads.
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result1);
   EXPECT_EQ(5u, context1);
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result2);
   EXPECT_EQ(6u, context2);
 
-  // Cancel one waiter, awake other for unsatisfiability.
+  // Cancel one awakable, awake other for unsatisfiability.
   {
-    WaiterList waiter_list;
+    AwakableList awakable_list;
     test::SimpleWaiterThread thread1(&result1, &context1);
-    waiter_list.AddWaiter(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 7);
+    awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 7);
     thread1.Start();
 
     base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
 
     // Should do nothing.
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_NONE,
         MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE));
 
     test::SimpleWaiterThread thread2(&result2, &context2);
-    waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 8);
+    awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 8);
     thread2.Start();
 
     base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
 
     // Awake #1.
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_READABLE,
         MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE));
-    waiter_list.RemoveWaiter(thread1.waiter());
+    awakable_list.Remove(thread1.waiter());
 
     base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
 
     test::SimpleWaiterThread thread3(&result3, &context3);
-    waiter_list.AddWaiter(thread3.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 9);
+    awakable_list.Add(thread3.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 9);
     thread3.Start();
 
     test::SimpleWaiterThread thread4(&result4, &context4);
-    waiter_list.AddWaiter(thread4.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 10);
+    awakable_list.Add(thread4.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 10);
     thread4.Start();
 
     base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
 
     // Awake #2 and #3 for unsatisfiability.
-    waiter_list.AwakeWaitersForStateChange(HandleSignalsState(
+    awakable_list.AwakeForStateChange(HandleSignalsState(
         MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE));
-    waiter_list.RemoveWaiter(thread2.waiter());
-    waiter_list.RemoveWaiter(thread3.waiter());
+    awakable_list.Remove(thread2.waiter());
+    awakable_list.Remove(thread3.waiter());
 
     // Cancel #4.
-    waiter_list.CancelAllWaiters();
+    awakable_list.CancelAll();
   }  // Join threads.
   EXPECT_EQ(MOJO_RESULT_OK, result1);
   EXPECT_EQ(7u, context1);
diff --git a/mojo/edk/system/channel_unittest.cc b/mojo/edk/system/channel_unittest.cc
index e84ab5b..c51f740 100644
--- a/mojo/edk/system/channel_unittest.cc
+++ b/mojo/edk/system/channel_unittest.cc
@@ -231,7 +231,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Don't wait for the shutdown to run ...
   io_thread()->PostTask(FROM_HERE,
@@ -242,7 +242,7 @@
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, nullptr));
   HandleSignalsState hss;
-  mp->RemoveWaiter(0, &waiter, &hss);
+  mp->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -277,8 +277,9 @@
   Waiter waiter;
   waiter.Init();
   HandleSignalsState hss;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, &hss));
+  EXPECT_EQ(
+      MOJO_RESULT_FAILED_PRECONDITION,
+      mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
diff --git a/mojo/edk/system/core.cc b/mojo/edk/system/core.cc
index 27d33b2..3b51a82 100644
--- a/mojo/edk/system/core.cc
+++ b/mojo/edk/system/core.cc
@@ -47,10 +47,11 @@
 // |Dispatcher|s for the handles that it wants to wait on with a |Waiter|
 // object; this |Waiter| object may be created on the stack of that thread or be
 // kept in thread local storage for that thread (TODO(vtl): future improvement).
-// The |Dispatcher| then adds the |Waiter| to a |WaiterList| that's either owned
-// by that |Dispatcher| (see |SimpleDispatcher|) or by a secondary object (e.g.,
-// |MessagePipe|). To signal/wake a |Waiter|, the object in question -- either a
-// |SimpleDispatcher| or a secondary object -- talks to its |WaiterList|.
+// The |Dispatcher| then adds the |Waiter| to an |AwakableList| that's either
+// owned by that |Dispatcher| (see |SimpleDispatcher|) or by a secondary object
+// (e.g., |MessagePipe|). To signal/wake a |Waiter|, the object in question --
+// either a |SimpleDispatcher| or a secondary object -- talks to its
+// |AwakableList|.
 
 // Thread-safety notes
 //
@@ -532,7 +533,7 @@
 
 // Note: We allow |handles| to repeat the same handle multiple times, since
 // different flags may be specified.
-// TODO(vtl): This incurs a performance cost in |RemoveWaiter()|. Analyze this
+// TODO(vtl): This incurs a performance cost in |Remove()|. Analyze this
 // more carefully and address it if necessary.
 MojoResult Core::WaitManyInternal(const MojoHandle* handles,
                                   const MojoHandleSignals* signals,
@@ -561,7 +562,7 @@
   uint32_t i;
   MojoResult rv = MOJO_RESULT_OK;
   for (i = 0; i < num_handles; i++) {
-    rv = dispatchers[i]->AddWaiter(
+    rv = dispatchers[i]->AddAwakable(
         &waiter, signals[i], i, signals_states ? &signals_states[i] : nullptr);
     if (rv != MOJO_RESULT_OK) {
       *result_index = i;
@@ -579,8 +580,8 @@
   // |Wait()|/|WaitMany()| call. (Only after doing this can |waiter| be
   // destroyed, but this would still be required if the waiter were in TLS.)
   for (i = 0; i < num_added; i++) {
-    dispatchers[i]->RemoveWaiter(&waiter,
-                                 signals_states ? &signals_states[i] : nullptr);
+    dispatchers[i]->RemoveAwakable(
+        &waiter, signals_states ? &signals_states[i] : nullptr);
   }
   if (signals_states) {
     for (; i < num_handles; i++)
diff --git a/mojo/edk/system/core_test_base.cc b/mojo/edk/system/core_test_base.cc
index ea06c29..76e70e2 100644
--- a/mojo/edk/system/core_test_base.cc
+++ b/mojo/edk/system/core_test_base.cc
@@ -123,27 +123,27 @@
     return MOJO_RESULT_UNIMPLEMENTED;
   }
 
-  MojoResult AddWaiterImplNoLock(Waiter* /*waiter*/,
-                                 MojoHandleSignals /*signals*/,
-                                 uint32_t /*context*/,
-                                 HandleSignalsState* signals_state) override {
-    info_->IncrementAddWaiterCallCount();
+  MojoResult AddAwakableImplNoLock(Awakable* /*awakable*/,
+                                   MojoHandleSignals /*signals*/,
+                                   uint32_t /*context*/,
+                                   HandleSignalsState* signals_state) override {
+    info_->IncrementAddAwakableCallCount();
     lock().AssertAcquired();
     if (signals_state)
       *signals_state = HandleSignalsState();
     return MOJO_RESULT_FAILED_PRECONDITION;
   }
 
-  void RemoveWaiterImplNoLock(Waiter* /*waiter*/,
-                              HandleSignalsState* signals_state) override {
-    info_->IncrementRemoveWaiterCallCount();
+  void RemoveAwakableImplNoLock(Awakable* /*awakable*/,
+                                HandleSignalsState* signals_state) override {
+    info_->IncrementRemoveAwakableCallCount();
     lock().AssertAcquired();
     if (signals_state)
       *signals_state = HandleSignalsState();
   }
 
-  void CancelAllWaitersNoLock() override {
-    info_->IncrementCancelAllWaitersCallCount();
+  void CancelAllAwakablesNoLock() override {
+    info_->IncrementCancelAllAwakablesCallCount();
     lock().AssertAcquired();
   }
 
@@ -196,9 +196,9 @@
       read_data_call_count_(0),
       begin_read_data_call_count_(0),
       end_read_data_call_count_(0),
-      add_waiter_call_count_(0),
-      remove_waiter_call_count_(0),
-      cancel_all_waiters_call_count_(0) {
+      add_awakable_call_count_(0),
+      remove_awakable_call_count_(0),
+      cancel_all_awakables_call_count_(0) {
 }
 
 CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() {
@@ -259,19 +259,19 @@
   return end_read_data_call_count_;
 }
 
-unsigned CoreTestBase_MockHandleInfo::GetAddWaiterCallCount() const {
+unsigned CoreTestBase_MockHandleInfo::GetAddAwakableCallCount() const {
   base::AutoLock locker(lock_);
-  return add_waiter_call_count_;
+  return add_awakable_call_count_;
 }
 
-unsigned CoreTestBase_MockHandleInfo::GetRemoveWaiterCallCount() const {
+unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const {
   base::AutoLock locker(lock_);
-  return remove_waiter_call_count_;
+  return remove_awakable_call_count_;
 }
 
-unsigned CoreTestBase_MockHandleInfo::GetCancelAllWaitersCallCount() const {
+unsigned CoreTestBase_MockHandleInfo::GetCancelAllAwakablesCallCount() const {
   base::AutoLock locker(lock_);
-  return cancel_all_waiters_call_count_;
+  return cancel_all_awakables_call_count_;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() {
@@ -329,19 +329,19 @@
   end_read_data_call_count_++;
 }
 
-void CoreTestBase_MockHandleInfo::IncrementAddWaiterCallCount() {
+void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() {
   base::AutoLock locker(lock_);
-  add_waiter_call_count_++;
+  add_awakable_call_count_++;
 }
 
-void CoreTestBase_MockHandleInfo::IncrementRemoveWaiterCallCount() {
+void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() {
   base::AutoLock locker(lock_);
-  remove_waiter_call_count_++;
+  remove_awakable_call_count_++;
 }
 
-void CoreTestBase_MockHandleInfo::IncrementCancelAllWaitersCallCount() {
+void CoreTestBase_MockHandleInfo::IncrementCancelAllAwakablesCallCount() {
   base::AutoLock locker(lock_);
-  cancel_all_waiters_call_count_++;
+  cancel_all_awakables_call_count_++;
 }
 
 }  // namespace test
diff --git a/mojo/edk/system/core_test_base.h b/mojo/edk/system/core_test_base.h
index 2881176..80a926b 100644
--- a/mojo/edk/system/core_test_base.h
+++ b/mojo/edk/system/core_test_base.h
@@ -58,9 +58,9 @@
   unsigned GetReadDataCallCount() const;
   unsigned GetBeginReadDataCallCount() const;
   unsigned GetEndReadDataCallCount() const;
-  unsigned GetAddWaiterCallCount() const;
-  unsigned GetRemoveWaiterCallCount() const;
-  unsigned GetCancelAllWaitersCallCount() const;
+  unsigned GetAddAwakableCallCount() const;
+  unsigned GetRemoveAwakableCallCount() const;
+  unsigned GetCancelAllAwakablesCallCount() const;
 
   // For use by |MockDispatcher|:
   void IncrementCtorCallCount();
@@ -74,9 +74,9 @@
   void IncrementReadDataCallCount();
   void IncrementBeginReadDataCallCount();
   void IncrementEndReadDataCallCount();
-  void IncrementAddWaiterCallCount();
-  void IncrementRemoveWaiterCallCount();
-  void IncrementCancelAllWaitersCallCount();
+  void IncrementAddAwakableCallCount();
+  void IncrementRemoveAwakableCallCount();
+  void IncrementCancelAllAwakablesCallCount();
 
  private:
   mutable base::Lock lock_;  // Protects the following members.
@@ -91,9 +91,9 @@
   unsigned read_data_call_count_;
   unsigned begin_read_data_call_count_;
   unsigned end_read_data_call_count_;
-  unsigned add_waiter_call_count_;
-  unsigned remove_waiter_call_count_;
-  unsigned cancel_all_waiters_call_count_;
+  unsigned add_awakable_call_count_;
+  unsigned remove_awakable_call_count_;
+  unsigned cancel_all_awakables_call_count_;
 
   DISALLOW_COPY_AND_ASSIGN(CoreTestBase_MockHandleInfo);
 };
diff --git a/mojo/edk/system/core_unittest.cc b/mojo/edk/system/core_unittest.cc
index 51a4022..d7976a3 100644
--- a/mojo/edk/system/core_unittest.cc
+++ b/mojo/edk/system/core_unittest.cc
@@ -95,30 +95,30 @@
   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndReadData(h, 0));
   EXPECT_EQ(1u, info.GetEndReadDataCallCount());
 
-  EXPECT_EQ(0u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(0u, info.GetAddAwakableCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
                          NullUserPointer()));
-  EXPECT_EQ(1u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(1u, info.GetAddAwakableCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0, NullUserPointer()));
-  EXPECT_EQ(2u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(2u, info.GetAddAwakableCallCount());
   MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
                          MakeUserPointer(&hss)));
-  EXPECT_EQ(3u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(3u, info.GetAddAwakableCallCount());
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   EXPECT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
       core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, NullUserPointer()));
-  EXPECT_EQ(4u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(4u, info.GetAddAwakableCallCount());
   hss = kFullMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000,
                          MakeUserPointer(&hss)));
-  EXPECT_EQ(5u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(5u, info.GetAddAwakableCallCount());
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
@@ -128,14 +128,14 @@
       core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
                        MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
                        NullUserPointer()));
-  EXPECT_EQ(6u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(6u, info.GetAddAwakableCallCount());
   uint32_t result_index = static_cast<uint32_t>(-1);
   EXPECT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
       core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
                        MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
                        NullUserPointer()));
-  EXPECT_EQ(7u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(7u, info.GetAddAwakableCallCount());
   EXPECT_EQ(0u, result_index);
   hss = kFullMojoHandleSignalsState;
   EXPECT_EQ(
@@ -143,7 +143,7 @@
       core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
                        MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
                        MakeUserPointer(&hss)));
-  EXPECT_EQ(8u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(8u, info.GetAddAwakableCallCount());
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   result_index = static_cast<uint32_t>(-1);
@@ -153,21 +153,21 @@
       core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
                        MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
                        MakeUserPointer(&hss)));
-  EXPECT_EQ(9u, info.GetAddWaiterCallCount());
+  EXPECT_EQ(9u, info.GetAddAwakableCallCount());
   EXPECT_EQ(0u, result_index);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   EXPECT_EQ(0u, info.GetDtorCallCount());
   EXPECT_EQ(0u, info.GetCloseCallCount());
-  EXPECT_EQ(0u, info.GetCancelAllWaitersCallCount());
+  EXPECT_EQ(0u, info.GetCancelAllAwakablesCallCount());
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-  EXPECT_EQ(1u, info.GetCancelAllWaitersCallCount());
+  EXPECT_EQ(1u, info.GetCancelAllAwakablesCallCount());
   EXPECT_EQ(1u, info.GetCloseCallCount());
   EXPECT_EQ(1u, info.GetDtorCallCount());
 
-  // No waiters should ever have ever been added.
-  EXPECT_EQ(0u, info.GetRemoveWaiterCallCount());
+  // No awakables should ever have ever been added.
+  EXPECT_EQ(0u, info.GetRemoveAwakableCallCount());
 }
 
 TEST_F(CoreTest, InvalidArguments) {
diff --git a/mojo/edk/system/data_pipe.cc b/mojo/edk/system/data_pipe.cc
index cbacb89..2f433bd 100644
--- a/mojo/edk/system/data_pipe.cc
+++ b/mojo/edk/system/data_pipe.cc
@@ -10,10 +10,10 @@
 #include <limits>
 
 #include "base/logging.h"
+#include "mojo/edk/system/awakable_list.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/options_validation.h"
-#include "mojo/edk/system/waiter_list.h"
 
 namespace mojo {
 namespace system {
@@ -83,10 +83,10 @@
   return MOJO_RESULT_OK;
 }
 
-void DataPipe::ProducerCancelAllWaiters() {
+void DataPipe::ProducerCancelAllAwakables() {
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
-  producer_waiter_list_->CancelAllWaiters();
+  producer_awakable_list_->CancelAll();
 }
 
 void DataPipe::ProducerClose() {
@@ -94,13 +94,13 @@
   DCHECK(producer_open_);
   producer_open_ = false;
   DCHECK(has_local_producer_no_lock());
-  producer_waiter_list_.reset();
+  producer_awakable_list_.reset();
   // Not a bug, except possibly in "user" code.
   DVLOG_IF(2, producer_in_two_phase_write_no_lock())
       << "Producer closed with active two-phase write";
   producer_two_phase_max_num_bytes_written_ = 0;
   ProducerCloseImplNoLock();
-  AwakeConsumerWaitersForStateChangeNoLock(
+  AwakeConsumerAwakablesForStateChangeNoLock(
       ConsumerGetHandleSignalsStateImplNoLock());
 }
 
@@ -132,7 +132,7 @@
   HandleSignalsState new_consumer_state =
       ConsumerGetHandleSignalsStateImplNoLock();
   if (!new_consumer_state.equals(old_consumer_state))
-    AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state);
+    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
   return rv;
 }
 
@@ -159,10 +159,10 @@
                                                    min_num_bytes_to_write);
   if (rv != MOJO_RESULT_OK)
     return rv;
-  // Note: No need to awake producer waiters, even though we're going from
+  // Note: No need to awake producer awakables, even though we're going from
   // writable to non-writable (since you can't wait on non-writability).
   // Similarly, though this may have discarded data (in "may discard" mode),
-  // making it non-readable, there's still no need to awake consumer waiters.
+  // making it non-readable, there's still no need to awake consumer awakables.
   DCHECK(producer_in_two_phase_write_no_lock());
   return MOJO_RESULT_OK;
 }
@@ -189,15 +189,15 @@
   // Two-phase write ended even on failure.
   DCHECK(!producer_in_two_phase_write_no_lock());
   // If we're now writable, we *became* writable (since we weren't writable
-  // during the two-phase write), so awake producer waiters.
+  // during the two-phase write), so awake producer awakables.
   HandleSignalsState new_producer_state =
       ProducerGetHandleSignalsStateImplNoLock();
   if (new_producer_state.satisfies(MOJO_HANDLE_SIGNAL_WRITABLE))
-    AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
+    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
   HandleSignalsState new_consumer_state =
       ConsumerGetHandleSignalsStateImplNoLock();
   if (!new_consumer_state.equals(old_consumer_state))
-    AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state);
+    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
   return rv;
 }
 
@@ -207,10 +207,10 @@
   return ProducerGetHandleSignalsStateImplNoLock();
 }
 
-MojoResult DataPipe::ProducerAddWaiter(Waiter* waiter,
-                                       MojoHandleSignals signals,
-                                       uint32_t context,
-                                       HandleSignalsState* signals_state) {
+MojoResult DataPipe::ProducerAddAwakable(Awakable* awakable,
+                                         MojoHandleSignals signals,
+                                         uint32_t context,
+                                         HandleSignalsState* signals_state) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
 
@@ -226,15 +226,15 @@
     return MOJO_RESULT_FAILED_PRECONDITION;
   }
 
-  producer_waiter_list_->AddWaiter(waiter, signals, context);
+  producer_awakable_list_->Add(awakable, signals, context);
   return MOJO_RESULT_OK;
 }
 
-void DataPipe::ProducerRemoveWaiter(Waiter* waiter,
-                                    HandleSignalsState* signals_state) {
+void DataPipe::ProducerRemoveAwakable(Awakable* awakable,
+                                      HandleSignalsState* signals_state) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
-  producer_waiter_list_->RemoveWaiter(waiter);
+  producer_awakable_list_->Remove(awakable);
   if (signals_state)
     *signals_state = ProducerGetHandleSignalsStateImplNoLock();
 }
@@ -244,10 +244,10 @@
   return producer_in_two_phase_write_no_lock();
 }
 
-void DataPipe::ConsumerCancelAllWaiters() {
+void DataPipe::ConsumerCancelAllAwakables() {
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
-  consumer_waiter_list_->CancelAllWaiters();
+  consumer_awakable_list_->CancelAll();
 }
 
 void DataPipe::ConsumerClose() {
@@ -255,13 +255,13 @@
   DCHECK(consumer_open_);
   consumer_open_ = false;
   DCHECK(has_local_consumer_no_lock());
-  consumer_waiter_list_.reset();
+  consumer_awakable_list_.reset();
   // Not a bug, except possibly in "user" code.
   DVLOG_IF(2, consumer_in_two_phase_read_no_lock())
       << "Consumer closed with active two-phase read";
   consumer_two_phase_max_num_bytes_read_ = 0;
   ConsumerCloseImplNoLock();
-  AwakeProducerWaitersForStateChangeNoLock(
+  AwakeProducerAwakablesForStateChangeNoLock(
       ProducerGetHandleSignalsStateImplNoLock());
 }
 
@@ -291,7 +291,7 @@
   HandleSignalsState new_producer_state =
       ProducerGetHandleSignalsStateImplNoLock();
   if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
+    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
   return rv;
 }
 
@@ -320,7 +320,7 @@
   HandleSignalsState new_producer_state =
       ProducerGetHandleSignalsStateImplNoLock();
   if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
+    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
   return rv;
 }
 
@@ -380,15 +380,15 @@
   // Two-phase read ended even on failure.
   DCHECK(!consumer_in_two_phase_read_no_lock());
   // If we're now readable, we *became* readable (since we weren't readable
-  // during the two-phase read), so awake consumer waiters.
+  // during the two-phase read), so awake consumer awakables.
   HandleSignalsState new_consumer_state =
       ConsumerGetHandleSignalsStateImplNoLock();
   if (new_consumer_state.satisfies(MOJO_HANDLE_SIGNAL_READABLE))
-    AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state);
+    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
   HandleSignalsState new_producer_state =
       ProducerGetHandleSignalsStateImplNoLock();
   if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
+    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
   return rv;
 }
 
@@ -398,10 +398,10 @@
   return ConsumerGetHandleSignalsStateImplNoLock();
 }
 
-MojoResult DataPipe::ConsumerAddWaiter(Waiter* waiter,
-                                       MojoHandleSignals signals,
-                                       uint32_t context,
-                                       HandleSignalsState* signals_state) {
+MojoResult DataPipe::ConsumerAddAwakable(Awakable* awakable,
+                                         MojoHandleSignals signals,
+                                         uint32_t context,
+                                         HandleSignalsState* signals_state) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
 
@@ -417,15 +417,15 @@
     return MOJO_RESULT_FAILED_PRECONDITION;
   }
 
-  consumer_waiter_list_->AddWaiter(waiter, signals, context);
+  consumer_awakable_list_->Add(awakable, signals, context);
   return MOJO_RESULT_OK;
 }
 
-void DataPipe::ConsumerRemoveWaiter(Waiter* waiter,
-                                    HandleSignalsState* signals_state) {
+void DataPipe::ConsumerRemoveAwakable(Awakable* awakable,
+                                      HandleSignalsState* signals_state) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
-  consumer_waiter_list_->RemoveWaiter(waiter);
+  consumer_awakable_list_->Remove(awakable);
   if (signals_state)
     *signals_state = ConsumerGetHandleSignalsStateImplNoLock();
 }
@@ -444,8 +444,10 @@
       capacity_num_bytes_(validated_options.capacity_num_bytes),
       producer_open_(true),
       consumer_open_(true),
-      producer_waiter_list_(has_local_producer ? new WaiterList() : nullptr),
-      consumer_waiter_list_(has_local_consumer ? new WaiterList() : nullptr),
+      producer_awakable_list_(has_local_producer ? new AwakableList()
+                                                 : nullptr),
+      consumer_awakable_list_(has_local_consumer ? new AwakableList()
+                                                 : nullptr),
       producer_two_phase_max_num_bytes_written_(0),
       consumer_two_phase_max_num_bytes_read_(0) {
   // Check that the passed in options actually are validated.
@@ -457,24 +459,24 @@
 DataPipe::~DataPipe() {
   DCHECK(!producer_open_);
   DCHECK(!consumer_open_);
-  DCHECK(!producer_waiter_list_);
-  DCHECK(!consumer_waiter_list_);
+  DCHECK(!producer_awakable_list_);
+  DCHECK(!consumer_awakable_list_);
 }
 
-void DataPipe::AwakeProducerWaitersForStateChangeNoLock(
+void DataPipe::AwakeProducerAwakablesForStateChangeNoLock(
     const HandleSignalsState& new_producer_state) {
   lock_.AssertAcquired();
   if (!has_local_producer_no_lock())
     return;
-  producer_waiter_list_->AwakeWaitersForStateChange(new_producer_state);
+  producer_awakable_list_->AwakeForStateChange(new_producer_state);
 }
 
-void DataPipe::AwakeConsumerWaitersForStateChangeNoLock(
+void DataPipe::AwakeConsumerAwakablesForStateChangeNoLock(
     const HandleSignalsState& new_consumer_state) {
   lock_.AssertAcquired();
   if (!has_local_consumer_no_lock())
     return;
-  consumer_waiter_list_->AwakeWaitersForStateChange(new_consumer_state);
+  consumer_awakable_list_->AwakeForStateChange(new_consumer_state);
 }
 
 }  // namespace system
diff --git a/mojo/edk/system/data_pipe.h b/mojo/edk/system/data_pipe.h
index 767d405..d893465 100644
--- a/mojo/edk/system/data_pipe.h
+++ b/mojo/edk/system/data_pipe.h
@@ -20,8 +20,8 @@
 namespace mojo {
 namespace system {
 
-class Waiter;
-class WaiterList;
+class Awakable;
+class AwakableList;
 
 // |DataPipe| is a base class for secondary objects implementing data pipes,
 // similar to |MessagePipe| (see the explanatory comment in core.cc). It is
@@ -48,7 +48,7 @@
 
   // These are called by the producer dispatcher to implement its methods of
   // corresponding names.
-  void ProducerCancelAllWaiters();
+  void ProducerCancelAllAwakables();
   void ProducerClose();
   MojoResult ProducerWriteData(UserPointer<const void> elements,
                                UserPointer<uint32_t> num_bytes,
@@ -58,16 +58,17 @@
                                     bool all_or_none);
   MojoResult ProducerEndWriteData(uint32_t num_bytes_written);
   HandleSignalsState ProducerGetHandleSignalsState();
-  MojoResult ProducerAddWaiter(Waiter* waiter,
-                               MojoHandleSignals signals,
-                               uint32_t context,
-                               HandleSignalsState* signals_state);
-  void ProducerRemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state);
+  MojoResult ProducerAddAwakable(Awakable* awakable,
+                                 MojoHandleSignals signals,
+                                 uint32_t context,
+                                 HandleSignalsState* signals_state);
+  void ProducerRemoveAwakable(Awakable* awakable,
+                              HandleSignalsState* signals_state);
   bool ProducerIsBusy() const;
 
   // These are called by the consumer dispatcher to implement its methods of
   // corresponding names.
-  void ConsumerCancelAllWaiters();
+  void ConsumerCancelAllAwakables();
   void ConsumerClose();
   // This does not validate its arguments, except to check that |*num_bytes| is
   // a multiple of |element_num_bytes_|.
@@ -83,11 +84,12 @@
                                    bool all_or_none);
   MojoResult ConsumerEndReadData(uint32_t num_bytes_read);
   HandleSignalsState ConsumerGetHandleSignalsState();
-  MojoResult ConsumerAddWaiter(Waiter* waiter,
-                               MojoHandleSignals signals,
-                               uint32_t context,
-                               HandleSignalsState* signals_state);
-  void ConsumerRemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state);
+  MojoResult ConsumerAddAwakable(Awakable* awakable,
+                                 MojoHandleSignals signals,
+                                 uint32_t context,
+                                 HandleSignalsState* signals_state);
+  void ConsumerRemoveAwakable(Awakable* awakable,
+                              HandleSignalsState* signals_state);
   bool ConsumerIsBusy() const;
 
  protected:
@@ -179,18 +181,18 @@
   }
 
  private:
-  void AwakeProducerWaitersForStateChangeNoLock(
+  void AwakeProducerAwakablesForStateChangeNoLock(
       const HandleSignalsState& new_producer_state);
-  void AwakeConsumerWaitersForStateChangeNoLock(
+  void AwakeConsumerAwakablesForStateChangeNoLock(
       const HandleSignalsState& new_consumer_state);
 
   bool has_local_producer_no_lock() const {
     lock_.AssertAcquired();
-    return !!producer_waiter_list_;
+    return !!producer_awakable_list_;
   }
   bool has_local_consumer_no_lock() const {
     lock_.AssertAcquired();
-    return !!consumer_waiter_list_;
+    return !!consumer_awakable_list_;
   }
 
   const bool may_discard_;
@@ -202,8 +204,8 @@
   bool producer_open_;
   bool consumer_open_;
   // Non-null only if the producer or consumer, respectively, is local.
-  scoped_ptr<WaiterList> producer_waiter_list_;
-  scoped_ptr<WaiterList> consumer_waiter_list_;
+  scoped_ptr<AwakableList> producer_awakable_list_;
+  scoped_ptr<AwakableList> consumer_awakable_list_;
   // These are nonzero if and only if a two-phase write/read is in progress.
   uint32_t producer_two_phase_max_num_bytes_written_;
   uint32_t consumer_two_phase_max_num_bytes_read_;
diff --git a/mojo/edk/system/data_pipe_consumer_dispatcher.cc b/mojo/edk/system/data_pipe_consumer_dispatcher.cc
index 3c14f35..f47dfb1 100644
--- a/mojo/edk/system/data_pipe_consumer_dispatcher.cc
+++ b/mojo/edk/system/data_pipe_consumer_dispatcher.cc
@@ -28,9 +28,9 @@
   DCHECK(!data_pipe_.get());
 }
 
-void DataPipeConsumerDispatcher::CancelAllWaitersNoLock() {
+void DataPipeConsumerDispatcher::CancelAllAwakablesNoLock() {
   lock().AssertAcquired();
-  data_pipe_->ConsumerCancelAllWaiters();
+  data_pipe_->ConsumerCancelAllAwakables();
 }
 
 void DataPipeConsumerDispatcher::CloseImplNoLock() {
@@ -109,20 +109,21 @@
   return data_pipe_->ConsumerGetHandleSignalsState();
 }
 
-MojoResult DataPipeConsumerDispatcher::AddWaiterImplNoLock(
-    Waiter* waiter,
+MojoResult DataPipeConsumerDispatcher::AddAwakableImplNoLock(
+    Awakable* awakable,
     MojoHandleSignals signals,
     uint32_t context,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  return data_pipe_->ConsumerAddWaiter(waiter, signals, context, signals_state);
+  return data_pipe_->ConsumerAddAwakable(awakable, signals, context,
+                                         signals_state);
 }
 
-void DataPipeConsumerDispatcher::RemoveWaiterImplNoLock(
-    Waiter* waiter,
+void DataPipeConsumerDispatcher::RemoveAwakableImplNoLock(
+    Awakable* awakable,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  data_pipe_->ConsumerRemoveWaiter(waiter, signals_state);
+  data_pipe_->ConsumerRemoveAwakable(awakable, signals_state);
 }
 
 bool DataPipeConsumerDispatcher::IsBusyNoLock() const {
diff --git a/mojo/edk/system/data_pipe_consumer_dispatcher.h b/mojo/edk/system/data_pipe_consumer_dispatcher.h
index 6555fb5..10a3d94 100644
--- a/mojo/edk/system/data_pipe_consumer_dispatcher.h
+++ b/mojo/edk/system/data_pipe_consumer_dispatcher.h
@@ -32,7 +32,7 @@
   ~DataPipeConsumerDispatcher() override;
 
   // |Dispatcher| protected methods:
-  void CancelAllWaitersNoLock() override;
+  void CancelAllAwakablesNoLock() override;
   void CloseImplNoLock() override;
   scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock()
       override;
@@ -44,12 +44,12 @@
                                      MojoReadDataFlags flags) override;
   MojoResult EndReadDataImplNoLock(uint32_t num_bytes_read) override;
   HandleSignalsState GetHandleSignalsStateImplNoLock() const override;
-  MojoResult AddWaiterImplNoLock(Waiter* waiter,
-                                 MojoHandleSignals signals,
-                                 uint32_t context,
-                                 HandleSignalsState* signals_state) override;
-  void RemoveWaiterImplNoLock(Waiter* waiter,
-                              HandleSignalsState* signals_state) override;
+  MojoResult AddAwakableImplNoLock(Awakable* awakable,
+                                   MojoHandleSignals signals,
+                                   uint32_t context,
+                                   HandleSignalsState* signals_state) override;
+  void RemoveAwakableImplNoLock(Awakable* awakable,
+                                HandleSignalsState* signals_state) override;
   bool IsBusyNoLock() const override;
 
   // Protected by |lock()|:
diff --git a/mojo/edk/system/data_pipe_producer_dispatcher.cc b/mojo/edk/system/data_pipe_producer_dispatcher.cc
index 0a82c9a..513ab73 100644
--- a/mojo/edk/system/data_pipe_producer_dispatcher.cc
+++ b/mojo/edk/system/data_pipe_producer_dispatcher.cc
@@ -28,9 +28,9 @@
   DCHECK(!data_pipe_.get());
 }
 
-void DataPipeProducerDispatcher::CancelAllWaitersNoLock() {
+void DataPipeProducerDispatcher::CancelAllAwakablesNoLock() {
   lock().AssertAcquired();
-  data_pipe_->ProducerCancelAllWaiters();
+  data_pipe_->ProducerCancelAllAwakables();
 }
 
 void DataPipeProducerDispatcher::CloseImplNoLock() {
@@ -82,20 +82,21 @@
   return data_pipe_->ProducerGetHandleSignalsState();
 }
 
-MojoResult DataPipeProducerDispatcher::AddWaiterImplNoLock(
-    Waiter* waiter,
+MojoResult DataPipeProducerDispatcher::AddAwakableImplNoLock(
+    Awakable* awakable,
     MojoHandleSignals signals,
     uint32_t context,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  return data_pipe_->ProducerAddWaiter(waiter, signals, context, signals_state);
+  return data_pipe_->ProducerAddAwakable(awakable, signals, context,
+                                         signals_state);
 }
 
-void DataPipeProducerDispatcher::RemoveWaiterImplNoLock(
-    Waiter* waiter,
+void DataPipeProducerDispatcher::RemoveAwakableImplNoLock(
+    Awakable* awakable,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  data_pipe_->ProducerRemoveWaiter(waiter, signals_state);
+  data_pipe_->ProducerRemoveAwakable(awakable, signals_state);
 }
 
 bool DataPipeProducerDispatcher::IsBusyNoLock() const {
diff --git a/mojo/edk/system/data_pipe_producer_dispatcher.h b/mojo/edk/system/data_pipe_producer_dispatcher.h
index bf13148..39c070c 100644
--- a/mojo/edk/system/data_pipe_producer_dispatcher.h
+++ b/mojo/edk/system/data_pipe_producer_dispatcher.h
@@ -32,7 +32,7 @@
   ~DataPipeProducerDispatcher() override;
 
   // |Dispatcher| protected methods:
-  void CancelAllWaitersNoLock() override;
+  void CancelAllAwakablesNoLock() override;
   void CloseImplNoLock() override;
   scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock()
       override;
@@ -44,12 +44,12 @@
                                       MojoWriteDataFlags flags) override;
   MojoResult EndWriteDataImplNoLock(uint32_t num_bytes_written) override;
   HandleSignalsState GetHandleSignalsStateImplNoLock() const override;
-  MojoResult AddWaiterImplNoLock(Waiter* waiter,
-                                 MojoHandleSignals signals,
-                                 uint32_t context,
-                                 HandleSignalsState* signals_state) override;
-  void RemoveWaiterImplNoLock(Waiter* waiter,
-                              HandleSignalsState* signals_state) override;
+  MojoResult AddAwakableImplNoLock(Awakable* awakable,
+                                   MojoHandleSignals signals,
+                                   uint32_t context,
+                                   HandleSignalsState* signals_state) override;
+  void RemoveAwakableImplNoLock(Awakable* awakable,
+                                HandleSignalsState* signals_state) override;
   bool IsBusyNoLock() const override;
 
   // Protected by |lock()|:
diff --git a/mojo/edk/system/dispatcher.cc b/mojo/edk/system/dispatcher.cc
index bed5f9e..e2f2b87 100644
--- a/mojo/edk/system/dispatcher.cc
+++ b/mojo/edk/system/dispatcher.cc
@@ -220,10 +220,10 @@
   return GetHandleSignalsStateImplNoLock();
 }
 
-MojoResult Dispatcher::AddWaiter(Waiter* waiter,
-                                 MojoHandleSignals signals,
-                                 uint32_t context,
-                                 HandleSignalsState* signals_state) {
+MojoResult Dispatcher::AddAwakable(Awakable* awakable,
+                                   MojoHandleSignals signals,
+                                   uint32_t context,
+                                   HandleSignalsState* signals_state) {
   base::AutoLock locker(lock_);
   if (is_closed_) {
     if (signals_state)
@@ -231,18 +231,19 @@
     return MOJO_RESULT_INVALID_ARGUMENT;
   }
 
-  return AddWaiterImplNoLock(waiter, signals, context, signals_state);
+  return AddAwakableImplNoLock(awakable, signals, context, signals_state);
 }
 
-void Dispatcher::RemoveWaiter(Waiter* waiter,
-                              HandleSignalsState* handle_signals_state) {
+void Dispatcher::RemoveAwakable(Awakable* awakable,
+                                HandleSignalsState* handle_signals_state) {
   base::AutoLock locker(lock_);
   if (is_closed_) {
     if (handle_signals_state)
       *handle_signals_state = HandleSignalsState();
     return;
   }
-  RemoveWaiterImplNoLock(waiter, handle_signals_state);
+
+  RemoveAwakableImplNoLock(awakable, handle_signals_state);
 }
 
 Dispatcher::Dispatcher() : is_closed_(false) {
@@ -253,7 +254,7 @@
   DCHECK(is_closed_);
 }
 
-void Dispatcher::CancelAllWaitersNoLock() {
+void Dispatcher::CancelAllAwakablesNoLock() {
   lock_.AssertAcquired();
   DCHECK(is_closed_);
   // By default, waiting isn't supported. Only dispatchers that can be waited on
@@ -370,10 +371,11 @@
   return HandleSignalsState();
 }
 
-MojoResult Dispatcher::AddWaiterImplNoLock(Waiter* /*waiter*/,
-                                           MojoHandleSignals /*signals*/,
-                                           uint32_t /*context*/,
-                                           HandleSignalsState* signals_state) {
+MojoResult Dispatcher::AddAwakableImplNoLock(
+    Awakable* /*awakable*/,
+    MojoHandleSignals /*signals*/,
+    uint32_t /*context*/,
+    HandleSignalsState* signals_state) {
   lock_.AssertAcquired();
   DCHECK(!is_closed_);
   // By default, waiting isn't supported. Only dispatchers that can be waited on
@@ -383,8 +385,8 @@
   return MOJO_RESULT_FAILED_PRECONDITION;
 }
 
-void Dispatcher::RemoveWaiterImplNoLock(Waiter* /*waiter*/,
-                                        HandleSignalsState* signals_state) {
+void Dispatcher::RemoveAwakableImplNoLock(Awakable* /*awakable*/,
+                                          HandleSignalsState* signals_state) {
   lock_.AssertAcquired();
   DCHECK(!is_closed_);
   // By default, waiting isn't supported. Only dispatchers that can be waited on
@@ -427,7 +429,7 @@
   DCHECK(!is_closed_);
 
   is_closed_ = true;
-  CancelAllWaitersNoLock();
+  CancelAllAwakablesNoLock();
   CloseImplNoLock();
 }
 
@@ -437,7 +439,7 @@
   DCHECK(!is_closed_);
 
   is_closed_ = true;
-  CancelAllWaitersNoLock();
+  CancelAllAwakablesNoLock();
   return CreateEquivalentDispatcherAndCloseImplNoLock();
 }
 
diff --git a/mojo/edk/system/dispatcher.h b/mojo/edk/system/dispatcher.h
index b17bfae..c069269 100644
--- a/mojo/edk/system/dispatcher.h
+++ b/mojo/edk/system/dispatcher.h
@@ -39,7 +39,7 @@
 class LocalMessagePipeEndpoint;
 class ProxyMessagePipeEndpoint;
 class TransportData;
-class Waiter;
+class Awakable;
 
 typedef std::vector<scoped_refptr<Dispatcher>> DispatcherVector;
 
@@ -128,7 +128,7 @@
   // threads.
   HandleSignalsState GetHandleSignalsState() const;
 
-  // Adds a waiter to this dispatcher. The waiter will be woken up when this
+  // Adds an awakable to this dispatcher, which will be woken up when this
   // object changes state to satisfy |signals| with context |context|. It will
   // also be woken up when it becomes impossible for the object to ever satisfy
   // |signals| with a suitable error status.
@@ -137,20 +137,20 @@
   // to the current handle signals state (on success, it is left untouched).
   //
   // Returns:
-  //  - |MOJO_RESULT_OK| if the waiter was added;
+  //  - |MOJO_RESULT_OK| if the awakable was added;
   //  - |MOJO_RESULT_ALREADY_EXISTS| if |signals| is already satisfied;
   //  - |MOJO_RESULT_INVALID_ARGUMENT| if the dispatcher has been closed; and
   //  - |MOJO_RESULT_FAILED_PRECONDITION| if it is not (or no longer) possible
   //    that |signals| will ever be satisfied.
-  MojoResult AddWaiter(Waiter* waiter,
-                       MojoHandleSignals signals,
-                       uint32_t context,
-                       HandleSignalsState* signals_state);
-  // Removes a waiter from this dispatcher. (It is valid to call this multiple
-  // times for the same |waiter| on the same object, so long as |AddWaiter()|
-  // was called at most once.) If |signals_state| is non-null, |*signals_state|
-  // will be set to the current handle signals state.
-  void RemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state);
+  MojoResult AddAwakable(Awakable* awakable,
+                         MojoHandleSignals signals,
+                         uint32_t context,
+                         HandleSignalsState* signals_state);
+  // Removes an awakable from this dispatcher. (It is valid to call this
+  // multiple times for the same |awakable| on the same object, so long as
+  // |AddAwakable()| was called at most once.) If |signals_state| is non-null,
+  // |*signals_state| will be set to the current handle signals state.
+  void RemoveAwakable(Awakable* awakable, HandleSignalsState* signals_state);
 
   // A dispatcher must be put into a special state in order to be sent across a
   // message pipe. Outside of tests, only |HandleTableAccess| is allowed to do
@@ -220,9 +220,10 @@
   virtual ~Dispatcher();
 
   // These are to be overridden by subclasses (if necessary). They are called
-  // exactly once -- first |CancelAllWaitersNoLock()|, then |CloseImplNoLock()|,
+  // exactly once -- first |CancelAllAwakablesNoLock()|, then
+  // |CloseImplNoLock()|,
   // when the dispatcher is being closed. They are called under |lock_|.
-  virtual void CancelAllWaitersNoLock();
+  virtual void CancelAllAwakablesNoLock();
   virtual void CloseImplNoLock();
   virtual scoped_refptr<Dispatcher>
   CreateEquivalentDispatcherAndCloseImplNoLock() = 0;
@@ -266,12 +267,12 @@
       MojoMapBufferFlags flags,
       scoped_ptr<embedder::PlatformSharedBufferMapping>* mapping);
   virtual HandleSignalsState GetHandleSignalsStateImplNoLock() const;
-  virtual MojoResult AddWaiterImplNoLock(Waiter* waiter,
-                                         MojoHandleSignals signals,
-                                         uint32_t context,
-                                         HandleSignalsState* signals_state);
-  virtual void RemoveWaiterImplNoLock(Waiter* waiter,
-                                      HandleSignalsState* signals_state);
+  virtual MojoResult AddAwakableImplNoLock(Awakable* awakable,
+                                           MojoHandleSignals signals,
+                                           uint32_t context,
+                                           HandleSignalsState* signals_state);
+  virtual void RemoveAwakableImplNoLock(Awakable* awakable,
+                                        HandleSignalsState* signals_state);
 
   // These implement the API used to serialize dispatchers to a |Channel|
   // (described below). They will only be called on a dispatcher that's attached
diff --git a/mojo/edk/system/dispatcher_unittest.cc b/mojo/edk/system/dispatcher_unittest.cc
index 0b15436..97e2eed 100644
--- a/mojo/edk/system/dispatcher_unittest.cc
+++ b/mojo/edk/system/dispatcher_unittest.cc
@@ -67,16 +67,16 @@
   w.Init();
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            d->AddWaiter(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss));
+            d->AddAwakable(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   // Okay to remove even if it wasn't added (or was already removed).
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
@@ -104,11 +104,11 @@
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0));
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->AddWaiter(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss));
+            d->AddAwakable(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 }
@@ -212,8 +212,8 @@
       }
       case ADD_WAITER: {
         HandleSignalsState hss;
-        MojoResult r =
-            dispatcher_->AddWaiter(&waiter_, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss);
+        MojoResult r = dispatcher_->AddAwakable(
+            &waiter_, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss);
         EXPECT_TRUE(r == MOJO_RESULT_FAILED_PRECONDITION ||
                     r == MOJO_RESULT_INVALID_ARGUMENT);
         EXPECT_EQ(0u, hss.satisfied_signals);
@@ -222,7 +222,7 @@
       }
       case REMOVE_WAITER: {
         HandleSignalsState hss;
-        dispatcher_->RemoveWaiter(&waiter_, &hss);
+        dispatcher_->RemoveAwakable(&waiter_, &hss);
         EXPECT_EQ(0u, hss.satisfied_signals);
         EXPECT_EQ(0u, hss.satisfiable_signals);
         break;
@@ -234,7 +234,7 @@
 
     // Always try to remove the waiter, in case we added it.
     HandleSignalsState hss;
-    dispatcher_->RemoveWaiter(&waiter_, &hss);
+    dispatcher_->RemoveAwakable(&waiter_, &hss);
     EXPECT_EQ(0u, hss.satisfied_signals);
     EXPECT_EQ(0u, hss.satisfiable_signals);
   }
diff --git a/mojo/edk/system/local_data_pipe_unittest.cc b/mojo/edk/system/local_data_pipe_unittest.cc
index cea50a0..1223a2b 100644
--- a/mojo/edk/system/local_data_pipe_unittest.cc
+++ b/mojo/edk/system/local_data_pipe_unittest.cc
@@ -237,7 +237,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -247,7 +247,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 34, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 34, &hss));
 
   // Write two elements.
   int32_t elements[2] = {123, 456};
@@ -259,13 +259,13 @@
 
   // Adding a waiter should now succeed.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56,
+                                    nullptr));
   // And it shouldn't be writable yet.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  dp->ProducerRemoveWaiter(&waiter, &hss);
+  dp->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -283,22 +283,22 @@
 
   // Add a waiter.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56,
+                                    nullptr));
   // And it still shouldn't be writable yet.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  dp->ProducerRemoveWaiter(&waiter, &hss);
+  dp->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Do it again.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 78, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 78,
+                                    nullptr));
 
   // Read one element.
   elements[0] = -1;
@@ -315,7 +315,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
   EXPECT_EQ(78u, context);
   hss = HandleSignalsState();
-  dp->ProducerRemoveWaiter(&waiter, &hss);
+  dp->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -335,9 +335,9 @@
 
   // Add a waiter.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 90, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 90,
+                                    nullptr));
 
   // Read one element, using a two-phase read.
   const void* read_buffer = nullptr;
@@ -359,7 +359,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
   EXPECT_EQ(90u, context);
   hss = HandleSignalsState();
-  dp->ProducerRemoveWaiter(&waiter, &hss);
+  dp->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -374,9 +374,9 @@
 
   // Add a waiter.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12,
+                                    nullptr));
 
   // Close the consumer.
   dp->ConsumerClose();
@@ -385,7 +385,7 @@
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(1000, &context));
   EXPECT_EQ(12u, context);
   hss = HandleSignalsState();
-  dp->ProducerRemoveWaiter(&waiter, &hss);
+  dp->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -412,8 +412,8 @@
     // Add a waiter.
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 12,
-                                    nullptr));
+              dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                                      12, nullptr));
 
     // Close the consumer.
     dp->ConsumerClose();
@@ -423,7 +423,7 @@
     EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
     EXPECT_EQ(12u, context);
     hss = HandleSignalsState();
-    dp->ProducerRemoveWaiter(&waiter, &hss);
+    dp->ProducerRemoveAwakable(&waiter, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -436,8 +436,8 @@
     // Add a waiter.
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 12,
-                                    nullptr));
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                                      12, nullptr));
 
     // Close the producer.
     dp->ProducerClose();
@@ -447,7 +447,7 @@
     EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
     EXPECT_EQ(12u, context);
     hss = HandleSignalsState();
-    dp->ConsumerRemoveWaiter(&waiter, &hss);
+    dp->ConsumerRemoveAwakable(&waiter, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -475,9 +475,9 @@
     // Never writable.
     waiter.Init();
     hss = HandleSignalsState();
-    EXPECT_EQ(
-        MOJO_RESULT_FAILED_PRECONDITION,
-        dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, &hss));
+    EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12,
+                                      &hss));
     EXPECT_EQ(0u, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfiable_signals);
@@ -485,11 +485,11 @@
     // Not yet readable.
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34,
-                                    nullptr));
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34,
+                                      nullptr));
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
     hss = HandleSignalsState();
-    dp->ConsumerRemoveWaiter(&waiter, &hss);
+    dp->ConsumerRemoveAwakable(&waiter, &hss);
     EXPECT_EQ(0u, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfiable_signals);
@@ -504,9 +504,9 @@
     // Should already be readable.
     waiter.Init();
     hss = HandleSignalsState();
-    EXPECT_EQ(
-        MOJO_RESULT_ALREADY_EXISTS,
-        dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, &hss));
+    EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56,
+                                      &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfiable_signals);
@@ -520,9 +520,9 @@
     // Should still be readable.
     waiter.Init();
     hss = HandleSignalsState();
-    EXPECT_EQ(
-        MOJO_RESULT_ALREADY_EXISTS,
-        dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78, &hss));
+    EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78,
+                                      &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfiable_signals);
@@ -541,9 +541,9 @@
     // Should still be readable.
     waiter.Init();
     hss = HandleSignalsState();
-    EXPECT_EQ(
-        MOJO_RESULT_ALREADY_EXISTS,
-        dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78, &hss));
+    EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78,
+                                      &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfiable_signals);
@@ -562,8 +562,8 @@
     // Adding a waiter should now succeed.
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 90,
-                                    nullptr));
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 90,
+                                      nullptr));
 
     // Write one element.
     elements[0] = 789;
@@ -577,7 +577,7 @@
     EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
     EXPECT_EQ(90u, context);
     hss = HandleSignalsState();
-    dp->ConsumerRemoveWaiter(&waiter, &hss);
+    dp->ConsumerRemoveAwakable(&waiter, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfiable_signals);
@@ -588,9 +588,9 @@
     // Should still be readable.
     waiter.Init();
     hss = HandleSignalsState();
-    EXPECT_EQ(
-        MOJO_RESULT_ALREADY_EXISTS,
-        dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
+    EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12,
+                                      &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -610,9 +610,9 @@
     // Should be never-readable.
     waiter.Init();
     hss = HandleSignalsState();
-    EXPECT_EQ(
-        MOJO_RESULT_FAILED_PRECONDITION,
-        dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, &hss));
+    EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34,
+                                      &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -646,9 +646,9 @@
     // Should already be readable.
     waiter.Init();
     hss = HandleSignalsState();
-    EXPECT_EQ(
-        MOJO_RESULT_ALREADY_EXISTS,
-        dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
+    EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12,
+                                      &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfiable_signals);
@@ -670,9 +670,9 @@
     // Should still be readable.
     waiter.Init();
     hss = HandleSignalsState();
-    EXPECT_EQ(
-        MOJO_RESULT_ALREADY_EXISTS,
-        dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, &hss));
+    EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34,
+                                      &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfiable_signals);
@@ -694,8 +694,8 @@
     // Adding a waiter should now succeed.
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56,
-                                    nullptr));
+              dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56,
+                                      nullptr));
 
     // Close the producer.
     dp->ProducerClose();
@@ -704,7 +704,7 @@
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(1000, &context));
     EXPECT_EQ(56u, context);
     hss = HandleSignalsState();
-    dp->ConsumerRemoveWaiter(&waiter, &hss);
+    dp->ConsumerRemoveAwakable(&waiter, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -733,7 +733,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -748,24 +748,24 @@
 
   // At this point, it shouldn't be writable.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 1, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 1,
+                                    nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  dp->ProducerRemoveWaiter(&waiter, &hss);
+  dp->ProducerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // It shouldn't be readable yet either.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 2, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 2,
+                                    nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  dp->ConsumerRemoveWaiter(&waiter, &hss);
+  dp->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -779,7 +779,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -789,7 +789,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 4, &hss));
+      dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 4, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -809,7 +809,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
+      dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -831,19 +831,19 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // But not readable.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7,
+                                    nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  dp->ConsumerRemoveWaiter(&waiter, &hss);
+  dp->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -856,7 +856,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, &hss));
+      dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -886,19 +886,19 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Not readable.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1,
+                                    nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  dp->ConsumerRemoveWaiter(&waiter, &hss);
+  dp->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -915,7 +915,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 2, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 2, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -925,7 +925,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss));
+      dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -943,7 +943,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -953,7 +953,7 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
+      dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ -972,19 +972,19 @@
   hss = HandleSignalsState();
   EXPECT_EQ(
       MOJO_RESULT_ALREADY_EXISTS,
-      dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
+      dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // No longer readable.
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7,
+                                    nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  dp->ConsumerRemoveWaiter(&waiter, &hss);
+  dp->ConsumerRemoveAwakable(&waiter, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
diff --git a/mojo/edk/system/local_message_pipe_endpoint.cc b/mojo/edk/system/local_message_pipe_endpoint.cc
index 86d241c..576ad50 100644
--- a/mojo/edk/system/local_message_pipe_endpoint.cc
+++ b/mojo/edk/system/local_message_pipe_endpoint.cc
@@ -35,7 +35,7 @@
   HandleSignalsState new_state = GetHandleSignalsState();
 
   if (!new_state.equals(old_state))
-    waiter_list_.AwakeWaitersForStateChange(new_state);
+    awakable_list_.AwakeForStateChange(new_state);
 
   return true;
 }
@@ -48,7 +48,7 @@
   bool was_empty = message_queue_.IsEmpty();
   message_queue_.AddMessage(message.Pass());
   if (was_empty)
-    waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsState());
+    awakable_list_.AwakeForStateChange(GetHandleSignalsState());
 }
 
 void LocalMessagePipeEndpoint::Close() {
@@ -57,9 +57,9 @@
   message_queue_.Clear();
 }
 
-void LocalMessagePipeEndpoint::CancelAllWaiters() {
+void LocalMessagePipeEndpoint::CancelAllAwakables() {
   DCHECK(is_open_);
-  waiter_list_.CancelAllWaiters();
+  awakable_list_.CancelAll();
 }
 
 MojoResult LocalMessagePipeEndpoint::ReadMessage(
@@ -117,7 +117,7 @@
     if (message_queue_.IsEmpty()) {
       // It's currently not possible to wait for non-readability, but we should
       // do the state change anyway.
-      waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsState());
+      awakable_list_.AwakeForStateChange(GetHandleSignalsState());
     }
   }
 
@@ -144,8 +144,8 @@
   return rv;
 }
 
-MojoResult LocalMessagePipeEndpoint::AddWaiter(
-    Waiter* waiter,
+MojoResult LocalMessagePipeEndpoint::AddAwakable(
+    Awakable* awakable,
     MojoHandleSignals signals,
     uint32_t context,
     HandleSignalsState* signals_state) {
@@ -163,14 +163,15 @@
     return MOJO_RESULT_FAILED_PRECONDITION;
   }
 
-  waiter_list_.AddWaiter(waiter, signals, context);
+  awakable_list_.Add(awakable, signals, context);
   return MOJO_RESULT_OK;
 }
 
-void LocalMessagePipeEndpoint::RemoveWaiter(Waiter* waiter,
-                                            HandleSignalsState* signals_state) {
+void LocalMessagePipeEndpoint::RemoveAwakable(
+    Awakable* awakable,
+    HandleSignalsState* signals_state) {
   DCHECK(is_open_);
-  waiter_list_.RemoveWaiter(waiter);
+  awakable_list_.Remove(awakable);
   if (signals_state)
     *signals_state = GetHandleSignalsState();
 }
diff --git a/mojo/edk/system/local_message_pipe_endpoint.h b/mojo/edk/system/local_message_pipe_endpoint.h
index 7eb3949..eb1c6ee 100644
--- a/mojo/edk/system/local_message_pipe_endpoint.h
+++ b/mojo/edk/system/local_message_pipe_endpoint.h
@@ -7,11 +7,11 @@
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "mojo/edk/system/awakable_list.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/message_in_transit_queue.h"
 #include "mojo/edk/system/message_pipe_endpoint.h"
 #include "mojo/edk/system/system_impl_export.h"
-#include "mojo/edk/system/waiter_list.h"
 
 namespace mojo {
 namespace system {
@@ -30,18 +30,19 @@
   // There's a dispatcher for |LocalMessagePipeEndpoint|s, so we have to
   // implement/override these:
   void Close() override;
-  void CancelAllWaiters() override;
+  void CancelAllAwakables() override;
   MojoResult ReadMessage(UserPointer<void> bytes,
                          UserPointer<uint32_t> num_bytes,
                          DispatcherVector* dispatchers,
                          uint32_t* num_dispatchers,
                          MojoReadMessageFlags flags) override;
   HandleSignalsState GetHandleSignalsState() const override;
-  MojoResult AddWaiter(Waiter* waiter,
-                       MojoHandleSignals signals,
-                       uint32_t context,
-                       HandleSignalsState* signals_state) override;
-  void RemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state) override;
+  MojoResult AddAwakable(Awakable* awakable,
+                         MojoHandleSignals signals,
+                         uint32_t context,
+                         HandleSignalsState* signals_state) override;
+  void RemoveAwakable(Awakable* awakable,
+                      HandleSignalsState* signals_state) override;
 
   // This is only to be used by |MessagePipe|:
   MessageInTransitQueue* message_queue() { return &message_queue_; }
@@ -52,7 +53,7 @@
 
   // Queue of incoming messages.
   MessageInTransitQueue message_queue_;
-  WaiterList waiter_list_;
+  AwakableList awakable_list_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalMessagePipeEndpoint);
 };
diff --git a/mojo/edk/system/message_pipe.cc b/mojo/edk/system/message_pipe.cc
index 2bf313f..a314ef3 100644
--- a/mojo/edk/system/message_pipe.cc
+++ b/mojo/edk/system/message_pipe.cc
@@ -104,12 +104,12 @@
   return endpoints_[port]->GetType();
 }
 
-void MessagePipe::CancelAllWaiters(unsigned port) {
+void MessagePipe::CancelAllAwakables(unsigned port) {
   DCHECK(port == 0 || port == 1);
 
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port]);
-  endpoints_[port]->CancelAllWaiters();
+  endpoints_[port]->CancelAllAwakables();
 }
 
 void MessagePipe::Close(unsigned port) {
@@ -173,28 +173,29 @@
   return endpoints_[port]->GetHandleSignalsState();
 }
 
-MojoResult MessagePipe::AddWaiter(unsigned port,
-                                  Waiter* waiter,
-                                  MojoHandleSignals signals,
-                                  uint32_t context,
-                                  HandleSignalsState* signals_state) {
+MojoResult MessagePipe::AddAwakable(unsigned port,
+                                    Awakable* awakable,
+                                    MojoHandleSignals signals,
+                                    uint32_t context,
+                                    HandleSignalsState* signals_state) {
   DCHECK(port == 0 || port == 1);
 
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port]);
 
-  return endpoints_[port]->AddWaiter(waiter, signals, context, signals_state);
+  return endpoints_[port]->AddAwakable(awakable, signals, context,
+                                       signals_state);
 }
 
-void MessagePipe::RemoveWaiter(unsigned port,
-                               Waiter* waiter,
-                               HandleSignalsState* signals_state) {
+void MessagePipe::RemoveAwakable(unsigned port,
+                                 Awakable* awakable,
+                                 HandleSignalsState* signals_state) {
   DCHECK(port == 0 || port == 1);
 
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port]);
 
-  endpoints_[port]->RemoveWaiter(waiter, signals_state);
+  endpoints_[port]->RemoveAwakable(awakable, signals_state);
 }
 
 void MessagePipe::StartSerialize(unsigned /*port*/,
diff --git a/mojo/edk/system/message_pipe.h b/mojo/edk/system/message_pipe.h
index 791eece..431b5a6 100644
--- a/mojo/edk/system/message_pipe.h
+++ b/mojo/edk/system/message_pipe.h
@@ -28,9 +28,9 @@
 namespace mojo {
 namespace system {
 
+class Awakable;
 class Channel;
 class ChannelEndpoint;
-class Waiter;
 
 // |MessagePipe| is the secondary object implementing a message pipe (see the
 // explanatory comment in core.cc). It is typically owned by the dispatcher(s)
@@ -72,7 +72,7 @@
 
   // These are called by the dispatcher to implement its methods of
   // corresponding names. In all cases, the port |port| must be open.
-  void CancelAllWaiters(unsigned port);
+  void CancelAllAwakables(unsigned port);
   void Close(unsigned port);
   // Unlike |MessagePipeDispatcher::WriteMessage()|, this does not validate its
   // arguments.
@@ -88,14 +88,14 @@
                          uint32_t* num_dispatchers,
                          MojoReadMessageFlags flags);
   HandleSignalsState GetHandleSignalsState(unsigned port) const;
-  MojoResult AddWaiter(unsigned port,
-                       Waiter* waiter,
-                       MojoHandleSignals signals,
-                       uint32_t context,
-                       HandleSignalsState* signals_state);
-  void RemoveWaiter(unsigned port,
-                    Waiter* waiter,
-                    HandleSignalsState* signals_state);
+  MojoResult AddAwakable(unsigned port,
+                         Awakable* awakable,
+                         MojoHandleSignals signals,
+                         uint32_t context,
+                         HandleSignalsState* signals_state);
+  void RemoveAwakable(unsigned port,
+                      Awakable* awakable,
+                      HandleSignalsState* signals_state);
   void StartSerialize(unsigned port,
                       Channel* channel,
                       size_t* max_size,
diff --git a/mojo/edk/system/message_pipe_dispatcher.cc b/mojo/edk/system/message_pipe_dispatcher.cc
index df861df..81506e8 100644
--- a/mojo/edk/system/message_pipe_dispatcher.cc
+++ b/mojo/edk/system/message_pipe_dispatcher.cc
@@ -116,9 +116,9 @@
   return port_;
 }
 
-void MessagePipeDispatcher::CancelAllWaitersNoLock() {
+void MessagePipeDispatcher::CancelAllAwakablesNoLock() {
   lock().AssertAcquired();
-  message_pipe_->CancelAllWaiters(port_);
+  message_pipe_->CancelAllAwakables(port_);
 }
 
 void MessagePipeDispatcher::CloseImplNoLock() {
@@ -178,21 +178,21 @@
   return message_pipe_->GetHandleSignalsState(port_);
 }
 
-MojoResult MessagePipeDispatcher::AddWaiterImplNoLock(
-    Waiter* waiter,
+MojoResult MessagePipeDispatcher::AddAwakableImplNoLock(
+    Awakable* awakable,
     MojoHandleSignals signals,
     uint32_t context,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  return message_pipe_->AddWaiter(port_, waiter, signals, context,
-                                  signals_state);
+  return message_pipe_->AddAwakable(port_, awakable, signals, context,
+                                    signals_state);
 }
 
-void MessagePipeDispatcher::RemoveWaiterImplNoLock(
-    Waiter* waiter,
+void MessagePipeDispatcher::RemoveAwakableImplNoLock(
+    Awakable* awakable,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  message_pipe_->RemoveWaiter(port_, waiter, signals_state);
+  message_pipe_->RemoveAwakable(port_, awakable, signals_state);
 }
 
 void MessagePipeDispatcher::StartSerializeImplNoLock(
diff --git a/mojo/edk/system/message_pipe_dispatcher.h b/mojo/edk/system/message_pipe_dispatcher.h
index 9afdb70..fb16dd3 100644
--- a/mojo/edk/system/message_pipe_dispatcher.h
+++ b/mojo/edk/system/message_pipe_dispatcher.h
@@ -73,7 +73,7 @@
   unsigned GetPortNoLock() const;
 
   // |Dispatcher| protected methods:
-  void CancelAllWaitersNoLock() override;
+  void CancelAllAwakablesNoLock() override;
   void CloseImplNoLock() override;
   scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock()
       override;
@@ -88,12 +88,12 @@
                                    uint32_t* num_dispatchers,
                                    MojoReadMessageFlags flags) override;
   HandleSignalsState GetHandleSignalsStateImplNoLock() const override;
-  MojoResult AddWaiterImplNoLock(Waiter* waiter,
-                                 MojoHandleSignals signals,
-                                 uint32_t context,
-                                 HandleSignalsState* signals_state) override;
-  void RemoveWaiterImplNoLock(Waiter* waiter,
-                              HandleSignalsState* signals_state) override;
+  MojoResult AddAwakableImplNoLock(Awakable* awakable,
+                                   MojoHandleSignals signals,
+                                   uint32_t context,
+                                   HandleSignalsState* signals_state) override;
+  void RemoveAwakableImplNoLock(Awakable* awakable,
+                                HandleSignalsState* signals_state) override;
   void StartSerializeImplNoLock(Channel* channel,
                                 size_t* max_size,
                                 size_t* max_platform_handles) override;
diff --git a/mojo/edk/system/message_pipe_dispatcher_unittest.cc b/mojo/edk/system/message_pipe_dispatcher_unittest.cc
index 303ae6a..b5562b0 100644
--- a/mojo/edk/system/message_pipe_dispatcher_unittest.cc
+++ b/mojo/edk/system/message_pipe_dispatcher_unittest.cc
@@ -59,7 +59,7 @@
     w.Init();
     hss = HandleSignalsState();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
     EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
     // Shouldn't need to remove the waiter (it was not added).
@@ -68,7 +68,7 @@
     // |d1|), then wait.
     w.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
     buffer[0] = 123456789;
     EXPECT_EQ(MOJO_RESULT_OK,
               d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
@@ -78,7 +78,7 @@
     EXPECT_EQ(1u, context);
     EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
     hss = HandleSignalsState();
-    d0->RemoveWaiter(&w, &hss);
+    d0->RemoveAwakable(&w, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
               hss.satisfied_signals);
     EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -87,7 +87,7 @@
     w.Init();
     hss = HandleSignalsState();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
               hss.satisfied_signals);
     EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -106,19 +106,19 @@
     // Wait for zero time for readability on |d0| (will time out).
     w.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr));
     stopwatch.Start();
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, nullptr));
     EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
     hss = HandleSignalsState();
-    d0->RemoveWaiter(&w, &hss);
+    d0->RemoveAwakable(&w, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
     EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
     // Wait for non-zero, finite time for readability on |d0| (will time out).
     w.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr));
     stopwatch.Start();
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
               w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), nullptr));
@@ -126,14 +126,14 @@
     EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout());
     EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout());
     hss = HandleSignalsState();
-    d0->RemoveWaiter(&w, &hss);
+    d0->RemoveAwakable(&w, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
     EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
     // Check the peer closed signal.
     w.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 12, nullptr));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 12, nullptr));
 
     // Close the peer.
     EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
@@ -142,7 +142,7 @@
     EXPECT_EQ(MOJO_RESULT_OK, w.Wait(1000, &context));
     EXPECT_EQ(12u, context);
     hss = HandleSignalsState();
-    d0->RemoveWaiter(&w, &hss);
+    d0->RemoveAwakable(&w, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -249,7 +249,7 @@
     w.Init();
     hss = HandleSignalsState();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
               hss.satisfied_signals);
     EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -269,7 +269,7 @@
     w.Init();
     hss = HandleSignalsState();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, &hss));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -289,7 +289,7 @@
     w.Init();
     hss = HandleSignalsState();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
               hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -309,7 +309,7 @@
     w.Init();
     hss = HandleSignalsState();
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -317,7 +317,7 @@
     w.Init();
     hss = HandleSignalsState();
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
+              d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
@@ -559,15 +559,15 @@
       // Wait for it to be readable.
       w.Init();
       hss = HandleSignalsState();
-      result =
-          read_dispatcher_->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss);
+      result = read_dispatcher_->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0,
+                                             &hss);
       EXPECT_TRUE(result == MOJO_RESULT_OK ||
                   result == MOJO_RESULT_ALREADY_EXISTS)
           << "result: " << result;
       if (result == MOJO_RESULT_OK) {
         // Actually need to wait.
         EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, nullptr));
-        read_dispatcher_->RemoveWaiter(&w, &hss);
+        read_dispatcher_->RemoveAwakable(&w, &hss);
       }
       // We may not actually be readable, since we're racing with other threads.
       EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
diff --git a/mojo/edk/system/message_pipe_endpoint.cc b/mojo/edk/system/message_pipe_endpoint.cc
index df623d4..4b8bc5e 100644
--- a/mojo/edk/system/message_pipe_endpoint.cc
+++ b/mojo/edk/system/message_pipe_endpoint.cc
@@ -9,7 +9,7 @@
 namespace mojo {
 namespace system {
 
-void MessagePipeEndpoint::CancelAllWaiters() {
+void MessagePipeEndpoint::CancelAllAwakables() {
   NOTREACHED();
 }
 
@@ -27,18 +27,18 @@
   return HandleSignalsState();
 }
 
-MojoResult MessagePipeEndpoint::AddWaiter(Waiter* /*waiter*/,
-                                          MojoHandleSignals /*signals*/,
-                                          uint32_t /*context*/,
-                                          HandleSignalsState* signals_state) {
+MojoResult MessagePipeEndpoint::AddAwakable(Awakable* /*awakable*/,
+                                            MojoHandleSignals /*signals*/,
+                                            uint32_t /*context*/,
+                                            HandleSignalsState* signals_state) {
   NOTREACHED();
   if (signals_state)
     *signals_state = HandleSignalsState();
   return MOJO_RESULT_INTERNAL;
 }
 
-void MessagePipeEndpoint::RemoveWaiter(Waiter* /*waiter*/,
-                                       HandleSignalsState* signals_state) {
+void MessagePipeEndpoint::RemoveAwakable(Awakable* /*awakable*/,
+                                         HandleSignalsState* signals_state) {
   NOTREACHED();
   if (signals_state)
     *signals_state = HandleSignalsState();
diff --git a/mojo/edk/system/message_pipe_endpoint.h b/mojo/edk/system/message_pipe_endpoint.h
index 7bc0a0d..0b5f12e 100644
--- a/mojo/edk/system/message_pipe_endpoint.h
+++ b/mojo/edk/system/message_pipe_endpoint.h
@@ -23,7 +23,7 @@
 namespace system {
 
 class ChannelEndpoint;
-class Waiter;
+class Awakable;
 
 // This is an interface to one of the ends of a message pipe, and is used by
 // |MessagePipe|. Its most important role is to provide a sink for messages
@@ -58,18 +58,19 @@
   // These methods implement the methods of the same name in |MessagePipe|,
   // though |MessagePipe|'s implementation may have to do a little more if the
   // operation involves both endpoints.
-  virtual void CancelAllWaiters();
+  virtual void CancelAllAwakables();
   virtual MojoResult ReadMessage(UserPointer<void> bytes,
                                  UserPointer<uint32_t> num_bytes,
                                  DispatcherVector* dispatchers,
                                  uint32_t* num_dispatchers,
                                  MojoReadMessageFlags flags);
   virtual HandleSignalsState GetHandleSignalsState() const;
-  virtual MojoResult AddWaiter(Waiter* waiter,
-                               MojoHandleSignals signals,
-                               uint32_t context,
-                               HandleSignalsState* signals_state);
-  virtual void RemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state);
+  virtual MojoResult AddAwakable(Awakable* awakable,
+                                 MojoHandleSignals signals,
+                                 uint32_t context,
+                                 HandleSignalsState* signals_state);
+  virtual void RemoveAwakable(Awakable* awakable,
+                              HandleSignalsState* signals_state);
 
   // Implementations must override these if they represent a proxy endpoint. An
   // implementation for a local endpoint needs not override these methods, since
diff --git a/mojo/edk/system/message_pipe_test_utils.cc b/mojo/edk/system/message_pipe_test_utils.cc
index e5df26d..e88ffd5 100644
--- a/mojo/edk/system/message_pipe_test_utils.cc
+++ b/mojo/edk/system/message_pipe_test_utils.cc
@@ -21,14 +21,15 @@
   Waiter waiter;
   waiter.Init();
 
-  MojoResult add_result = mp->AddWaiter(0, &waiter, signals, 0, signals_state);
+  MojoResult add_result =
+      mp->AddAwakable(0, &waiter, signals, 0, signals_state);
   if (add_result != MOJO_RESULT_OK) {
     return (add_result == MOJO_RESULT_ALREADY_EXISTS) ? MOJO_RESULT_OK
                                                       : add_result;
   }
 
   MojoResult wait_result = waiter.Wait(MOJO_DEADLINE_INDEFINITE, nullptr);
-  mp->RemoveWaiter(0, &waiter, signals_state);
+  mp->RemoveAwakable(0, &waiter, signals_state);
   return wait_result;
 }
 
diff --git a/mojo/edk/system/message_pipe_unittest.cc b/mojo/edk/system/message_pipe_unittest.cc
index c700891..a30b636 100644
--- a/mojo/edk/system/message_pipe_unittest.cc
+++ b/mojo/edk/system/message_pipe_unittest.cc
@@ -337,25 +337,26 @@
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
+            mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE |
-                                          MOJO_HANDLE_SIGNAL_WRITABLE,
-                          0, &hss));
+            mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE |
+                                            MOJO_HANDLE_SIGNAL_WRITABLE,
+                            0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
   // Not yet readable.
   waiter.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
+  ASSERT_EQ(
+      MOJO_RESULT_OK,
+      mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  mp->RemoveWaiter(0, &waiter, &hss);
+  mp->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
@@ -363,10 +364,10 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 2, nullptr));
+      mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 2, nullptr));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
   hss = HandleSignalsState();
-  mp->RemoveWaiter(0, &waiter, &hss);
+  mp->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
@@ -380,16 +381,16 @@
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss));
+            mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE |
-                                          MOJO_HANDLE_SIGNAL_WRITABLE,
-                          0, &hss));
+            mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE |
+                                            MOJO_HANDLE_SIGNAL_WRITABLE,
+                            0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -397,7 +398,7 @@
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
+            mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -408,8 +409,9 @@
   // Port 1 should be signaled with peer closed.
   waiter.Init();
   hss = HandleSignalsState();
-  EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 5, &hss));
+  EXPECT_EQ(
+      MOJO_RESULT_ALREADY_EXISTS,
+      mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 5, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -419,7 +421,7 @@
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
+            mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -429,7 +431,7 @@
   waiter.Init();
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, &hss));
+            mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -447,8 +449,9 @@
   // Now port 1 should no longer be readable.
   waiter.Init();
   hss = HandleSignalsState();
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, nullptr));
+  EXPECT_EQ(
+      MOJO_RESULT_FAILED_PRECONDITION,
+      mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, nullptr));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
@@ -469,8 +472,8 @@
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1,
-                            nullptr));
+              mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
+                              1, nullptr));
     thread.Start();
 
     buffer[0] = 123456789;
@@ -480,7 +483,7 @@
                                nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     HandleSignalsState hss;
-    mp->RemoveWaiter(1, thread.waiter(), &hss);
+    mp->RemoveAwakable(1, thread.waiter(), &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
               hss.satisfied_signals);
     EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -499,16 +502,16 @@
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2,
-                            nullptr));
+              mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
+                              2, nullptr));
     thread.Start();
 
     // Close port 1 first -- this should result in the waiter being cancelled.
-    mp->CancelAllWaiters(1);
+    mp->CancelAllAwakables(1);
     mp->Close(1);
 
-    // Port 1 is closed, so |Dispatcher::RemoveWaiter()| wouldn't call into the
-    // |MessagePipe| to remove any waiter.
+    // Port 1 is closed, so |Dispatcher::RemoveAwakable()| wouldn't call into
+    // the |MessagePipe| to remove any waiter.
 
     mp->Close(0);
   }  // Joins |thread|.
@@ -522,16 +525,16 @@
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                            3, nullptr));
+              mp->AddAwakable(1, thread.waiter(),
+                              MOJO_HANDLE_SIGNAL_PEER_CLOSED, 3, nullptr));
     thread.Start();
 
     // Close port 1 first -- this should result in the waiter being cancelled.
-    mp->CancelAllWaiters(1);
+    mp->CancelAllAwakables(1);
     mp->Close(1);
 
-    // Port 1 is closed, so |Dispatcher::RemoveWaiter()| wouldn't call into the
-    // |MessagePipe| to remove any waiter.
+    // Port 1 is closed, so |Dispatcher::RemoveAwakable()| wouldn't call into
+    // the |MessagePipe| to remove any waiter.
 
     mp->Close(0);
   }  // Joins |thread|.
@@ -545,21 +548,21 @@
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 4,
-                            nullptr));
+              mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
+                              4, nullptr));
     thread.Start();
 
     // Close port 0 first -- this should wake the waiter up, since port 1 will
     // never be readable.
-    mp->CancelAllWaiters(0);
+    mp->CancelAllAwakables(0);
     mp->Close(0);
 
     HandleSignalsState hss;
-    mp->RemoveWaiter(1, thread.waiter(), &hss);
+    mp->RemoveAwakable(1, thread.waiter(), &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
-    mp->CancelAllWaiters(1);
+    mp->CancelAllAwakables(1);
     mp->Close(1);
   }  // Joins |thread|.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
diff --git a/mojo/edk/system/remote_message_pipe_unittest.cc b/mojo/edk/system/remote_message_pipe_unittest.cc
index 926ca0b..dd9ec2c 100644
--- a/mojo/edk/system/remote_message_pipe_unittest.cc
+++ b/mojo/edk/system/remote_message_pipe_unittest.cc
@@ -193,7 +193,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   EXPECT_EQ(
@@ -205,7 +205,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -223,7 +223,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
+      mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
 
   EXPECT_EQ(
       MOJO_RESULT_OK,
@@ -233,7 +233,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
-  mp0->RemoveWaiter(0, &waiter, &hss);
+  mp0->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -255,13 +255,13 @@
   waiter.Init();
   hss = HandleSignalsState();
   MojoResult result =
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, &hss);
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, &hss);
   if (result == MOJO_RESULT_OK) {
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
     EXPECT_EQ(789u, context);
     hss = HandleSignalsState();
-    mp1->RemoveWaiter(1, &waiter, &hss);
+    mp1->RemoveAwakable(1, &waiter, &hss);
   }
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
@@ -292,12 +292,12 @@
   waiter.Init();
   hss = HandleSignalsState();
   MojoResult result =
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 101, &hss);
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 101, &hss);
   if (result == MOJO_RESULT_OK) {
     EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
     EXPECT_EQ(101u, context);
     hss = HandleSignalsState();
-    mp1->RemoveWaiter(1, &waiter, &hss);
+    mp1->RemoveAwakable(1, &waiter, &hss);
   }
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
@@ -339,7 +339,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp0->WriteMessage(0, UserPointer<const void>(&remote_id),
@@ -349,7 +349,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -373,7 +373,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp3->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+      mp3->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
 
   EXPECT_EQ(
       MOJO_RESULT_OK,
@@ -383,7 +383,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
-  mp3->RemoveWaiter(0, &waiter, &hss);
+  mp3->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -419,7 +419,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   EXPECT_EQ(
       MOJO_RESULT_OK,
@@ -429,7 +429,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -500,7 +500,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   BootstrapChannelEndpointNoWait(1, ep1);
 
@@ -512,7 +512,7 @@
   // not appear as writable (there's a race, and it may not have noticed that
   // the other side was closed yet -- e.g., inserting a sleep here would make it
   // much more likely to notice that it's no longer writable).
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
@@ -562,7 +562,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   BootstrapChannelEndpointNoWait(1, ep1);
 
@@ -574,7 +574,7 @@
   // not appear as writable (there's a race, and it may not have noticed that
   // the other side was closed yet -- e.g., inserting a sleep here would make it
   // much more likely to notice that it's no longer writable).
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
@@ -613,7 +613,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
@@ -639,7 +639,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -667,8 +667,8 @@
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456,
-                                  nullptr));
+            dispatcher->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456,
+                                    nullptr));
 
   // Write to "local_mp", port 1.
   EXPECT_EQ(
@@ -683,7 +683,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
-  dispatcher->RemoveWaiter(&waiter, &hss);
+  dispatcher->RemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -701,8 +701,8 @@
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
-                                nullptr));
+            local_mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                  nullptr));
 
   // Write to the dispatcher.
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
@@ -713,7 +713,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
-  local_mp->RemoveWaiter(1, &waiter, &hss);
+  local_mp->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -787,7 +787,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
@@ -813,7 +813,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -921,7 +921,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
@@ -947,7 +947,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -1040,7 +1040,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
@@ -1066,7 +1066,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -1177,7 +1177,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
+      mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
@@ -1203,7 +1203,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveWaiter(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -1236,7 +1236,7 @@
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
-      mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
+      mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
 
   // Write to MP 1, port 1.
   {
@@ -1262,7 +1262,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
-  mp0->RemoveWaiter(0, &waiter, &hss);
+  mp0->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -1289,8 +1289,8 @@
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
-                                  nullptr));
+            dispatcher->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                    nullptr));
 
   // Write to "local_mp", port 1.
   EXPECT_EQ(
@@ -1302,7 +1302,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
-  dispatcher->RemoveWaiter(&waiter, &hss);
+  dispatcher->RemoveAwakable(&waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
@@ -1320,8 +1320,8 @@
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
-                                nullptr));
+            local_mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                  nullptr));
 
   // Write to the dispatcher.
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
@@ -1332,7 +1332,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
-  local_mp->RemoveWaiter(1, &waiter, &hss);
+  local_mp->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
diff --git a/mojo/edk/system/simple_dispatcher.cc b/mojo/edk/system/simple_dispatcher.cc
index 3eb7a4f..f7db875 100644
--- a/mojo/edk/system/simple_dispatcher.cc
+++ b/mojo/edk/system/simple_dispatcher.cc
@@ -17,16 +17,16 @@
 
 void SimpleDispatcher::HandleSignalsStateChangedNoLock() {
   lock().AssertAcquired();
-  waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsStateImplNoLock());
+  awakable_list_.AwakeForStateChange(GetHandleSignalsStateImplNoLock());
 }
 
-void SimpleDispatcher::CancelAllWaitersNoLock() {
+void SimpleDispatcher::CancelAllAwakablesNoLock() {
   lock().AssertAcquired();
-  waiter_list_.CancelAllWaiters();
+  awakable_list_.CancelAll();
 }
 
-MojoResult SimpleDispatcher::AddWaiterImplNoLock(
-    Waiter* waiter,
+MojoResult SimpleDispatcher::AddAwakableImplNoLock(
+    Awakable* awakable,
     MojoHandleSignals signals,
     uint32_t context,
     HandleSignalsState* signals_state) {
@@ -44,15 +44,15 @@
     return MOJO_RESULT_FAILED_PRECONDITION;
   }
 
-  waiter_list_.AddWaiter(waiter, signals, context);
+  awakable_list_.Add(awakable, signals, context);
   return MOJO_RESULT_OK;
 }
 
-void SimpleDispatcher::RemoveWaiterImplNoLock(
-    Waiter* waiter,
+void SimpleDispatcher::RemoveAwakableImplNoLock(
+    Awakable* awakable,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  waiter_list_.RemoveWaiter(waiter);
+  awakable_list_.Remove(awakable);
   if (signals_state)
     *signals_state = GetHandleSignalsStateImplNoLock();
 }
diff --git a/mojo/edk/system/simple_dispatcher.h b/mojo/edk/system/simple_dispatcher.h
index b1260ef..eddf614 100644
--- a/mojo/edk/system/simple_dispatcher.h
+++ b/mojo/edk/system/simple_dispatcher.h
@@ -8,9 +8,9 @@
 #include <list>
 
 #include "base/macros.h"
+#include "mojo/edk/system/awakable_list.h"
 #include "mojo/edk/system/dispatcher.h"
 #include "mojo/edk/system/system_impl_export.h"
-#include "mojo/edk/system/waiter_list.h"
 
 namespace mojo {
 namespace system {
@@ -30,17 +30,17 @@
   void HandleSignalsStateChangedNoLock();
 
   // |Dispatcher| protected methods:
-  void CancelAllWaitersNoLock() override;
-  MojoResult AddWaiterImplNoLock(Waiter* waiter,
-                                 MojoHandleSignals signals,
-                                 uint32_t context,
-                                 HandleSignalsState* signals_state) override;
-  void RemoveWaiterImplNoLock(Waiter* waiter,
-                              HandleSignalsState* signals_state) override;
+  void CancelAllAwakablesNoLock() override;
+  MojoResult AddAwakableImplNoLock(Awakable* awakable,
+                                   MojoHandleSignals signals,
+                                   uint32_t context,
+                                   HandleSignalsState* signals_state) override;
+  void RemoveAwakableImplNoLock(Awakable* awakable,
+                                HandleSignalsState* signals_state) override;
 
  private:
   // Protected by |lock()|:
-  WaiterList waiter_list_;
+  AwakableList awakable_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleDispatcher);
 };
diff --git a/mojo/edk/system/simple_dispatcher_unittest.cc b/mojo/edk/system/simple_dispatcher_unittest.cc
index f23ff68..b8e57e9 100644
--- a/mojo/edk/system/simple_dispatcher_unittest.cc
+++ b/mojo/edk/system/simple_dispatcher_unittest.cc
@@ -104,7 +104,7 @@
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
+            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,
             hss.satisfiable_signals);
@@ -114,14 +114,14 @@
   w.Init();
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, nullptr));
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_WRITABLE);
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   EXPECT_EQ(1u, context);
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
@@ -130,14 +130,14 @@
   w.Init();
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr));
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_WRITABLE);
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_OK, w.Wait(0, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   EXPECT_EQ(2u, context);
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
@@ -146,7 +146,7 @@
   w.Init();
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr));
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_WRITABLE);
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_OK,
@@ -154,7 +154,7 @@
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   EXPECT_EQ(3u, context);
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
@@ -163,12 +163,12 @@
   w.Init();
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr));
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, nullptr));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
@@ -178,7 +178,7 @@
   w.Init();
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 5, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 5, nullptr));
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
             w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), nullptr));
@@ -186,7 +186,7 @@
   EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout());
   EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout());
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
@@ -208,7 +208,7 @@
   d->SetSatisfiedSignals(0);
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
   // Shouldn't need to remove the waiter (it was not added).
@@ -218,7 +218,7 @@
   d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE |
                            MOJO_HANDLE_SIGNAL_WRITABLE);
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr));
   d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE);
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ -226,7 +226,7 @@
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   EXPECT_EQ(2u, context);
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
@@ -235,14 +235,14 @@
   d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE |
                            MOJO_HANDLE_SIGNAL_WRITABLE);
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr));
   d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE);
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, w.Wait(0, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   EXPECT_EQ(3u, context);
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
@@ -252,7 +252,7 @@
   d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE |
                            MOJO_HANDLE_SIGNAL_WRITABLE);
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr));
   d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE);
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ -260,7 +260,7 @@
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   EXPECT_EQ(4u, context);
   hss = HandleSignalsState();
-  d->RemoveWaiter(&w, &hss);
+  d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
@@ -281,7 +281,7 @@
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss));
+            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).
@@ -290,7 +290,7 @@
   d = new MockSimpleDispatcher();
   w.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr));
+            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));
@@ -302,7 +302,7 @@
   d = new MockSimpleDispatcher();
   w.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr));
+            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));
@@ -315,7 +315,7 @@
   d = new MockSimpleDispatcher();
   w.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr));
+            d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_CANCELLED,
diff --git a/mojo/edk/system/waiter.cc b/mojo/edk/system/waiter.cc
index 6dcd713..f9047cb 100644
--- a/mojo/edk/system/waiter.cc
+++ b/mojo/edk/system/waiter.cc
@@ -49,7 +49,7 @@
   if (awoken_) {
     DCHECK_NE(awake_result_, MOJO_RESULT_INTERNAL);
     if (context)
-      *context = awake_context_;
+      *context = static_cast<uint32_t>(awake_context_);
     return awake_result_;
   }
 
@@ -78,11 +78,11 @@
 
   DCHECK_NE(awake_result_, MOJO_RESULT_INTERNAL);
   if (context)
-    *context = awake_context_;
+    *context = static_cast<uint32_t>(awake_context_);
   return awake_result_;
 }
 
-void Waiter::Awake(MojoResult result, uint32_t context) {
+void Waiter::Awake(MojoResult result, uintptr_t context) {
   base::AutoLock locker(lock_);
 
   if (awoken_)
diff --git a/mojo/edk/system/waiter.h b/mojo/edk/system/waiter.h
index 03ada16..999f286 100644
--- a/mojo/edk/system/waiter.h
+++ b/mojo/edk/system/waiter.h
@@ -10,6 +10,7 @@
 #include "base/macros.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
+#include "mojo/edk/system/awakable.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/c/system/types.h"
 
@@ -20,7 +21,7 @@
 // under other locks, in particular, |Dispatcher::lock_|s, so |Waiter| methods
 // must never call out to other objects (in particular, |Dispatcher|s). This
 // class is thread-safe.
-class MOJO_SYSTEM_IMPL_EXPORT Waiter {
+class MOJO_SYSTEM_IMPL_EXPORT Waiter : public Awakable {
  public:
   Waiter();
   ~Waiter();
@@ -39,12 +40,12 @@
   //     case |*context| is not modified.
   //
   // Usually, the context passed to |Awake()| will be the value passed to
-  // |Dispatcher::AddWaiter()|, which is usually the index to the array of
+  // |Dispatcher::AddAwakable()|, which is usually the index to the array of
   // handles passed to |MojoWaitMany()| (or 0 for |MojoWait()|).
   //
   // Typical |Awake()| results are:
   //   - |MOJO_RESULT_OK| if one of the flags passed to
-  //     |MojoWait()|/|MojoWaitMany()| (hence |Dispatcher::AddWaiter()|) was
+  //     |MojoWait()|/|MojoWaitMany()| (hence |Dispatcher::AddAwakable()|) was
   //     satisfied;
   //   - |MOJO_RESULT_CANCELLED| if a handle (on which
   //     |MojoWait()|/|MojoWaitMany()| was called) was closed (hence the
@@ -57,7 +58,7 @@
 
   // Wake the waiter up with the given result and context (or no-op if it's been
   // woken up already).
-  void Awake(MojoResult result, uint32_t context);
+  void Awake(MojoResult result, uintptr_t context) override;
 
  private:
   base::ConditionVariable cv_;  // Associated to |lock_|.
@@ -67,10 +68,7 @@
 #endif
   bool awoken_;
   MojoResult awake_result_;
-  // This is a |uint32_t| because we really only need to store an index (for
-  // |MojoWaitMany()|). But in tests, it's convenient to use this for other
-  // purposes (e.g., to distinguish between different wake-up reasons).
-  uint32_t awake_context_;
+  uintptr_t awake_context_;
 
   DISALLOW_COPY_AND_ASSIGN(Waiter);
 };
diff --git a/mojo/edk/system/waiter_list.cc b/mojo/edk/system/waiter_list.cc
deleted file mode 100644
index 42dfe15..0000000
--- a/mojo/edk/system/waiter_list.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// 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.
-
-#include "mojo/edk/system/waiter_list.h"
-
-#include "base/logging.h"
-#include "mojo/edk/system/handle_signals_state.h"
-#include "mojo/edk/system/waiter.h"
-
-namespace mojo {
-namespace system {
-
-WaiterList::WaiterList() {
-}
-
-WaiterList::~WaiterList() {
-  DCHECK(waiters_.empty());
-}
-
-void WaiterList::AwakeWaitersForStateChange(const HandleSignalsState& state) {
-  for (WaiterInfoList::iterator it = waiters_.begin(); it != waiters_.end();
-       ++it) {
-    if (state.satisfies(it->signals))
-      it->waiter->Awake(MOJO_RESULT_OK, it->context);
-    else if (!state.can_satisfy(it->signals))
-      it->waiter->Awake(MOJO_RESULT_FAILED_PRECONDITION, it->context);
-  }
-}
-
-void WaiterList::CancelAllWaiters() {
-  for (WaiterInfoList::iterator it = waiters_.begin(); it != waiters_.end();
-       ++it) {
-    it->waiter->Awake(MOJO_RESULT_CANCELLED, it->context);
-  }
-  waiters_.clear();
-}
-
-void WaiterList::AddWaiter(Waiter* waiter,
-                           MojoHandleSignals signals,
-                           uint32_t context) {
-  waiters_.push_back(WaiterInfo(waiter, signals, context));
-}
-
-void WaiterList::RemoveWaiter(Waiter* waiter) {
-  // We allow a thread to wait on the same handle multiple times simultaneously,
-  // so we need to scan the entire list and remove all occurrences of |waiter|.
-  for (WaiterInfoList::iterator it = waiters_.begin(); it != waiters_.end();) {
-    WaiterInfoList::iterator maybe_delete = it;
-    ++it;
-    if (maybe_delete->waiter == waiter)
-      waiters_.erase(maybe_delete);
-  }
-}
-
-}  // namespace system
-}  // namespace mojo
diff --git a/mojo/edk/system/waiter_list.h b/mojo/edk/system/waiter_list.h
deleted file mode 100644
index 6bbc799..0000000
--- a/mojo/edk/system/waiter_list.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// 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.
-
-#ifndef MOJO_EDK_SYSTEM_WAITER_LIST_H_
-#define MOJO_EDK_SYSTEM_WAITER_LIST_H_
-
-#include <stdint.h>
-
-#include <list>
-
-#include "base/macros.h"
-#include "mojo/edk/system/system_impl_export.h"
-#include "mojo/public/c/system/types.h"
-
-namespace mojo {
-namespace system {
-
-class Waiter;
-struct HandleSignalsState;
-
-// |WaiterList| tracks all the |Waiter|s that are waiting on a given
-// handle/|Dispatcher|. There should be a |WaiterList| for each handle that can
-// be waited on (in any way). In the simple case, the |WaiterList| is owned by
-// the |Dispatcher|, whereas in more complex cases it is owned by the secondary
-// object (see simple_dispatcher.* and the explanatory comment in core.cc). This
-// class is thread-unsafe (all concurrent access must be protected by some
-// lock).
-class MOJO_SYSTEM_IMPL_EXPORT WaiterList {
- public:
-  WaiterList();
-  ~WaiterList();
-
-  void AwakeWaitersForStateChange(const HandleSignalsState& state);
-  void CancelAllWaiters();
-  void AddWaiter(Waiter* waiter, MojoHandleSignals signals, uint32_t context);
-  void RemoveWaiter(Waiter* waiter);
-
- private:
-  struct WaiterInfo {
-    WaiterInfo(Waiter* waiter, MojoHandleSignals signals, uint32_t context)
-        : waiter(waiter), signals(signals), context(context) {}
-
-    Waiter* waiter;
-    MojoHandleSignals signals;
-    uint32_t context;
-  };
-  typedef std::list<WaiterInfo> WaiterInfoList;
-
-  WaiterInfoList waiters_;
-
-  DISALLOW_COPY_AND_ASSIGN(WaiterList);
-};
-
-}  // namespace system
-}  // namespace mojo
-
-#endif  // MOJO_EDK_SYSTEM_WAITER_LIST_H_
diff --git a/mojo/edk/system/waiter_test_utils.cc b/mojo/edk/system/waiter_test_utils.cc
index 39cb14e..ea243ed 100644
--- a/mojo/edk/system/waiter_test_utils.cc
+++ b/mojo/edk/system/waiter_test_utils.cc
@@ -55,14 +55,14 @@
 void WaiterThread::Run() {
   waiter_.Init();
 
-  *result_out_ = dispatcher_->AddWaiter(&waiter_, handle_signals_, context_,
-                                        signals_state_out_);
+  *result_out_ = dispatcher_->AddAwakable(&waiter_, handle_signals_, context_,
+                                          signals_state_out_);
   if (*result_out_ != MOJO_RESULT_OK)
     return;
 
   *did_wait_out_ = true;
   *result_out_ = waiter_.Wait(deadline_, context_out_);
-  dispatcher_->RemoveWaiter(&waiter_, signals_state_out_);
+  dispatcher_->RemoveAwakable(&waiter_, signals_state_out_);
 }
 
 }  // namespace test
diff --git a/mojo/edk/system/waiter_test_utils.h b/mojo/edk/system/waiter_test_utils.h
index cec0f3e..b11d78d 100644
--- a/mojo/edk/system/waiter_test_utils.h
+++ b/mojo/edk/system/waiter_test_utils.h
@@ -29,19 +29,19 @@
 //
 //    MojoResult result;
 //    {
-//      WaiterList waiter_list;
+//      AwakableList awakable_list;
 //      test::SimpleWaiterThread thread(&result);
-//      waiter_list.AddWaiter(thread.waiter(), ...);
+//      awakable_list.Add(thread.waiter(), ...);
 //      thread.Start();
 //      ... some stuff to wake the waiter ...
-//      waiter_list.RemoveWaiter(thread.waiter());
+//      awakable_list.Remove(thread.waiter());
 //    }  // Join |thread|.
 //    EXPECT_EQ(..., result);
 //
 // There's a bit of unrealism in its use: In this sort of usage, calls such as
-// |Waiter::Init()|, |AddWaiter()|, and |RemoveWaiter()| are done in the main
-// (test) thread, not the waiter thread (as would actually happen in real code).
-// (We accept this unrealism for simplicity, since |WaiterList| is
+// |Waiter::Init()|, |AddAwakable()|, and |RemoveAwakable()| are done in the
+// main (test) thread, not the waiter thread (as would actually happen in real
+// code). (We accept this unrealism for simplicity, since |AwakableList| is
 // thread-unsafe so making it more realistic would require adding nontrivial
 // synchronization machinery.)
 class SimpleWaiterThread : public base::SimpleThread {