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

mojo/edk/system/remote_message_pipe_unittest.cc

 // Copyright 2014 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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <memory>
 #include <utility>
@@ skipping 178 matching lines @@
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // Write in one direction: MP 0, port 0 -> ... -> MP 1, port 1.
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to MP 0, port 0.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                         nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, 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);
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
             mp1->ReadMessage(1, UserPointer<void>(buffer),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // Write in the other direction: MP 1, port 1 -> ... -> MP 0, port 0.
 
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             456, nullptr));
+            mp0->AddAwakable(0, &waiter, 456, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
                         nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
-  mp0->RemoveAwakable(0, &waiter, &hss);
+  mp0->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);
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             mp0->ReadMessage(0, UserPointer<void>(buffer),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kWorld, buffer);
 
   // Close MP 0, port 0.
   mp0->Close(0);
 
   // Try to wait for MP 1, port 1 to become readable. This will eventually fail
   // when it realizes that MP 0, port 0 has been closed. (It may also fail
   // immediately.)
   waiter.Init();
   hss = HandleSignalsState();
-  MojoResult result = mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE,
-                                       false, 789, &hss);
+  MojoResult result = mp1->AddAwakable(1, &waiter, 789, false,
+                                       MOJO_HANDLE_SIGNAL_READABLE, &hss);
   if (result == MOJO_RESULT_OK) {
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
     EXPECT_EQ(789u, context);
     hss = HandleSignalsState();
-    mp1->RemoveAwakable(1, &waiter, &hss);
+    mp1->RemoveAwakable(1, false, &waiter, 0, &hss);
   }
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   // And MP 1, port 1.
   mp1->Close(1);
 }
 
 TEST_F(RemoteMessagePipeTest, PeerClosed) {
   Waiter waiter;
   HandleSignalsState hss;
   uint64_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
   RefPtr<ChannelEndpoint> ep0;
   auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // Close MP 0, port 0.
   mp0->Close(0);
 
   // Try to wait for MP 1, port 1 to be signaled with peer closed.
   waiter.Init();
   hss = HandleSignalsState();
-  MojoResult result = mp1->AddAwakable(
-      1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, false, 101, &hss);
+  MojoResult result = mp1->AddAwakable(1, &waiter, 101, false,
+                                       MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss);
   if (result == MOJO_RESULT_OK) {
     EXPECT_EQ(MOJO_RESULT_OK,
               waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
     EXPECT_EQ(101u, context);
     hss = HandleSignalsState();
-    mp1->RemoveAwakable(1, &waiter, &hss);
+    mp1->RemoveAwakable(1, false, &waiter, 0, &hss);
   }
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   // And MP 1, port 1.
   mp1->Close(1);
 }
 
 TEST_F(RemoteMessagePipeTest, Multiplex) {
   static const char kHello[] = "hello";
@@ skipping 28 matching lines @@
   EXPECT_GT(max_endpoint_info_size, 0u);
   ASSERT_EQ(0u, max_platform_handle_count);
   std::unique_ptr<char[]> endpoint_info(new char[max_endpoint_info_size]);
   size_t endpoint_info_size;
   mp2->EndSerialize(1, channels(0), endpoint_info.get(), &endpoint_info_size,
                     nullptr);
   EXPECT_EQ(max_endpoint_info_size, endpoint_info_size);
 
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp0->WriteMessage(0, UserPointer<const void>(endpoint_info.get()),
                               static_cast<uint32_t>(endpoint_info_size),
                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, 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(endpoint_info_size, channels(1)->GetSerializedEndpointSize());
   std::unique_ptr<char[]> received_endpoint_info(new char[endpoint_info_size]);
   buffer_size = static_cast<uint32_t>(endpoint_info_size);
   EXPECT_EQ(MOJO_RESULT_OK,
             mp1->ReadMessage(1, UserPointer<void>(received_endpoint_info.get()),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(endpoint_info_size, static_cast<size_t>(buffer_size));
   EXPECT_EQ(0, memcmp(received_endpoint_info.get(), endpoint_info.get(),
                       endpoint_info_size));
 
   // Warning: The local side of mp3 is port 0, not port 1.
   RefPtr<IncomingEndpoint> incoming_endpoint =
       channels(1)->DeserializeEndpoint(received_endpoint_info.get());
   ASSERT_TRUE(incoming_endpoint);
   RefPtr<MessagePipe> mp3 = incoming_endpoint->ConvertToMessagePipe();
   ASSERT_TRUE(mp3);
 
   // Write: MP 2, port 0 -> MP 3, port 1.
 
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp3->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             789, nullptr));
+            mp3->AddAwakable(0, &waiter, 789, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp2->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                         nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
-  mp3->RemoveAwakable(0, &waiter, &hss);
+  mp3->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);
 
   // Make sure there's nothing on MP 0, port 0 or MP 1, port 1 or MP 2, port 0.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp0->ReadMessage(0, UserPointer<void>(buffer),
@@ skipping 16 matching lines @@
             mp3->ReadMessage(0, UserPointer<void>(buffer),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
 
   // Write: MP 0, port 0 -> MP 1, port 1 again.
 
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
                         nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, 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 | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Make sure there's nothing on the other ports.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp0->ReadMessage(0, UserPointer<void>(buffer),
@@ skipping 50 matching lines @@
 
   BootstrapChannelEndpointNoWait(0, std::move(ep0));
 
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   BootstrapChannelEndpointNoWait(1, std::move(ep1));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   // Note: MP 1, port 1 should definitely should be readable, but it may or may
   // 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->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, false, &waiter, 0, &hss);
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
             mp1->ReadMessage(1, UserPointer<void>(buffer),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
@@ skipping 28 matching lines @@
   // Close MP 0, port 0 before channel 1 is even connected.
   mp0->Close(0);
 
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   BootstrapChannelEndpointNoWait(1, std::move(ep1));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   // Note: MP 1, port 1 should definitely should be readable, but it may or may
   // 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->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, false, &waiter, 0, &hss);
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
             mp1->ReadMessage(1, UserPointer<void>(buffer),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
@@ skipping 19 matching lines @@
       MessagePipeDispatcher::kDefaultCreateOptions);
   auto local_mp = MessagePipe::CreateLocalLocal();
   dispatcher->Init(local_mp.Clone(), 0);
   Handle handle(std::move(dispatcher),
                 MessagePipeDispatcher::kDefaultHandleRights);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to MP 0, port 0.
   {
     HandleTransport transport(test::HandleTryStartTransport(handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when
     // the |handle.dispatcher| is destroyed.
     EXPECT_TRUE(handle.dispatcher->HasOneRef());
     handle.reset();
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, 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);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   HandleVector read_handles;
@@ skipping 12 matching lines @@
   EXPECT_EQ(Dispatcher::Type::MESSAGE_PIPE,
             read_handles[0].dispatcher->GetType());
   EXPECT_EQ(MessagePipeDispatcher::kDefaultHandleRights,
             read_handles[0].rights);
   dispatcher = RefPtr<MessagePipeDispatcher>(
       static_cast<MessagePipeDispatcher*>(read_handles[0].dispatcher.get()));
 
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456,
-                                    nullptr));
+            dispatcher->AddAwakable(&waiter, 456, false,
+                                    MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to "local_mp", port 1.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
                              nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // TODO(vtl): FIXME -- We (racily) crash if I close |dispatcher| immediately
   // here. (We don't crash if I sleep and then close.)
 
   // Wait for the dispatcher to become readable.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
-  dispatcher->RemoveAwakable(&waiter, &hss);
+  dispatcher->RemoveAwakable(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);
 
   // Read from the dispatcher.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
                                     MakeUserPointer(&read_buffer_size), 0,
                                     nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            local_mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE,
-                                  false, 789, nullptr));
+            local_mp->AddAwakable(1, &waiter, 789, false,
+                                  MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to the dispatcher.
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
                                 UserPointer<const void>(kHello), sizeof(kHello),
                                 nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
-  local_mp->RemoveAwakable(1, &waiter, &hss);
+  local_mp->RemoveAwakable(1, 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);
 
   // Read from "local_mp", port 1.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 62 matching lines @@
   RefPtr<ChannelEndpoint> ep0;
   auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
   auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to MP 0, port 0.
   {
     HandleTransport transport(test::HandleTryStartTransport(handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when
     // the |handle.dispatcher| is destroyed.
     EXPECT_TRUE(handle.dispatcher->HasOneRef());
     handle.reset();
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, 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);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   HandleVector read_handles;
@@ skipping 87 matching lines @@
   ASSERT_TRUE(mapping0->GetBase());
   ASSERT_EQ(100u, mapping0->GetLength());
   static_cast<char*>(mapping0->GetBase())[0] = 'A';
   static_cast<char*>(mapping0->GetBase())[50] = 'B';
   static_cast<char*>(mapping0->GetBase())[99] = 'C';
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to MP 0, port 0.
   {
     HandleTransport transport(test::HandleTryStartTransport(handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when
     // the |handle.dispatcher| is destroyed.
     EXPECT_TRUE(handle.dispatcher->HasOneRef());
     handle.reset();
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, 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);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   HandleVector read_handles;
@@ skipping 68 matching lines @@
   // be passed.
   auto dispatcher =
       PlatformHandleDispatcher::Create(PlatformHandleFromFILE(std::move(fp)));
   Handle handle(std::move(dispatcher),
                 PlatformHandleDispatcher::kDefaultHandleRights);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to MP 0, port 0.
   {
     HandleTransport transport(test::HandleTryStartTransport(handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when
     // the |handle.dispatcher| is destroyed.
     EXPECT_TRUE(handle.dispatcher->HasOneRef());
     handle.reset();
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, 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);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   HandleVector read_handles;
@@ skipping 93 matching lines @@
       MessagePipeDispatcher::kDefaultCreateOptions);
   auto local_mp = MessagePipe::CreateLocalLocal();
   dispatcher->Init(local_mp.Clone(), 0);
   Handle handle(std::move(dispatcher),
                 MessagePipeDispatcher::kDefaultHandleRights);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             123, nullptr));
+            mp1->AddAwakable(1, &waiter, 123, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to MP 0, port 0.
   {
     HandleTransport transport(test::HandleTryStartTransport(handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when
     // the |handle.dispatcher| is destroyed.
     EXPECT_TRUE(handle.dispatcher->HasOneRef());
     handle.reset();
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
-  mp1->RemoveAwakable(1, &waiter, &hss);
+  mp1->RemoveAwakable(1, 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);
 
   // Read from MP 1, port 1.
   char read_buffer[100] = {0};
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   HandleVector read_handles;
@@ skipping 15 matching lines @@
             read_handles[0].rights);
   handle = std::move(read_handles[0]);
   read_handles.clear();
 
   // Now pass it back.
 
   // Prepare to wait on MP 0, port 0. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, false,
-                             456, nullptr));
+            mp0->AddAwakable(0, &waiter, 456, false,
+                             MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to MP 1, port 1.
   {
     HandleTransport transport(test::HandleTryStartTransport(handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<HandleTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(
         MOJO_RESULT_OK,
         mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
                           &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when
     // the |handle.dispatcher| is destroyed.
     EXPECT_TRUE(handle.dispatcher->HasOneRef());
     handle.reset();
   }
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(456u, context);
   hss = HandleSignalsState();
-  mp0->RemoveAwakable(0, &waiter, &hss);
+  mp0->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);
 
   // Read from MP 0, port 0.
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   read_num_handles = 10;  // Maximum to get.
   EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 11 matching lines @@
             read_handles[0].dispatcher->GetType());
   EXPECT_EQ(MessagePipeDispatcher::kDefaultHandleRights,
             read_handles[0].rights);
   dispatcher = RefPtr<MessagePipeDispatcher>(
       static_cast<MessagePipeDispatcher*>(read_handles[0].dispatcher.get()));
   read_handles.clear();
 
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
-                                    nullptr));
+            dispatcher->AddAwakable(&waiter, 789, false,
+                                    MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to "local_mp", port 1.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
                              nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait for the dispatcher to become readable.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
-  dispatcher->RemoveAwakable(&waiter, &hss);
+  dispatcher->RemoveAwakable(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);
 
   // Read from the dispatcher.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
                                     MakeUserPointer(&read_buffer_size), 0,
                                     nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            local_mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE,
-                                  false, 789, nullptr));
+            local_mp->AddAwakable(1, &waiter, 789, false,
+                                  MOJO_HANDLE_SIGNAL_READABLE, nullptr));
 
   // Write to the dispatcher.
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
                                 UserPointer<const void>(kHello), sizeof(kHello),
                                 nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context, nullptr));
   EXPECT_EQ(789u, context);
   hss = HandleSignalsState();
-  local_mp->RemoveAwakable(1, &waiter, &hss);
+  local_mp->RemoveAwakable(1, 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);
 
   // Read from "local_mp", port 1.
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 10 matching lines @@
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
   // Note that |local_mp|'s port 0 belong to |dispatcher|, which was closed.
   local_mp->Close(1);
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo