Implement WaitSetDispatcher::WaitSetWaitImpl().

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 42 matching lines @@
 MOJO_STATIC_ASSERT(sizeof(struct MojoWaitSetAddOptions) == 8,
                    "MojoWaitSetAddOptions has wrong size");
 
 // |MojoWaitSetResult|: Returned by |MojoWaitSetWait()| to indicate the state of
 // entries. See |MojoWaitSetWait()| for the values of these fields.
 
 struct MOJO_ALIGNAS(8) MojoWaitSetResult {
   uint64_t cookie;
   MojoResult wait_result;
   uint32_t reserved;
-  MojoHandleSignals satisfied_signals;
-  MojoHandleSignals satisfiable_signals;
+  struct MojoHandleSignalsState signals_state;
 };
 MOJO_STATIC_ASSERT(sizeof(struct MojoWaitSetResult) == 24,
                    "MojoWaitSetResult has wrong size");
 
 MOJO_BEGIN_EXTERN_C
 
 // |MojoCreateWaitSet()|: Creates a new wait set.
 //
 // A wait set is an object that can be used to wait for a set of handles to
 // satisfy some set of signals simultaneously.
@@ skipping 74 matching lines @@
 //         or more of the signals in the entry
 //     - |MOJO_RESULT_CANCELLED| if the handle referred to by the entry was
 //         closed
 //     - |MOJO_RESULT_BUSY| if the handle referred to by the entry is currently
 //         in use in some transaction
 //     - |MOJO_RESULT_FAILED_PRECONDITION| if it becomes impossible that the
 //         handle referred to by the entry will ever satisfy any of entry's
 //         signals
 //   - |reserved| is set to 0
 //
-//   When the |wait_result| is |MOJO_RESULT_OK| or
-//   |MOJO_RESULT_FAILED_PRECONDITION| the |satisfied_signals| and
-//   |satisfiable_signals| entries are set to the signals the handle currently
-//   satisfies and could possibly satisfy. When the |wait_result| is any other
-//   value the |satisfied_signals| and |satisfiable_signals| entries are set to
-//   |MOJO_HANDLE_SIGNALS_NONE|.
+//   When |wait_result| is |MOJO_RESULT_OK| or |MOJO_RESULT_FAILED_PRECONDITION|
+//   |signals_state| is set to the handle's current signal state; otherwise, it
+//   is set to a zeroed |MojoHandleSignalsState| (in particular, both fields
+//   will then be |MOJO_HANDLE_SIGNALS_NONE|).
 //
 // On any result other than |MOJO_RESULT_OK|, |*num_results|, |*results| and
 // |*max_results| are not modified.
 //
 // Returns:
 //   |MOJO_RESULT_OK| if one or more entries in the wait set become satisfied or
 //       unsatisfiable.
 //   |MOJO_RESULT_INVALID_ARGUMENT| if |wait_set_handle| does not refer to a
 //       valid wait set handle.
 //   |MOJO_RESULT_CANCELLED| if |wait_set_handle| is closed during the wait.
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if a system/quota/etc. limit was reached.
 //   |MOJO_RESULT_BUSY| if |wait_set_handle| is in use in some transaction. Note
 //       that waiting on a wait set handle does not count as a transaction. It
 //       is valid to call |MojoWaitSetWait()| on the same wait set handle
 //       concurrently from different threads.
 //   |MOJO_RESULT_DEADLINE_EXCEEDED| if the deadline is passed without any
 //       entries in the wait set becoming satisfied or unsatisfiable.
 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_