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

mojo/edk/system/ipc_support_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/ipc_support.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 34 matching lines @@
 const char kConnectionIdFlag[] = "test-connection-id";
 
 // Tests writing a message (containing just data) to |write_mp| and then reading
 // it from |read_mp| (it should be the next message, i.e., there should be no
 // other messages already enqueued in that direction).
 void TestWriteReadMessage(MessagePipeDispatcher* write_mp,
                           MessagePipeDispatcher* read_mp) {
   // Set up waiting on the read end first (to avoid racing).
   Waiter waiter;
   waiter.Init();
-  ASSERT_EQ(
-      MOJO_RESULT_OK,
-      read_mp->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 0, nullptr));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            read_mp->AddAwakable(&waiter, 0, false, MOJO_HANDLE_SIGNAL_READABLE,
+                                 nullptr));
 
   // Write a message with just 'x' through the write end.
   EXPECT_EQ(MOJO_RESULT_OK,
             write_mp->WriteMessage(UserPointer<const void>("x"), 1, nullptr,
                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait for it to arrive.
   EXPECT_EQ(MOJO_RESULT_OK,
             waiter.Wait(test::ActionTimeout(), nullptr, nullptr));
-  read_mp->RemoveAwakable(&waiter, nullptr);
+  read_mp->RemoveAwakable(false, &waiter, 0, nullptr);
 
   // Read the message from the read end.
   char buffer[10] = {};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             read_mp->ReadMessage(UserPointer<void>(buffer),
                                  MakeUserPointer(&buffer_size), 0, nullptr,
                                  MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(1u, buffer_size);
   EXPECT_EQ('x', buffer[0]);
 }
 
 // Writes a message pipe dispatcher (in a message) to |write_mp| and reads it
 // from |read_mp| (it should be the next message, i.e., there should be no other
 // other messages already enqueued in that direction).
 // TODO(vtl): Probably |mp_to_send| should be a |Handle|, and so should the
 // return value.
 RefPtr<MessagePipeDispatcher> SendMessagePipeDispatcher(
     MessagePipeDispatcher* write_mp,
     MessagePipeDispatcher* read_mp,
     RefPtr<MessagePipeDispatcher>&& mp_to_send) {
   CHECK_NE(mp_to_send.get(), write_mp);
   CHECK_NE(mp_to_send.get(), read_mp);
   Handle mp_handle_to_send(std::move(mp_to_send),
                            MessagePipeDispatcher::kDefaultHandleRights);
 
   // Set up waiting on the read end first (to avoid racing).
   Waiter waiter;
   waiter.Init();
-  CHECK_EQ(
-      read_mp->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 0, nullptr),
-      MOJO_RESULT_OK);
+  CHECK_EQ(read_mp->AddAwakable(&waiter, 0, false, MOJO_HANDLE_SIGNAL_READABLE,
+                                nullptr),
+           MOJO_RESULT_OK);
 
   // Write a message with just |mp_handle_to_send| through the write end.
   HandleTransport transport(test::HandleTryStartTransport(mp_handle_to_send));
   CHECK(transport.is_valid());
   std::vector<HandleTransport> transports;
   transports.push_back(transport);
   CHECK_EQ(write_mp->WriteMessage(NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   transport.End();
   mp_handle_to_send.reset();
 
   // Wait for it to arrive.
   CHECK_EQ(waiter.Wait(test::ActionTimeout(), nullptr, nullptr),
            MOJO_RESULT_OK);
-  read_mp->RemoveAwakable(&waiter, nullptr);
+  read_mp->RemoveAwakable(false, &waiter, 0, nullptr);
 
   // Read the message from the read end.
   HandleVector handles;
   uint32_t num_handles = 10;
   CHECK_EQ(read_mp->ReadMessage(NullUserPointer(), NullUserPointer(), &handles,
                                 &num_handles, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   CHECK_EQ(handles.size(), 1u);
   CHECK_EQ(num_handles, 1u);
   CHECK_EQ(handles[0].dispatcher->GetType(), Dispatcher::Type::MESSAGE_PIPE);
@@ skipping 592 matching lines @@
 
   test_io_thread.PostTaskAndWait(
       [&ipc_support]() { ipc_support.ShutdownOnIOThread(); });
 }
 
 // TODO(vtl): Also test the case of the master "dying" before the slave. (The
 // slave should get OnMasterDisconnect(), which we currently don't test.)
 
 }  // namespace system
 }  // namespace mojo