Revert of Mojo EDK: Introduce MojoQueryHandleSignalsState API

mojo/edk/system/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 <stdint.h>
 #include <string.h>
 
 #include "base/memory/ref_counted.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/test/mojo_test_base.h"
@@ skipping 82 matching lines @@
   buffer[1] = 456;
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe1_, buffer, &buffer_size));
 
   // Write from port 1 (to port 0).
   buffer[0] = 789012345;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0])));
 
   MojoHandleSignalsState state;
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Read from port 0.
   buffer[0] = 123;
   buffer[1] = 456;
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe0_, buffer, &buffer_size));
   ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   ASSERT_EQ(789012345, buffer[0]);
   ASSERT_EQ(456, buffer[1]);
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe0_, buffer, &buffer_size));
 
   // Write two messages from port 0 (to port 1).
   buffer[0] = 123456789;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0])));
   buffer[0] = 234567890;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0])));
 
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Read from port 1 with buffer size 0 (should get the size of next message).
   // Also test that giving a null buffer is okay when the buffer size is 0.
   buffer_size = 0;
   ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             ReadMessage(pipe1_, nullptr, &buffer_size));
   ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
   // Read from port 1 with buffer size 1 (too small; should get the size of next
   // message).
   buffer[0] = 123;
   buffer[1] = 456;
   buffer_size = 1;
   ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             ReadMessage(pipe1_, buffer, &buffer_size));
   ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   ASSERT_EQ(123, buffer[0]);
   ASSERT_EQ(456, buffer[1]);
 
   // Read from port 1.
   buffer[0] = 123;
   buffer[1] = 456;
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size));
   ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   ASSERT_EQ(123456789, buffer[0]);
   ASSERT_EQ(456, buffer[1]);
 
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Read again from port 1.
   buffer[0] = 123;
   buffer[1] = 456;
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size));
   ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   ASSERT_EQ(234567890, buffer[0]);
   ASSERT_EQ(456, buffer[1]);
 
   // Read again from port 1 -- it should be empty.
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe1_, buffer, &buffer_size));
 
   // Write from port 0 (to port 1).
   buffer[0] = 345678901;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0])));
 
   // Close port 0.
   MojoClose(pipe0_);
   pipe0_ = MOJO_HANDLE_INVALID;
 
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Try to write from port 1 (to port 0).
   buffer[0] = 456789012;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             WriteMessage(pipe1_, buffer, sizeof(buffer[0])));
 
   // Read from port 1; should still get message (even though port 0 was closed).
   buffer[0] = 123;
   buffer[1] = 456;
@@ skipping 14 matching lines @@
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Write some messages from port 1 (to port 0).
   for (int32_t i = 0; i < 5; i++) {
     buffer[0] = i;
     ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, kBufferSize));
   }
 
   MojoHandleSignalsState state;
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Port 0 shouldn't be empty.
   buffer_size = 0;
   ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             ReadMessage(pipe0_, nullptr, &buffer_size));
   ASSERT_EQ(kBufferSize, buffer_size);
 
   // Close port 0 first, which should have outstanding (incoming) messages.
   MojoClose(pipe0_);
   MojoClose(pipe1_);
   pipe0_ = pipe1_ = MOJO_HANDLE_INVALID;
 }
 
 TEST_F(MessagePipeTest, DiscardMode) {
   int32_t buffer[2];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Write from port 1 (to port 0).
   buffer[0] = 789012345;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0])));
 
   MojoHandleSignalsState state;
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Read/discard from port 0 (no buffer); get size.
   buffer_size = 0;
   ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             ReadMessage(pipe0_, nullptr, &buffer_size, true));
   ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT,
             ReadMessage(pipe0_, buffer, &buffer_size, true));
 
   // Write from port 1 (to port 0).
   buffer[0] = 890123456;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteMessage(pipe1_, buffer, sizeof(buffer[0])));
 
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Read from port 0 (buffer big enough).
   buffer[0] = 123;
   buffer[1] = 456;
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe0_, buffer, &buffer_size, true));
   ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   ASSERT_EQ(890123456, buffer[0]);
   ASSERT_EQ(456, buffer[1]);
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT,
             ReadMessage(pipe0_, buffer, &buffer_size, true));
 
   // Write from port 1 (to port 0).
   buffer[0] = 901234567;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0])));
 
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Read/discard from port 0 (buffer too small); get size.
   buffer_size = 1;
   ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             ReadMessage(pipe0_, buffer, &buffer_size, true));
   ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT,
             ReadMessage(pipe0_, buffer, &buffer_size, true));
 
   // Write from port 1 (to port 0).
   buffer[0] = 123456789;
   buffer[1] = 0;
   ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0])));
 
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
 
   // Discard from port 0.
   buffer_size = 1;
   ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             ReadMessage(pipe0_, nullptr, 0, true));
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT,
             ReadMessage(pipe0_, buffer, &buffer_size, true));
 }
 
 TEST_F(MessagePipeTest, BasicWaiting) {
   MojoHandleSignalsState hss;
 
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
-  // Always writable (until the other port is closed). Not yet readable. Peer
-  // not closed.
-  hss = GetSignalsState(pipe0_);
+  // Always writable (until the other port is closed).
+  hss = MojoHandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
+                                     &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
   hss = MojoHandleSignalsState();
 
+  // Not yet readable.
+  ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
+            MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
+
+  // The peer is not closed.
+  hss = MojoHandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
+            MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 0, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
+
   // Write from port 0 (to port 1), to make port 1 readable.
   buffer[0] = 123456789;
   ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, kBufferSize));
 
   // Port 1 should already be readable now.
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
   // ... and still writable.
   hss = MojoHandleSignalsState();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, &hss));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
 
   // Close port 0.
   MojoClose(pipe0_);
   pipe0_ = MOJO_HANDLE_INVALID;
 
   // Port 1 should be signaled with peer closed.
   hss = MojoHandleSignalsState();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Port 1 should not be writable.
   hss = MojoHandleSignalsState();
 
   ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, &hss));
+            MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE,
+                     MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // But it should still be readable.
   hss = MojoHandleSignalsState();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss));
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
 
   // Read from port 1.
   buffer[0] = 0;
   buffer_size = kBufferSize;
   ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size));
   ASSERT_EQ(123456789, buffer[0]);
 
   // Now port 1 should no longer be readable.
   hss = MojoHandleSignalsState();
   ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss));
+            MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE,
+                     MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 }
 
 TEST_F(MessagePipeTest, InvalidMessageObjects) {
   // null message
   ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoFreeMessage(MOJO_MESSAGE_HANDLE_INVALID));
 
   // null message
@@ skipping 27 matching lines @@
   void* buffer = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer));
   ASSERT_TRUE(buffer);
   memcpy(buffer, kMessage.data(), kMessage.size());
 
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoWriteMessageNew(a, message, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
-  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(b, MOJO_HANDLE_SIGNAL_READABLE));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWait(b, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE,
+                     nullptr));
   uint32_t num_bytes = 0;
   uint32_t num_handles = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoReadMessageNew(b, &message, &num_bytes, nullptr, &num_handles,
                                MOJO_READ_MESSAGE_FLAG_NONE));
   ASSERT_NE(MOJO_MESSAGE_HANDLE_INVALID, message);
   EXPECT_EQ(static_cast<uint32_t>(kMessage.size()), num_bytes);
   EXPECT_EQ(0u, num_handles);
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer));
@@ skipping 13 matching lines @@
 const size_t kPingPongIterations = 500;
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(HandlePingPong, MessagePipeTest, h) {
   // Waits for a handle to become readable and writes it back to the sender.
   for (size_t i = 0; i < kPingPongIterations; i++) {
     MojoHandle handles[kPingPongHandlesPerIteration];
     ReadMessageWithHandles(h, handles, kPingPongHandlesPerIteration);
     WriteMessageWithHandles(h, "", handles, kPingPongHandlesPerIteration);
   }
 
-  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, nullptr));
   char msg[4];
   uint32_t num_bytes = 4;
   EXPECT_EQ(MOJO_RESULT_OK, ReadMessage(h, msg, &num_bytes));
 }
 
 // This test is flaky: http://crbug.com/585784
 TEST_F(MessagePipeTest, DISABLED_DataPipeConsumerHandlePingPong) {
   MojoHandle p, c[kPingPongHandlesPerIteration];
   for (size_t i = 0; i < kPingPongHandlesPerIteration; ++i) {
     EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &p, &c[i]));
@@ skipping 164 matching lines @@
   CreateMessagePipe(&a, &b);
   CreateMessagePipe(&c, &d);
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
   EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c));
 
   // Handles b and c should be closed.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c));
 
-  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d));
 }
 
 TEST_F(FuseMessagePipeTest, FuseAfterPeerWriteAndClosure) {
   // Test that peer write and closure prior to fusion still results in the
   // both message arrival and awareness of peer closure.
 
   MojoHandle a, b, c, d;
   CreateMessagePipe(&a, &b);
   CreateMessagePipe(&c, &d);
 
   const std::string kTestMessage = "ayyy lmao";
   WriteMessage(a, kTestMessage);
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c));
 
   // Handles b and c should be closed.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c));
 
   EXPECT_EQ(kTestMessage, ReadMessage(d));
-  EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                                     MOJO_DEADLINE_INDEFINITE, nullptr));
+
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d));
 }
 
 TEST_F(MessagePipeTest, ClosePipesStressTest) {
   // Stress test to exercise https://crbug.com/665869.
   const size_t kNumPipes = 100000;
   for (size_t i = 0; i < kNumPipes; ++i) {
     MojoHandle a, b;
     CreateMessagePipe(&a, &b);
     MojoClose(a);
     MojoClose(b);
   }
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo