Mojo: MojoWaitFlags -> MojoHandleSignals.

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 85 matching lines @@
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING,
                          MOJO_DEADLINE_INDEFINITE));
   EXPECT_EQ(1u, info.GetAddWaiterCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 0));
   EXPECT_EQ(2u, info.GetAddWaiterCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 10 * 1000));
   EXPECT_EQ(3u, info.GetAddWaiterCallCount());
-  MojoWaitFlags wait_flags = MOJO_WAIT_FLAG_EVERYTHING;
+  MojoHandleSignals handle_signals = MOJO_WAIT_FLAG_EVERYTHING;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->WaitMany(&h, &wait_flags, 1, MOJO_DEADLINE_INDEFINITE));
+            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());
   EXPECT_EQ(1u, info.GetDtorCallCount());
 
@@ skipping 22 matching lines @@
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->Wait(MOJO_HANDLE_INVALID, MOJO_WAIT_FLAG_EVERYTHING,
                            MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->Wait(10, MOJO_WAIT_FLAG_EVERYTHING,
                            MOJO_DEADLINE_INDEFINITE));
   }
 
   // |WaitMany()|:
   {
-    MojoHandle handles[2] = { MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID };
-    MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_EVERYTHING,
-                               MOJO_WAIT_FLAG_EVERYTHING };
+    MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
+    MojoHandleSignals signals[2] = {MOJO_WAIT_FLAG_EVERYTHING,
+                                    MOJO_WAIT_FLAG_EVERYTHING};
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(handles, flags, 0, MOJO_DEADLINE_INDEFINITE));
+              core()->WaitMany(handles, signals, 0, MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(NULL, flags, 0, MOJO_DEADLINE_INDEFINITE));
+              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, flags, 1, MOJO_DEADLINE_INDEFINITE));
+              core()->WaitMany(NULL, signals, 1, MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WaitMany(handles, NULL, 1, MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(handles, flags, 1, MOJO_DEADLINE_INDEFINITE));
+              core()->WaitMany(handles, signals, 1, MOJO_DEADLINE_INDEFINITE));
 
     MockHandleInfo info[2];
     handles[0] = CreateMockHandle(&info[0]);
 
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              core()->WaitMany(handles, flags, 1, MOJO_DEADLINE_INDEFINITE));
+              core()->WaitMany(handles, signals, 1, MOJO_DEADLINE_INDEFINITE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
+              core()->WaitMany(handles, signals, 2, MOJO_DEADLINE_INDEFINITE));
     handles[1] = handles[0] + 1;  // Invalid handle.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
+              core()->WaitMany(handles, signals, 2, MOJO_DEADLINE_INDEFINITE));
     handles[1] = CreateMockHandle(&info[1]);
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
+              core()->WaitMany(handles, signals, 2, MOJO_DEADLINE_INDEFINITE));
 
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[0]));
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[1]));
   }
 
   // |CreateMessagePipe()|:
   {
     MojoHandle h;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->CreateMessagePipe(NULL, NULL, NULL));
@@ skipping 122 matching lines @@
                                   MOJO_READ_MESSAGE_FLAG_NONE));
     // Checked by |Core|, shouldn't go through to the dispatcher.
     EXPECT_EQ(1u, info.GetReadMessageCallCount());
 
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
   }
 }
 
 // TODO(vtl): test |Wait()| and |WaitMany()| properly
 //  - including |WaitMany()| with the same handle more than once (with
-//    same/different flags)
+//    same/different signals)
 
 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.
-  MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_READABLE, MOJO_WAIT_FLAG_READABLE };
+  MojoHandleSignals signals[2] = {MOJO_WAIT_FLAG_READABLE,
+                                  MOJO_WAIT_FLAG_READABLE};
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            core()->WaitMany(h, flags, 2, 0));
+            core()->WaitMany(h, signals, 2, 0));
 
   // Try to read anyway.
   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));
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
 
   // Also check that |h[1]| is writable using |WaitMany()|.
-  flags[0] = MOJO_WAIT_FLAG_READABLE;
-  flags[1] = MOJO_WAIT_FLAG_WRITABLE;
-  EXPECT_EQ(1, core()->WaitMany(h, flags, 2, MOJO_DEADLINE_INDEFINITE));
+  signals[0] = MOJO_WAIT_FLAG_READABLE;
+  signals[1] = MOJO_WAIT_FLAG_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.
-  flags[0] = MOJO_WAIT_FLAG_READABLE;
-  flags[1] = MOJO_WAIT_FLAG_READABLE;
-  EXPECT_EQ(0, core()->WaitMany(h, flags, 2, MOJO_DEADLINE_INDEFINITE));
+  signals[0] = MOJO_WAIT_FLAG_READABLE;
+  signals[1] = MOJO_WAIT_FLAG_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';
@@ skipping 492 matching lines @@
   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