OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 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 goog.provide('__crWeb.mojoApi'); |
| 6 |
| 7 // Note: The API should stay in sync with the IDL definitions in |
| 8 // third_party/WebKit/Source/core/mojo |
| 9 |
| 10 var Mojo = Mojo || {}; |
| 11 |
| 12 /** |
| 13 * MojoResult {number}: Result codes for Mojo operations. |
| 14 */ |
| 15 Mojo.RESULT_OK = 0; |
| 16 Mojo.RESULT_CANCELLED = 1; |
| 17 Mojo.RESULT_UNKNOWN = 2; |
| 18 Mojo.RESULT_INVALID_ARGUMENT = 3; |
| 19 Mojo.RESULT_DEADLINE_EXCEEDED = 4; |
| 20 Mojo.RESULT_NOT_FOUND = 5; |
| 21 Mojo.RESULT_ALREADY_EXISTS = 6; |
| 22 Mojo.RESULT_PERMISSION_DENIED = 7; |
| 23 Mojo.RESULT_RESOURCE_EXHAUSTED = 8; |
| 24 Mojo.RESULT_FAILED_PRECONDITION = 9; |
| 25 Mojo.RESULT_ABORTED = 10; |
| 26 Mojo.RESULT_OUT_OF_RANGE = 11; |
| 27 Mojo.RESULT_UNIMPLEMENTED = 12; |
| 28 Mojo.RESULT_INTERNAL = 13; |
| 29 Mojo.RESULT_UNAVAILABLE = 14; |
| 30 Mojo.RESULT_DATA_LOSS = 15; |
| 31 Mojo.RESULT_BUSY = 16; |
| 32 Mojo.RESULT_SHOULD_WAIT = 17; |
| 33 |
| 34 /** |
| 35 * Creates a message pipe. |
| 36 * |
| 37 * @return {result: !MojoResult, handle0: !MojoHandle=, handle1: !MojoHandle=} |
| 38 * Result code and (on success) the two message pipe handles. |
| 39 */ |
| 40 Mojo.createMessagePipe = function() { |
| 41 var result = Mojo.internal.sendMessage({ |
| 42 name: "Mojo.createMessagePipe", |
| 43 args: {} |
| 44 }); |
| 45 if (result.result == Mojo.RESULT_OK) { |
| 46 result.handle0 = new MojoHandle(result.handle0); |
| 47 result.handle1 = new MojoHandle(result.handle1); |
| 48 } |
| 49 return result; |
| 50 }; |
| 51 |
| 52 /** |
| 53 * Binds to the specified Mojo interface. |
| 54 * @param {string} interfaceName The interface name to connect. |
| 55 * @param {!MojoHandle} requestHandle The interface request handle. |
| 56 */ |
| 57 Mojo.bindInterface = function(interfaceName, requestHandle) { |
| 58 Mojo.internal.sendMessage({ |
| 59 name: "Mojo.bindInterface", |
| 60 args: { |
| 61 interfaceName: interfaceName, |
| 62 requestHandle: requestHandle.takeNativeHandle_() |
| 63 } |
| 64 }); |
| 65 }; |
| 66 |
| 67 /** |
| 68 * @constructor |
| 69 * @param {?number=} nativeHandle An opaque number representing the underlying |
| 70 * Mojo system resource. |
| 71 */ |
| 72 var MojoHandle = function(nativeHandle) { |
| 73 if (nativeHandle === undefined) |
| 74 nativeHandle = null; |
| 75 |
| 76 /** |
| 77 * @type {number|null} |
| 78 */ |
| 79 this.nativeHandle_ = nativeHandle; |
| 80 }; |
| 81 |
| 82 /** |
| 83 * Takes the native handle value. This is not part of the public API. |
| 84 * @return {?number} |
| 85 */ |
| 86 MojoHandle.prototype.takeNativeHandle_ = function() { |
| 87 var nativeHandle = this.nativeHandle_; |
| 88 this.nativeHandle_ = null; |
| 89 return nativeHandle; |
| 90 }; |
| 91 |
| 92 /** |
| 93 * Closes the handle. |
| 94 */ |
| 95 MojoHandle.prototype.close = function() { |
| 96 if (this.nativeHandle_ === null) |
| 97 return; |
| 98 |
| 99 var nativeHandle = this.nativeHandle_; |
| 100 this.nativeHandle_ = null; |
| 101 Mojo.internal.sendMessage({ |
| 102 name: "MojoHandle.close", |
| 103 args: { |
| 104 handle: nativeHandle |
| 105 } |
| 106 }); |
| 107 }; |
| 108 |
| 109 /** |
| 110 * Begins watching the handle for |signals| to be satisfied or unsatisfiable. |
| 111 * |
| 112 * @param {readable: boolean=, writable: boolean=, peerClosed: boolean=} signals |
| 113 * The signals to watch. |
| 114 * @param {!function(!MojoResult)} calback Called with a result any time |
| 115 * the watched signals become satisfied or unsatisfiable. |
| 116 * |
| 117 * @return {!MojoWatcher} A MojoWatcher instance that could be used to cancel |
| 118 * the watch. |
| 119 */ |
| 120 MojoHandle.prototype.watch = function(signals, callback) { |
| 121 var HANDLE_SIGNAL_NONE = 0; |
| 122 var HANDLE_SIGNAL_READABLE = 1; |
| 123 var HANDLE_SIGNAL_WRITABLE = 2; |
| 124 var HANDLE_SIGNAL_PEER_CLOSED = 4; |
| 125 |
| 126 var signalsValue = HANDLE_SIGNAL_NONE; |
| 127 if (signals.readable) { |
| 128 signalsValue |= HANDLE_SIGNAL_READABLE; |
| 129 } |
| 130 if (signals.writable) { |
| 131 signalsValue |= HANDLE_SIGNAL_WRITABLE; |
| 132 } |
| 133 if (signalsValue.peerClosed) { |
| 134 signalsValue |= HANDLE_SIGNAL_PEER_CLOSED; |
| 135 } |
| 136 |
| 137 var watchId = Mojo.internal.sendMessage({ |
| 138 name: "MojoHandle.watch", |
| 139 args: { |
| 140 handle: this.nativeHandle_, |
| 141 signals: signalsValue, |
| 142 callbackId: Mojo.internal.watchCallbacksHolder.getNextCallbackId() |
| 143 } |
| 144 }); |
| 145 Mojo.internal.watchCallbacksHolder.addWatchCallback(watchId, callback); |
| 146 |
| 147 return new MojoWatcher(watchId); |
| 148 }; |
| 149 |
| 150 /** |
| 151 * Writes a message to the message pipe. |
| 152 * |
| 153 * @param {!ArrayBufferView} buffer The message data. May be empty. |
| 154 * @param {!Array<!MojoHandle>} handles Any handles to attach. Handles are |
| 155 * transferred and will no longer be valid. May be empty. |
| 156 * @return {!MojoResult} Result code. |
| 157 */ |
| 158 MojoHandle.prototype.writeMessage = function(buffer, handles) { |
| 159 var nativeHandles = handles.map(function(handle) { |
| 160 return handle.takeNativeHandle_(); |
| 161 }); |
| 162 return Mojo.internal.sendMessage({ |
| 163 name: "MojoHandle.writeMessage", |
| 164 args: { |
| 165 handle: this.nativeHandle_, |
| 166 buffer: buffer, |
| 167 handles: nativeHandles, |
| 168 } |
| 169 }); |
| 170 }; |
| 171 |
| 172 /** |
| 173 * Reads a message from the message pipe. |
| 174 * |
| 175 * @return {result: !MojoResult, |
| 176 * buffer: !ArrayBufferView=, |
| 177 * handles: !Array<!MojoHandle>=} |
| 178 * Result code and (on success) the data and handles recevied. |
| 179 */ |
| 180 MojoHandle.prototype.readMessage = function() { |
| 181 var result = Mojo.internal.sendMessage({ |
| 182 name: "MojoHandle.readMessage", |
| 183 args: { |
| 184 handle: this.nativeHandle_ |
| 185 } |
| 186 }); |
| 187 |
| 188 if (result.result == Mojo.RESULT_OK) { |
| 189 result.buffer = new Uint8Array(result.buffer).buffer; |
| 190 result.handles = result.handles.map(function(handle) { |
| 191 return new MojoHandle(handle); |
| 192 }); |
| 193 } |
| 194 return result; |
| 195 }; |
| 196 |
| 197 /** |
| 198 * MojoWatcher identifies a watch on a MojoHandle and can be used to cancel the |
| 199 * watch. |
| 200 * |
| 201 * @constructor |
| 202 * @param {number} An opaque id representing the watch. |
| 203 */ |
| 204 var MojoWatcher = function(watchId) { |
| 205 this.watchId_ = watchId; |
| 206 }; |
| 207 |
| 208 /* |
| 209 * Cancels a handle watch. |
| 210 */ |
| 211 MojoWatcher.prototype.cancel = function() { |
| 212 Mojo.internal.sendMessage({ |
| 213 name: "MojoWatcher.cancel", |
| 214 args: { |
| 215 watchId: this.watchId_ |
| 216 } |
| 217 }); |
| 218 Mojo.internal.watchCallbacksHolder.removeWatchCallback(watchId); |
| 219 }; |
| 220 |
| 221 // ----------------------------------------------------------------------------- |
| 222 // Mojo API implementation details. It is not part of the public API. |
| 223 |
| 224 Mojo.internal = Mojo.internal || {}; |
| 225 |
| 226 /** |
| 227 * Synchronously sends a message to Mojo backend. |
| 228 * @param {!Object} message The message to send. |
| 229 * @return {Object=} Response from Mojo backend. |
| 230 */ |
| 231 Mojo.internal.sendMessage = function(message) { |
| 232 var response = window.prompt(__gCrWeb.common.JSONStringify(message)); |
| 233 return response ? JSON.parse(response) : undefined; |
| 234 }; |
| 235 |
| 236 /** |
| 237 * Holds callbacks for all currently active watches. |
| 238 */ |
| 239 Mojo.internal.watchCallbacksHolder = (function() { |
| 240 /** |
| 241 * Next callback id to be used for watch. |
| 242 * @type{number} |
| 243 */ |
| 244 var nextCallbackId = 0; |
| 245 |
| 246 /** |
| 247 * Map where keys are callbacks ids and values are callbacks. |
| 248 * @type {!Map<number, !function(!MojoResult)>} |
| 249 */ |
| 250 var callbacks = new Map(); |
| 251 |
| 252 /** |
| 253 * Map where keys are watch ids and values are callback ids. |
| 254 * @type {!Map<number, number>} |
| 255 */ |
| 256 var callbackIds = new Map(); |
| 257 |
| 258 /** |
| 259 * Calls watch callback. |
| 260 * |
| 261 * @param {number} callbackId Callback id previously returned from |
| 262 {@code getNextCallbackId}. |
| 263 * @param {!MojoResult} mojoResult The result code to call the callback with. |
| 264 */ |
| 265 var callCallback = function(callbackId, mojoResult) { |
| 266 var callback = callbacks.get(callbackId); |
| 267 |
| 268 // Signalling the watch is asynchronous operation and this function may be |
| 269 // called for already removed watch. |
| 270 if (callback) |
| 271 callback(mojoResult); |
| 272 }; |
| 273 |
| 274 /** |
| 275 * Returns next callback id to be used for watch (idempotent). |
| 276 * |
| 277 * @return {number} callback id. |
| 278 */ |
| 279 var getNextCallbackId = function() { |
| 280 return nextCallbackId; |
| 281 }; |
| 282 |
| 283 /** |
| 284 * Adds callback which must be executed when the watch fires. |
| 285 * |
| 286 * @param {number} watchId The value returned from "MojoHandle.watch" Mojo |
| 287 * backend. |
| 288 * @param {!function(!MojoResult)} callback The callback which should be |
| 289 * executed when the watch fires. |
| 290 */ |
| 291 var addWatchCallback = function(watchId, callback) { |
| 292 callbackIds.set(watchId, nextCallbackId); |
| 293 callbacks.set(nextCallbackId, callback); |
| 294 ++nextCallbackId; |
| 295 }; |
| 296 |
| 297 /** |
| 298 * Removes callback which should no longer be executed. |
| 299 * |
| 300 * @param {!number} watchId The id to remove callback for. |
| 301 */ |
| 302 var removeWatchCallback = function (watchId) { |
| 303 callbacks.delete(callbackIds.get(watchId)); |
| 304 callbackIds.delete(watchId); |
| 305 }; |
| 306 |
| 307 return { |
| 308 callCallback: callCallback, |
| 309 getNextCallbackId: getNextCallbackId, |
| 310 addWatchCallback: addWatchCallback, |
| 311 removeWatchCallback: removeWatchCallback |
| 312 }; |
| 313 })(); |
| 314 |
OLD | NEW |