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

mojo/public/cpp/system/tests/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.
 
 // This file tests the C++ Mojo system core wrappers.
 // TODO(vtl): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets
 // compiled into a different binary from the C API tests.
 
 #include "mojo/public/cpp/system/core.h"
 
@@ skipping 81 matching lines @@
 
     EXPECT_EQ(kInvalidHandleValue, h.get().value());
 
     // This should be a no-op.
     Close(h.Pass());
 
     // It should still be invalid.
     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));
   }
 
   // |MakeScopedHandle| (just compilation tests):
   {
     EXPECT_FALSE(MakeScopedHandle(Handle()).is_valid());
     EXPECT_FALSE(MakeScopedHandle(MessagePipeHandle()).is_valid());
     EXPECT_FALSE(MakeScopedHandle(DataPipeProducerHandle()).is_valid());
     EXPECT_FALSE(MakeScopedHandle(DataPipeConsumerHandle()).is_valid());
@@ skipping 38 matching lines @@
       CreateMessagePipe(NULL, &h0, &h1);
       EXPECT_TRUE(h0.get().is_valid());
       EXPECT_TRUE(h1.get().is_valid());
       EXPECT_NE(h0.get().value(), h1.get().value());
       // Save the handle values, so we can check that things got closed
       // correctly.
       hv0 = h0.get().value();
       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.
       Close(h1.Pass());
       EXPECT_FALSE(h1.get().is_valid());
 
       // 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
     // should fail.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0));
 
     // Actually test writing/reading messages.
     {
       ScopedMessagePipeHandle h0;
       ScopedMessagePipeHandle h1;
       CreateMessagePipe(NULL, &h0, &h1);
 
       const char kHello[] = "hello";
       const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
       EXPECT_EQ(MOJO_RESULT_OK,
                 WriteMessageRaw(h0.get(),
                                 kHello, kHelloSize,
                                 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));
       EXPECT_EQ(MOJO_RESULT_OK,
                 ReadMessageRaw(h1.get(),
                                buffer, &buffer_size,
                                NULL, NULL,
                                MOJO_READ_MESSAGE_FLAG_NONE));
       EXPECT_EQ(kHelloSize, buffer_size);
       EXPECT_STREQ(kHello, buffer);
@@ skipping 21 matching lines @@
       EXPECT_EQ(MOJO_RESULT_OK,
                 WriteMessageRaw(h1.get(),
                                 kHello, kHelloSize,
                                 handles, handles_count,
                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
       // |handles[0]| should actually be invalid now.
       EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handles[0]));
 
       // 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));
       for (size_t i = 0; i < MOJO_ARRAYSIZE(handles); i++)
         handles[i] = kInvalidHandleValue;
       handles_count = static_cast<uint32_t>(MOJO_ARRAYSIZE(handles));
       EXPECT_EQ(MOJO_RESULT_OK,
                 ReadMessageRaw(h0.get(),
                                buffer, &buffer_size,
                                handles, &handles_count,
                                MOJO_READ_MESSAGE_FLAG_NONE));
       EXPECT_EQ(kHelloSize, buffer_size);
       EXPECT_STREQ(kHello, buffer);
       EXPECT_EQ(1u, handles_count);
       EXPECT_NE(kInvalidHandleValue, handles[0]);
 
       // Read from the sent/received handle.
       mp.handle1.reset(MessagePipeHandle(handles[0]));
       // 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));
       for (size_t i = 0; i < MOJO_ARRAYSIZE(handles); i++)
         handles[i] = kInvalidHandleValue;
       handles_count = static_cast<uint32_t>(MOJO_ARRAYSIZE(handles));
       EXPECT_EQ(MOJO_RESULT_OK,
                 ReadMessageRaw(mp.handle1.get(),
                                buffer, &buffer_size,
                                handles, &handles_count,
@@ skipping 129 matching lines @@
 
   buffer1 = buffer1.Pass();
 
   EXPECT_TRUE(buffer1.is_valid());
 }
 
 // TODO(vtl): Write data pipe tests.
 
 }  // namespace
 }  // namespace mojo