Mojo: Move waiting APIs to public library

mojo/public/c/system/types.h

 // Copyright 2014 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 contains types and constants/macros common to different Mojo system
 // APIs.
 //
 // Note: This header should be compilable as C.
 
 #ifndef MOJO_PUBLIC_C_SYSTEM_TYPES_H_
@@ skipping 62 matching lines @@
 //   |MOJO_RESULT_UNAVAILABLE| - The operation is (temporarily) currently
 //       unavailable. The caller may simply retry the operation (possibly with a
 //       backoff).
 //   |MOJO_RESULT_DATA_LOSS| - Unrecoverable data loss or corruption.
 //   |MOJO_RESULT_BUSY| - One of the resources involved is currently being used
 //       (possibly on another thread) in a way that prevents the current
 //       operation from proceeding, e.g., if the other operation may result in
 //       the resource being invalidated.
 //   |MOJO_RESULT_SHOULD_WAIT| - The request cannot currently be completed
 //       (e.g., if the data requested is not yet available). The caller should
-//       wait for it to be feasible using |MojoWait()| or |MojoWaitMany()|.
+//       wait for it to be feasible using a watcher.
 //
 // The codes from |MOJO_RESULT_OK| to |MOJO_RESULT_DATA_LOSS| come from
 // Google3's canonical error codes.
 //
 // TODO(vtl): Add a |MOJO_RESULT_UNSATISFIABLE|?
 
 typedef uint32_t MojoResult;
 
 #ifdef __cplusplus
 const MojoResult MOJO_RESULT_OK = 0;
@@ skipping 40 matching lines @@
 //   |MOJO_DEADLINE_INDEFINITE| - Used to indicate "forever".
 
 typedef uint64_t MojoDeadline;
 
 #ifdef __cplusplus
 const MojoDeadline MOJO_DEADLINE_INDEFINITE = static_cast<MojoDeadline>(-1);
 #else
 #define MOJO_DEADLINE_INDEFINITE ((MojoDeadline) - 1)
 #endif
 
-// |MojoHandleSignals|: Used to specify signals that can be waited on for a
+// |MojoHandleSignals|: Used to specify signals that can be watched for on a
 // handle (and which can be triggered), e.g., the ability to read or write to
 // the handle.
-//   |MOJO_HANDLE_SIGNAL_NONE| - No flags. |MojoWait()|, etc. will return
-//       |MOJO_RESULT_FAILED_PRECONDITION| if you attempt to wait on this.
+//   |MOJO_HANDLE_SIGNAL_NONE| - No flags. A registered watch will always fail
+//       to arm with |MOJO_RESULT_FAILED_PRECONDITION| when watching for this.
 //   |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.
 //   |MOJO_HANDLE_SIGNAL_PEER_CLOSED| - The peer handle is closed.
 //   |MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE| - Can read data from a data pipe
 //       consumer handle (implying MOJO_HANDLE_SIGNAL_READABLE is also set),
 //       AND there is some nonzero quantity of new data available on the pipe
 //       since the last |MojoReadData()| or |MojoBeginReadData()| call on the
 //       handle.
 
 typedef uint32_t MojoHandleSignals;
 
 #ifdef __cplusplus
 const MojoHandleSignals MOJO_HANDLE_SIGNAL_NONE = 0;
 const MojoHandleSignals MOJO_HANDLE_SIGNAL_READABLE = 1 << 0;
 const MojoHandleSignals MOJO_HANDLE_SIGNAL_WRITABLE = 1 << 1;
 const MojoHandleSignals MOJO_HANDLE_SIGNAL_PEER_CLOSED = 1 << 2;
 const MojoHandleSignals MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE = 1 << 3;
 #else
 #define MOJO_HANDLE_SIGNAL_NONE ((MojoHandleSignals)0)
 #define MOJO_HANDLE_SIGNAL_READABLE ((MojoHandleSignals)1 << 0)
 #define MOJO_HANDLE_SIGNAL_WRITABLE ((MojoHandleSignals)1 << 1)
 #define MOJO_HANDLE_SIGNAL_PEER_CLOSED ((MojoHandleSignals)1 << 2)
 #define MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE ((MojoHandleSignals)1 << 3);
 #endif
 
-// |MojoHandleSignalsState|: Returned by wait functions to indicate the
-// signaling state of handles. Members are as follows:
+// |MojoHandleSignalsState|: Returned by watch notification callbacks and
+// |MojoQueryHandleSignalsState| functions to indicate the signaling state of
+// handles. Members are as follows:
 //   - |satisfied signals|: Bitmask of signals that were satisfied at some time
 //         before the call returned.
 //   - |satisfiable signals|: These are the signals that are possible to
 //         satisfy. For example, if the return value was
 //         |MOJO_RESULT_FAILED_PRECONDITION|, you can use this field to
 //         determine which, if any, of the signals can still be satisfied.
 // Note: This struct is not extensible (and only has 32-bit quantities), so it's
 // 32-bit-aligned.
 MOJO_STATIC_ASSERT(MOJO_ALIGNOF(int32_t) == 4, "int32_t has weird alignment");
 struct MOJO_ALIGNAS(4) MojoHandleSignalsState {
@@ skipping 32 matching lines @@
 //       users should refrain from making sync calls.
 typedef uint32_t MojoPropertyType;
 
 #ifdef __cplusplus
 const MojoPropertyType MOJO_PROPERTY_TYPE_SYNC_CALL_ALLOWED = 0;
 #else
 #define MOJO_PROPERTY_TYPE_SYNC_CALL_ALLOWED ((MojoPropertyType)0)
 #endif
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_TYPES_H_