Add Dispatcher methods for wait sets.

mojo/public/c/system/wait_set.h

 // Copyright 2016 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 functions for waiting on multiple handles using wait sets.
 //
 // Note: This header should be compilable as C.
 
 #ifndef MOJO_PUBLIC_C_SYSTEM_WAIT_SET_H_
 #define MOJO_PUBLIC_C_SYSTEM_WAIT_SET_H_
@@ skipping 23 matching lines @@
 
 // |MojoWaitSetAddOptions|: Used to specify parameters in adding an entry to a
 // wait set with |MojoWaitSetAdd()|.
 //   |uint32_t struct_size|: Set to the size of the |MojoWaitSetAddOptions|
 //       struct. (Used to allow for future extensions.)
 //   |MojoWaitSetAddOptionsFlags flags|: Reserved for future use.
 //       |MOJO_WAIT_SET_ADD_OPTIONS_FLAGS_NONE|: No flags, default mode.
 
 typedef uint32_t MojoWaitSetAddOptionsFlags;
 
+#define MOJO_CREATE_WAIT_SET_OPTIONS_FLAG_NONE \
+  ((MojoCreateWaitSetOptionsFlags)0)
+
 struct MOJO_ALIGNAS(8) MojoWaitSetAddOptions {
   uint32_t struct_size;
   MojoWaitSetAddOptionsFlags flags;
 };
 MOJO_STATIC_ASSERT(sizeof(MojoWaitSetAddOptions) == 8,
                    "MojoWaitSetAddOptions has wrong size");
 
 // |MojoWaitSetResult|: Returned by |MojoWaitSetWait()| to indicate the state of
 // entries. See |MojoWaitSetWait()| for the values of these fields.
 
@@ skipping 20 matching lines @@
 //   |MOJO_RESULT_OK| if a wait set was successfully created. On success,
 //       |*handle| will be the handle of the wait set.
 //   |MOJO_RESULT_INVALID_ARGUMENT| if some argument was invalid (e.g.,
 //       |options| is non null and |*options| is invalid).
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if a process/system/quota/etc. limit has
 //       been reached.
 MojoResult MojoCreateWaitSet(const struct MojoCreateWaitSetOptions*
                                  MOJO_RESTRICT options,  // Optional in.
                              MojoHandle* handle);        // Out.
 
-// |MojoWaitSetAdd()|: Adds an entry to watch for to the wait set.
+// |MojoWaitSetAdd()|: Adds an entry to watch for to the wait set specified by
+// |wait_set_handle| (which must have the |MOJO_HANDLE_RIGHT_WRITE| right).
 //
 // An entry in a wait set is composed of a handle, a signal set, and a
 // caller-specified cookie value. The cookie value must be unique across all
 // entries in a particular wait set but is otherwise opaque and can be any value
 // that is useful to the caller. If |options| is null the default options will
 // be used.
 //
 // In all failure cases the wait set is unchanged.
 //
 // Returns:
 //   |MOJO_RESULT_OK| if the handle was added to the wait set.
 //   |MOJO_RESULT_INVALID_ARGUMENT| if |wait_set_handle| or |handle| do not
 //       refer to valid handles, |wait_set_handle| is not a handle to a wait
 //       set, |cookie| is not a unique value within this wait set, or |options|
 //       is not null and |*options| is not a valid options structure.
 //   |MOJO_RESULT_BUSY| if |wait_set_handle| or |handle| are currently in use in
 //       some transaction.
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if the handle could not be added due to
 //       hitting a system or quota limitation.
 MojoResult MojoWaitSetAdd(const struct MojoWaitSetAddOptions* MOJO_RESTRICT
                               options,                 // Optional in.
                           MojoHandle wait_set_handle,  // In.
                           MojoHandle handle,           // In.
                           MojoHandleSignals signals,   // In.
                           uint64_t cookie);            // In.
 
-// |MojoWaitSetRemove()|: Removes an entry from the wait set.
+// |MojoWaitSetRemove()|: Removes an entry from the wait set specified by
+// |wait_set_handle| (which must have the |MOJO_HANDLE_RIGHT_WRITE| right).
 //
 // Returns:
 //   |MOJO_RESULT_OK| if the entry was successfully removed.
 //   |MOJO_RESULT_INVALID_ARGUMENT| if |wait_set_handle| does not refer to a
 //       valid wait set or if |cookie| does not identify an entry within the
 //       wait set.
 MojoResult MojoWaitSetRemove(MojoHandle wait_set_handle,  // In.
                              uint64_t cookie);            // In.
 
-// |MojoWaitSetWait()|: Waits on all entries in the wait set for at least one of
-// the following:
+// |MojoWaitSetWait()|: Waits on all entries in the wait set specified by
+// |wait_set_handle| (which must have the |MOJO_HANDLE_RIGHT_READ| right) for at
+// least one of the following:
 //   - At least one entry's handle satisfies a signal in that entry's signal
 //     set.
 //   - At least one entry's handle can never satisfy a signal in that entry's
 //     signal set.
 //   - |deadline| expires.
 //   - The wait set is closed.
 //
 // On success, sets |*max_results| to the total number of possible results at
 // the time of the call. Also returns information for up to |*num_results|
 // entries in |*results| and sets |*num_results| to the number of entries the
@@ skipping 38 matching lines @@
 MojoResult MojoWaitSetWait(
     MojoHandle wait_set_handle,                       // In.
     MojoDeadline deadline,                            // In.
     uint32_t* MOJO_RESTRICT num_results,              // In/out.
     struct MojoWaitSetResult* MOJO_RESTRICT results,  // Out.
     uint32_t* MOJO_RESTRICT max_results);             // Optional out.
 
 MOJO_END_EXTERN_C
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_WAIT_SET_H_