src/mojo/public/js/bindings/core.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Module "mojo/public/js/bindings/core"
   6 //
   7 // Note: This file is for documentation purposes only. The code here is not
   8 // actually executed. The real module is implemented natively in Mojo.
   9 //
  10 // This module provides the JavaScript bindings for mojo/public/c/system/core.h.
  11 // Refer to that file for more detailed documentation for equivalent methods.
  12
  13 while (1);
  14
  15 /**
  16  * MojoHandle: An opaque handles to a Mojo object (e.g. a message pipe).
  17  */
  18 var kInvalidHandle;
  19
  20 /**
  21  * MojoResult {number}: Result codes for Mojo operations.
  22  * See core.h for more information.
  23  */
  24 var RESULT_OK;
  25 var RESULT_CANCELLED;
  26 var RESULT_UNKNOWN;
  27 var RESULT_INVALID_ARGUMENT;
  28 var RESULT_DEADLINE_EXCEEDED;
  29 var RESULT_NOT_FOUND;
  30 var RESULT_ALREADY_EXISTS;
  31 var RESULT_PERMISSION_DENIED;
  32 var RESULT_RESOURCE_EXHAUSTED;
  33 var RESULT_FAILED_PRECONDITION;
  34 var RESULT_ABORTED;
  35 var RESULT_OUT_OF_RANGE;
  36 var RESULT_UNIMPLEMENTED;
  37 var RESULT_INTERNAL;
  38 var RESULT_UNAVAILABLE;
  39 var RESULT_DATA_LOSS;
  40 var RESULT_BUSY;
  41 var RESULT_SHOULD_WAIT;
  42
  43 /**
  44  * MojoDeadline {number}: Used to specify deadlines (timeouts), in microseconds.
  45  * See core.h for more information.
  46  */
  47 var DEADLINE_INDEFINITE;
  48
  49 /**
  50  * MojoHandleSignals: Used to specify signals that can be waited on for a handle
  51  *(and which can be triggered), e.g., the ability to read or write to
  52  * the handle.
  53  * See core.h for more information.
  54  */
  55 var HANDLE_SIGNAL_NONE;
  56 var HANDLE_SIGNAL_READABLE;
  57 var HANDLE_SIGNAL_WRITABLE;
  58
  59 /**
  60  * MojoCreateDataMessageOptions: Used to specify creation parameters for a data
  61  * pipe to |createDataMessage()|.
  62  * See core.h for more information.
  63  */
  64 dictionary MojoCreateDataMessageOptions {
  65   MojoCreateDataMessageOptionsFlags flags;  // See below.
  66 };
  67
  68 // MojoCreateDataMessageOptionsFlags
  69 var CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE;
  70
  71 /*
  72  * MojoWriteMessageFlags: Used to specify different modes to |writeMessage()|.
  73  * See core.h for more information.
  74  */
  75 var WRITE_MESSAGE_FLAG_NONE;
  76
  77 /**
  78  * MojoReadMessageFlags: Used to specify different modes to |readMessage()|.
  79  * See core.h for more information.
  80  */
  81 var READ_MESSAGE_FLAG_NONE;
  82 var READ_MESSAGE_FLAG_MAY_DISCARD;
  83
  84 /**
  85  * MojoCreateDataPipeOptions: Used to specify creation parameters for a data
  86  * pipe to |createDataPipe()|.
  87  * See core.h for more information.
  88  */
  89 dictionary MojoCreateDataPipeOptions {
  90   MojoCreateDataPipeOptionsFlags flags;  // See below.
  91   int32 elementNumBytes;  // The size of an element, in bytes.
  92   int32 capacityNumBytes;  // The capacity of the data pipe, in bytes.
  93 };
  94
  95 // MojoCreateDataPipeOptionsFlags
  96 var CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
  97 var CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD;
  98
  99 /*
 100  * MojoWriteDataFlags: Used to specify different modes to |writeData()|.
 101  * See core.h for more information.
 102  */
 103 var WRITE_DATA_FLAG_NONE;
 104 var WRITE_DATA_FLAG_ALL_OR_NONE;
 105
 106 /**
 107  * MojoReadDataFlags: Used to specify different modes to |readData()|.
 108  * See core.h for more information.
 109  */
 110 var READ_DATA_FLAG_NONE;
 111 var READ_DATA_FLAG_ALL_OR_NONE;
 112 var READ_DATA_FLAG_DISCARD;
 113 var READ_DATA_FLAG_QUERY;
 114
 115 /**
 116  * Closes the given |handle|. See MojoClose for more info.
 117  * @param {MojoHandle} Handle to close.
 118  * @return {MojoResult} Result code.
 119  */
 120 function close(handle) { [native code] }
 121
 122 /**
 123  * Waits on the given handle until a signal indicated by |signals| is
 124  * satisfied or until |deadline| is passed. See MojoWait for more information.
 125  *
 126  * @param {MojoHandle} handle Handle to wait on.
 127  * @param {MojoHandleSignals} signals Specifies the condition to wait for.
 128  * @param {MojoDeadline} deadline Stops waiting if this is reached.
 129  * @return {MojoResult} Result code.
 130  */
 131 function wait(handle, signals, deadline) { [native code] }
 132
 133 /**
 134  * Waits on |handles[0]|, ..., |handles[handles.length-1]| for at least one of
 135  * them to satisfy the state indicated by |flags[0]|, ...,
 136  * |flags[handles.length-1]|, respectively, or until |deadline| has passed.
 137  * See MojoWaitMany for more information.
 138  *
 139  * @param {Array.MojoHandle} handles Handles to wait on.
 140  * @param {Array.MojoHandleSignals} signals Specifies the condition to wait for,
 141  *   for each corresponding handle. Must be the same length as |handles|.
 142  * @param {MojoDeadline} deadline Stops waiting if this is reached.
 143  * @return {MojoResult} Result code.
 144  */
 145 function waitMany(handles, signals, deadline) { [native code] }
 146
 147 /**
 148  * Creates a message pipe. This function always succeeds.
 149  * See MojoCreateMessagePipe for more information on message pipes.
 150  *
 151  * @param {MojoCreateMessagePipeOptions} optionsDict Options to control the
 152  * message pipe parameters. May be null.
 153  * @return {MessagePipe} An object of the form {
 154  *     handle0,
 155  *     handle1,
 156  *   }
 157  *   where |handle0| and |handle1| are MojoHandles to each end of the channel.
 158  */
 159 function createMessagePipe(optionsDict) { [native code] }
 160
 161 /**
 162  * Writes a message to the message pipe endpoint given by |handle|. See
 163  * MojoWriteMessage for more information, including return codes.
 164  *
 165  * @param {MojoHandle} handle The endpoint to write to.
 166  * @param {ArrayBufferView} buffer The message data. May be empty.
 167  * @param {Array.MojoHandle} handlesArray Any handles to attach. Handles are
 168  *   transferred on success and will no longer be valid. May be empty.
 169  * @param {MojoWriteMessageFlags} flags Flags.
 170  * @return {MojoResult} Result code.
 171  */
 172 function writeMessage(handle, buffer, handlesArray, flags) { [native code] }
 173
 174 /**
 175  * Reads a message from the message pipe endpoint given by |handle|. See
 176  * MojoReadMessage for more information, including return codes.
 177  *
 178  * @param {MojoHandle} handle The endpoint to read from.
 179  * @param {MojoReadMessageFlags} flags Flags.
 180  * @return {object} An object of the form {
 181  *     result,  // |RESULT_OK| on success, error code otherwise.
 182  *     buffer,  // An ArrayBufferView of the message data (only on success).
 183  *     handles  // An array of MojoHandles transferred, if any.
 184  *   }
 185  */
 186 function readMessage(handle, flags) { [native code] }
 187
 188 /**
 189  * Creates a data pipe, which is a unidirectional communication channel for
 190  * unframed data, with the given options. See MojoCreateDataPipe for more
 191  * more information, including return codes.
 192  *
 193  * @param {MojoCreateDataPipeOptions} optionsDict Options to control the data
 194  *   pipe parameters. May be null.
 195  * @return {object} An object of the form {
 196  *     result,  // |RESULT_OK| on success, error code otherwise.
 197  *     producerHandle,  // MojoHandle to use with writeData (only on success).
 198  *     consumerHandle,  // MojoHandle to use with readData (only on success).
 199  *   }
 200  */
 201 function createDataPipe(optionsDict) { [native code] }
 202
 203 /**
 204  * Writes the given data to the data pipe producer given by |handle|. See
 205  * MojoWriteData for more information, including return codes.
 206  *
 207  * @param {MojoHandle} handle A producerHandle returned by createDataPipe.
 208  * @param {ArrayBufferView} buffer The data to write.
 209  * @param {MojoWriteDataFlags} flags Flags.
 210  * @return {object} An object of the form {
 211  *     result,  // |RESULT_OK| on success, error code otherwise.
 212  *     numBytes,  // The number of bytes written.
 213  *   }
 214  */
 215 function writeData(handle, buffer, flags) { [native code] }
 216
 217 /**
 218  * Reads data from the data pipe consumer given by |handle|. May also
 219  * be used to discard data. See MojoReadData for more information, including
 220  * return codes.
 221  *
 222  * @param {MojoHandle} handle A consumerHandle returned by createDataPipe.
 223  * @param {MojoReadDataFlags} flags Flags.
 224  * @return {object} An object of the form {
 225  *     result,  // |RESULT_OK| on success, error code otherwise.
 226  *     buffer,  // An ArrayBufferView of the data read (only on success).
 227  *   }
 228  */
 229 function readData(handle, flags) { [native code] }