Mojo: Armed Watchers

mojo/edk/system/watch_unittest.cc

 // Copyright 2016 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 <functional>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/edk/system/request_context.h"
 #include "mojo/edk/test/mojo_test_base.h"
 #include "mojo/public/c/system/functions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace edk {
 namespace {
 
 void IgnoreResult(uintptr_t context,
                   MojoResult result,
                   MojoHandleSignalsState signals,
                   MojoWatchNotificationFlags flags) {
 }
 
 // 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 =
       std::function<void(MojoResult result, MojoHandleSignalsState state)>;
 
   WatchHelper() : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
   ~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;
   }
 
  private:
   static void OnNotify(uintptr_t context,
                        MojoResult result,
                        MojoHandleSignalsState state,
                        MojoWatchNotificationFlags flags) {
     WatchHelper* watcher = reinterpret_cast<WatchHelper*>(context);
@@ skipping 33 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WatchTest);
 };
 
 TEST_F(WatchTest, NotifyBasic) {
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
 
   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);
 }
 
 TEST_F(WatchTest, NotifyUnsatisfiable) {
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
 
   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);
         EXPECT_EQ(0u,
                   state.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE);
         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);
 }
 
 TEST_F(WatchTest, NotifyCancellation) {
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
 
   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();
 
   CloseHandle(a);
 }
 
 TEST_F(WatchTest, InvalidArguemnts) {
   MojoHandle a, b;
   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 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 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 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);
 }
 
 TEST_F(WatchTest, MultipleWatches) {
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
 
   // Add multiple watchers to |b| and see that they are both notified by a
   // single write to |a|.
   base::RunLoop loop;
   int expected_notifications = 2;
   auto on_readable = [&] (MojoResult result, MojoHandleSignalsState state) {
     EXPECT_EQ(MOJO_RESULT_OK, result);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE,
               state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE);
     EXPECT_GT(expected_notifications, 0);
     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);
 }
 
 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);
 }
 
 TEST_F(WatchTest, RespondFromCallback) {
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
 
   // Watch |a| and |b|. Write to |a|, then write to |b| from within the callback
   // which notifies it of the available message.
   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);
         EXPECT_TRUE(b_watcher.is_watching());
 
         // 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);
         EXPECT_TRUE(a_watcher.is_watching());
 
         // Expect to receive back the message that was originally sent to |b|.
         EXPECT_EQ(kTestMessage, ReadMessage(a));
 
         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);
 }
 
 TEST_F(WatchTest, WatchDataPipeConsumer) {
   MojoHandle a, b;
   CreateDataPipe(&a, &b, 64);
 
   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);
 }
 
 TEST_F(WatchTest, WatchDataPipeProducer) {
   MojoHandle a, b;
   CreateDataPipe(&a, &b, 8);
 
   // Fill the pipe to capacity so writes will block.
   WriteData(a, "xxxxxxxx");
 
   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);
 }
 
 TEST_F(WatchTest, WakeUpSelfWithinWatchCallback) {
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
 
   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);
         EXPECT_TRUE(b_watcher.is_watching());
         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);
 }
 
 TEST_F(WatchTest, NestedCancellation) {
   // Verifies that cancellations in nested system request contexts preempt
   // other notifications for the same watcher. This tests against the condition
   // hit by http://crbug.com/622298.
 
   MojoHandle a, b, c, d;
   CreateMessagePipe(&a, &b);
   CreateMessagePipe(&c, &d);
 
   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
     // test this case.
     mojo::edk::RequestContext request_context(
         mojo::edk::RequestContext::Source::SYSTEM);
 
     // Trigger the |c_watcher| callback above.
     CloseHandle(d);
   }
 
   loop.Run();
 
   EXPECT_FALSE(a_watcher.is_watching());
   EXPECT_FALSE(a_watcher_run);
 
-  c_watcher.Cancel();
+  c_watcher.Unregister();
 
   CloseHandle(a);
   CloseHandle(c);
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo