Index: mojo/edk/system/watch_unittest.cc |
diff --git a/mojo/edk/system/watch_unittest.cc b/mojo/edk/system/watch_unittest.cc |
index ec28d94f8058f25d40abcb88bcebbc1161364bed..2e335b4940e6bf0fba8b3348dd3f1598222f376c 100644 |
--- a/mojo/edk/system/watch_unittest.cc |
+++ b/mojo/edk/system/watch_unittest.cc |
@@ -26,7 +26,7 @@ void IgnoreResult(uintptr_t context, |
} |
// A test helper class for watching a handle. The WatchHelper instance is used |
-// as a watch context for a single watch callback. |
+// as a watcher context for a single watcher callback. |
class WatchHelper { |
public: |
using Callback = |
@@ -37,23 +37,28 @@ class WatchHelper { |
CHECK(!watching_); |
} |
- void Watch(MojoHandle handle, |
- MojoHandleSignals signals, |
- const Callback& callback) { |
+ void Register(MojoHandle handle, |
+ MojoHandleSignals signals, |
+ const Callback& callback) { |
CHECK(!watching_); |
handle_ = handle; |
callback_ = callback; |
watching_ = true; |
- CHECK_EQ(MOJO_RESULT_OK, MojoWatch(handle_, signals, &WatchHelper::OnNotify, |
- reinterpret_cast<uintptr_t>(this))); |
+ CHECK_EQ(MOJO_RESULT_OK, |
+ MojoRegisterWatcher(handle_, signals, &WatchHelper::OnNotify, |
+ reinterpret_cast<uintptr_t>(this))); |
+ } |
+ |
+ MojoResult Arm() { |
+ return MojoArmWatcher(handle_, reinterpret_cast<uintptr_t>(this)); |
} |
bool is_watching() const { return watching_; } |
- void Cancel() { |
+ void Unregister() { |
CHECK_EQ(MOJO_RESULT_OK, |
- MojoCancelWatch(handle_, reinterpret_cast<uintptr_t>(this))); |
+ MojoUnregisterWatcher(handle_, reinterpret_cast<uintptr_t>(this))); |
CHECK(watching_); |
watching_ = false; |
} |
@@ -107,21 +112,22 @@ TEST_F(WatchTest, NotifyBasic) { |
base::RunLoop loop; |
WatchHelper b_watcher; |
- b_watcher.Watch( |
+ b_watcher.Register( |
b, MOJO_HANDLE_SIGNAL_READABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
EXPECT_EQ(MOJO_RESULT_OK, result); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, |
state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); |
EXPECT_TRUE(b_watcher.is_watching()); |
loop.Quit(); |
}); |
+ EXPECT_EQ(MOJO_RESULT_OK, b_watcher.Arm()); |
WriteMessage(a, "Hello!"); |
loop.Run(); |
EXPECT_TRUE(b_watcher.is_watching()); |
- b_watcher.Cancel(); |
+ b_watcher.Unregister(); |
CloseHandle(a); |
CloseHandle(b); |
@@ -133,9 +139,9 @@ TEST_F(WatchTest, NotifyUnsatisfiable) { |
base::RunLoop loop; |
WatchHelper b_watcher; |
- b_watcher.Watch( |
+ b_watcher.Register( |
b, MOJO_HANDLE_SIGNAL_READABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); |
EXPECT_EQ(0u, |
state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); |
@@ -144,11 +150,12 @@ TEST_F(WatchTest, NotifyUnsatisfiable) { |
EXPECT_TRUE(b_watcher.is_watching()); |
loop.Quit(); |
}); |
+ EXPECT_EQ(MOJO_RESULT_OK, b_watcher.Arm()); |
CloseHandle(a); |
loop.Run(); |
- b_watcher.Cancel(); |
+ b_watcher.Unregister(); |
CloseHandle(b); |
} |
@@ -159,15 +166,14 @@ TEST_F(WatchTest, NotifyCancellation) { |
base::RunLoop loop; |
WatchHelper b_watcher; |
- b_watcher.Watch( |
- b, MOJO_HANDLE_SIGNAL_READABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
- EXPECT_EQ(MOJO_RESULT_CANCELLED, result); |
- EXPECT_EQ(0u, state.satisfied_signals); |
- EXPECT_EQ(0u, state.satisfiable_signals); |
- EXPECT_FALSE(b_watcher.is_watching()); |
- loop.Quit(); |
- }); |
+ b_watcher.Register(b, MOJO_HANDLE_SIGNAL_READABLE, |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
+ EXPECT_EQ(MOJO_RESULT_CANCELLED, result); |
+ EXPECT_EQ(0u, state.satisfied_signals); |
+ EXPECT_EQ(0u, state.satisfiable_signals); |
+ EXPECT_FALSE(b_watcher.is_watching()); |
+ loop.Quit(); |
+ }); |
CloseHandle(b); |
loop.Run(); |
@@ -180,38 +186,49 @@ TEST_F(WatchTest, InvalidArguemnts) { |
CreateMessagePipe(&a, &b); |
uintptr_t context = reinterpret_cast<uintptr_t>(this); |
- EXPECT_EQ(MOJO_RESULT_OK, MojoWatch(a, MOJO_HANDLE_SIGNAL_READABLE, |
- &IgnoreResult, context)); |
+ EXPECT_EQ(MOJO_RESULT_OK, MojoRegisterWatcher(a, MOJO_HANDLE_SIGNAL_READABLE, |
+ &IgnoreResult, context)); |
+ |
+ // Can't arm a watcher that doesn't exist. |
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoArmWatcher(a, ~context)); |
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoArmWatcher(b, context)); |
- // Can't cancel a watch that doesn't exist. |
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoCancelWatch(a, ~context)); |
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoCancelWatch(b, context)); |
+ // Can't cancel a watcher that doesn't exist. |
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoUnregisterWatcher(a, ~context)); |
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoUnregisterWatcher(b, context)); |
CloseHandle(a); |
CloseHandle(b); |
- // Can't watch a handle that doesn't exist. |
+ // Can't do anything with a handle that doesn't exist. |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
- MojoWatch(a, MOJO_HANDLE_SIGNAL_READABLE, &IgnoreResult, context)); |
+ MojoRegisterWatcher(a, MOJO_HANDLE_SIGNAL_READABLE, &IgnoreResult, |
+ context)); |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
- MojoWatch(b, MOJO_HANDLE_SIGNAL_READABLE, &IgnoreResult, context)); |
+ MojoRegisterWatcher(b, MOJO_HANDLE_SIGNAL_READABLE, &IgnoreResult, |
+ context)); |
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoArmWatcher(a, context)); |
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoArmWatcher(b, context)); |
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoUnregisterWatcher(a, context)); |
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoUnregisterWatcher(b, context)); |
} |
TEST_F(WatchTest, NoDuplicateContext) { |
MojoHandle a, b; |
CreateMessagePipe(&a, &b); |
- // Try to add the same watch twice; should fail. |
+ // Try to add the same watcher twice; should fail. |
uintptr_t context = reinterpret_cast<uintptr_t>(this); |
- EXPECT_EQ(MOJO_RESULT_OK, MojoWatch(a, MOJO_HANDLE_SIGNAL_READABLE, |
- &IgnoreResult, context)); |
+ EXPECT_EQ(MOJO_RESULT_OK, MojoRegisterWatcher(a, MOJO_HANDLE_SIGNAL_READABLE, |
+ &IgnoreResult, context)); |
EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, |
- MojoWatch(a, MOJO_HANDLE_SIGNAL_READABLE, &IgnoreResult, context)); |
+ MojoRegisterWatcher(a, MOJO_HANDLE_SIGNAL_READABLE, &IgnoreResult, |
+ context)); |
// Cancel and add it again; should be OK. |
- EXPECT_EQ(MOJO_RESULT_OK, MojoCancelWatch(a, context)); |
- EXPECT_EQ(MOJO_RESULT_OK, MojoWatch(a, MOJO_HANDLE_SIGNAL_READABLE, |
- &IgnoreResult, context)); |
+ EXPECT_EQ(MOJO_RESULT_OK, MojoUnregisterWatcher(a, context)); |
+ EXPECT_EQ(MOJO_RESULT_OK, MojoRegisterWatcher(a, MOJO_HANDLE_SIGNAL_READABLE, |
+ &IgnoreResult, context)); |
CloseHandle(a); |
CloseHandle(b); |
@@ -233,43 +250,50 @@ TEST_F(WatchTest, MultipleWatches) { |
if (--expected_notifications == 0) |
loop.Quit(); |
}; |
+ |
WatchHelper watcher1; |
+ watcher1.Register(b, MOJO_HANDLE_SIGNAL_READABLE, on_readable); |
+ EXPECT_EQ(MOJO_RESULT_OK, watcher1.Arm()); |
+ |
WatchHelper watcher2; |
- watcher1.Watch(b, MOJO_HANDLE_SIGNAL_READABLE, on_readable); |
- watcher2.Watch(b, MOJO_HANDLE_SIGNAL_READABLE, on_readable); |
+ watcher2.Register(b, MOJO_HANDLE_SIGNAL_READABLE, on_readable); |
+ EXPECT_EQ(MOJO_RESULT_OK, watcher2.Arm()); |
WriteMessage(a, "Ping!"); |
loop.Run(); |
- watcher1.Cancel(); |
- watcher2.Cancel(); |
+ watcher1.Unregister(); |
+ watcher2.Unregister(); |
CloseHandle(a); |
CloseHandle(b); |
} |
-TEST_F(WatchTest, WatchWhileSatisfied) { |
+TEST_F(WatchTest, ArmWhileSatisfied) { |
MojoHandle a, b; |
CreateMessagePipe(&a, &b); |
- // Write to |a| and then start watching |b|. The callback should be invoked |
- // synchronously. |
- WriteMessage(a, "hey"); |
+ // Write to |a| while watching for |b| to become readable. |
bool signaled = false; |
WatchHelper b_watcher; |
base::RunLoop loop; |
- b_watcher.Watch( |
+ b_watcher.Register( |
b, MOJO_HANDLE_SIGNAL_READABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
EXPECT_EQ(MOJO_RESULT_OK, result); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, |
state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); |
signaled = true; |
loop.Quit(); |
}); |
+ EXPECT_EQ(MOJO_RESULT_OK, b_watcher.Arm()); |
+ WriteMessage(a, "hey"); |
loop.Run(); |
EXPECT_TRUE(signaled); |
- b_watcher.Cancel(); |
+ |
+ // Now |b| is still readable, so arming should indicate as much. |
+ EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, b_watcher.Arm()); |
+ b_watcher.Unregister(); |
CloseHandle(a); |
CloseHandle(b); |
@@ -279,11 +303,12 @@ TEST_F(WatchTest, WatchWhileUnsatisfiable) { |
MojoHandle a, b; |
CreateMessagePipe(&a, &b); |
- // Close |a| and then try to watch |b|. MojoWatch() should fail. |
+ // Close |a| and then try to watch |b|. MojoRegisterWatcher() should fail. |
CloseHandle(a); |
uintptr_t context = reinterpret_cast<uintptr_t>(this); |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
- MojoWatch(b, MOJO_HANDLE_SIGNAL_READABLE, &IgnoreResult, context)); |
+ MojoRegisterWatcher(b, MOJO_HANDLE_SIGNAL_READABLE, &IgnoreResult, |
+ context)); |
CloseHandle(b); |
} |
@@ -297,9 +322,9 @@ TEST_F(WatchTest, RespondFromCallback) { |
const std::string kTestMessage = "hello worlds."; |
base::RunLoop loop; |
WatchHelper b_watcher; |
- b_watcher.Watch( |
+ b_watcher.Register( |
b, MOJO_HANDLE_SIGNAL_READABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
EXPECT_EQ(MOJO_RESULT_OK, result); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, |
state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); |
@@ -308,11 +333,12 @@ TEST_F(WatchTest, RespondFromCallback) { |
// Echo a's message back to it. |
WriteMessage(b, ReadMessage(b)); |
}); |
+ EXPECT_EQ(MOJO_RESULT_OK, b_watcher.Arm()); |
WatchHelper a_watcher; |
- a_watcher.Watch( |
+ a_watcher.Register( |
a, MOJO_HANDLE_SIGNAL_READABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
EXPECT_EQ(MOJO_RESULT_OK, result); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, |
state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); |
@@ -323,12 +349,13 @@ TEST_F(WatchTest, RespondFromCallback) { |
loop.Quit(); |
}); |
+ EXPECT_EQ(MOJO_RESULT_OK, a_watcher.Arm()); |
WriteMessage(a, kTestMessage); |
loop.Run(); |
- a_watcher.Cancel(); |
- b_watcher.Cancel(); |
+ a_watcher.Unregister(); |
+ b_watcher.Unregister(); |
CloseHandle(a); |
CloseHandle(b); |
@@ -340,21 +367,22 @@ TEST_F(WatchTest, WatchDataPipeConsumer) { |
base::RunLoop loop; |
WatchHelper b_watcher; |
- b_watcher.Watch( |
+ b_watcher.Register( |
b, MOJO_HANDLE_SIGNAL_READABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
EXPECT_EQ(MOJO_RESULT_OK, result); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, |
state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); |
EXPECT_TRUE(b_watcher.is_watching()); |
loop.Quit(); |
}); |
+ EXPECT_EQ(MOJO_RESULT_OK, b_watcher.Arm()); |
WriteData(a, "Hello!"); |
loop.Run(); |
EXPECT_TRUE(b_watcher.is_watching()); |
- b_watcher.Cancel(); |
+ b_watcher.Unregister(); |
CloseHandle(a); |
CloseHandle(b); |
@@ -369,21 +397,22 @@ TEST_F(WatchTest, WatchDataPipeProducer) { |
base::RunLoop loop; |
WatchHelper a_watcher; |
- a_watcher.Watch( |
+ a_watcher.Register( |
a, MOJO_HANDLE_SIGNAL_WRITABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
EXPECT_EQ(MOJO_RESULT_OK, result); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, |
state.satisfied_signals & MOJO_HANDLE_SIGNAL_WRITABLE); |
EXPECT_TRUE(a_watcher.is_watching()); |
loop.Quit(); |
}); |
+ EXPECT_EQ(MOJO_RESULT_OK, a_watcher.Arm()); |
EXPECT_EQ("xxxxxxxx", ReadData(b, 8)); |
loop.Run(); |
EXPECT_TRUE(a_watcher.is_watching()); |
- a_watcher.Cancel(); |
+ a_watcher.Unregister(); |
CloseHandle(a); |
CloseHandle(b); |
@@ -396,9 +425,9 @@ TEST_F(WatchTest, WakeUpSelfWithinWatchCallback) { |
int expected_notifications = 2; |
base::RunLoop loop; |
WatchHelper b_watcher; |
- b_watcher.Watch( |
+ b_watcher.Register( |
b, MOJO_HANDLE_SIGNAL_READABLE, |
- [&] (MojoResult result, MojoHandleSignalsState state) { |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
EXPECT_EQ(MOJO_RESULT_OK, result); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, |
state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); |
@@ -406,16 +435,21 @@ TEST_F(WatchTest, WakeUpSelfWithinWatchCallback) { |
if (--expected_notifications == 0) { |
loop.Quit(); |
} else { |
+ // Read the message off the pipe and re-arm the watcher. |
+ ReadMessage(b); |
+ EXPECT_EQ(MOJO_RESULT_OK, b_watcher.Arm()); |
+ |
// Trigger b's watch again from within this callback. This should be |
// safe to do. |
WriteMessage(a, "hey"); |
} |
}); |
+ EXPECT_EQ(MOJO_RESULT_OK, b_watcher.Arm()); |
WriteMessage(a, "hey hey hey"); |
loop.Run(); |
- b_watcher.Cancel(); |
+ b_watcher.Unregister(); |
CloseHandle(a); |
CloseHandle(b); |
@@ -433,26 +467,25 @@ TEST_F(WatchTest, NestedCancellation) { |
base::RunLoop loop; |
bool a_watcher_run = false; |
WatchHelper a_watcher; |
- a_watcher.Watch( |
- a, MOJO_HANDLE_SIGNAL_READABLE, |
- [&](MojoResult result, MojoHandleSignalsState state) { |
- a_watcher_run = true; |
- }); |
+ a_watcher.Register(a, MOJO_HANDLE_SIGNAL_READABLE, |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
+ a_watcher_run = true; |
+ }); |
WatchHelper c_watcher; |
- c_watcher.Watch( |
- c, MOJO_HANDLE_SIGNAL_READABLE, |
- [&](MojoResult result, MojoHandleSignalsState state) { |
- // This will trigger a notification on |a_watcher| above to be executed |
- // once this handler finishes running... |
- CloseHandle(b); |
+ c_watcher.Register(c, MOJO_HANDLE_SIGNAL_READABLE, |
+ [&](MojoResult result, MojoHandleSignalsState state) { |
+ // This will trigger a notification on |a_watcher| above |
+ // to be executed once this handler finishes running... |
+ CloseHandle(b); |
- // ...but this should prevent that notification from dispatching because |
- // |a_watcher| is now cancelled. |
- a_watcher.Cancel(); |
+ // ...but this should prevent that notification from |
+ // dispatching because |a_watcher| is now cancelled. |
+ a_watcher.Unregister(); |
- loop.Quit(); |
- }); |
+ loop.Quit(); |
+ }); |
+ c_watcher.Arm(); |
{ |
// Force "system" notifications for the synchronous behavior required to |
@@ -469,7 +502,7 @@ TEST_F(WatchTest, NestedCancellation) { |
EXPECT_FALSE(a_watcher.is_watching()); |
EXPECT_FALSE(a_watcher_run); |
- c_watcher.Cancel(); |
+ c_watcher.Unregister(); |
CloseHandle(a); |
CloseHandle(c); |