Mojo: MojoWaitFlags -> MojoHandleSignals.

mojo/public/js/bindings/core.js

 // 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.
 
 // Module "mojo/public/js/bindings/core"
 //
 // Note: This file is for documentation purposes only. The code here is not
 // actually executed. The real module is implemented natively in Mojo.
 //
 // This module provides the JavaScript bindings for mojo/public/c/system/core.h.
@@ skipping 29 matching lines @@
 var RESULT_BUSY;
 var RESULT_SHOULD_WAIT;
 
 /**
  * MojoDeadline {number}: Used to specify deadlines (timeouts), in microseconds.
  * See core.h for more information.
  */
 var DEADLINE_INDEFINITE;
 
 /**
- * MojoWaitFlags: Used to specify the state of a handle to wait on (e.g., the
- * ability to read or write to it).
+ * MojoHandleSignals: Used to specify signals that can be waited on for a handle
+ *(and which can be triggered), e.g., the ability to read or write to
+ * the handle.
  * See core.h for more information.
  */
 var WAIT_FLAG_NONE;
 var WAIT_FLAG_READABLE;
 var WAIT_FLAG_WRITABLE;
 var WAIT_FLAG_EVERYTHING;
 
 /*
  * MojoWriteMessageFlags: Used to specify different modes to |writeMessage()|.
  * See core.h for more information.
@@ skipping 39 matching lines @@
 var READ_DATA_FLAG_QUERY;
 
 /**
  * Closes the given |handle|. See MojoClose for more info.
  * @param {MojoHandle} Handle to close.
  * @return {MojoResult} Result code.
  */
 function close(handle) { [native code] }
 
 /**
- * Waits on the given handle until the state indicated by |waitFlags| is
+ * Waits on the given handle until a signal indicated by |signals| is
  * satisfied or until |deadline| is passed. See MojoWait for more information.
  *
  * @param {MojoHandle} handle Handle to wait on.
- * @param {MojoWaitFlags} waitFlags Specifies the condition to wait for.
+ * @param {MojoHandleSignals} signals Specifies the condition to wait for.
  * @param {MojoDeadline} deadline Stops waiting if this is reached.
  * @return {MojoResult} Result code.
  */
-function wait(handle, waitFlags, deadline) { [native code] }
+function wait(handle, signals, deadline) { [native code] }
 
 /**
  * Waits on |handles[0]|, ..., |handles[handles.length-1]| for at least one of
  * them to satisfy the state indicated by |flags[0]|, ...,
  * |flags[handles.length-1]|, respectively, or until |deadline| has passed.
  * See MojoWaitMany for more information.
  *
  * @param {Array.MojoHandle} handles Handles to wait on.
- * @param {Array.MojoWaitFlags} waitFlags Specifies the condition to wait for,
+ * @param {Array.MojoHandleSignals} signals Specifies the condition to wait for,
  *   for each corresponding handle. Must be the same length as |handles|.
  * @param {MojoDeadline} deadline Stops waiting if this is reached.
  * @return {MojoResult} Result code.
  */
-function waitMany(handles, waitFlags, deadline) { [native code] }
+function waitMany(handles, signals, deadline) { [native code] }
 
 /**
  * Creates a message pipe. This function always succeeds.
  * See MojoCreateMessagePipe for more information on message pipes.
  *
  * @return {MessagePipe} An object of the form {
  *     handle0,
  *     handle1,
  *   }
  *   where |handle0| and |handle1| are MojoHandles to each end of the channel.
@@ skipping 62 matching lines @@
  * return codes.
  *
  * @param {MojoHandle} handle A consumerHandle returned by createDataPipe.
  * @param {MojoReadDataFlags} flags Flags.
  * @return {object} An object of the form {
  *     result,  // |RESULT_OK| on success, error code otherwise.
  *     buffer,  // An ArrayBufferView of the data read (only on success).
  *   }
  */
 function readData(handle, flags) { [native code] }