Mojo EDK: Introduce MojoQueryHandleSignalsState API

mojo/edk/system/multiprocess_message_pipe_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
@@ skipping 73 matching lines @@
 // For each message received, sends a reply message with the same contents
 // repeated twice, until the other end is closed or it receives "quitquitquit"
 // (which it doesn't reply to). It'll return the number of messages received,
 // not including any "quitquitquit" message, modulo 100.
 DEFINE_TEST_CLIENT_WITH_PIPE(EchoEcho, MultiprocessMessagePipeTest, h) {
   const std::string quitquitquit("quitquitquit");
   int rv = 0;
   for (;; rv = (rv + 1) % 100) {
     // Wait for our end of the message pipe to be readable.
     HandleSignalsState hss;
-    MojoResult result =
-        MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                 MOJO_DEADLINE_INDEFINITE, &hss);
+    MojoResult result = WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss);
     if (result != MOJO_RESULT_OK) {
       // It was closed, probably.
       CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION);
       CHECK_EQ(hss.satisfied_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED);
       CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED);
       break;
     } else {
       CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
       CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
     }
@@ skipping 25 matching lines @@
 TEST_P(MultiprocessMessagePipeTestWithPeerSupport, Basic) {
   RUN_CHILD_ON_PIPE(EchoEcho, h)
     std::string hello("hello");
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, hello.data(),
                                static_cast<uint32_t>(hello.size()), nullptr, 0u,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_OK,
-              MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE, &hss));
+              WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     // The child may or may not have closed its end of the message pipe and died
     // (and we may or may not know it yet), so our end may or may not appear as
     // writable.
     EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
     EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
     std::string read_buffer(1000, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
     CHECK_EQ(MojoReadMessage(h, &read_buffer[0],
                              &read_buffer_size, nullptr, 0,
@@ skipping 18 matching lines @@
       std::string write_buffer(i, 'A' + (i % 26));
       ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, write_buffer.data(),
                                static_cast<uint32_t>(write_buffer.size()),
                                nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE));
     }
 
     for (size_t i = 0; i < kNumMessages; i++) {
       HandleSignalsState hss;
       ASSERT_EQ(MOJO_RESULT_OK,
-                MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                         MOJO_DEADLINE_INDEFINITE, &hss));
+                WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss));
       // The child may or may not have closed its end of the message pipe and
       // died (and we may or may not know it yet), so our end may or may not
       // appear as writable.
       ASSERT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
       ASSERT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
       std::string read_buffer(kNumMessages * 2, '\0');
       uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
       ASSERT_EQ(MojoReadMessage(h, &read_buffer[0],
                                 &read_buffer_size, nullptr, 0,
                                 MOJO_READ_MESSAGE_FLAG_NONE),
                MOJO_RESULT_OK);
       read_buffer.resize(read_buffer_size);
 
       ASSERT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer);
     }
 
     const std::string quitquitquit("quitquitquit");
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, quitquitquit.data(),
                                static_cast<uint32_t>(quitquitquit.size()),
                                nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Wait for it to become readable, which should fail (since we sent
     // "quitquitquit").
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE, &hss));
+              WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
   END_CHILD_AND_EXPECT_EXIT_CODE(static_cast<int>(kNumMessages % 100));
 }
 
 DEFINE_TEST_CLIENT_WITH_PIPE(CheckSharedBuffer, MultiprocessMessagePipeTest,
                              h) {
   // Wait for the first message from our parent.
   HandleSignalsState hss;
-  CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-               MOJO_DEADLINE_INDEFINITE, &hss),
+  CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss),
            MOJO_RESULT_OK);
   // In this test, the parent definitely doesn't close its end of the message
   // pipe before we do.
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE |
                                     MOJO_HANDLE_SIGNAL_WRITABLE |
                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED);
 
   // It should have a shared buffer.
@@ skipping 24 matching lines @@
 
   // And send a message to signal that we've written stuff.
   const std::string go2("go 2");
   CHECK_EQ(MojoWriteMessage(h, go2.data(),
                             static_cast<uint32_t>(go2.size()), nullptr, 0u,
                             MOJO_WRITE_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
 
   // Now wait for our parent to send us a message.
   hss = HandleSignalsState();
-  CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                    MOJO_DEADLINE_INDEFINITE, &hss),
+  CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss),
            MOJO_RESULT_OK);
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE |
                                         MOJO_HANDLE_SIGNAL_WRITABLE |
                                         MOJO_HANDLE_SIGNAL_PEER_CLOSED);
 
   read_buffer = std::string(100, '\0');
   num_bytes = static_cast<uint32_t>(read_buffer.size());
   CHECK_EQ(MojoReadMessage(h, &read_buffer[0], &num_bytes,
@@ skipping 35 matching lines @@
     handles[0] = duplicated_shared_buffer;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, &go1[0],
                                static_cast<uint32_t>(go1.size()), &handles[0],
                                arraysize(handles),
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Wait for a message from the child.
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_OK,
-              MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE, &hss));
+              WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
     EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
     std::string read_buffer(100, '\0');
     uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoReadMessage(h, &read_buffer[0],
                               &num_bytes, nullptr, 0,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     read_buffer.resize(num_bytes);
@@ skipping 15 matching lines @@
     // And send a message to signal that we've written stuff.
     const std::string go3("go 3");
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, &go3[0],
                                static_cast<uint32_t>(go3.size()), nullptr, 0u,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Wait for |h| to become readable, which should fail.
     hss = HandleSignalsState();
     ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE, &hss));
+              WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
   END_CHILD()
 }
 
 DEFINE_TEST_CLIENT_WITH_PIPE(CheckPlatformHandleFile,
                              MultiprocessMessagePipeTest, h) {
   HandleSignalsState hss;
-  CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                    MOJO_DEADLINE_INDEFINITE, &hss),
+  CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss),
            MOJO_RESULT_OK);
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE |
                                         MOJO_HANDLE_SIGNAL_WRITABLE |
                                         MOJO_HANDLE_SIGNAL_PEER_CLOSED);
 
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   MojoHandle handles[255];  // Maximum number to receive.
@@ skipping 64 matching lines @@
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, message,
                                static_cast<uint32_t>(strlen(message)),
                                &handles[0],
                                static_cast<uint32_t>(handles.size()),
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Wait for it to become readable, which should fail.
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE, &hss));
+              WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
   END_CHILD()
 }
 
 // Android multi-process tests are not executing the new process. This is flaky.
 #if !defined(OS_ANDROID)
 INSTANTIATE_TEST_CASE_P(PipeCount,
                         MultiprocessMessagePipeTestWithPipeCount,
                         // TODO(rockot): Re-enable the 140-pipe case when
                         // ChannelPosix has support for sending lots of handles.
                         testing::Values(1u, 128u /*, 140u*/));
 #endif
 
 DEFINE_TEST_CLIENT_WITH_PIPE(CheckMessagePipe, MultiprocessMessagePipeTest, h) {
   // Wait for the first message from our parent.
   HandleSignalsState hss;
-  CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                    MOJO_DEADLINE_INDEFINITE, &hss),
+  CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss),
            MOJO_RESULT_OK);
   // In this test, the parent definitely doesn't close its end of the message
   // pipe before we do.
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE |
                                     MOJO_HANDLE_SIGNAL_WRITABLE |
                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED);
 
   // It should have a message pipe.
   MojoHandle handles[10];
   uint32_t num_handlers = arraysize(handles);
   CHECK_EQ(MojoReadMessage(h, nullptr,
                            nullptr, &handles[0],
                            &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   CHECK_EQ(num_handlers, 1u);
 
   // Read data from the received message pipe.
-  CHECK_EQ(MojoWait(handles[0], MOJO_HANDLE_SIGNAL_READABLE,
-               MOJO_DEADLINE_INDEFINITE, &hss),
+  CHECK_EQ(WaitForSignals(handles[0], MOJO_HANDLE_SIGNAL_READABLE, &hss),
            MOJO_RESULT_OK);
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE |
                                     MOJO_HANDLE_SIGNAL_WRITABLE |
                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED);
 
   std::string read_buffer(100, '\0');
   uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
   CHECK_EQ(MojoReadMessage(handles[0], &read_buffer[0],
@@ skipping 30 matching lines @@
               MojoWriteMessage(mp1, &hello[0],
                                static_cast<uint32_t>(hello.size()), nullptr, 0,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, nullptr, 0, &mp2, 1,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Wait for a message from the child.
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_OK,
-              MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE, &hss));
+              WaitForSignals(mp1, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
     EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
     std::string read_buffer(100, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
     CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0],
                              &read_buffer_size, nullptr,
                              0, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
@@ skipping 16 matching lines @@
               MojoWriteMessage(mp1, &hello[0],
                                static_cast<uint32_t>(hello.size()), nullptr, 0u,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, nullptr, 0u, &mp2, 1u,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Wait for a message from the child.
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_OK,
-              MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE, &hss));
+              WaitForSignals(mp1, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
     EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
     std::string read_buffer(100, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
     CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0],
                              &read_buffer_size, nullptr,
                              0, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
     CHECK_EQ(read_buffer, std::string("world"));
   END_CHILD();
 }
 
 DEFINE_TEST_CLIENT_WITH_PIPE(DataPipeConsumer, MultiprocessMessagePipeTest, h) {
   // Wait for the first message from our parent.
   HandleSignalsState hss;
-  CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                    MOJO_DEADLINE_INDEFINITE, &hss),
+  CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss),
            MOJO_RESULT_OK);
   // In this test, the parent definitely doesn't close its end of the message
   // pipe before we do.
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE |
                                     MOJO_HANDLE_SIGNAL_WRITABLE |
                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED);
 
   // It should have a message pipe.
   MojoHandle handles[10];
   uint32_t num_handlers = arraysize(handles);
   CHECK_EQ(MojoReadMessage(h, nullptr,
                            nullptr, &handles[0],
                            &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   CHECK_EQ(num_handlers, 1u);
 
   // Read data from the received message pipe.
-  CHECK_EQ(MojoWait(handles[0], MOJO_HANDLE_SIGNAL_READABLE,
-               MOJO_DEADLINE_INDEFINITE, &hss),
+  CHECK_EQ(WaitForSignals(handles[0], MOJO_HANDLE_SIGNAL_READABLE, &hss),
            MOJO_RESULT_OK);
   CHECK_EQ(hss.satisfied_signals,
            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
   CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE |
                                     MOJO_HANDLE_SIGNAL_WRITABLE |
                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED);
 
   std::string read_buffer(100, '\0');
   uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
   CHECK_EQ(MojoReadMessage(handles[0], &read_buffer[0],
@@ skipping 30 matching lines @@
               MojoWriteMessage(mp1, &hello[0],
                                static_cast<uint32_t>(hello.size()), nullptr, 0u,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, nullptr, 0, &mp2, 1u,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Wait for a message from the child.
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_OK,
-              MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_DEADLINE_INDEFINITE, &hss));
+              WaitForSignals(mp1, MOJO_HANDLE_SIGNAL_READABLE, &hss));
     EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
     EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
     std::string read_buffer(100, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
     CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0],
                              &read_buffer_size, nullptr,
                              0, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
@@ skipping 225 matching lines @@
       ReadMessageWithHandles(h, &p1, 1);
       WriteMessageWithHandles(h, "", &p1, 1);
     }
     ReadMessageWithHandles(h, &p0, 1);
     WriteMessage(h, "quit");
   END_CHILD()
 
   EXPECT_EQ("bye", ReadMessage(p0));
 
   // We should still be able to observe peer closure from the other end.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            MojoWait(p0, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                     MOJO_DEADLINE_INDEFINITE, nullptr));
+  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(p0, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 }
 
 // Parses commands from the parent pipe and does whatever it's asked to do.
 DEFINE_TEST_CLIENT_WITH_PIPE(CommandDrivenClient, MultiprocessMessagePipeTest,
                              h) {
   base::hash_map<std::string, MojoHandle> named_pipes;
   for (;;) {
     MojoHandle p;
     auto parts = base::SplitString(ReadMessageWithOptionalHandle(h, &p), ":",
                                    base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
@@ skipping 163 matching lines @@
         END_CHILD()
       END_CHILD()
     END_CHILD()
   END_CHILD()
 }
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReceivePipeWithClosedPeer,
                                   MultiprocessMessagePipeTest, h) {
   MojoHandle p;
   EXPECT_EQ("foo", ReadMessageWithHandles(h, &p, 1));
-
-  auto result = MojoWait(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                         MOJO_DEADLINE_INDEFINITE, nullptr);
-  EXPECT_EQ(MOJO_RESULT_OK, result);
+  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 }
 
 TEST_P(MultiprocessMessagePipeTestWithPeerSupport, SendPipeThenClosePeer) {
   RUN_CHILD_ON_PIPE(ReceivePipeWithClosedPeer, h)
     MojoHandle a, b;
     CreateMessagePipe(&a, &b);
 
     // Send |a| and immediately close |b|. The child should observe closure.
     WriteMessageWithHandles(h, "foo", &a, 1);
     MojoClose(b);
@@ skipping 25 matching lines @@
   // Receive a pipe from the parent. This is akin to an "application request".
   MojoHandle application_client;
   EXPECT_EQ("c2a", ReadMessageWithHandles(h, &application_client, 1));
 
   // Receive a pipe from the "application" "client".
   MojoHandle service_client;
   EXPECT_EQ("c2s lol",
             ReadMessageWithHandles(application_client, &service_client, 1));
 
   // Wait for the service client to signal closure.
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(service_client,
-                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            WaitForSignals(service_client, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(service_client));
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(application_client));
 }
 
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_SendPipeWithClosedPeerBetweenChildren \
     DISABLED_SendPipeWithClosedPeerBetweenChildren
 #else
@@ skipping 25 matching lines @@
   CreateMessagePipe(&c, &d);
 
   // Send |a| over |c|, immediately close |b|, then send |a| back over |d|.
   WriteMessageWithHandles(c, "foo", &a, 1);
   EXPECT_EQ("foo", ReadMessageWithHandles(d, &a, 1));
   WriteMessageWithHandles(d, "bar", &a, 1);
   EXPECT_EQ("bar", ReadMessageWithHandles(c, &a, 1));
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
 
   // We should be able to detect peer closure on |a|.
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(a, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(a, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 }
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(WriteCloseSendPeerClient,
                                   MultiprocessMessagePipeTest, h) {
   MojoHandle pipe[2];
   EXPECT_EQ("foo", ReadMessageWithHandles(h, pipe, 2));
 
   // Write some messages to the first endpoint and then close it.
   WriteMessage(pipe[0], "baz");
   WriteMessage(pipe[0], "qux");
@@ skipping 22 matching lines @@
     WriteMessageWithHandles(h, "foo", pipe, 2);
 
     // Read back an endpoint which should have messages on it.
     MojoHandle p;
     EXPECT_EQ("bar", ReadMessageWithHandles(h, &p, 1));
 
     EXPECT_EQ("baz", ReadMessage(p));
     EXPECT_EQ("qux", ReadMessage(p));
 
     // Expect to have peer closure signaled.
-    EXPECT_EQ(MOJO_RESULT_OK, MojoWait(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                       MOJO_DEADLINE_INDEFINITE, nullptr));
+    EXPECT_EQ(MOJO_RESULT_OK,
+              WaitForSignals(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 
     WriteMessage(h, "quit");
   END_CHILD()
 }
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MessagePipeStatusChangeInTransitClient,
                                   MultiprocessMessagePipeTest, parent) {
   // This test verifies that peer closure is detectable through various
   // mechanisms when it races with handle transfer.
   MojoHandle handles[4];
   EXPECT_EQ("o_O", ReadMessageWithHandles(parent, handles, 4));
 
-  // Wait on handle 0 using MojoWait.
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(handles[0], MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            WaitForSignals(handles[0], MOJO_HANDLE_SIGNAL_PEER_CLOSED));
 
   base::MessageLoop message_loop;
 
   // Wait on handle 1 using a SimpleWatcher.
   {
     base::RunLoop run_loop;
     SimpleWatcher watcher(FROM_HERE, SimpleWatcher::ArmingPolicy::AUTOMATIC);
     watcher.Watch(Handle(handles[1]), MOJO_HANDLE_SIGNAL_PEER_CLOSED,
                   base::Bind(
                       [](base::RunLoop* loop, MojoResult result) {
@@ skipping 61 matching lines @@
     set_process_error_callback(base::Bind(&OnProcessError,
                                           &second_process_error));
     RUN_CHILD_ON_PIPE(BadMessageClient, child2)
       MojoHandle a, b, c, d;
       CreateMessagePipe(&a, &b);
       CreateMessagePipe(&c, &d);
       WriteMessageWithHandles(child1, "hi", &b, 1);
       WriteMessageWithHandles(child2, "hi", &d, 1);
 
       // Read a message from the pipe we sent to child1 and flag it as bad.
-      ASSERT_EQ(MOJO_RESULT_OK, MojoWait(a, MOJO_HANDLE_SIGNAL_READABLE,
-                                         MOJO_DEADLINE_INDEFINITE, nullptr));
+      ASSERT_EQ(MOJO_RESULT_OK, WaitForSignals(a, MOJO_HANDLE_SIGNAL_READABLE));
       uint32_t num_bytes = 0;
       MojoMessageHandle message;
       ASSERT_EQ(MOJO_RESULT_OK,
                 MojoReadMessageNew(a, &message, &num_bytes, nullptr, 0,
                                    MOJO_READ_MESSAGE_FLAG_NONE));
       EXPECT_EQ(MOJO_RESULT_OK,
                 MojoNotifyBadMessage(message, kFirstErrorMessage.data(),
                                      kFirstErrorMessage.size()));
       EXPECT_EQ(MOJO_RESULT_OK, MojoFreeMessage(message));
 
       // Read a message from the pipe we sent to child2 and flag it as bad.
-      ASSERT_EQ(MOJO_RESULT_OK, MojoWait(c, MOJO_HANDLE_SIGNAL_READABLE,
-                                         MOJO_DEADLINE_INDEFINITE, nullptr));
+      ASSERT_EQ(MOJO_RESULT_OK, WaitForSignals(c, MOJO_HANDLE_SIGNAL_READABLE));
       ASSERT_EQ(MOJO_RESULT_OK,
                 MojoReadMessageNew(c, &message, &num_bytes, nullptr, 0,
                                    MOJO_READ_MESSAGE_FLAG_NONE));
       EXPECT_EQ(MOJO_RESULT_OK,
                 MojoNotifyBadMessage(message, kSecondErrorMessage.data(),
                                      kSecondErrorMessage.size()));
       EXPECT_EQ(MOJO_RESULT_OK, MojoFreeMessage(message));
 
       WriteMessage(child2, "bye");
     END_CHILD();
 
     WriteMessage(child1, "bye");
   END_CHILD()
 
   // The error messages should match the processes which triggered them.
   EXPECT_NE(std::string::npos, first_process_error.find(kFirstErrorMessage));
   EXPECT_NE(std::string::npos, second_process_error.find(kSecondErrorMessage));
 }
 INSTANTIATE_TEST_CASE_P(
     ,
     MultiprocessMessagePipeTestWithPeerSupport,
     testing::Values(test::MojoTestBase::LaunchType::CHILD,
                     test::MojoTestBase::LaunchType::PEER,
                     test::MojoTestBase::LaunchType::NAMED_CHILD,
                     test::MojoTestBase::LaunchType::NAMED_PEER));
 }  // namespace
 }  // namespace edk
 }  // namespace mojo