[mojo-edk] Add MojoWatch and MojoCancelWatch APIs

mojo/edk/system/wait_set_dispatcher_unittest.cc

 // Copyright 2015 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/wait_set_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 15 matching lines @@
 class WaitSetDispatcherTest : public ::testing::Test {
  public:
   WaitSetDispatcherTest() {}
   ~WaitSetDispatcherTest() override {}
 
   void SetUp() override {
     CreateMessagePipe(&dispatcher0_, &dispatcher1_);
   }
 
   void TearDown() override {
+    Dispatcher::RequestContext request_context;
     for (auto& d : dispatchers_to_close_)
-      d->Close();
+      d->Close(&request_context);
   }
 
   MojoResult GetOneReadyDispatcher(
       const scoped_refptr<WaitSetDispatcher>& wait_set,
       scoped_refptr<Dispatcher>* ready_dispatcher,
       uintptr_t* context) {
     uint32_t count = 1;
     MojoResult dispatcher_result = MOJO_RESULT_UNKNOWN;
     DispatcherVector dispatchers;
     MojoResult result = wait_set->GetReadyDispatchers(
@@ skipping 43 matching lines @@
 TEST_F(WaitSetDispatcherTest, Basic) {
   scoped_refptr<WaitSetDispatcher> wait_set = new WaitSetDispatcher();
   CloseOnShutdown(wait_set);
   ASSERT_EQ(MOJO_RESULT_OK,
             wait_set->AddWaitingDispatcher(dispatcher0_,
                                            MOJO_HANDLE_SIGNAL_READABLE, 1));
   ASSERT_EQ(MOJO_RESULT_OK,
             wait_set->AddWaitingDispatcher(dispatcher1_,
                                            MOJO_HANDLE_SIGNAL_WRITABLE, 2));
 
+  Dispatcher::RequestContext request_context;
   Waiter w;
   uintptr_t context = 0;
   w.Init();
   HandleSignalsState hss;
   // |dispatcher1_| should already be writable.
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             wait_set->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
@@ skipping 20 matching lines @@
   EXPECT_FALSE(hss.satisfies(MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, nullptr));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, nullptr));
 
   // Write to |dispatcher1_|, which should make |dispatcher0_| readable.
   char buffer[] = "abcd";
   w.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
-                                       MOJO_WRITE_MESSAGE_FLAG_NONE));
+                                       MOJO_WRITE_MESSAGE_FLAG_NONE,
+                                       &request_context));
   EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, nullptr));
   woken_dispatcher = nullptr;
   context = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, &context));
   EXPECT_EQ(dispatcher0_, woken_dispatcher);
   EXPECT_EQ(1u, context);
 
   // Again, if a ready dispatcher isn't removed, it will continue to be
   // returned.
   woken_dispatcher = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, nullptr));
   EXPECT_EQ(dispatcher0_, woken_dispatcher);
 
   wait_set->RemoveAwakable(&w, nullptr);
 }
 
 TEST_F(WaitSetDispatcherTest, HandleWithoutRemoving) {
   scoped_refptr<WaitSetDispatcher> wait_set = new WaitSetDispatcher();
   CloseOnShutdown(wait_set);
   ASSERT_EQ(MOJO_RESULT_OK,
             wait_set->AddWaitingDispatcher(dispatcher0_,
                                            MOJO_HANDLE_SIGNAL_READABLE, 1));
 
+  Dispatcher::RequestContext request_context;
   Waiter w;
   uintptr_t context = 0;
   w.Init();
   HandleSignalsState hss;
   // No ready dispatcher.
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_OK,
             wait_set->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
   EXPECT_FALSE(hss.satisfies(MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, nullptr));
   scoped_refptr<Dispatcher> woken_dispatcher;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, nullptr));
 
   // The tested behaviour below should be repeatable.
   for (size_t i = 0; i < 3; i++) {
     // Write to |dispatcher1_|, which should make |dispatcher0_| readable.
     char buffer[] = "abcd";
     w.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
               dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
-                                         MOJO_WRITE_MESSAGE_FLAG_NONE));
+                                         MOJO_WRITE_MESSAGE_FLAG_NONE,
+                                         &request_context));
     EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, nullptr));
     woken_dispatcher = nullptr;
     context = 0;
     EXPECT_EQ(MOJO_RESULT_OK,
               GetOneReadyDispatcher(wait_set, &woken_dispatcher, &context));
     EXPECT_EQ(dispatcher0_, woken_dispatcher);
     EXPECT_EQ(1u, context);
 
     // Read from |dispatcher0_| which should change it's state to non-readable.
     char read_buffer[sizeof(buffer) + 5];
     uint32_t num_bytes = sizeof(read_buffer);
     ASSERT_EQ(MOJO_RESULT_OK,
               dispatcher0_->ReadMessage(read_buffer, &num_bytes, nullptr,
-                                        nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
+                                        nullptr, MOJO_READ_MESSAGE_FLAG_NONE,
+                                        &request_context));
     EXPECT_EQ(sizeof(buffer), num_bytes);
 
     // No dispatchers are ready.
     w.Init();
     woken_dispatcher = nullptr;
     context = 0;
     EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
               GetOneReadyDispatcher(wait_set, &woken_dispatcher, &context));
     EXPECT_EQ(nullptr, woken_dispatcher);
     EXPECT_EQ(0u, context);
@@ skipping 17 matching lines @@
   ASSERT_EQ(MOJO_RESULT_OK,
             wait_set->AddWaitingDispatcher(dispatcher1_,
                                            MOJO_HANDLE_SIGNAL_WRITABLE, 0));
   ASSERT_EQ(MOJO_RESULT_OK,
             wait_set->AddWaitingDispatcher(mp1_dispatcher0,
                                            MOJO_HANDLE_SIGNAL_WRITABLE, 0));
   ASSERT_EQ(MOJO_RESULT_OK,
             wait_set->AddWaitingDispatcher(mp1_dispatcher1,
                                            MOJO_HANDLE_SIGNAL_WRITABLE, 0));
 
+  Dispatcher::RequestContext request_context;
   Waiter w;
   w.Init();
   HandleSignalsState hss;
   // The three writable dispatchers should be ready.
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             wait_set->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
   scoped_refptr<Dispatcher> woken_dispatcher;
@@ skipping 55 matching lines @@
                                           nullptr));
   EXPECT_EQ(2u, count);
   std::sort(dispatchers_vector.begin(), dispatchers_vector.end());
   EXPECT_EQ(expected_dispatchers, dispatchers_vector);
 
   // Write to |dispatcher1_|, which should make |dispatcher0_| readable.
   char buffer[] = "abcd";
   w.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
-                                       MOJO_WRITE_MESSAGE_FLAG_NONE));
+                                       MOJO_WRITE_MESSAGE_FLAG_NONE,
+                                       &request_context));
   {
     Waiter mp_w;
     mp_w.Init();
     // Wait for |dispatcher0_| to be readable.
     if (dispatcher0_->AddAwakable(&mp_w, MOJO_HANDLE_SIGNAL_READABLE, 0,
                                   nullptr) == MOJO_RESULT_OK) {
       EXPECT_EQ(MOJO_RESULT_OK, mp_w.Wait(MOJO_DEADLINE_INDEFINITE, 0));
       dispatcher0_->RemoveAwakable(&mp_w, nullptr);
     }
   }
@@ skipping 29 matching lines @@
                                            MOJO_HANDLE_SIGNAL_READABLE, 0));
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             wait_set->AddWaitingDispatcher(dispatcher0_,
                                            MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   // Remove a dispatcher that wasn't added.
   EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
             wait_set->RemoveWaitingDispatcher(dispatcher1_));
 
   // Add to a closed wait set.
-  wait_set->Close();
+  Dispatcher::RequestContext request_context;
+  wait_set->Close(&request_context);
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             wait_set->AddWaitingDispatcher(dispatcher0_,
                                            MOJO_HANDLE_SIGNAL_READABLE, 0));
 }
 
 TEST_F(WaitSetDispatcherTest, NotSatisfiable) {
   scoped_refptr<WaitSetDispatcher> wait_set = new WaitSetDispatcher();
   CloseOnShutdown(wait_set);
 
   // Wait sets can only satisfy MOJO_HANDLE_SIGNAL_READABLE.
   Waiter w;
   w.Init();
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             wait_set->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             wait_set->AddAwakable(&w, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 }
 
 TEST_F(WaitSetDispatcherTest, ClosedDispatchers) {
   scoped_refptr<WaitSetDispatcher> wait_set = new WaitSetDispatcher();
   CloseOnShutdown(wait_set);
 
+  Dispatcher::RequestContext request_context;
   Waiter w;
   w.Init();
   HandleSignalsState hss;
   // A dispatcher that was added and then closed will be cancelled.
   ASSERT_EQ(MOJO_RESULT_OK,
             wait_set->AddWaitingDispatcher(dispatcher0_,
                                            MOJO_HANDLE_SIGNAL_READABLE, 0));
   EXPECT_EQ(MOJO_RESULT_OK,
             wait_set->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
-  dispatcher0_->Close();
+  dispatcher0_->Close(&request_context);
   EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, nullptr));
   EXPECT_TRUE(
       wait_set->GetHandleSignalsState().satisfies(MOJO_HANDLE_SIGNAL_READABLE));
   scoped_refptr<Dispatcher> woken_dispatcher;
   EXPECT_EQ(MOJO_RESULT_CANCELLED,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, nullptr));
   EXPECT_EQ(dispatcher0_, woken_dispatcher);
 
   // Dispatcher will be implicitly removed because it may be impossible to
   // remove explicitly.
@@ skipping 43 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, nullptr));
   EXPECT_EQ(nested_wait_set, woken_dispatcher);
 
   wait_set->RemoveAwakable(&w, nullptr);
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo