Mojo: Move waiting APIs to public library

mojo/public/c/system/tests/core_unittest.cc

Index: mojo/public/c/system/tests/core_unittest.cc
diff --git a/mojo/public/c/system/tests/core_unittest.cc b/mojo/public/c/system/tests/core_unittest.cc
index ada99d4b73aa329014e99f5cc6cfa3888ad4347b..a9da2557170cf989cdcd83c47c81e8b2c3268eb2 100644
--- a/mojo/public/c/system/tests/core_unittest.cc
+++ b/mojo/public/c/system/tests/core_unittest.cc
@@ -9,6 +9,7 @@
 #include <stdint.h>
 #include <string.h>
 
+#include "mojo/public/cpp/system/wait.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
@@ -31,7 +32,6 @@ TEST(CoreTest, GetTimeTicksNow) {
 // Tests that everything that takes a handle properly recognizes it.
 TEST(CoreTest, InvalidHandle) {
   MojoHandle h0, h1;
-  MojoHandleSignals sig;
   char buffer[10] = {0};
   uint32_t buffer_size;
   void* write_pointer;
@@ -40,18 +40,8 @@ TEST(CoreTest, InvalidHandle) {
   // Close:
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(MOJO_HANDLE_INVALID));
 
-  // Wait:
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      MojoWait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, 0, nullptr));
-
-  h0 = MOJO_HANDLE_INVALID;
-  sig = ~MOJO_HANDLE_SIGNAL_NONE;
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE, nullptr, nullptr));
-
   // Message pipe:
+  h0 = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoWriteMessage(h0, buffer, 3, nullptr, 0,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
@@ -104,10 +94,6 @@ TEST(CoreTest, BasicMessagePipe) {
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals);
   EXPECT_EQ(kSignalAll, state.satisfiable_signals);
 
-  // Last parameter is optional.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            MojoWait(h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, nullptr));
-
   // Try to read.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
@@ -121,11 +107,12 @@ TEST(CoreTest, BasicMessagePipe) {
                                              0, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // |h0| should be readable.
-  uint32_t result_index = 1;
+  size_t result_index = 1;
   MojoHandleSignalsState states[1];
   sig = MOJO_HANDLE_SIGNAL_READABLE;
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE,
-                                         &result_index, states));
+  Handle handle0(h0);
+  EXPECT_EQ(MOJO_RESULT_OK,
+            mojo::WaitMany(&handle0, &sig, 1, &result_index, states));
 
   EXPECT_EQ(0u, result_index);
   EXPECT_EQ(kSignalReadadableWritable, states[0].satisfied_signals);
@@ -147,15 +134,15 @@ TEST(CoreTest, BasicMessagePipe) {
   // Close |h0|.
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0));
 
-  EXPECT_EQ(MOJO_RESULT_OK,
-            MojoWait(h1, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                     MOJO_DEADLINE_INDEFINITE, &state));
+  EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h1),
+                                       MOJO_HANDLE_SIGNAL_PEER_CLOSED, &state));
 
   // |h1| should no longer be readable or writable.
   EXPECT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
-      MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-               MOJO_DEADLINE_INDEFINITE, &state));
+      mojo::Wait(mojo::Handle(h1),
+                 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+                 &state));
 
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);
@@ -210,11 +197,12 @@ TEST(CoreTest, BasicDataPipe) {
                                           MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // |hc| should be(come) readable.
-  uint32_t result_index = 1;
+  size_t result_index = 1;
   MojoHandleSignalsState states[1];
   sig = MOJO_HANDLE_SIGNAL_READABLE;
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWaitMany(&hc, &sig, 1, MOJO_DEADLINE_INDEFINITE,
-                                         &result_index, states));
+  Handle consumer_handle(hc);
+  EXPECT_EQ(MOJO_RESULT_OK,
+            mojo::WaitMany(&consumer_handle, &sig, 1, &result_index, states));
 
   EXPECT_EQ(0u, result_index);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
@@ -243,9 +231,8 @@ TEST(CoreTest, BasicDataPipe) {
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hp));
 
   // |hc| should still be readable.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            MojoWait(hc, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-                     MOJO_DEADLINE_INDEFINITE, &state));
+  EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(hc),
+                                       MOJO_HANDLE_SIGNAL_PEER_CLOSED, &state));
 
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             state.satisfied_signals);
@@ -263,8 +250,7 @@ TEST(CoreTest, BasicDataPipe) {
 
   // |hc| should no longer be readable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE,
-                     &state));
+            mojo::Wait(mojo::Handle(hc), MOJO_HANDLE_SIGNAL_READABLE, &state));
 
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);