Mojo: Rename MOJO_WAIT_FLAG_... -> MOJO_HANDLE_SIGNAL_....

mojo/system/core_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 "mojo/system/core.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/threading/platform_thread.h"
@@ skipping 76 matching lines @@
             core()->BeginReadData(h, NULL, NULL, MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(1u, info.GetBeginReadDataCallCount());
 
   EXPECT_EQ(0u, info.GetEndReadDataCallCount());
   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
             core()->EndReadData(h, 0));
   EXPECT_EQ(1u, info.GetEndReadDataCallCount());
 
   EXPECT_EQ(0u, info.GetAddWaiterCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING,
+            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE,
                          MOJO_DEADLINE_INDEFINITE));
   EXPECT_EQ(1u, info.GetAddWaiterCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 0));
+            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0));
   EXPECT_EQ(2u, info.GetAddWaiterCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 10 * 1000));
+            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000));
   EXPECT_EQ(3u, info.GetAddWaiterCallCount());
-  MojoHandleSignals handle_signals = MOJO_WAIT_FLAG_EVERYTHING;
+  MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE));
   EXPECT_EQ(4u, info.GetAddWaiterCallCount());
 
   EXPECT_EQ(0u, info.GetDtorCallCount());
   EXPECT_EQ(0u, info.GetCloseCallCount());
   EXPECT_EQ(0u, info.GetCancelAllWaitersCallCount());
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
   EXPECT_EQ(1u, info.GetCancelAllWaitersCallCount());
   EXPECT_EQ(1u, info.GetCloseCallCount());
@@ skipping 15 matching lines @@
     MojoHandle h = CreateMockHandle(&info);
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
     EXPECT_EQ(1u, info.GetCloseCallCount());
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h));
     EXPECT_EQ(1u, info.GetCloseCallCount());
   }
 
   // |Wait()|:
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(MOJO_HANDLE_INVALID, MOJO_WAIT_FLAG_EVERYTHING,
+              core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
                            MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(10, MOJO_WAIT_FLAG_EVERYTHING,
+              core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
                            MOJO_DEADLINE_INDEFINITE));
   }
 
   // |WaitMany()|:
   {
     MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
-    MojoHandleSignals signals[2] = {MOJO_WAIT_FLAG_EVERYTHING,
-                                    MOJO_WAIT_FLAG_EVERYTHING};
+    MojoHandleSignals signals[2] = {~MOJO_HANDLE_SIGNAL_NONE,
+                                    ~MOJO_HANDLE_SIGNAL_NONE};
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WaitMany(handles, signals, 0, MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WaitMany(NULL, signals, 0, MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WaitMany(handles, NULL, 0, MOJO_DEADLINE_INDEFINITE));
 
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WaitMany(NULL, signals, 1, MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
@@ skipping 33 matching lines @@
   // |WriteMessage()|:
   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
   // |num_handles|.
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WriteMessage(MOJO_HANDLE_INVALID, NULL, 0, NULL, 0,
                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
-    MojoHandle handles[2] = { MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID };
+    MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
 
     // Null |handles| with nonzero |num_handles|.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WriteMessage(h, NULL, 0, NULL, 1,
                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
     // Checked by |Core|, shouldn't go through to the dispatcher.
     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 
     // Huge handle count (implausibly big on some systems -- more than can be
     // stored in a 32-bit address space).
@@ skipping 107 matching lines @@
 TEST_F(CoreTest, MessagePipe) {
   MojoHandle h[2];
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->CreateMessagePipe(NULL, &h[0], &h[1]));
   // Should get two distinct, valid handles.
   EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[0], h[1]);
 
   // Neither should be readable.
-  MojoHandleSignals signals[2] = {MOJO_WAIT_FLAG_READABLE,
-                                  MOJO_WAIT_FLAG_READABLE};
+  MojoHandleSignals signals[2] = {MOJO_HANDLE_SIGNAL_READABLE,
+                                  MOJO_HANDLE_SIGNAL_READABLE};
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
             core()->WaitMany(h, signals, 2, 0));
 
   // Try to read anyway.
-  char buffer[1] = { 'a' };
+  char buffer[1] = {'a'};
   uint32_t buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             core()->ReadMessage(h[0], buffer, &buffer_size, NULL, NULL,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   // Check that it left its inputs alone.
   EXPECT_EQ('a', buffer[0]);
   EXPECT_EQ(1u, buffer_size);
 
   // Both should be writable.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h[0], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
+            core()->Wait(h[0], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
+            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000));
 
   // Also check that |h[1]| is writable using |WaitMany()|.
-  signals[0] = MOJO_WAIT_FLAG_READABLE;
-  signals[1] = MOJO_WAIT_FLAG_WRITABLE;
+  signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
+  signals[1] = MOJO_HANDLE_SIGNAL_WRITABLE;
   EXPECT_EQ(1, core()->WaitMany(h, signals, 2, MOJO_DEADLINE_INDEFINITE));
 
   // Write to |h[1]|.
   buffer[0] = 'b';
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h[1], buffer, 1, NULL, 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Check that |h[0]| is now readable.
-  signals[0] = MOJO_WAIT_FLAG_READABLE;
-  signals[1] = MOJO_WAIT_FLAG_READABLE;
+  signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
+  signals[1] = MOJO_HANDLE_SIGNAL_READABLE;
   EXPECT_EQ(0, core()->WaitMany(h, signals, 2, MOJO_DEADLINE_INDEFINITE));
 
   // Read from |h[0]|.
   // First, get only the size.
   buffer_size = 0;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             core()->ReadMessage(h[0], NULL, &buffer_size, NULL, NULL,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(1u, buffer_size);
   // Then actually read it.
   buffer[0] = 'c';
   buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h[0], buffer, &buffer_size, NULL, NULL,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ('b', buffer[0]);
   EXPECT_EQ(1u, buffer_size);
 
   // |h[0]| should no longer be readable.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            core()->Wait(h[0], MOJO_WAIT_FLAG_READABLE, 0));
+            core()->Wait(h[0], MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   // Write to |h[0]|.
   buffer[0] = 'd';
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h[0], buffer, 1, NULL, 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Close |h[0]|.
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
 
   // Check that |h[1]| is no longer writable (and will never be).
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
+            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000));
 
   // Check that |h[1]| is still readable (for the moment).
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000));
 
   // Discard a message from |h[1]|.
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             core()->ReadMessage(h[1], NULL, NULL, NULL, NULL,
                                 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // |h[1]| is no longer readable (and will never be).
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000));
 
   // Try writing to |h[1]|.
   buffer[0] = 'e';
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->WriteMessage(h[1], buffer, 1, NULL, 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
 }
 
@@ skipping 14 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->CreateMessagePipe(NULL, &h_passing[0], &h_passing[1]));
 
   // Make sure that |h_passing[]| work properly.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0],
                                  kHello, kHelloSize,
                                  NULL, 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE,
+                         1000000000));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h_passing[1],
                                 buffer, &num_bytes,
                                 handles, &num_handles,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
@@ skipping 15 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->CreateMessagePipe(NULL, &h_passed[0], &h_passed[1]));
 
   // Make sure that |h_passed[]| work properly.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passed[0],
                                  kHello, kHelloSize,
                                  NULL, 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passed[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h_passed[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h_passed[1],
                                 buffer, &num_bytes,
                                 handles, &num_handles,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
 
   // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0],
                                  kWorld, kWorldSize,
                                  &h_passed[1], 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE,
+                         1000000000));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h_passing[1],
                                 buffer, &num_bytes,
                                 handles, &num_handles,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kWorldSize, num_bytes);
   EXPECT_STREQ(kWorld, buffer);
   EXPECT_EQ(1u, num_handles);
@@ skipping 10 matching lines @@
   // fails. See above note.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h_passed[1]));
 
   // Write to |h_passed[0]|. Should receive on |h_received|.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passed[0],
                                  kHello, kHelloSize,
                                  NULL, 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_received, MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h_received,
                                 buffer, &num_bytes,
                                 handles, &num_handles,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passed[0]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_received));
 }
 
 TEST_F(CoreTest, DataPipe) {
   MojoHandle ph, ch;  // p is for producer and c is for consumer.
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->CreateDataPipe(NULL, &ph, &ch));
   // Should get two distinct, valid handles.
   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
   EXPECT_NE(ph, ch);
 
   // Producer should be never-readable, but already writable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(ph, MOJO_WAIT_FLAG_READABLE, 0));
+            core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ph, MOJO_WAIT_FLAG_WRITABLE, 0));
+            core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
 
   // Consumer should be never-writable, and not yet readable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(ch, MOJO_WAIT_FLAG_WRITABLE, 0));
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   // Write.
-  char elements[2] = { 'A', 'B' };
+  char elements[2] = {'A', 'B'};
   uint32_t num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph, elements, &num_bytes,
                               MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(2u, num_bytes);
 
   // Consumer should now be readable.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   // Read one character.
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = 1u;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(ch, elements, &num_bytes,
                              MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ('A', elements[0]);
   EXPECT_EQ(-1, elements[1]);
@@ skipping 55 matching lines @@
             core()->ReadData(ch, NULL, &num_bytes,
                              MOJO_READ_DATA_FLAG_DISCARD));
 
   // Actually check our data and end the two-phase read.
   EXPECT_EQ('D', static_cast<const char*>(read_ptr)[0]);
   EXPECT_EQ('E', static_cast<const char*>(read_ptr)[1]);
   EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 2u));
 
   // Consumer should now be no longer readable.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   // TODO(vtl): More.
 
   // Close the producer.
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
 
   // The consumer should now be never-readable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 }
 
 // Tests passing data pipe producer and consumer handles.
 TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   const char kHello[] = "hello";
   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
   const char kWorld[] = "world!!!";
   const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
@@ skipping 11 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->CreateDataPipe(NULL, &ph, &ch));
 
   // Send |ch| from |h_passing[0]| to |h_passing[1]|.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0],
                                  kHello, kHelloSize,
                                  &ch, 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE,
+                         1000000000));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h_passing[1],
                                 buffer, &num_bytes,
                                 handles, &num_handles,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(1u, num_handles);
   MojoHandle ch_received = handles[0];
   EXPECT_NE(ch_received, MOJO_HANDLE_INVALID);
   EXPECT_NE(ch_received, h_passing[0]);
   EXPECT_NE(ch_received, h_passing[1]);
   EXPECT_NE(ch_received, ph);
 
   // Note: We rely on the Mojo system not re-using handle values very often.
   EXPECT_NE(ch_received, ch);
 
   // |ch| should no longer be valid; check that trying to close it fails. See
   // above note.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ch));
 
   // Write to |ph|. Should receive on |ch_received|.
   num_bytes = kWorldSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph, kWorld, &num_bytes,
                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ch_received, MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000));
   num_bytes = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(ch_received, buffer, &num_bytes,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kWorldSize, num_bytes);
   EXPECT_STREQ(kWorld, buffer);
 
   // Now pass |ph| in the same direction.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0],
                                  kWorld, kWorldSize,
                                  &ph, 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE,
+                         1000000000));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h_passing[1],
                                 buffer, &num_bytes,
                                 handles, &num_handles,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kWorldSize, num_bytes);
   EXPECT_STREQ(kWorld, buffer);
   EXPECT_EQ(1u, num_handles);
   MojoHandle ph_received = handles[0];
   EXPECT_NE(ph_received, MOJO_HANDLE_INVALID);
   EXPECT_NE(ph_received, h_passing[0]);
   EXPECT_NE(ph_received, h_passing[1]);
   EXPECT_NE(ph_received, ch_received);
 
   // Again, rely on the Mojo system not re-using handle values very often.
   EXPECT_NE(ph_received, ph);
 
   // |ph| should no longer be valid; check that trying to close it fails. See
   // above note.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ph));
 
   // Write to |ph_received|. Should receive on |ch_received|.
   num_bytes = kHelloSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph_received, kHello, &num_bytes,
                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ch_received, MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000));
   num_bytes = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(ch_received, buffer, &num_bytes,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
 
   ph = ph_received;
   ph_received = MOJO_HANDLE_INVALID;
   ch = ch_received;
@@ skipping 13 matching lines @@
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // But |ch| can, even if |ph| is in a two-phase write.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0],
                                  kHello, kHelloSize,
                                  &ch, 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   ch = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE,
+                         1000000000));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h_passing[1],
                                 buffer, &num_bytes,
                                 handles, &num_handles,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(1u, num_handles);
   ch = handles[0];
   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
 
   // Complete the two-phase write.
   static_cast<char*>(write_ptr)[0] = 'x';
   EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 1));
 
   // Wait for |ch| to be readable.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000));
 
   // Make sure that |ch| can't be sent if it's in a two-phase read.
   const void* read_ptr = NULL;
   num_bytes = 1;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginReadData(ch, &read_ptr, &num_bytes,
                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
   EXPECT_EQ(MOJO_RESULT_BUSY,
             core()->WriteMessage(h_passing[0],
                                  kHello, kHelloSize,
                                  &ch, 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // But |ph| can, even if |ch| is in a two-phase read.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passing[0],
                                  kWorld, kWorldSize,
                                  &ph, 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   ph = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE,
+                         1000000000));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(h_passing[1],
                                 buffer, &num_bytes,
                                 handles, &num_handles,
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kWorldSize, num_bytes);
   EXPECT_STREQ(kWorld, buffer);
   EXPECT_EQ(1u, num_handles);
   ph = handles[0];
   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
 
   // Complete the two-phase read.
   EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
   EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 1));
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 }
 
 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo