Mojo: Rename (Mojo)WaitFlagsState -> (Mojo)HandleSignalsState.

(And wait_flags_state.h -> handle_signals_state.h.)

Still to do: Java (WaitFlags -> HandleSignals).

R=sky@chromium.org

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

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

mojo/mojo.gyp

@@ -181,6 +181,7 @@
         'system/dispatcher.cc',
         'system/dispatcher.h',
         'system/entrypoints.cc',
+        'system/handle_signals_state.h',
         'system/handle_table.cc',
         'system/handle_table.h',
         'system/local_data_pipe.cc',
@@ -220,7 +221,6 @@
         'system/simple_dispatcher.h',
         'system/transport_data.cc',
         'system/transport_data.h',
-        'system/wait_flags_state.h',
         'system/waiter.cc',
         'system/waiter.h',
         'system/waiter_list.cc',

mojo/public/c/system/types.h

@@ -165,13 +165,12 @@ const MojoHandleSignals MOJO_HANDLE_SIGNAL_WRITABLE = 1 << 1;
 // TODO(vtl): Add out parameters with this to MojoWait/MojoWaitMany.
 // Note: This struct is not extensible (and only has 32-bit quantities), so it's
 // 32-bit-aligned.
-// TODO(vtl): Rename this to MojoHandleSignalsState.
 MOJO_COMPILE_ASSERT(MOJO_ALIGNOF(int32_t) == 4, int32_t_has_weird_alignment);
-struct MOJO_ALIGNAS(4) MojoWaitFlagsState {
+struct MOJO_ALIGNAS(4) MojoHandleSignalsState {
   MojoHandleSignals satisfied_signals;
   MojoHandleSignals satisfiable_signals;
 };
-MOJO_COMPILE_ASSERT(sizeof(MojoWaitFlagsState) == 8,
-                    MojoWaitFlagsState_has_wrong_size);
+MOJO_COMPILE_ASSERT(sizeof(MojoHandleSignalsState) == 8,
+                    MojoHandleSignalsState_has_wrong_size);
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_TYPES_H_

mojo/public/js/bindings/support.js

@@ -10,7 +10,7 @@
 while (1);
 
 /*
- * Waits on the given handle until the state indicated by |waitFlags| is
+ * Waits on the given handle until the state indicated by |signals| is
  * satisfied.
  *
  * @param {MojoHandle} handle The handle to wait on.
@@ -21,7 +21,7 @@ while (1);
  * @return {MojoWaitId} A waitId that can be passed to cancelWait to cancel the
  * wait.
  */
-function asyncWait(handle, waitFlags, callback) { [native code] }
+function asyncWait(handle, signals, callback) { [native code] }
 
 /*
  * Cancels the asyncWait operation specified by the given |waitId|.

mojo/system/BUILD.gn

@@ -43,6 +43,7 @@ component("system") {
     "dispatcher.cc",
     "dispatcher.h",
     "entrypoints.cc",
+    "handle_signals_state.h",
     "handle_table.cc",
     "handle_table.h",
     "local_data_pipe.cc",
@@ -82,7 +83,6 @@ component("system") {
     "simple_dispatcher.h",
     "transport_data.cc",
     "transport_data.h",
-    "wait_flags_state.h",
     "waiter.cc",
     "waiter.h",
     "waiter_list.cc",

mojo/system/data_pipe.cc

@@ -90,7 +90,8 @@ void DataPipe::ProducerClose() {
       << "Producer closed with active two-phase write";
   producer_two_phase_max_num_bytes_written_ = 0;
   ProducerCloseImplNoLock();
-  AwakeConsumerWaitersForStateChangeNoLock(ConsumerGetWaitFlagsStateNoLock());
+  AwakeConsumerWaitersForStateChangeNoLock(
+      ConsumerGetHandleSignalsStateNoLock());
 }
 
 MojoResult DataPipe::ProducerWriteData(const void* elements,
@@ -111,9 +112,9 @@ MojoResult DataPipe::ProducerWriteData(const void* elements,
   if (*num_bytes == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
-  WaitFlagsState old_consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  HandleSignalsState old_consumer_state = ConsumerGetHandleSignalsStateNoLock();
   MojoResult rv = ProducerWriteDataImplNoLock(elements, num_bytes, all_or_none);
-  WaitFlagsState new_consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  HandleSignalsState new_consumer_state = ConsumerGetHandleSignalsStateNoLock();
   if (!new_consumer_state.equals(old_consumer_state))
     AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state);
   return rv;
@@ -154,7 +155,7 @@ MojoResult DataPipe::ProducerEndWriteData(uint32_t num_bytes_written) {
   // Note: Allow successful completion of the two-phase write even if the
   // consumer has been closed.
 
-  WaitFlagsState old_consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  HandleSignalsState old_consumer_state = ConsumerGetHandleSignalsStateNoLock();
   MojoResult rv;
   if (num_bytes_written > producer_two_phase_max_num_bytes_written_ ||
       num_bytes_written % element_num_bytes_ != 0) {
@@ -167,10 +168,10 @@ MojoResult DataPipe::ProducerEndWriteData(uint32_t num_bytes_written) {
   DCHECK(!producer_in_two_phase_write_no_lock());
   // 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();
+  HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateNoLock();
   if (new_producer_state.satisfies(MOJO_HANDLE_SIGNAL_WRITABLE))
     AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
-  WaitFlagsState new_consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  HandleSignalsState new_consumer_state = ConsumerGetHandleSignalsStateNoLock();
   if (!new_consumer_state.equals(old_consumer_state))
     AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state);
   return rv;
@@ -182,7 +183,7 @@ MojoResult DataPipe::ProducerAddWaiter(Waiter* waiter,
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
 
-  WaitFlagsState producer_state = ProducerGetWaitFlagsStateNoLock();
+  HandleSignalsState producer_state = ProducerGetHandleSignalsStateNoLock();
   if (producer_state.satisfies(signals))
     return MOJO_RESULT_ALREADY_EXISTS;
   if (!producer_state.can_satisfy(signals))
@@ -220,7 +221,8 @@ void DataPipe::ConsumerClose() {
       << "Consumer closed with active two-phase read";
   consumer_two_phase_max_num_bytes_read_ = 0;
   ConsumerCloseImplNoLock();
-  AwakeProducerWaitersForStateChangeNoLock(ProducerGetWaitFlagsStateNoLock());
+  AwakeProducerWaitersForStateChangeNoLock(
+      ProducerGetHandleSignalsStateNoLock());
 }
 
 MojoResult DataPipe::ConsumerReadData(void* elements,
@@ -238,9 +240,9 @@ MojoResult DataPipe::ConsumerReadData(void* elements,
   if (*num_bytes == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
-  WaitFlagsState old_producer_state = ProducerGetWaitFlagsStateNoLock();
+  HandleSignalsState old_producer_state = ProducerGetHandleSignalsStateNoLock();
   MojoResult rv = ConsumerReadDataImplNoLock(elements, num_bytes, all_or_none);
-  WaitFlagsState new_producer_state = ProducerGetWaitFlagsStateNoLock();
+  HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateNoLock();
   if (!new_producer_state.equals(old_producer_state))
     AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
   return rv;
@@ -260,9 +262,9 @@ MojoResult DataPipe::ConsumerDiscardData(uint32_t* num_bytes,
   if (*num_bytes == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
-  WaitFlagsState old_producer_state = ProducerGetWaitFlagsStateNoLock();
+  HandleSignalsState old_producer_state = ProducerGetHandleSignalsStateNoLock();
   MojoResult rv = ConsumerDiscardDataImplNoLock(num_bytes, all_or_none);
-  WaitFlagsState new_producer_state = ProducerGetWaitFlagsStateNoLock();
+  HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateNoLock();
   if (!new_producer_state.equals(old_producer_state))
     AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
   return rv;
@@ -306,7 +308,7 @@ MojoResult DataPipe::ConsumerEndReadData(uint32_t num_bytes_read) {
   if (!consumer_in_two_phase_read_no_lock())
     return MOJO_RESULT_FAILED_PRECONDITION;
 
-  WaitFlagsState old_producer_state = ProducerGetWaitFlagsStateNoLock();
+  HandleSignalsState old_producer_state = ProducerGetHandleSignalsStateNoLock();
   MojoResult rv;
   if (num_bytes_read > consumer_two_phase_max_num_bytes_read_ ||
       num_bytes_read % element_num_bytes_ != 0) {
@@ -319,10 +321,10 @@ MojoResult DataPipe::ConsumerEndReadData(uint32_t num_bytes_read) {
   DCHECK(!consumer_in_two_phase_read_no_lock());
   // 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();
+  HandleSignalsState new_consumer_state = ConsumerGetHandleSignalsStateNoLock();
   if (new_consumer_state.satisfies(MOJO_HANDLE_SIGNAL_READABLE))
     AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state);
-  WaitFlagsState new_producer_state = ProducerGetWaitFlagsStateNoLock();
+  HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateNoLock();
   if (!new_producer_state.equals(old_producer_state))
     AwakeProducerWaitersForStateChangeNoLock(new_producer_state);
   return rv;
@@ -334,7 +336,7 @@ MojoResult DataPipe::ConsumerAddWaiter(Waiter* waiter,
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
 
-  WaitFlagsState consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  HandleSignalsState consumer_state = ConsumerGetHandleSignalsStateNoLock();
   if (consumer_state.satisfies(signals))
     return MOJO_RESULT_ALREADY_EXISTS;
   if (!consumer_state.can_satisfy(signals))
@@ -382,7 +384,7 @@ DataPipe::~DataPipe() {
 }
 
 void DataPipe::AwakeProducerWaitersForStateChangeNoLock(
-    const WaitFlagsState& new_producer_state) {
+    const HandleSignalsState& new_producer_state) {
   lock_.AssertAcquired();
   if (!has_local_producer_no_lock())
     return;
@@ -390,7 +392,7 @@ void DataPipe::AwakeProducerWaitersForStateChangeNoLock(
 }
 
 void DataPipe::AwakeConsumerWaitersForStateChangeNoLock(
-    const WaitFlagsState& new_consumer_state) {
+    const HandleSignalsState& new_consumer_state) {
   lock_.AssertAcquired();
   if (!has_local_consumer_no_lock())
     return;

mojo/system/data_pipe.h

@@ -13,8 +13,8 @@
 #include "base/synchronization/lock.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/types.h"
+#include "mojo/system/handle_signals_state.h"
 #include "mojo/system/system_impl_export.h"
-#include "mojo/system/wait_flags_state.h"
 
 namespace mojo {
 namespace system {
@@ -108,7 +108,7 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe :
   virtual MojoResult ProducerEndWriteDataImplNoLock(
       uint32_t num_bytes_written) = 0;
   // Note: A producer should not be writable during a two-phase write.
-  virtual WaitFlagsState ProducerGetWaitFlagsStateNoLock() const = 0;
+  virtual HandleSignalsState ProducerGetHandleSignalsStateNoLock() const = 0;
 
   virtual void ConsumerCloseImplNoLock() = 0;
   // |*num_bytes| will be a nonzero multiple of |element_num_bytes_|.
@@ -124,7 +124,7 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe :
                                                      bool all_or_none) = 0;
   virtual MojoResult ConsumerEndReadDataImplNoLock(uint32_t num_bytes_read) = 0;
   // Note: A consumer should not be writable during a two-phase read.
-  virtual WaitFlagsState ConsumerGetWaitFlagsStateNoLock() const = 0;
+  virtual HandleSignalsState ConsumerGetHandleSignalsStateNoLock() const = 0;
 
   // Thread-safe and fast (they don't take the lock):
   bool may_discard() const { return may_discard_; }
@@ -168,9 +168,9 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe :
 
  private:
   void AwakeProducerWaitersForStateChangeNoLock(
-      const WaitFlagsState& new_producer_state);
+      const HandleSignalsState& new_producer_state);
   void AwakeConsumerWaitersForStateChangeNoLock(
-      const WaitFlagsState& new_consumer_state);
+      const HandleSignalsState& new_consumer_state);
 
   bool has_local_producer_no_lock() const {
     lock_.AssertAcquired();

mojo/system/wait_flags_state.h → mojo/system/handle_signals_state.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef MOJO_SYSTEM_WAIT_FLAGS_STATE_H_
-#define MOJO_SYSTEM_WAIT_FLAGS_STATE_H_
+#ifndef MOJO_SYSTEM_HANDLE_SIGNALS_STATE_H_
+#define MOJO_SYSTEM_HANDLE_SIGNALS_STATE_H_
 
 #include "base/macros.h"
 #include "mojo/public/c/system/types.h"
@@ -12,19 +12,21 @@
 namespace mojo {
 namespace system {
 
-// Just "add" some constructors and methods to the C struct |MojoWaitFlagsState|
-// (for convenience). This should add no overhead.
-struct MOJO_SYSTEM_IMPL_EXPORT WaitFlagsState : public MojoWaitFlagsState {
-  WaitFlagsState() {
+// Just "add" some constructors and methods to the C struct
+// |MojoHandleSignalsState| (for convenience). This should add no overhead.
+struct MOJO_SYSTEM_IMPL_EXPORT HandleSignalsState
+    : public MojoHandleSignalsState {
+  HandleSignalsState() {
     satisfied_signals = MOJO_HANDLE_SIGNAL_NONE;
     satisfiable_signals = MOJO_HANDLE_SIGNAL_NONE;
   }
-  WaitFlagsState(MojoHandleSignals satisfied, MojoHandleSignals satisfiable) {
+  HandleSignalsState(MojoHandleSignals satisfied,
+                     MojoHandleSignals satisfiable) {
     satisfied_signals = satisfied;
     satisfiable_signals = satisfiable;
   }
 
-  bool equals(const WaitFlagsState& other) const {
+  bool equals(const HandleSignalsState& other) const {
     return satisfied_signals == other.satisfied_signals &&
            satisfiable_signals == other.satisfiable_signals;
   }
@@ -39,10 +41,10 @@ struct MOJO_SYSTEM_IMPL_EXPORT WaitFlagsState : public MojoWaitFlagsState {
 
   // (Copy and assignment allowed.)
 };
-COMPILE_ASSERT(sizeof(WaitFlagsState) == sizeof(MojoWaitFlagsState),
-               WaitFlagsState_should_add_no_overhead);
+COMPILE_ASSERT(sizeof(HandleSignalsState) == sizeof(MojoHandleSignalsState),
+               HandleSignalsState_should_add_no_overhead);
 
 }  // namespace system
 }  // namespace mojo
 
-#endif  // MOJO_SYSTEM_WAIT_FLAGS_STATE_H_
+#endif  // MOJO_SYSTEM_HANDLE_SIGNALS_STATE_H_

mojo/system/local_data_pipe.cc

@@ -151,8 +151,8 @@ MojoResult LocalDataPipe::ProducerEndWriteDataImplNoLock(
   return MOJO_RESULT_OK;
 }
 
-WaitFlagsState LocalDataPipe::ProducerGetWaitFlagsStateNoLock() const {
-  WaitFlagsState rv;
+HandleSignalsState LocalDataPipe::ProducerGetHandleSignalsStateNoLock() const {
+  HandleSignalsState rv;
   if (consumer_open_no_lock()) {
     if ((may_discard() || current_num_bytes_ < capacity_num_bytes()) &&
         !producer_in_two_phase_write_no_lock())
@@ -273,8 +273,8 @@ MojoResult LocalDataPipe::ConsumerEndReadDataImplNoLock(
   return MOJO_RESULT_OK;
 }
 
-WaitFlagsState LocalDataPipe::ConsumerGetWaitFlagsStateNoLock() const {
-  WaitFlagsState rv;
+HandleSignalsState LocalDataPipe::ConsumerGetHandleSignalsStateNoLock() const {
+  HandleSignalsState rv;
   if (current_num_bytes_ > 0) {
     if (!consumer_in_two_phase_read_no_lock())
       rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_READABLE;

mojo/system/local_data_pipe.h

@@ -40,7 +40,8 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalDataPipe : public DataPipe {
       bool all_or_none) OVERRIDE;
   virtual MojoResult ProducerEndWriteDataImplNoLock(
       uint32_t num_bytes_written) OVERRIDE;
-  virtual WaitFlagsState ProducerGetWaitFlagsStateNoLock() const OVERRIDE;
+  virtual HandleSignalsState
+      ProducerGetHandleSignalsStateNoLock() const OVERRIDE;
   virtual void ConsumerCloseImplNoLock() OVERRIDE;
   virtual MojoResult ConsumerReadDataImplNoLock(void* elements,
                                                 uint32_t* num_bytes,
@@ -53,7 +54,8 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalDataPipe : public DataPipe {
                                                      bool all_or_none) OVERRIDE;
   virtual MojoResult ConsumerEndReadDataImplNoLock(
       uint32_t num_bytes_read) OVERRIDE;
-  virtual WaitFlagsState ConsumerGetWaitFlagsStateNoLock() const OVERRIDE;
+  virtual HandleSignalsState
+      ConsumerGetHandleSignalsStateNoLock() const OVERRIDE;
 
   void EnsureBufferNoLock();
   void DestroyBufferNoLock();

mojo/system/local_message_pipe_endpoint.cc

@@ -31,9 +31,9 @@ bool LocalMessagePipeEndpoint::OnPeerClose() {
   DCHECK(is_open_);
   DCHECK(is_peer_open_);
 
-  WaitFlagsState old_state = GetWaitFlagsState();
+  HandleSignalsState old_state = GetHandleSignalsState();
   is_peer_open_ = false;
-  WaitFlagsState new_state = GetWaitFlagsState();
+  HandleSignalsState new_state = GetHandleSignalsState();
 
   if (!new_state.equals(old_state))
     waiter_list_.AwakeWaitersForStateChange(new_state);
@@ -49,7 +49,7 @@ void LocalMessagePipeEndpoint::EnqueueMessage(
   bool was_empty = message_queue_.IsEmpty();
   message_queue_.AddMessage(message.Pass());
   if (was_empty)
-    waiter_list_.AwakeWaitersForStateChange(GetWaitFlagsState());
+    waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsState());
 }
 
 void LocalMessagePipeEndpoint::Close() {
@@ -117,7 +117,7 @@ MojoResult LocalMessagePipeEndpoint::ReadMessage(void* bytes,
     if (message_queue_.IsEmpty()) {
       // It's currently not possible to wait for non-readability, but we should
       // do the state change anyway.
-      waiter_list_.AwakeWaitersForStateChange(GetWaitFlagsState());
+      waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsState());
     }
   }
 
@@ -132,7 +132,7 @@ MojoResult LocalMessagePipeEndpoint::AddWaiter(Waiter* waiter,
                                                uint32_t context) {
   DCHECK(is_open_);
 
-  WaitFlagsState state = GetWaitFlagsState();
+  HandleSignalsState state = GetHandleSignalsState();
   if (state.satisfies(signals))
     return MOJO_RESULT_ALREADY_EXISTS;
   if (!state.can_satisfy(signals))
@@ -147,8 +147,8 @@ void LocalMessagePipeEndpoint::RemoveWaiter(Waiter* waiter) {
   waiter_list_.RemoveWaiter(waiter);
 }
 
-WaitFlagsState LocalMessagePipeEndpoint::GetWaitFlagsState() {
-  WaitFlagsState rv;
+HandleSignalsState LocalMessagePipeEndpoint::GetHandleSignalsState() {
+  HandleSignalsState rv;
   if (!message_queue_.IsEmpty()) {
     rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_READABLE;
     rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_READABLE;

mojo/system/local_message_pipe_endpoint.h

@@ -7,10 +7,10 @@
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "mojo/system/handle_signals_state.h"
 #include "mojo/system/message_in_transit_queue.h"
 #include "mojo/system/message_pipe_endpoint.h"
 #include "mojo/system/system_impl_export.h"
-#include "mojo/system/wait_flags_state.h"
 #include "mojo/system/waiter_list.h"
 
 namespace mojo {
@@ -45,7 +45,7 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalMessagePipeEndpoint
   MessageInTransitQueue* message_queue() { return &message_queue_; }
 
  private:
-  WaitFlagsState GetWaitFlagsState();
+  HandleSignalsState GetHandleSignalsState();
 
   bool is_open_;
   bool is_peer_open_;

mojo/system/platform_handle_dispatcher.cc

@@ -114,8 +114,9 @@ bool PlatformHandleDispatcher::EndSerializeAndCloseImplNoLock(
   return true;
 }
 
-WaitFlagsState PlatformHandleDispatcher::GetWaitFlagsStateNoLock() const {
-  return WaitFlagsState();
+HandleSignalsState
+    PlatformHandleDispatcher::GetHandleSignalsStateNoLock() const {
+  return HandleSignalsState();
 }
 
 }  // namespace system

mojo/system/platform_handle_dispatcher.h

@@ -51,7 +51,7 @@ class MOJO_SYSTEM_IMPL_EXPORT PlatformHandleDispatcher
       embedder::PlatformHandleVector* platform_handles) OVERRIDE;
 
   // |SimpleDispatcher| method:
-  virtual WaitFlagsState GetWaitFlagsStateNoLock() const OVERRIDE;
+  virtual HandleSignalsState GetHandleSignalsStateNoLock() const OVERRIDE;
 
   embedder::ScopedPlatformHandle platform_handle_;
 

mojo/system/shared_buffer_dispatcher.cc

@@ -263,9 +263,9 @@ bool SharedBufferDispatcher::EndSerializeAndCloseImplNoLock(
   return true;
 }
 
-WaitFlagsState SharedBufferDispatcher::GetWaitFlagsStateNoLock() const {
+HandleSignalsState SharedBufferDispatcher::GetHandleSignalsStateNoLock() const {
   // TODO(vtl): Add transferrable flag.
-  return WaitFlagsState();
+  return HandleSignalsState();
 }
 
 }  // namespace system

mojo/system/shared_buffer_dispatcher.h

@@ -85,7 +85,7 @@ class MOJO_SYSTEM_IMPL_EXPORT SharedBufferDispatcher : public SimpleDispatcher {
       embedder::PlatformHandleVector* platform_handles) OVERRIDE;
 
   // |SimpleDispatcher| method:
-  virtual WaitFlagsState GetWaitFlagsStateNoLock() const OVERRIDE;
+  virtual HandleSignalsState GetHandleSignalsStateNoLock() const OVERRIDE;
 
   scoped_refptr<RawSharedBuffer> shared_buffer_;
 

mojo/system/simple_dispatcher.cc

@@ -15,9 +15,9 @@ SimpleDispatcher::SimpleDispatcher() {
 SimpleDispatcher::~SimpleDispatcher() {
 }
 
-void SimpleDispatcher::WaitFlagsStateChangedNoLock() {
+void SimpleDispatcher::HandleSignalsStateChangedNoLock() {
   lock().AssertAcquired();
-  waiter_list_.AwakeWaitersForStateChange(GetWaitFlagsStateNoLock());
+  waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsStateNoLock());
 }
 
 void SimpleDispatcher::CancelAllWaitersNoLock() {
@@ -30,7 +30,7 @@ MojoResult SimpleDispatcher::AddWaiterImplNoLock(Waiter* waiter,
                                                  uint32_t context) {
   lock().AssertAcquired();
 
-  WaitFlagsState state(GetWaitFlagsStateNoLock());
+  HandleSignalsState state(GetHandleSignalsStateNoLock());
   if (state.satisfies(signals))
     return MOJO_RESULT_ALREADY_EXISTS;
   if (!state.can_satisfy(signals))

mojo/system/simple_dispatcher.h

@@ -9,8 +9,8 @@
 
 #include "base/basictypes.h"
 #include "mojo/system/dispatcher.h"
+#include "mojo/system/handle_signals_state.h"
 #include "mojo/system/system_impl_export.h"
-#include "mojo/system/wait_flags_state.h"
 #include "mojo/system/waiter_list.h"
 
 namespace mojo {
@@ -26,12 +26,12 @@ class MOJO_SYSTEM_IMPL_EXPORT SimpleDispatcher : public Dispatcher {
   virtual ~SimpleDispatcher();
 
   // To be called by subclasses when the state changes (so
-  // |GetWaitFlagsStateNoLock()| should be checked again). Must be called under
-  // lock.
-  void WaitFlagsStateChangedNoLock();
+  // |GetHandleSignalsStateNoLock()| should be checked again). Must be called
+  // under lock.
+  void HandleSignalsStateChangedNoLock();
 
   // Never called after the dispatcher has been closed; called under |lock_|.
-  virtual WaitFlagsState GetWaitFlagsStateNoLock() const = 0;
+  virtual HandleSignalsState GetHandleSignalsStateNoLock() const = 0;
 
   // |Dispatcher| protected methods:
   virtual void CancelAllWaitersNoLock() OVERRIDE;

mojo/system/simple_dispatcher_unittest.cc

@@ -43,7 +43,7 @@ class MockSimpleDispatcher : public SimpleDispatcher {
       return;
 
     state_.satisfied_signals = new_satisfied_signals;
-    WaitFlagsStateChangedNoLock();
+    HandleSignalsStateChangedNoLock();
   }
 
   void SetSatisfiableSignals(MojoHandleSignals new_satisfiable_signals) {
@@ -57,7 +57,7 @@ class MockSimpleDispatcher : public SimpleDispatcher {
       return;
 
     state_.satisfiable_signals = new_satisfiable_signals;
-    WaitFlagsStateChangedNoLock();
+    HandleSignalsStateChangedNoLock();
   }
 
   virtual Type GetType() const OVERRIDE {
@@ -76,13 +76,13 @@ class MockSimpleDispatcher : public SimpleDispatcher {
   }
 
   // |SimpleDispatcher| implementation:
-  virtual WaitFlagsState GetWaitFlagsStateNoLock() const OVERRIDE {
+  virtual HandleSignalsState GetHandleSignalsStateNoLock() const OVERRIDE {
     lock().AssertAcquired();
     return state_;
   }
 
   // Protected by |lock()|:
-  WaitFlagsState state_;
+  HandleSignalsState state_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSimpleDispatcher);
 };

mojo/system/waiter_list.cc

@@ -5,7 +5,7 @@
 #include "mojo/system/waiter_list.h"
 
 #include "base/logging.h"
-#include "mojo/system/wait_flags_state.h"
+#include "mojo/system/handle_signals_state.h"
 #include "mojo/system/waiter.h"
 
 namespace mojo {
@@ -18,7 +18,7 @@ WaiterList::~WaiterList() {
   DCHECK(waiters_.empty());
 }
 
-void WaiterList::AwakeWaitersForStateChange(const WaitFlagsState& state) {
+void WaiterList::AwakeWaitersForStateChange(const HandleSignalsState& state) {
   for (WaiterInfoList::iterator it = waiters_.begin(); it != waiters_.end();
        ++it) {
     if (state.satisfies(it->signals))

mojo/system/waiter_list.h

@@ -17,7 +17,7 @@ namespace mojo {
 namespace system {
 
 class Waiter;
-struct WaitFlagsState;
+struct HandleSignalsState;
 
 // |WaiterList| tracks all the |Waiter|s that are waiting on a given
 // handle/|Dispatcher|. There should be a |WaiterList| for each handle that can
@@ -31,7 +31,7 @@ class MOJO_SYSTEM_IMPL_EXPORT WaiterList {
   WaiterList();
   ~WaiterList();
 
-  void AwakeWaitersForStateChange(const WaitFlagsState& state);
+  void AwakeWaitersForStateChange(const HandleSignalsState& state);
   void CancelAllWaiters();
   void AddWaiter(Waiter* waiter, MojoHandleSignals signals, uint32_t context);
   void RemoveWaiter(Waiter* waiter);

mojo/system/waiter_list_unittest.cc

@@ -11,8 +11,8 @@
 
 #include "base/threading/platform_thread.h"  // For |Sleep()|.
 #include "base/time/time.h"
+#include "mojo/system/handle_signals_state.h"
 #include "mojo/system/test_utils.h"
-#include "mojo/system/wait_flags_state.h"
 #include "mojo/system/waiter.h"
 #include "mojo/system/waiter_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -72,9 +72,9 @@ TEST(WaiterListTest, BasicAwakeSatisfied) {
     waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread.Start();
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_HANDLE_SIGNAL_READABLE |
-                           MOJO_HANDLE_SIGNAL_WRITABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE,
+                           MOJO_HANDLE_SIGNAL_READABLE |
+                               MOJO_HANDLE_SIGNAL_WRITABLE));
     waiter_list.RemoveWaiter(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_OK, result);
@@ -86,9 +86,9 @@ TEST(WaiterListTest, BasicAwakeSatisfied) {
     test::SimpleWaiterThread thread(&result, &context);
     waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_WRITABLE,
-                       MOJO_HANDLE_SIGNAL_READABLE |
-                           MOJO_HANDLE_SIGNAL_WRITABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_WRITABLE,
+                           MOJO_HANDLE_SIGNAL_READABLE |
+                               MOJO_HANDLE_SIGNAL_WRITABLE));
     waiter_list.RemoveWaiter(thread.waiter());
     waiter_list.RemoveWaiter(thread.waiter());  // Double-remove okay.
     thread.Start();
@@ -104,9 +104,9 @@ TEST(WaiterListTest, BasicAwakeSatisfied) {
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_HANDLE_SIGNAL_READABLE |
-                           MOJO_HANDLE_SIGNAL_WRITABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE,
+                           MOJO_HANDLE_SIGNAL_READABLE |
+                               MOJO_HANDLE_SIGNAL_WRITABLE));
     waiter_list.RemoveWaiter(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_OK, result);
@@ -124,7 +124,8 @@ TEST(WaiterListTest, BasicAwakeUnsatisfiable) {
     waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1);
     thread.Start();
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_HANDLE_SIGNAL_WRITABLE));
     waiter_list.RemoveWaiter(thread.waiter());
   }  // Join |thread|.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
@@ -136,8 +137,8 @@ TEST(WaiterListTest, BasicAwakeUnsatisfiable) {
     test::SimpleWaiterThread thread(&result, &context);
     waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2);
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_HANDLE_SIGNAL_READABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE,
+                           MOJO_HANDLE_SIGNAL_READABLE));
     waiter_list.RemoveWaiter(thread.waiter());
     thread.Start();
   }  // Join |thread|.
@@ -152,7 +153,8 @@ TEST(WaiterListTest, BasicAwakeUnsatisfiable) {
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_HANDLE_SIGNAL_WRITABLE));
     waiter_list.RemoveWaiter(thread.waiter());
     waiter_list.RemoveWaiter(thread.waiter());  // Double-remove okay.
   }  // Join |thread|.
@@ -198,9 +200,9 @@ TEST(WaiterListTest, MultipleWaiters) {
     thread2.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_HANDLE_SIGNAL_READABLE |
-                           MOJO_HANDLE_SIGNAL_WRITABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE,
+                           MOJO_HANDLE_SIGNAL_READABLE |
+                               MOJO_HANDLE_SIGNAL_WRITABLE));
     waiter_list.RemoveWaiter(thread1.waiter());
     waiter_list.CancelAllWaiters();
   }  // Join threads.
@@ -220,7 +222,8 @@ TEST(WaiterListTest, MultipleWaiters) {
     thread2.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_HANDLE_SIGNAL_READABLE));
     waiter_list.RemoveWaiter(thread2.waiter());
     waiter_list.CancelAllWaiters();
   }  // Join threads.
@@ -240,9 +243,9 @@ TEST(WaiterListTest, MultipleWaiters) {
 
     // Should do nothing.
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_NONE,
-                       MOJO_HANDLE_SIGNAL_READABLE |
-                           MOJO_HANDLE_SIGNAL_WRITABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_HANDLE_SIGNAL_READABLE |
+                               MOJO_HANDLE_SIGNAL_WRITABLE));
 
     test::SimpleWaiterThread thread2(&result2, &context2);
     waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 8);
@@ -252,9 +255,9 @@ TEST(WaiterListTest, MultipleWaiters) {
 
     // Awake #1.
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_READABLE,
-                       MOJO_HANDLE_SIGNAL_READABLE |
-                           MOJO_HANDLE_SIGNAL_WRITABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE,
+                           MOJO_HANDLE_SIGNAL_READABLE |
+                               MOJO_HANDLE_SIGNAL_WRITABLE));
     waiter_list.RemoveWaiter(thread1.waiter());
 
     base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
@@ -271,7 +274,8 @@ TEST(WaiterListTest, MultipleWaiters) {
 
     // Awake #2 and #3 for unsatisfiability.
     waiter_list.AwakeWaitersForStateChange(
-        WaitFlagsState(MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE));
+        HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_HANDLE_SIGNAL_READABLE));
     waiter_list.RemoveWaiter(thread2.waiter());
     waiter_list.RemoveWaiter(thread3.waiter());