Update comments in system headers to include MOJO_RESULT_BUSY behavior.

mojo/public/c/system/message_pipe.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/constants and functions specific to message pipes.
 //
 // Note: This header should be compilable as C.
 
 #ifndef MOJO_PUBLIC_C_SYSTEM_MESSAGE_PIPE_H_
 #define MOJO_PUBLIC_C_SYSTEM_MESSAGE_PIPE_H_
@@ skipping 84 matching lines @@
 //       |message_pipe_handle| is not a valid handle, or some of the
 //       requirements above are not satisfied).
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if some system limit has been reached, or
 //       the number of handles to send is too large (TODO(vtl): reconsider the
 //       latter case).
 //   |MOJO_RESULT_FAILED_PRECONDITION| if the other endpoint has been closed.
 //       Note that closing an endpoint is not necessarily synchronous (e.g.,
 //       across processes), so this function may succeed even if the other
 //       endpoint has been closed (in which case the message would be dropped).
 //   |MOJO_RESULT_UNIMPLEMENTED| if an unsupported flag was set in |*options|.
-//   |MOJO_RESULT_BUSY| if some handle to be sent is currently in use.
+//   |MOJO_RESULT_BUSY| if |message_pipe_handle| is currently in use in some
+//       transaction (that, e.g., may result in it being invalidated, such as
+//       being sent in a message), or if some handle to be sent is currently in
+//       use.
 //
 // TODO(vtl): Add a notion of capacity for message pipes, and return
 // |MOJO_RESULT_SHOULD_WAIT| if the message pipe is full.
 MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,  // In.
                             const void* bytes,               // Optional in.
                             uint32_t num_bytes,              // In.
                             const MojoHandle* handles,       // Optional in.
                             uint32_t num_handles,            // In.
                             MojoWriteMessageFlags flags);    // In.
 
@@ skipping 18 matching lines @@
 // parameter(s) must also be set to zero or passed as null.
 //
 // Returns:
 //   |MOJO_RESULT_OK| on success (i.e., a message was actually read).
 //   |MOJO_RESULT_INVALID_ARGUMENT| if some argument was invalid.
 //   |MOJO_RESULT_FAILED_PRECONDITION| if the other endpoint has been closed.
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if the message was too large to fit in the
 //       provided buffer(s). The message will have been left in the queue or
 //       discarded, depending on flags.
 //   |MOJO_RESULT_SHOULD_WAIT| if no message was available to be read.
+//   |MOJO_RESULT_BUSY| if |message_pipe_handle| is currently in use in some
+//       transaction (that, e.g., may result in it being invalidated, such as
+//       being sent in a message).
 //
 // TODO(vtl): Reconsider the |MOJO_RESULT_RESOURCE_EXHAUSTED| error code; should
 // distinguish this from the hitting-system-limits case.
 MojoResult MojoReadMessage(
     MojoHandle message_pipe_handle,       // In.
     void* MOJO_RESTRICT bytes,            // Optional out.
     uint32_t* MOJO_RESTRICT num_bytes,    // Optional in/out.
     MojoHandle* MOJO_RESTRICT handles,    // Optional out.
     uint32_t* MOJO_RESTRICT num_handles,  // Optional in/out.
     MojoReadMessageFlags flags);          // In.
 
 MOJO_END_EXTERN_C
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_MESSAGE_PIPE_H_