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 {