Extract Awakable from Waiter
This CL extracts simple Awakable interface from Waiter and
rename WaiterList to AwakableList.
This is a preparation for introducing system-integrated
AsyncWaiter.
R=viettrungluu@chromium.org
BUG=377980
Review URL: https://codereview.chromium.org/779503003
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 {
