Update comments in system headers to include MOJO_RESULT_BUSY behavior.

mojo/public/c/system/wait.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 basic functions common to different Mojo system APIs.
 //
 // Note: This header should be compilable as C.
 
 #ifndef MOJO_PUBLIC_C_SYSTEM_WAIT_H_
 #define MOJO_PUBLIC_C_SYSTEM_WAIT_H_
@@ skipping 25 matching lines @@
 //       satisfied).
 //   |MOJO_RESULT_CANCELLED| if |handle| was closed (necessarily from another
 //       thread) during the wait.
 //   |MOJO_RESULT_INVALID_ARGUMENT| if |handle| is not a valid handle (e.g., if
 //       it has already been closed). The |signals_state| value is unchanged.
 //   |MOJO_RESULT_DEADLINE_EXCEEDED| if the deadline has passed without any of
 //       the signals being satisfied.
 //   |MOJO_RESULT_FAILED_PRECONDITION| if it becomes known that none of the
 //       signals in |signals| can ever be satisfied (e.g., when waiting on one
 //       end of a message pipe and the other end is closed).
+//   |MOJO_RESULT_BUSY| if |handle| is currently in use in some transaction
+//       (that, e.g., may result in it being invalidated, such as being sent in
+//       a message).
 //
 // If there are multiple waiters (on different threads, obviously) waiting on
 // the same handle and signal, and that signal becomes satisfied, all waiters
 // will be awoken.
 MojoResult MojoWait(
     MojoHandle handle,                              // In.
     MojoHandleSignals signals,                      // In.
     MojoDeadline deadline,                          // In.
     struct MojoHandleSignalsState* signals_state);  // Optional out.
 
@@ skipping 29 matching lines @@
 //       another thread) during the wait.
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if there are too many handles. The
 //       |signals_state| array is unchanged.
 //   |MOJO_RESULT_INVALID_ARGUMENT| if some |handle[i]| is not a valid handle
 //       (e.g., if it is zero or if it has already been closed). The
 //       |signals_state| array is unchanged.
 //   |MOJO_RESULT_DEADLINE_EXCEEDED| if the deadline has passed without any of
 //       handles satisfying any of its signals.
 //   |MOJO_RESULT_FAILED_PRECONDITION| if it is or becomes impossible that SOME
 //       |handle[i]| will ever satisfy any of the signals in |signals[i]|.
+//   |MOJO_RESULT_BUSY| if some |handle[i]| is currently in use in some
+//       transaction (that, e.g., may result in it being invalidated, such as
+//       being sent in a message).
 MojoResult MojoWaitMany(const MojoHandle* MOJO_RESTRICT handles,         // In.
                         const MojoHandleSignals* MOJO_RESTRICT signals,  // In.
                         uint32_t num_handles,                            // In.
                         MojoDeadline deadline,                           // In.
                         uint32_t* MOJO_RESTRICT result_index,  // Optional out
                         struct MojoHandleSignalsState* MOJO_RESTRICT
                             signals_states);  // Optional out
 
 MOJO_END_EXTERN_C
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_WAIT_H_