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

Still to rename: MojoWaitFlagsState and WaitFlagsState (and
wait_flags_state.*).

Also, remove MOJO_WAIT_FLAG_EVERYTHING. People shouldn't use it (since
they'd get unexpected results if we added flags/signals). Tests can
still use ~MOJO_HANDLE_SIGNAL_NONE.

R=sky@chromium.org

Review URL: https://codereview.chromium.org/336313007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@278084 0039d316-1c4b-4281-b951-d872f2087c98

mojo/bindings/js/core.cc

@@ -242,10 +242,9 @@ v8::Local<v8::Value> Core::GetModule(v8::Isolate* isolate) {
 
         .SetValue("DEADLINE_INDEFINITE", MOJO_DEADLINE_INDEFINITE)
 
-        .SetValue("WAIT_FLAG_NONE", MOJO_WAIT_FLAG_NONE)
-        .SetValue("WAIT_FLAG_READABLE", MOJO_WAIT_FLAG_READABLE)
-        .SetValue("WAIT_FLAG_READABLE", MOJO_WAIT_FLAG_READABLE)
-        .SetValue("WAIT_FLAG_EVERYTHING", MOJO_WAIT_FLAG_EVERYTHING)
+        .SetValue("HANDLE_SIGNAL_NONE", MOJO_HANDLE_SIGNAL_NONE)
+        .SetValue("HANDLE_SIGNAL_READABLE", MOJO_HANDLE_SIGNAL_READABLE)
+        .SetValue("HANDLE_SIGNAL_READABLE", MOJO_HANDLE_SIGNAL_READABLE)
 
         .SetValue("WRITE_MESSAGE_FLAG_NONE", MOJO_WRITE_MESSAGE_FLAG_NONE)
 

mojo/common/data_pipe_utils.cc

@@ -34,7 +34,7 @@ bool BlockingCopyToFile(ScopedDataPipeConsumerHandle source,
         return false;
     } else if (result == MOJO_RESULT_SHOULD_WAIT) {
       result = Wait(source.get(),
-                    MOJO_WAIT_FLAG_READABLE,
+                    MOJO_HANDLE_SIGNAL_READABLE,
                     MOJO_DEADLINE_INDEFINITE);
       if (result != MOJO_RESULT_OK) {
         // If the producer handle was closed, then treat as EOF.

mojo/common/handle_watcher.cc

@@ -46,7 +46,7 @@ base::TimeTicks MojoDeadlineToTimeTicks(MojoDeadline deadline) {
 struct WatchData {
   WatchData()
       : id(0),
-        handle_signals(MOJO_WAIT_FLAG_NONE),
+        handle_signals(MOJO_HANDLE_SIGNAL_NONE),
         message_loop(NULL) {}
 
   WatcherID id;
@@ -299,7 +299,7 @@ void HandleWatcher::Start(const Handle& handle,
                           MojoDeadline deadline,
                           const base::Callback<void(MojoResult)>& callback) {
   DCHECK(handle.is_valid());
-  DCHECK_NE(MOJO_WAIT_FLAG_NONE, handle_signals);
+  DCHECK_NE(MOJO_HANDLE_SIGNAL_NONE, handle_signals);
 
   state_.reset(new State(this, handle, handle_signals, deadline, callback));
 }

mojo/common/handle_watcher_unittest.cc

@@ -78,8 +78,8 @@ class CallbackHelper {
   void StartWithCallback(HandleWatcher* watcher,
                          const MessagePipeHandle& handle,
                          const base::Callback<void(MojoResult)>& callback) {
-    watcher->Start(handle, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE,
-                   callback);
+    watcher->Start(handle, MOJO_HANDLE_SIGNAL_READABLE,
+                   MOJO_DEADLINE_INDEFINITE, callback);
   }
 
  private:
@@ -279,7 +279,7 @@ TEST_F(HandleWatcherTest, Deadline) {
 
   // Add another watcher wth a timeout of 500 microseconds.
   HandleWatcher watcher2;
-  watcher2.Start(test_pipe2.handle0.get(), MOJO_WAIT_FLAG_READABLE, 500,
+  watcher2.Start(test_pipe2.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE, 500,
                  callback_helper2.GetCallback());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
@@ -325,7 +325,7 @@ TEST(HandleWatcherCleanEnvironmentTest, AbortedOnMessageLoopDestruction) {
     base::MessageLoop loop;
 
     watcher.Start(pipe.handle0.get(),
-                  MOJO_WAIT_FLAG_READABLE,
+                  MOJO_HANDLE_SIGNAL_READABLE,
                   MOJO_DEADLINE_INDEFINITE,
                   base::Bind(&ObserveCallback, &was_signaled, &result));
 

mojo/common/message_pump_mojo.cc

@@ -215,7 +215,7 @@ MessagePumpMojo::WaitState MessagePumpMojo::GetWaitState(
     const RunState& run_state) const {
   WaitState wait_state;
   wait_state.handles.push_back(run_state.read_handle.get());
-  wait_state.wait_signals.push_back(MOJO_WAIT_FLAG_READABLE);
+  wait_state.wait_signals.push_back(MOJO_HANDLE_SIGNAL_READABLE);
 
   for (HandleToHandler::const_iterator i = handlers_.begin();
        i != handlers_.end(); ++i) {

mojo/common/message_pump_mojo.h

@@ -51,7 +51,7 @@ class MOJO_COMMON_EXPORT MessagePumpMojo : public base::MessagePump {
 
   // Contains the data needed to track a request to AddHandler().
   struct Handler {
-    Handler() : handler(NULL), wait_signals(MOJO_WAIT_FLAG_NONE), id(0) {}
+    Handler() : handler(NULL), wait_signals(MOJO_HANDLE_SIGNAL_NONE), id(0) {}
 
     MessagePumpMojoHandler* handler;
     MojoHandleSignals wait_signals;

mojo/embedder/embedder_unittest.cc

@@ -133,7 +133,7 @@ TEST_F(EmbedderTest, ChannelsBasic) {
 
     // Now wait for the other side to become readable.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(client_mp, MOJO_WAIT_FLAG_READABLE,
+              MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
                        MOJO_DEADLINE_INDEFINITE));
 
     char buffer[1000] = {};
@@ -200,7 +200,7 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
 
     // Wait for |client_mp| to become readable.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(client_mp, MOJO_WAIT_FLAG_READABLE,
+              MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
                        MOJO_DEADLINE_INDEFINITE));
 
     // Read a message from |client_mp|.
@@ -219,7 +219,8 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
 
     // Wait for |h1| to become readable.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(h1, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+              MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
+                       MOJO_DEADLINE_INDEFINITE));
 
     // Read a message from |h1|.
     memset(buffer, 0, sizeof(buffer));
@@ -235,7 +236,8 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
 
     // Wait for |h1| to become readable (again).
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(h1, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+              MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
+                       MOJO_DEADLINE_INDEFINITE));
 
     // Read the second message from |h1|.
     memset(buffer, 0, sizeof(buffer));
@@ -255,7 +257,8 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) {
 
     // Wait for |h0| to become readable.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(h0, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+              MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE,
+                       MOJO_DEADLINE_INDEFINITE));
 
     // Read a message from |h0|.
     memset(buffer, 0, sizeof(buffer));
@@ -320,7 +323,7 @@ TEST_F(EmbedderTest, MultiprocessChannels) {
 
     // 2. Read a message from |server_mp|.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(server_mp, MOJO_WAIT_FLAG_READABLE,
+              MojoWait(server_mp, MOJO_HANDLE_SIGNAL_READABLE,
                        MOJO_DEADLINE_INDEFINITE));
     char buffer[1000] = {};
     uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
@@ -355,7 +358,8 @@ TEST_F(EmbedderTest, MultiprocessChannels) {
 
     // 9. Read a message from |mp0|, which should have |mp2| attached.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(mp0, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+              MojoWait(mp0, MOJO_HANDLE_SIGNAL_READABLE,
+                       MOJO_DEADLINE_INDEFINITE));
     memset(buffer, 0, sizeof(buffer));
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
     MojoHandle mp2 = MOJO_HANDLE_INVALID;
@@ -371,7 +375,8 @@ TEST_F(EmbedderTest, MultiprocessChannels) {
 
     // 7. Read a message from |mp2|.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(mp2, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+              MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
+                       MOJO_DEADLINE_INDEFINITE));
     memset(buffer, 0, sizeof(buffer));
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
     EXPECT_EQ(MOJO_RESULT_OK,
@@ -388,7 +393,8 @@ TEST_F(EmbedderTest, MultiprocessChannels) {
 // TODO(vtl): crbug.com/351768
 #if 0
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              MojoWait(mp2, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+              MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
+                       MOJO_DEADLINE_INDEFINITE));
 #endif
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp2));
   }
@@ -416,7 +422,7 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
 
     // 1. Read the first message from |client_mp|.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(client_mp, MOJO_WAIT_FLAG_READABLE,
+              MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
                        MOJO_DEADLINE_INDEFINITE));
     char buffer[1000] = {};
     uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
@@ -436,7 +442,7 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
 
     // 4. Read a message from |client_mp|, which should have |mp1| attached.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(client_mp, MOJO_WAIT_FLAG_READABLE,
+              MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
                        MOJO_DEADLINE_INDEFINITE));
     // TODO(vtl): If the scope were to end here (and |client_mp| closed), we'd
     // die (again due to |Channel::HandleLocalError()|).
@@ -483,7 +489,8 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
 
     // 3. Read a message from |mp1|.
     EXPECT_EQ(MOJO_RESULT_OK,
-              MojoWait(mp1, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+              MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
+                       MOJO_DEADLINE_INDEFINITE));
     memset(buffer, 0, sizeof(buffer));
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
     EXPECT_EQ(MOJO_RESULT_OK,
@@ -495,7 +502,8 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
 
     // 11. Wait on |mp1| (which should eventually fail) and then close it.
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              MojoWait(mp1, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+              MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
+                       MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp1));
   }
 

mojo/examples/html_viewer/html_viewer.cc

@@ -38,7 +38,7 @@ class LaunchableConnection : public InterfaceImpl<launcher::Launchable> {
           MOJO_READ_DATA_FLAG_NONE);
       if (result == MOJO_RESULT_SHOULD_WAIT) {
         Wait(response_body_stream.get(),
-             MOJO_WAIT_FLAG_READABLE,
+             MOJO_HANDLE_SIGNAL_READABLE,
              MOJO_DEADLINE_INDEFINITE);
       } else if (result == MOJO_RESULT_OK) {
         fwrite(buf, num_bytes, 1, stdout);

mojo/examples/image_viewer/image_viewer.cc

@@ -43,7 +43,7 @@ class LaunchableConnection : public InterfaceImpl<launcher::Launchable> {
           MOJO_READ_DATA_FLAG_NONE);
       if (result == MOJO_RESULT_SHOULD_WAIT) {
         Wait(response_body_stream.get(),
-             MOJO_WAIT_FLAG_READABLE,
+             MOJO_HANDLE_SIGNAL_READABLE,
              MOJO_DEADLINE_INDEFINITE);
       } else if (result == MOJO_RESULT_OK) {
         buf += num_bytes;

mojo/examples/wget/wget.cc

@@ -89,7 +89,7 @@ class WGetApp : public Application, public URLLoaderClient {
           MOJO_READ_DATA_FLAG_NONE);
       if (result == MOJO_RESULT_SHOULD_WAIT) {
         Wait(response_body_stream_.get(),
-             MOJO_WAIT_FLAG_READABLE,
+             MOJO_HANDLE_SIGNAL_READABLE,
              MOJO_DEADLINE_INDEFINITE);
       } else if (result == MOJO_RESULT_OK) {
         fwrite(buf, num_bytes, 1, stdout);

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

@@ -86,7 +86,7 @@ class MessagePipeReaderThread : public mojo::Thread {
       }
 
       if (result == MOJO_RESULT_SHOULD_WAIT) {
-        result = MojoWait(handle_, MOJO_WAIT_FLAG_READABLE,
+        result = MojoWait(handle_, MOJO_HANDLE_SIGNAL_READABLE,
                           MOJO_DEADLINE_INDEFINITE);
         if (result == MOJO_RESULT_OK) {
           // Go to the top of the loop to read again.

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

@@ -34,9 +34,9 @@ TEST(CoreTest, InvalidHandle) {
 
   // Wait:
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            MojoWait(MOJO_HANDLE_INVALID, MOJO_WAIT_FLAG_EVERYTHING, 1000000));
+            MojoWait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, 1000000));
   h0 = MOJO_HANDLE_INVALID;
-  sig = MOJO_WAIT_FLAG_EVERYTHING;
+  sig = ~MOJO_HANDLE_SIGNAL_NONE;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE));
 
@@ -89,10 +89,10 @@ TEST(CoreTest, BasicMessagePipe) {
 
   // Shouldn't be readable.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            MojoWait(h0, MOJO_WAIT_FLAG_READABLE, 0));
+            MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   // Should be writable.
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h0, MOJO_WAIT_FLAG_WRITABLE, 0));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
 
   // Try to read.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
@@ -108,7 +108,7 @@ TEST(CoreTest, BasicMessagePipe) {
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // |h0| should be readable.
-  sig = MOJO_WAIT_FLAG_READABLE;
+  sig = MOJO_HANDLE_SIGNAL_READABLE;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE));
 
@@ -122,14 +122,15 @@ TEST(CoreTest, BasicMessagePipe) {
 
   // |h0| should no longer be readable.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            MojoWait(h0, MOJO_WAIT_FLAG_READABLE, 10));
+            MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, 10));
 
   // Close |h0|.
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0));
 
   // |h1| should no longer be readable or writable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            MojoWait(h1, MOJO_WAIT_FLAG_READABLE | MOJO_WAIT_FLAG_WRITABLE,
+            MojoWait(h1,
+                     MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
                      1000));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1));
@@ -151,10 +152,10 @@ TEST(CoreTest, BasicDataPipe) {
 
   // The consumer |hc| shouldn't be readable.
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            MojoWait(hc, MOJO_WAIT_FLAG_READABLE, 0));
+            MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   // The producer |hp| should be writable.
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(hp, MOJO_WAIT_FLAG_WRITABLE, 0));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(hp, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
 
   // Try to read from |hc|.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
@@ -176,7 +177,7 @@ TEST(CoreTest, BasicDataPipe) {
                           MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // |hc| should be(come) readable.
-  sig = MOJO_WAIT_FLAG_READABLE;
+  sig = MOJO_HANDLE_SIGNAL_READABLE;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoWaitMany(&hc, &sig, 1, MOJO_DEADLINE_INDEFINITE));
 
@@ -201,7 +202,7 @@ TEST(CoreTest, BasicDataPipe) {
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hp));
 
   // |hc| should still be readable.
-  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(hc, MOJO_WAIT_FLAG_READABLE, 0));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
   // Do a two-phase read from |hc|.
   read_pointer = NULL;
@@ -215,7 +216,7 @@ TEST(CoreTest, BasicDataPipe) {
 
   // |hc| should no longer be readable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            MojoWait(hc, MOJO_WAIT_FLAG_READABLE, 1000));
+            MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 1000));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hc));
 

mojo/public/c/system/tests/core_unittest_pure_c.c

@@ -54,13 +54,13 @@ const char* MinimalCTest(void) {
   EXPECT_NE(MOJO_RESULT_OK, MojoClose(handle0));
 
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            MojoWait(handle0, MOJO_WAIT_FLAG_EVERYTHING,
+            MojoWait(handle0, ~MOJO_HANDLE_SIGNAL_NONE,
                      MOJO_DEADLINE_INDEFINITE));
 
   handle1 = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(NULL, &handle0, &handle1));
 
-  signals = MOJO_WAIT_FLAG_READABLE;
+  signals = MOJO_HANDLE_SIGNAL_READABLE;
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
             MojoWaitMany(&handle0, &signals, 1, 1));
 
@@ -69,7 +69,7 @@ const char* MinimalCTest(void) {
                              0u, MOJO_WRITE_DATA_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK,
-            MojoWait(handle1, MOJO_WAIT_FLAG_READABLE,
+            MojoWait(handle1, MOJO_HANDLE_SIGNAL_READABLE,
                      MOJO_DEADLINE_INDEFINITE));
 
   num_bytes = (uint32_t) sizeof(buffer);

mojo/public/c/system/types.h

@@ -145,25 +145,21 @@ const MojoDeadline MOJO_DEADLINE_INDEFINITE = static_cast<MojoDeadline>(-1);
 // |MojoHandleSignals|: Used to specify signals that can be waited on for a
 // handle (and which can be triggered), e.g., the ability to read or write to
 // the handle.
-//   |MOJO_WAIT_FLAG_NONE| - No flags. |MojoWait()|, etc. will return
+//   |MOJO_HANDLE_SIGNAL_NONE| - No flags. |MojoWait()|, etc. will return
 //       |MOJO_RESULT_FAILED_PRECONDITION| if you attempt to wait on this.
-//   |MOJO_WAIT_FLAG_READABLE| - Can read (e.g., a message) from the handle.
-//   |MOJO_WAIT_FLAG_WRITABLE| - Can write (e.g., a message) to the handle.
-//   |MOJO_WAIT_FLAG_EVERYTHING| - All flags.
+//   |MOJO_HANDLE_SIGNAL_READABLE| - Can read (e.g., a message) from the handle.
+//   |MOJO_HANDLE_SIGNAL_WRITABLE| - Can write (e.g., a message) to the handle.
 
 typedef uint32_t MojoHandleSignals;
 
-// TODO(vtl): Rename these to MOJO_HANDLE_SIGNAL_....
 #ifdef __cplusplus
-const MojoHandleSignals MOJO_WAIT_FLAG_NONE = 0;
-const MojoHandleSignals MOJO_WAIT_FLAG_READABLE = 1 << 0;
-const MojoHandleSignals MOJO_WAIT_FLAG_WRITABLE = 1 << 1;
-const MojoHandleSignals MOJO_WAIT_FLAG_EVERYTHING = ~0;
+const MojoHandleSignals MOJO_HANDLE_SIGNAL_NONE = 0;
+const MojoHandleSignals MOJO_HANDLE_SIGNAL_READABLE = 1 << 0;
+const MojoHandleSignals MOJO_HANDLE_SIGNAL_WRITABLE = 1 << 1;
 #else
-#define MOJO_WAIT_FLAG_NONE ((MojoHandleSignals) 0)
-#define MOJO_WAIT_FLAG_READABLE ((MojoHandleSignals) 1 << 0)
-#define MOJO_WAIT_FLAG_WRITABLE ((MojoHandleSignals) 1 << 1)
-#define MOJO_WAIT_FLAG_EVERYTHING (~((MojoHandleSignals) 0))
+#define MOJO_HANDLE_SIGNAL_NONE ((MojoHandleSignals) 0)
+#define MOJO_HANDLE_SIGNAL_READABLE ((MojoHandleSignals) 1 << 0)
+#define MOJO_HANDLE_SIGNAL_WRITABLE ((MojoHandleSignals) 1 << 1)
 #endif
 
 // TODO(vtl): Add out parameters with this to MojoWait/MojoWaitMany.

mojo/public/cpp/bindings/lib/connector.cc

@@ -114,7 +114,7 @@ void Connector::OnHandleReady(MojoResult result) {
 
 void Connector::WaitToReadMore() {
   async_wait_id_ = waiter_->AsyncWait(message_pipe_.get().value(),
-                                      MOJO_WAIT_FLAG_READABLE,
+                                      MOJO_HANDLE_SIGNAL_READABLE,
                                       MOJO_DEADLINE_INDEFINITE,
                                       &Connector::CallOnHandleReady,
                                       this);

mojo/public/cpp/bindings/lib/sync_dispatcher.cc

@@ -18,7 +18,7 @@ bool WaitForMessageAndDispatch(MessagePipeHandle handle,
     if (rv == MOJO_RESULT_OK)
       return result;
     if (rv == MOJO_RESULT_SHOULD_WAIT)
-      rv = Wait(handle, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE);
+      rv = Wait(handle, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
     if (rv != MOJO_RESULT_OK)
       return false;
   }

mojo/public/cpp/environment/tests/async_waiter_unittest.cc

@@ -72,7 +72,7 @@ TEST_F(AsyncWaiterTest, CallbackNotified) {
   EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
 
   CallAsyncWait(test_pipe.handle0.get(),
-                MOJO_WAIT_FLAG_READABLE,
+                MOJO_HANDLE_SIGNAL_READABLE,
                 &callback);
   RunLoop::current()->Run();
   EXPECT_EQ(1, callback.result_count());
@@ -88,8 +88,12 @@ TEST_F(AsyncWaiterTest, TwoCallbacksNotified) {
   EXPECT_TRUE(test::WriteTextMessage(test_pipe1.handle1.get(), std::string()));
   EXPECT_TRUE(test::WriteTextMessage(test_pipe2.handle1.get(), std::string()));
 
-  CallAsyncWait(test_pipe1.handle0.get(), MOJO_WAIT_FLAG_READABLE, &callback1);
-  CallAsyncWait(test_pipe2.handle0.get(), MOJO_WAIT_FLAG_READABLE, &callback2);
+  CallAsyncWait(test_pipe1.handle0.get(),
+                MOJO_HANDLE_SIGNAL_READABLE,
+                &callback1);
+  CallAsyncWait(test_pipe2.handle0.get(),
+                MOJO_HANDLE_SIGNAL_READABLE,
+                &callback2);
 
   RunLoop::current()->Run();
   EXPECT_EQ(1, callback1.result_count());
@@ -106,7 +110,7 @@ TEST_F(AsyncWaiterTest, CancelCallback) {
 
   CallCancelWait(
       CallAsyncWait(test_pipe.handle0.get(),
-                    MOJO_WAIT_FLAG_READABLE,
+                    MOJO_HANDLE_SIGNAL_READABLE,
                     &callback));
   RunLoop::current()->Run();
   EXPECT_EQ(0, callback.result_count());

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

@@ -99,12 +99,12 @@ TEST(CoreCppTest, Basic) {
     EXPECT_EQ(kInvalidHandleValue, h.get().value());
 
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              Wait(h.get(), MOJO_WAIT_FLAG_EVERYTHING, 1000000));
+              Wait(h.get(), ~MOJO_HANDLE_SIGNAL_NONE, 1000000));
 
     std::vector<Handle> wh;
     wh.push_back(h.get());
     std::vector<MojoHandleSignals> sigs;
-    sigs.push_back(MOJO_WAIT_FLAG_EVERYTHING);
+    sigs.push_back(~MOJO_HANDLE_SIGNAL_NONE);
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               WaitMany(wh, sigs, MOJO_DEADLINE_INDEFINITE));
   }
@@ -163,13 +163,13 @@ TEST(CoreCppTest, Basic) {
       MojoHandle hv1 = h1.get().value();
 
       EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-                Wait(h0.get(), MOJO_WAIT_FLAG_READABLE, 0));
+                Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, 0));
       std::vector<Handle> wh;
       wh.push_back(h0.get());
       wh.push_back(h1.get());
       std::vector<MojoHandleSignals> sigs;
-      sigs.push_back(MOJO_WAIT_FLAG_READABLE);
-      sigs.push_back(MOJO_WAIT_FLAG_WRITABLE);
+      sigs.push_back(MOJO_HANDLE_SIGNAL_READABLE);
+      sigs.push_back(MOJO_HANDLE_SIGNAL_WRITABLE);
       EXPECT_EQ(1, WaitMany(wh, sigs, 1000));
 
       // Test closing |h1| explicitly.
@@ -178,11 +178,11 @@ TEST(CoreCppTest, Basic) {
 
       // Make sure |h1| is closed.
       EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-                MojoWait(hv1, MOJO_WAIT_FLAG_EVERYTHING,
+                MojoWait(hv1, ~MOJO_HANDLE_SIGNAL_NONE,
                          MOJO_DEADLINE_INDEFINITE));
 
       EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-                Wait(h0.get(), MOJO_WAIT_FLAG_READABLE,
+                Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE,
                      MOJO_DEADLINE_INDEFINITE));
     }
     // |hv0| should have been closed when |h0| went out of scope, so this close
@@ -203,7 +203,7 @@ TEST(CoreCppTest, Basic) {
                                 NULL, 0,
                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
       EXPECT_EQ(MOJO_RESULT_OK,
-                Wait(h1.get(), MOJO_WAIT_FLAG_READABLE,
+                Wait(h1.get(), MOJO_HANDLE_SIGNAL_READABLE,
                      MOJO_DEADLINE_INDEFINITE));
       char buffer[10] = { 0 };
       uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
@@ -245,7 +245,7 @@ TEST(CoreCppTest, Basic) {
 
       // Read "hello" and the sent handle.
       EXPECT_EQ(MOJO_RESULT_OK,
-                Wait(h0.get(), MOJO_WAIT_FLAG_READABLE,
+                Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE,
                      MOJO_DEADLINE_INDEFINITE));
       memset(buffer, 0, sizeof(buffer));
       buffer_size = static_cast<uint32_t>(sizeof(buffer));
@@ -267,7 +267,7 @@ TEST(CoreCppTest, Basic) {
       // Save |handles[0]| to check that it gets properly closed.
       hv0 = handles[0];
       EXPECT_EQ(MOJO_RESULT_OK,
-                Wait(mp.handle1.get(), MOJO_WAIT_FLAG_READABLE,
+                Wait(mp.handle1.get(), MOJO_HANDLE_SIGNAL_READABLE,
                      MOJO_DEADLINE_INDEFINITE));
       memset(buffer, 0, sizeof(buffer));
       buffer_size = static_cast<uint32_t>(sizeof(buffer));

mojo/public/cpp/test_support/lib/test_utils.cc

@@ -38,7 +38,7 @@ bool ReadTextMessage(const MessagePipeHandle& handle, std::string* text) {
         assert(false);  // Looping endlessly!?
         return false;
       }
-      rv = Wait(handle, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE);
+      rv = Wait(handle, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
       if (rv != MOJO_RESULT_OK)
         return false;
       did_wait = true;

mojo/public/cpp/utility/run_loop.h

@@ -57,7 +57,7 @@ class RunLoop {
   struct HandlerData {
     HandlerData()
         : handler(NULL),
-          handle_signals(MOJO_WAIT_FLAG_NONE),
+          handle_signals(MOJO_HANDLE_SIGNAL_NONE),
           deadline(0),
           id(0) {}
 

mojo/public/cpp/utility/tests/run_loop_unittest.cc

@@ -101,7 +101,7 @@ TEST_F(RunLoopTest, HandleReady) {
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
-                      MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE);
+                      MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
   run_loop.Run();
   EXPECT_EQ(1, handler.ready_count());
   EXPECT_EQ(0, handler.error_count());
@@ -137,7 +137,7 @@ TEST_F(RunLoopTest, QuitFromReady) {
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
-                      MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE);
+                      MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
   run_loop.Run();
   EXPECT_EQ(1, handler.ready_count());
   EXPECT_EQ(0, handler.error_count());
@@ -172,7 +172,7 @@ TEST_F(RunLoopTest, QuitWhenDeadlineExpired) {
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
-                      MOJO_WAIT_FLAG_READABLE,
+                      MOJO_HANDLE_SIGNAL_READABLE,
                       static_cast<MojoDeadline>(10000));
   run_loop.Run();
   EXPECT_EQ(0, handler.ready_count());

mojo/public/js/bindings/connector.js

@@ -77,7 +77,7 @@ define("mojo/public/js/bindings/connector", [
 
   Connector.prototype.waitToReadMore_ = function() {
     this.readWaitCookie_ = support.asyncWait(this.handle_,
-                                             core.WAIT_FLAG_READABLE,
+                                             core.HANDLE_SIGNAL_READABLE,
                                              this.readMore_.bind(this));
   };
 

mojo/public/js/bindings/core.js

@@ -52,10 +52,10 @@ var DEADLINE_INDEFINITE;
  * the handle.
  * See core.h for more information.
  */
-var WAIT_FLAG_NONE;
-var WAIT_FLAG_READABLE;
-var WAIT_FLAG_WRITABLE;
-var WAIT_FLAG_EVERYTHING;
+var HANDLE_SIGNAL_NONE;
+var HANDLE_SIGNAL_READABLE;
+var HANDLE_SIGNAL_WRITABLE;
+var HANDLE_SIGNAL_EVERYTHING;
 
 /*
  * MojoWriteMessageFlags: Used to specify different modes to |writeMessage()|.

mojo/spy/spy.cc

@@ -50,8 +50,8 @@ class MessageProcessor :
     pipes.push_back(client.get());
     pipes.push_back(interceptor.get());
     std::vector<MojoHandleSignals> handle_signals;
-    handle_signals.push_back(MOJO_WAIT_FLAG_READABLE);
-    handle_signals.push_back(MOJO_WAIT_FLAG_READABLE);
+    handle_signals.push_back(MOJO_HANDLE_SIGNAL_READABLE);
+    handle_signals.push_back(MOJO_HANDLE_SIGNAL_READABLE);
 
     scoped_ptr<char[]> mbuf(new char[kMessageBufSize]);
     scoped_ptr<MojoHandle[]> hbuf(new MojoHandle[kHandleBufSize]);
@@ -90,7 +90,7 @@ class MessageProcessor :
 
       mojo::MessagePipeHandle write_handle = (r == 0) ? pipes[1] : pipes[0];
       if (!CheckResult(Wait(write_handle,
-                            MOJO_WAIT_FLAG_WRITABLE,
+                            MOJO_HANDLE_SIGNAL_WRITABLE,
                             MOJO_DEADLINE_INDEFINITE)))
         break;
 

mojo/system/channel_unittest.cc

@@ -264,7 +264,7 @@ TEST_F(ChannelTest, ShutdownAfterAttach) {
   Waiter waiter;
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->AddWaiter(0, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
+            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   // Don't wait for the shutdown to run ...
   io_thread()->PostTask(FROM_HERE,
@@ -315,7 +315,7 @@ TEST_F(ChannelTest, WaitAfterAttachRunAndShutdown) {
   Waiter waiter;
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->AddWaiter(0, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
+            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   mp->Close(0);
 

mojo/system/data_pipe.cc

@@ -168,7 +168,7 @@ MojoResult DataPipe::ProducerEndWriteData(uint32_t num_bytes_written) {
   // If we're now writable, we *became* writable (since we weren't writable
   // during the two-phase write), so awake producer waiters.
   WaitFlagsState new_producer_state = ProducerGetWaitFlagsStateNoLock();
-  if (new_producer_state.satisfies(MOJO_WAIT_FLAG_WRITABLE))
+  if (new_producer_state.satisfies(MOJO_HANDLE_SIGNAL_WRITABLE))
     AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
   WaitFlagsState new_consumer_state = ConsumerGetWaitFlagsStateNoLock();
   if (!new_consumer_state.equals(old_consumer_state))
@@ -320,7 +320,7 @@ MojoResult DataPipe::ConsumerEndReadData(uint32_t num_bytes_read) {
   // If we're now readable, we *became* readable (since we weren't readable
   // during the two-phase read), so awake consumer waiters.
   WaitFlagsState new_consumer_state = ConsumerGetWaitFlagsStateNoLock();
-  if (new_consumer_state.satisfies(MOJO_WAIT_FLAG_READABLE))
+  if (new_consumer_state.satisfies(MOJO_HANDLE_SIGNAL_READABLE))
     AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state);
   WaitFlagsState new_producer_state = ProducerGetWaitFlagsStateNoLock();
   if (!new_producer_state.equals(old_producer_state))

mojo/system/dispatcher_unittest.cc

@@ -64,7 +64,7 @@ TEST(DispatcherTest, Basic) {
   Waiter w;
   w.Init();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            d->AddWaiter(&w, MOJO_WAIT_FLAG_EVERYTHING, 0));
+            d->AddWaiter(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0));
   // Okay to remove even if it wasn't added (or was already removed).
   d->RemoveWaiter(&w);
   d->RemoveWaiter(&w);
@@ -89,7 +89,7 @@ TEST(DispatcherTest, Basic) {
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->EndReadData(0));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->AddWaiter(&w, MOJO_WAIT_FLAG_EVERYTHING, 0));
+            d->AddWaiter(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0));
   d->RemoveWaiter(&w);
 }
 
@@ -192,7 +192,7 @@ class ThreadSafetyStressThread : public base::SimpleThread {
       }
       case ADD_WAITER: {
         MojoResult r = dispatcher_->AddWaiter(&waiter_,
-                                              MOJO_WAIT_FLAG_EVERYTHING, 0);
+                                              ~MOJO_HANDLE_SIGNAL_NONE, 0);
         EXPECT_TRUE(r == MOJO_RESULT_FAILED_PRECONDITION ||
                     r == MOJO_RESULT_INVALID_ARGUMENT);
         break;

mojo/system/local_data_pipe.cc

@@ -156,8 +156,8 @@ WaitFlagsState LocalDataPipe::ProducerGetWaitFlagsStateNoLock() const {
   if (consumer_open_no_lock()) {
     if ((may_discard() || current_num_bytes_ < capacity_num_bytes()) &&
         !producer_in_two_phase_write_no_lock())
-      rv.satisfied_signals |= MOJO_WAIT_FLAG_WRITABLE;
-    rv.satisfiable_signals |= MOJO_WAIT_FLAG_WRITABLE;
+      rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_WRITABLE;
+    rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_WRITABLE;
   }
   return rv;
 }
@@ -277,10 +277,10 @@ WaitFlagsState LocalDataPipe::ConsumerGetWaitFlagsStateNoLock() const {
   WaitFlagsState rv;
   if (current_num_bytes_ > 0) {
     if (!consumer_in_two_phase_read_no_lock())
-      rv.satisfied_signals |= MOJO_WAIT_FLAG_READABLE;
-    rv.satisfiable_signals |= MOJO_WAIT_FLAG_READABLE;
+      rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_READABLE;
+    rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_READABLE;
   } else if (producer_open_no_lock()) {
-    rv.satisfiable_signals |= MOJO_WAIT_FLAG_READABLE;
+    rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_READABLE;
   }
   return rv;
 }

mojo/system/local_message_pipe_endpoint.cc

@@ -150,12 +150,13 @@ void LocalMessagePipeEndpoint::RemoveWaiter(Waiter* waiter) {
 WaitFlagsState LocalMessagePipeEndpoint::GetWaitFlagsState() {
   WaitFlagsState rv;
   if (!message_queue_.IsEmpty()) {
-    rv.satisfied_signals |= MOJO_WAIT_FLAG_READABLE;
-    rv.satisfiable_signals |= MOJO_WAIT_FLAG_READABLE;
+    rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_READABLE;
+    rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_READABLE;
   }
   if (is_peer_open_) {
-    rv.satisfied_signals |= MOJO_WAIT_FLAG_WRITABLE;
-    rv.satisfiable_signals |= MOJO_WAIT_FLAG_READABLE | MOJO_WAIT_FLAG_WRITABLE;
+    rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_WRITABLE;
+    rv.satisfiable_signals |=
+        MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE;
   }
   return rv;
 }

mojo/system/message_pipe_dispatcher_unittest.cc

@@ -53,14 +53,14 @@ TEST(MessagePipeDispatcherTest, Basic) {
     // Try adding a writable waiter when already writable.
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 0));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
     // Shouldn't need to remove the waiter (it was not added).
 
     // Add a readable waiter to |d0|, then make it readable (by writing to
     // |d1|), then wait.
     w.Init();
     EXPECT_EQ(MOJO_RESULT_OK,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 1));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1));
     buffer[0] = 123456789;
     EXPECT_EQ(MOJO_RESULT_OK,
               d1->WriteMessage(buffer, kBufferSize,
@@ -75,7 +75,7 @@ TEST(MessagePipeDispatcherTest, Basic) {
     // Try adding a readable waiter when already readable (from above).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 2));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 2));
     // Shouldn't need to remove the waiter (it was not added).
 
     // Make |d0| no longer readable (by reading from it).
@@ -91,7 +91,7 @@ TEST(MessagePipeDispatcherTest, Basic) {
     // Wait for zero time for readability on |d0| (will time out).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_OK,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 3));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3));
     stopwatch.Start();
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, NULL));
     EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
@@ -100,7 +100,7 @@ TEST(MessagePipeDispatcherTest, Basic) {
     // Wait for non-zero, finite time for readability on |d0| (will time out).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_OK,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 3));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3));
     stopwatch.Start();
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
               w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), NULL));
@@ -185,7 +185,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     // Try waiting for readable on |d0|; should fail (already satisfied).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 0));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0));
 
     // Try reading from |d1|; should fail (nothing to read).
     buffer[0] = 0;
@@ -201,7 +201,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     // Try waiting for readable on |d0|; should fail (already satisfied).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 1));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1));
 
     // Read from |d0|.
     buffer[0] = 0;
@@ -216,7 +216,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     // Try waiting for readable on |d0|; should fail (already satisfied).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 2));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 2));
 
     // Read again from |d0|.
     buffer[0] = 0;
@@ -231,12 +231,12 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     // Try waiting for readable on |d0|; should fail (unsatisfiable).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 3));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3));
 
     // Try waiting for writable on |d0|; should fail (unsatisfiable).
     w.Init();
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              d0->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 4));
+              d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4));
 
     // Try reading from |d0|; should fail (nothing to read and other end
     // closed).
@@ -283,7 +283,7 @@ TEST(MessagePipeDispatcherTest, BasicThreaded) {
     // Wait for readable on |d1|, which will become readable after some time.
     {
       test::WaiterThread thread(d1,
-                               MOJO_WAIT_FLAG_READABLE,
+                               MOJO_HANDLE_SIGNAL_READABLE,
                                MOJO_DEADLINE_INDEFINITE,
                                1,
                                &did_wait, &result, &context);
@@ -307,7 +307,7 @@ TEST(MessagePipeDispatcherTest, BasicThreaded) {
     // Now |d1| is already readable. Try waiting for it again.
     {
       test::WaiterThread thread(d1,
-                                MOJO_WAIT_FLAG_READABLE,
+                                MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE,
                                 2,
                                 &did_wait, &result, &context);
@@ -332,7 +332,7 @@ TEST(MessagePipeDispatcherTest, BasicThreaded) {
     // cancel that wait.
     {
       test::WaiterThread thread(d1,
-                                MOJO_WAIT_FLAG_READABLE,
+                                MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE,
                                 3,
                                 &did_wait, &result, &context);
@@ -366,7 +366,7 @@ TEST(MessagePipeDispatcherTest, BasicThreaded) {
     // cancel that wait.
     {
       test::WaiterThread thread(d1,
-                                MOJO_WAIT_FLAG_READABLE,
+                                MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE,
                                 4,
                                 &did_wait, &result, &context);
@@ -470,7 +470,7 @@ class ReaderThread : public base::SimpleThread {
     for (;;) {
       // Wait for it to be readable.
       w.Init();
-      result = read_dispatcher_->AddWaiter(&w, MOJO_WAIT_FLAG_READABLE, 0);
+      result = read_dispatcher_->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0);
       EXPECT_TRUE(result == MOJO_RESULT_OK ||
                   result == MOJO_RESULT_ALREADY_EXISTS) << "result: " << result;
       if (result == MOJO_RESULT_OK) {

mojo/system/message_pipe_unittest.cc

@@ -366,18 +366,19 @@ TEST(MessagePipeTest, BasicWaiting) {
   // Always writable (until the other port is closed).
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(0, &waiter, MOJO_WAIT_FLAG_WRITABLE, 0));
+            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0));
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             mp->AddWaiter(0,
                           &waiter,
-                          MOJO_WAIT_FLAG_READABLE | MOJO_WAIT_FLAG_WRITABLE,
+                          MOJO_HANDLE_SIGNAL_READABLE |
+                              MOJO_HANDLE_SIGNAL_WRITABLE,
                           0));
 
   // Not yet readable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->AddWaiter(0, &waiter, MOJO_WAIT_FLAG_READABLE, 1));
+            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 1));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, NULL));
   mp->RemoveWaiter(0, &waiter);
 
@@ -392,17 +393,18 @@ TEST(MessagePipeTest, BasicWaiting) {
   // Port 1 should already be readable now.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 2));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 2));
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
             mp->AddWaiter(1,
                           &waiter,
-                          MOJO_WAIT_FLAG_READABLE | MOJO_WAIT_FLAG_WRITABLE,
+                          MOJO_HANDLE_SIGNAL_READABLE |
+                              MOJO_HANDLE_SIGNAL_WRITABLE,
                           0));
   // ... and still writable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_WRITABLE, 3));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3));
 
   // Close port 0.
   mp->Close(0);
@@ -410,12 +412,12 @@ TEST(MessagePipeTest, BasicWaiting) {
   // Now port 1 should not be writable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_WRITABLE, 4));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4));
 
   // But it should still be readable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            mp->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 5));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 5));
 
   // Read from port 1.
   buffer[0] = 0;
@@ -430,7 +432,7 @@ TEST(MessagePipeTest, BasicWaiting) {
   // Now port 1 should no longer be readable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 6));
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 6));
 
   mp->Close(1);
 }
@@ -449,7 +451,8 @@ TEST(MessagePipeTest, ThreadedWaiting) {
 
     thread.waiter()->Init();
     EXPECT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_WAIT_FLAG_READABLE, 1));
+              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
+                            1));
     thread.Start();
 
     buffer[0] = 123456789;
@@ -476,7 +479,8 @@ TEST(MessagePipeTest, ThreadedWaiting) {
 
     thread.waiter()->Init();
     EXPECT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_WAIT_FLAG_READABLE, 2));
+              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
+                            2));
     thread.Start();
 
     // Close port 1 first -- this should result in the waiter being cancelled.
@@ -498,7 +502,8 @@ TEST(MessagePipeTest, ThreadedWaiting) {
 
     thread.waiter()->Init();
     EXPECT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(1, thread.waiter(), MOJO_WAIT_FLAG_READABLE, 3));
+              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
+                            3));
     thread.Start();
 
     // Close port 0 first -- this should wake the waiter up, since port 1 will

mojo/system/multiprocess_message_pipe_unittest.cc

@@ -159,7 +159,7 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
   int rv = 0;
   for (;; rv = (rv + 1) % 100) {
     // Wait for our end of the message pipe to be readable.
-    MojoResult result = WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE);
+    MojoResult result = WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE);
     if (result != MOJO_RESULT_OK) {
       // It was closed, probably.
       CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION);
@@ -210,7 +210,7 @@ TEST_F(MultiprocessMessagePipeTest, Basic) {
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
-  EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE));
+  EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
   std::string read_buffer(1000, '\0');
   uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
@@ -259,7 +259,7 @@ TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   for (size_t i = 0; i < kNumMessages; i++) {
-    EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE));
+    EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
     std::string read_buffer(kNumMessages * 2, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
@@ -276,7 +276,7 @@ TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
   // Wait for it to become readable, which should fail (since we sent
   // "quitquitquit").
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE));
+            WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
   mp->Close(0);
 
@@ -295,7 +295,7 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
   channel_thread.Start(client_platform_handle.Pass(), mp);
 
   // Wait for the first message from our parent.
-  CHECK_EQ(WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE), MOJO_RESULT_OK);
+  CHECK_EQ(WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE), MOJO_RESULT_OK);
 
   // It should have a shared buffer.
   std::string read_buffer(100, '\0');
@@ -341,7 +341,7 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
            MOJO_RESULT_OK);
 
   // Now wait for our parent to send us a message.
-  CHECK_EQ(WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE), MOJO_RESULT_OK);
+  CHECK_EQ(WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE), MOJO_RESULT_OK);
 
   read_buffer = std::string(100, '\0');
   num_bytes = static_cast<uint32_t>(read_buffer.size());
@@ -413,7 +413,7 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
   dispatcher = NULL;
 
   // Wait for a message from the child.
-  EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE));
+  EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
@@ -445,7 +445,7 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
 
   // Wait for |mp| to become readable, which should fail.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE));
+            WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
   mp->Close(0);
 
@@ -462,7 +462,7 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) {
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
   channel_thread.Start(client_platform_handle.Pass(), mp);
 
-  CHECK_EQ(WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE), MOJO_RESULT_OK);
+  CHECK_EQ(WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE), MOJO_RESULT_OK);
 
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
@@ -543,7 +543,7 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_PlatformHandlePassing) {
 
   // Wait for it to become readable, which should fail.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE));
+            WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE));
 
   mp->Close(0);
 

mojo/system/remote_message_pipe_unittest.cc

@@ -197,7 +197,7 @@ TEST_F(RemoteMessagePipeTest, Basic) {
   // it later, it might already be readable.)
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
+            mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   // Write to MP 0, port 0.
   EXPECT_EQ(MOJO_RESULT_OK,
@@ -224,7 +224,7 @@ TEST_F(RemoteMessagePipeTest, Basic) {
 
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->AddWaiter(0, &waiter, MOJO_WAIT_FLAG_READABLE, 456));
+            mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp1->WriteMessage(1,
@@ -252,7 +252,8 @@ TEST_F(RemoteMessagePipeTest, Basic) {
   // when it realizes that MP 0, port 0 has been closed. (It may also fail
   // immediately.)
   waiter.Init();
-  MojoResult result = mp1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 789);
+  MojoResult result =
+      mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789);
   if (result == MOJO_RESULT_OK) {
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -298,7 +299,7 @@ TEST_F(RemoteMessagePipeTest, Multiplex) {
 
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp3->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 789));
+            mp3->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp2->WriteMessage(0,
@@ -344,7 +345,7 @@ TEST_F(RemoteMessagePipeTest, Multiplex) {
 
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
+            mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp0->WriteMessage(0,
@@ -427,7 +428,7 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) {
   // it later, it might already be readable.)
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
+            mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   BootstrapMessagePipeNoWait(1, mp1);
 
@@ -472,7 +473,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) {
   // it later, it might already be readable.)
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
+            mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   // Write to MP 0, port 0.
   {
@@ -528,7 +529,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) {
   // Wait for the dispatcher to become readable.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddWaiter(&waiter, MOJO_WAIT_FLAG_READABLE, 456));
+            dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456));
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
   dispatcher->RemoveWaiter(&waiter);
@@ -545,7 +546,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) {
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 789));
+            local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789));
 
   // Write to the dispatcher.
   EXPECT_EQ(MOJO_RESULT_OK,
@@ -620,7 +621,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) {
   // it later, it might already be readable.)
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
+            mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   // Write to MP 0, port 0.
   {
@@ -731,7 +732,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) {
   // it later, it might already be readable.)
   waiter.Init();
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->AddWaiter(1, &waiter, MOJO_WAIT_FLAG_READABLE, 123));
+            mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123));
 
   // Write to MP 0, port 0.
   {

mojo/system/wait_flags_state.h

@@ -16,8 +16,8 @@ namespace system {
 // (for convenience). This should add no overhead.
 struct MOJO_SYSTEM_IMPL_EXPORT WaitFlagsState : public MojoWaitFlagsState {
   WaitFlagsState() {
-    satisfied_signals = MOJO_WAIT_FLAG_NONE;
-    satisfiable_signals = MOJO_WAIT_FLAG_NONE;
+    satisfied_signals = MOJO_HANDLE_SIGNAL_NONE;
+    satisfiable_signals = MOJO_HANDLE_SIGNAL_NONE;
   }
   WaitFlagsState(MojoHandleSignals satisfied, MojoHandleSignals satisfiable) {
     satisfied_signals = satisfied;