// 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/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.
// Refer to that file for more detailed documentation for equivalent methods.

while (1);

/**
 * MojoHandle: An opaque handles to a Mojo object (e.g. a message pipe).
 */
var kInvalidHandle;

/**
 * MojoResult {number}: Result codes for Mojo operations.
 * See core.h for more information.
 */
var RESULT_OK;
var RESULT_CANCELLED;
var RESULT_UNKNOWN;
var RESULT_INVALID_ARGUMENT;
var RESULT_DEADLINE_EXCEEDED;
var RESULT_NOT_FOUND;
var RESULT_ALREADY_EXISTS;
var RESULT_PERMISSION_DENIED;
var RESULT_RESOURCE_EXHAUSTED;
var RESULT_FAILED_PRECONDITION;
var RESULT_ABORTED;
var RESULT_OUT_OF_RANGE;
var RESULT_UNIMPLEMENTED;
var RESULT_INTERNAL;
var RESULT_UNAVAILABLE;
var RESULT_DATA_LOSS;
var RESULT_BUSY;
var RESULT_SHOULD_WAIT;

/**
 * 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 HANDLE_SIGNAL_NONE;
var HANDLE_SIGNAL_READABLE;
var HANDLE_SIGNAL_WRITABLE;
var HANDLE_SIGNAL_PEER_CLOSED;
var HANDLE_SIGNAL_PEER_REMOTE;

/**
 * MojoCreateDataMessageOptions: Used to specify creation parameters for a data
 * pipe to |createDataMessage()|.
 * See core.h for more information.
 */
dictionary MojoCreateDataMessageOptions {
  MojoCreateDataMessageOptionsFlags flags;  // See below.
};

// MojoCreateDataMessageOptionsFlags
var CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE;

/*
 * MojoWriteMessageFlags: Used to specify different modes to |writeMessage()|.
 * See core.h for more information.
 */
var WRITE_MESSAGE_FLAG_NONE;

/**
 * MojoReadMessageFlags: Used to specify different modes to |readMessage()|.
 * See core.h for more information.
 */
var READ_MESSAGE_FLAG_NONE;

/**
 * MojoCreateDataPipeOptions: Used to specify creation parameters for a data
 * pipe to |createDataPipe()|.
 * See core.h for more information.
 */
dictionary MojoCreateDataPipeOptions {
  MojoCreateDataPipeOptionsFlags flags;  // See below.
  int32 elementNumBytes;  // The size of an element, in bytes.
  int32 capacityNumBytes;  // The capacity of the data pipe, in bytes.
};

// MojoCreateDataPipeOptionsFlags
var CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;

/*
 * MojoWriteDataFlags: Used to specify different modes to |writeData()|.
 * See core.h for more information.
 */
var WRITE_DATA_FLAG_NONE;
var WRITE_DATA_FLAG_ALL_OR_NONE;

/**
 * MojoReadDataFlags: Used to specify different modes to |readData()|.
 * See core.h for more information.
 */
var READ_DATA_FLAG_NONE;
var READ_DATA_FLAG_ALL_OR_NONE;
var READ_DATA_FLAG_DISCARD;
var READ_DATA_FLAG_QUERY;
var READ_DATA_FLAG_PEEK;

/**
 * MojoCreateSharedBufferOptionsFlags: Used to specify options to
 *   |createSharedBuffer()|.
 * See core.h for more information.
 */
var CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;

/**
 * MojoDuplicateBufferHandleOptionsFlags: Used to specify options to
 *   |duplicateBufferHandle()|.
 * See core.h for more information.
 */
var DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE;
var DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_READ_ONLY;

/**
 * MojoMapBufferFlags: Used to specify options to |mapBuffer()|.
 * See core.h for more information.
 */
var MAP_BUFFER_FLAG_NONE;

/**
 * Closes the given |handle|. See MojoClose for more info.
 * @param {MojoHandle} Handle to close.
 * @return {MojoResult} Result code.
 */
function close(handle) { [native code] }

/**
 * Queries the last known signaling state of |handle|.
 *
 * @param {MojoHandle} handle Handle to query.
 * @return {object} An object of the form {
 *     result,              // MOJO_RESULT_OK or MOJO_RESULT_INVALID_ARGUMENT
 *     satisfiedSignals,    // MojoHandleSignals (see above)
 *     satisfiableSignals,  // MojoHandleSignals
 * }
 */
function queryHandleSignalsState(handle) { [native code] }

/**
 * Waits on the given handle until a signal indicated by |signals| is
 * satisfied or an error occurs.
 *
 * @param {MojoHandle} handle Handle to wait on.
 * @param {MojoHandleSignals} signals Specifies the condition to wait for.
 * @return {MojoResult} Result code.
 */
function wait(handle, signals) { [native code] }

/**
 * Creates a message pipe. This function always succeeds.
 * See MojoCreateMessagePipe for more information on message pipes.
 *
 * @param {MojoCreateMessagePipeOptions} optionsDict Options to control the
 * message pipe parameters. May be null.
 * @return {MessagePipe} An object of the form {
 *     handle0,
 *     handle1,
 *   }
 *   where |handle0| and |handle1| are MojoHandles to each end of the channel.
 */
function createMessagePipe(optionsDict) { [native code] }

/**
 * Writes a message to the message pipe endpoint given by |handle|. See
 * MojoWriteMessage for more information, including return codes.
 *
 * @param {MojoHandle} handle The endpoint to write to.
 * @param {ArrayBufferView} buffer The message data. May be empty.
 * @param {Array.MojoHandle} handlesArray Any handles to attach. Handles are
 *   transferred on success and will no longer be valid. May be empty.
 * @param {MojoWriteMessageFlags} flags Flags.
 * @return {MojoResult} Result code.
 */
function writeMessage(handle, buffer, handlesArray, flags) { [native code] }

/**
 * Reads a message from the message pipe endpoint given by |handle|. See
 * MojoReadMessage for more information, including return codes.
 *
 * @param {MojoHandle} handle The endpoint to read from.
 * @param {MojoReadMessageFlags} flags Flags.
 * @return {object} An object of the form {
 *     result,  // |RESULT_OK| on success, error code otherwise.
 *     buffer,  // An ArrayBufferView of the message data (only on success).
 *     handles  // An array of MojoHandles transferred, if any.
 *   }
 */
function readMessage(handle, flags) { [native code] }

/**
 * Creates a data pipe, which is a unidirectional communication channel for
 * unframed data, with the given options. See MojoCreateDataPipe for more
 * more information, including return codes.
 *
 * @param {MojoCreateDataPipeOptions} optionsDict Options to control the data
 *   pipe parameters. May be null.
 * @return {object} An object of the form {
 *     result,  // |RESULT_OK| on success, error code otherwise.
 *     producerHandle,  // MojoHandle to use with writeData (only on success).
 *     consumerHandle,  // MojoHandle to use with readData (only on success).
 *   }
 */
function createDataPipe(optionsDict) { [native code] }

/**
 * Writes the given data to the data pipe producer given by |handle|. See
 * MojoWriteData for more information, including return codes.
 *
 * @param {MojoHandle} handle A producerHandle returned by createDataPipe.
 * @param {ArrayBufferView} buffer The data to write.
 * @param {MojoWriteDataFlags} flags Flags.
 * @return {object} An object of the form {
 *     result,  // |RESULT_OK| on success, error code otherwise.
 *     numBytes,  // The number of bytes written.
 *   }
 */
function writeData(handle, buffer, flags) { [native code] }

/**
 * Reads data from the data pipe consumer given by |handle|. May also
 * be used to discard data. See MojoReadData for more information, including
 * 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] }

/**
 * True if the argument is a message or data pipe handle.
 *
 * @param {value} an arbitrary JS value.
 * @return true or false
 */
function isHandle(value) { [native code] }

/**
 * Creates shared buffer of specified size |num_bytes|.
 * See MojoCreateSharedBuffer for more information including error codes.
 *
 * @param {number} num_bytes Size of the memory to be allocated for shared
 * @param {MojoCreateSharedBufferOptionsFlags} flags Flags.
 *   buffer.
 * @return {object} An object of the form {
 *     result,  // |RESULT_OK| on success, error code otherwise.
 *     handle,  // An MojoHandle for shared buffer (only on success).
 *   }
 */
function createSharedBuffer(num_bytes, flags) { [native code] }

/**
 * Duplicates the |buffer_handle| to a shared buffer. Duplicated handle can be
 * sent to another process over message pipe. See MojoDuplicateBufferHandle for
 * more information including error codes.
 *
 * @param {MojoHandle} buffer_handle MojoHandle.
 * @param {MojoCreateSharedBufferOptionsFlags} flags Flags.
 * @return {object} An object of the form {
 *     result,  // |RESULT_OK| on success, error code otherwise.
 *     handle,  // A duplicated MojoHandle for shared buffer (only on success).
 *   }
 */
function duplicateBufferHandle(buffer_handle, flags) { [native code] }

/**
 * Maps the part (at offset |offset| of length |num_bytes|) of the buffer given
 * by |buffer_handle| into ArrayBuffer memory |buffer|, with options specified
 * by |flags|. See MojoMapBuffer for more information including error codes.
 *
 * @param {MojoHandle} buffer_handle A sharedBufferHandle returned by
 *   createSharedBuffer.
 * @param {number} offset Offset.
 * @param {number} num_bytes Size of the memory to be mapped.
 * @param {MojoMapBufferFlags} flags Flags.
 * @return {object} An object of the form {
 *     result,  // |RESULT_OK| on success, error code otherwise.
 *     buffer,  // An ArrayBuffer (only on success).
 *   }
 */
function mapBuffer(buffer_handle, offset, num_bytes, flags) { [native code] }

/**
 * Unmaps buffer that was mapped using mapBuffer.
 * See MojoUnmapBuffer for more information including error codes.
 *
 * @param {ArrayBuffer} buffer ArrayBuffer.
 * @return {MojoResult} Result code.
 */
function unmapBuffer(buffer) { [native code] }