Rationalize AddAwakable...() and RemoveAwakable...() methods.

mojo/edk/system/remote_data_pipe_impl_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.
 
 // This file tests both |RemoteProducerDataPipeImpl| and
 // |RemoteConsumerDataPipeImpl|.
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 123 matching lines @@
   char read_buffer[100] = {};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint64_t context = 0;
 
   // Write on MP 0 (port 0). Wait and receive on MP 1 (port 0). (Add the waiter
   // first, to avoid any handling the case where it's already readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            message_pipe(1)->AddAwakable(
-                0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false, 123, nullptr));
+            message_pipe(1)->AddAwakable(0, &waiter, 123, false,
+                                         MOJO_HANDLE_SIGNAL_READABLE, nullptr));
   EXPECT_EQ(MOJO_RESULT_OK,
             message_pipe(0)->WriteMessage(0, UserPointer<const void>(kHello),
                                           sizeof(kHello), nullptr,
                                           MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(test::ActionTimeout(), &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
+  message_pipe(1)->RemoveAwakable(0, false, &waiter, 0, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
                 MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
   EXPECT_EQ(MOJO_RESULT_OK, message_pipe(1)->ReadMessage(
                                 0, UserPointer<void>(read_buffer),
                                 MakeUserPointer(&read_buffer_size), nullptr,
                                 nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
@@ skipping 23 matching lines @@
             dp->ProducerWriteData(UserPointer<const void>(elements),
                                   MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   dp->ProducerClose();
 
   // Write the consumer to MP 0 (port 0). Wait and receive on MP 1 (port 0).
   // (Add the waiter first, to avoid any handling the case where it's already
   // readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            message_pipe(1)->AddAwakable(
-                0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false, 123, nullptr));
+            message_pipe(1)->AddAwakable(0, &waiter, 123, false,
+                                         MOJO_HANDLE_SIGNAL_READABLE, nullptr));
   {
     HandleTransport transport(test::HandleTryStartTransport(consumer_handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |consumer_handle.dispatcher| should have been closed. This is
     // |DCHECK()|ed when it is destroyed.
     EXPECT_TRUE(consumer_handle.dispatcher->HasOneRef());
     consumer_handle.reset();
   }
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(test::ActionTimeout(), &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
+  message_pipe(1)->RemoveAwakable(0, false, &waiter, 0, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
                 MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
   EXPECT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->ReadMessage(0, UserPointer<void>(read_buffer),
                                          MakeUserPointer(&read_buffer_size),
                                          &read_handles, &read_num_handles,
                                          MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(0u, static_cast<size_t>(read_buffer_size));
   EXPECT_EQ(1u, read_handles.size());
   EXPECT_EQ(1u, read_num_handles);
   ASSERT_TRUE(read_handles[0]);
   EXPECT_TRUE(read_handles[0].dispatcher->HasOneRef());
 
   EXPECT_EQ(Dispatcher::Type::DATA_PIPE_CONSUMER,
             read_handles[0].dispatcher->GetType());
   EXPECT_EQ(DataPipeConsumerDispatcher::kDefaultHandleRights,
             read_handles[0].rights);
   consumer = RefPtr<DataPipeConsumerDispatcher>(
       static_cast<DataPipeConsumerDispatcher*>(
           read_handles[0].dispatcher.get()));
   read_handles.clear();
 
   waiter.Init();
   hss = HandleSignalsState();
-  MojoResult result =
-      consumer->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, &hss);
+  MojoResult result = consumer->AddAwakable(&waiter, 456, false,
+                                            MOJO_HANDLE_SIGNAL_READABLE, &hss);
   if (result == MOJO_RESULT_OK) {
     context = 0;
     EXPECT_EQ(MOJO_RESULT_OK,
               waiter.Wait(test::ActionTimeout(), &context, nullptr));
     EXPECT_EQ(456u, context);
-    consumer->RemoveAwakable(&waiter, &hss);
+    consumer->RemoveAwakable(false, &waiter, 0, &hss);
   } else {
     ASSERT_EQ(MOJO_RESULT_ALREADY_EXISTS, result);
   }
   // We don't know if the fact that the producer has been closed is known yet.
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READ_THRESHOLD));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READ_THRESHOLD));
 
   // Read one element.
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK, consumer->ReadData(UserPointer<void>(elements),
                                                MakeUserPointer(&num_bytes),
                                                MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   EXPECT_EQ(123, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   waiter.Init();
   hss = HandleSignalsState();
-  result =
-      consumer->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, &hss);
+  result = consumer->AddAwakable(&waiter, 789, false,
+                                 MOJO_HANDLE_SIGNAL_READABLE, &hss);
   if (result == MOJO_RESULT_OK) {
     context = 0;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               waiter.Wait(test::ActionTimeout(), &context, nullptr));
     EXPECT_EQ(789u, context);
-    consumer->RemoveAwakable(&waiter, &hss);
+    consumer->RemoveAwakable(false, &waiter, 0, &hss);
   } else {
     ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
   }
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   consumer->Close();
 }
 
 TEST_F(RemoteDataPipeImplTest, SendConsumerDuringTwoPhaseWrite) {
@@ skipping 17 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                        MakeUserPointer(&num_bytes)));
   ASSERT_GE(num_bytes, 1u * sizeof(int32_t));
 
   // Write the consumer to MP 0 (port 0). Wait and receive on MP 1 (port 0).
   // (Add the waiter first, to avoid any handling the case where it's already
   // readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            message_pipe(1)->AddAwakable(
-                0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false, 123, nullptr));
+            message_pipe(1)->AddAwakable(0, &waiter, 123, false,
+                                         MOJO_HANDLE_SIGNAL_READABLE, nullptr));
   {
     HandleTransport transport(test::HandleTryStartTransport(consumer_handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |consumer_handle.dispatcher| should have been closed. This is
     // |DCHECK()|ed when it is destroyed.
     EXPECT_TRUE(consumer_handle.dispatcher->HasOneRef());
     consumer_handle.reset();
   }
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(test::ActionTimeout(), &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
+  message_pipe(1)->RemoveAwakable(0, false, &waiter, 0, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
                 MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
   EXPECT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->ReadMessage(0, UserPointer<void>(read_buffer),
                                          MakeUserPointer(&read_buffer_size),
                                          &read_handles, &read_num_handles,
                                          MOJO_READ_MESSAGE_FLAG_NONE));
@@ skipping 15 matching lines @@
   // Now actually write the data, complete the two-phase write, and close the
   // producer.
   *static_cast<int32_t*>(write_ptr) = 123456;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(
                                 static_cast<uint32_t>(1u * sizeof(int32_t))));
   dp->ProducerClose();
 
   // Wait for the consumer to be readable.
   waiter.Init();
   hss = HandleSignalsState();
-  MojoResult result =
-      consumer->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, &hss);
+  MojoResult result = consumer->AddAwakable(&waiter, 456, false,
+                                            MOJO_HANDLE_SIGNAL_READABLE, &hss);
   if (result == MOJO_RESULT_OK) {
     context = 0;
     EXPECT_EQ(MOJO_RESULT_OK,
               waiter.Wait(test::ActionTimeout(), &context, nullptr));
     EXPECT_EQ(456u, context);
-    consumer->RemoveAwakable(&waiter, &hss);
+    consumer->RemoveAwakable(false, &waiter, 0, &hss);
   } else {
     ASSERT_EQ(MOJO_RESULT_ALREADY_EXISTS, result);
   }
   // We don't know if the fact that the producer has been closed is known yet.
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READ_THRESHOLD));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READ_THRESHOLD));
 
   // Read one element.
@@ skipping 43 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                        MakeUserPointer(&num_bytes)));
   ASSERT_GE(num_bytes, 1u * sizeof(int32_t));
 
   // Write the consumer to MP 0 (port 0). Wait and receive on MP 1 (port 0).
   // (Add the waiter first, to avoid any handling the case where it's already
   // readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            message_pipe(1)->AddAwakable(
-                0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false, 123, nullptr));
+            message_pipe(1)->AddAwakable(0, &waiter, 123, false,
+                                         MOJO_HANDLE_SIGNAL_READABLE, nullptr));
   {
     HandleTransport transport(test::HandleTryStartTransport(consumer_handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |consumer_handle.dispatcher| should have been closed. This is
     // |DCHECK()|ed when it is destroyed.
     EXPECT_TRUE(consumer_handle.dispatcher->HasOneRef());
     consumer_handle.reset();
   }
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(test::ActionTimeout(), &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
+  message_pipe(1)->RemoveAwakable(0, false, &waiter, 0, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
                 MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
   EXPECT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->ReadMessage(0, UserPointer<void>(read_buffer),
                                          MakeUserPointer(&read_buffer_size),
                                          &read_handles, &read_num_handles,
                                          MOJO_READ_MESSAGE_FLAG_NONE));
@@ skipping 15 matching lines @@
   // Now actually write the data, complete the two-phase write, and close the
   // producer.
   *static_cast<int32_t*>(write_ptr) = 789012;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(
                                 static_cast<uint32_t>(1u * sizeof(int32_t))));
   dp->ProducerClose();
 
   // Wait for the consumer to know that the producer is closed.
   waiter.Init();
   hss = HandleSignalsState();
-  MojoResult result =
-      consumer->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 456, &hss);
+  MojoResult result = consumer->AddAwakable(
+      &waiter, 456, false, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss);
   if (result == MOJO_RESULT_OK) {
     context = 0;
     EXPECT_EQ(MOJO_RESULT_OK,
               waiter.Wait(test::ActionTimeout(), &context, nullptr));
     EXPECT_EQ(456u, context);
-    consumer->RemoveAwakable(&waiter, &hss);
+    consumer->RemoveAwakable(false, &waiter, 0, &hss);
   } else {
     ASSERT_EQ(MOJO_RESULT_ALREADY_EXISTS, result);
   }
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             hss.satisfiable_signals);
 
   // Read some elements.
   int32_t elements[10] = {};
   num_bytes = static_cast<uint32_t>(sizeof(elements));
   EXPECT_EQ(MOJO_RESULT_OK, consumer->ReadData(UserPointer<void>(elements),
                                                MakeUserPointer(&num_bytes),
                                                MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(2u * sizeof(elements[0]), num_bytes);
   EXPECT_EQ(123456, elements[0]);
   EXPECT_EQ(789012, elements[1]);
   EXPECT_EQ(0, elements[2]);
 
   consumer->Close();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo