| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2012 the V8 project 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 (function(global, utils, extrasUtils) { | |
| 6 | |
| 7 "use strict"; | |
| 8 | |
| 9 %CheckIsBootstrapping(); | |
| 10 | |
| 11 // ------------------------------------------------------------------- | |
| 12 // Imports | |
| 13 | |
| 14 var InternalArray = utils.InternalArray; | |
| 15 var promiseHasHandlerSymbol = | |
| 16 utils.ImportNow("promise_has_handler_symbol"); | |
| 17 var promiseOnRejectSymbol = utils.ImportNow("promise_on_reject_symbol"); | |
| 18 var promiseOnResolveSymbol = | |
| 19 utils.ImportNow("promise_on_resolve_symbol"); | |
| 20 var promiseRawSymbol = utils.ImportNow("promise_raw_symbol"); | |
| 21 var promiseStatusSymbol = utils.ImportNow("promise_status_symbol"); | |
| 22 var promiseValueSymbol = utils.ImportNow("promise_value_symbol"); | |
| 23 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol"); | |
| 24 | |
| 25 // ------------------------------------------------------------------- | |
| 26 | |
| 27 // Status values: 0 = pending, +1 = resolved, -1 = rejected | |
| 28 var lastMicrotaskId = 0; | |
| 29 | |
| 30 var GlobalPromise = function Promise(resolver) { | |
| 31 if (resolver === promiseRawSymbol) return; | |
| 32 if (!%_IsConstructCall()) throw MakeTypeError(kNotAPromise, this); | |
| 33 if (!IS_CALLABLE(resolver)) | |
| 34 throw MakeTypeError(kResolverNotAFunction, resolver); | |
| 35 var promise = PromiseInit(this); | |
| 36 try { | |
| 37 %DebugPushPromise(promise, Promise); | |
| 38 resolver(function(x) { PromiseResolve(promise, x) }, | |
| 39 function(r) { PromiseReject(promise, r) }); | |
| 40 } catch (e) { | |
| 41 PromiseReject(promise, e); | |
| 42 } finally { | |
| 43 %DebugPopPromise(); | |
| 44 } | |
| 45 } | |
| 46 | |
| 47 // Core functionality. | |
| 48 | |
| 49 function PromiseSet(promise, status, value, onResolve, onReject) { | |
| 50 SET_PRIVATE(promise, promiseStatusSymbol, status); | |
| 51 SET_PRIVATE(promise, promiseValueSymbol, value); | |
| 52 SET_PRIVATE(promise, promiseOnResolveSymbol, onResolve); | |
| 53 SET_PRIVATE(promise, promiseOnRejectSymbol, onReject); | |
| 54 if (DEBUG_IS_ACTIVE) { | |
| 55 %DebugPromiseEvent({ promise: promise, status: status, value: value }); | |
| 56 } | |
| 57 return promise; | |
| 58 } | |
| 59 | |
| 60 function PromiseCreateAndSet(status, value) { | |
| 61 var promise = new GlobalPromise(promiseRawSymbol); | |
| 62 // If debug is active, notify about the newly created promise first. | |
| 63 if (DEBUG_IS_ACTIVE) PromiseSet(promise, 0, UNDEFINED); | |
| 64 return PromiseSet(promise, status, value); | |
| 65 } | |
| 66 | |
| 67 function PromiseInit(promise) { | |
| 68 return PromiseSet( | |
| 69 promise, 0, UNDEFINED, new InternalArray, new InternalArray) | |
| 70 } | |
| 71 | |
| 72 function PromiseDone(promise, status, value, promiseQueue) { | |
| 73 if (GET_PRIVATE(promise, promiseStatusSymbol) === 0) { | |
| 74 var tasks = GET_PRIVATE(promise, promiseQueue); | |
| 75 if (tasks.length) PromiseEnqueue(value, tasks, status); | |
| 76 PromiseSet(promise, status, value); | |
| 77 } | |
| 78 } | |
| 79 | |
| 80 function PromiseCoerce(constructor, x) { | |
| 81 if (!IsPromise(x) && IS_SPEC_OBJECT(x)) { | |
| 82 var then; | |
| 83 try { | |
| 84 then = x.then; | |
| 85 } catch(r) { | |
| 86 return %_CallFunction(constructor, r, PromiseRejected); | |
| 87 } | |
| 88 if (IS_CALLABLE(then)) { | |
| 89 var deferred = %_CallFunction(constructor, PromiseDeferred); | |
| 90 try { | |
| 91 %_Call(then, x, deferred.resolve, deferred.reject); | |
| 92 } catch(r) { | |
| 93 deferred.reject(r); | |
| 94 } | |
| 95 return deferred.promise; | |
| 96 } | |
| 97 } | |
| 98 return x; | |
| 99 } | |
| 100 | |
| 101 function PromiseHandle(value, handler, deferred) { | |
| 102 try { | |
| 103 %DebugPushPromise(deferred.promise, PromiseHandle); | |
| 104 DEBUG_PREPARE_STEP_IN_IF_STEPPING(handler); | |
| 105 var result = handler(value); | |
| 106 if (result === deferred.promise) | |
| 107 throw MakeTypeError(kPromiseCyclic, result); | |
| 108 else if (IsPromise(result)) | |
| 109 %_CallFunction(result, deferred.resolve, deferred.reject, PromiseChain); | |
| 110 else | |
| 111 deferred.resolve(result); | |
| 112 } catch (exception) { | |
| 113 try { deferred.reject(exception); } catch (e) { } | |
| 114 } finally { | |
| 115 %DebugPopPromise(); | |
| 116 } | |
| 117 } | |
| 118 | |
| 119 function PromiseEnqueue(value, tasks, status) { | |
| 120 var id, name, instrumenting = DEBUG_IS_ACTIVE; | |
| 121 %EnqueueMicrotask(function() { | |
| 122 if (instrumenting) { | |
| 123 %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name }); | |
| 124 } | |
| 125 for (var i = 0; i < tasks.length; i += 2) { | |
| 126 PromiseHandle(value, tasks[i], tasks[i + 1]) | |
| 127 } | |
| 128 if (instrumenting) { | |
| 129 %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name }); | |
| 130 } | |
| 131 }); | |
| 132 if (instrumenting) { | |
| 133 id = ++lastMicrotaskId; | |
| 134 name = status > 0 ? "Promise.resolve" : "Promise.reject"; | |
| 135 %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name }); | |
| 136 } | |
| 137 } | |
| 138 | |
| 139 function PromiseIdResolveHandler(x) { return x } | |
| 140 function PromiseIdRejectHandler(r) { throw r } | |
| 141 | |
| 142 function PromiseNopResolver() {} | |
| 143 | |
| 144 // ------------------------------------------------------------------- | |
| 145 // Define exported functions. | |
| 146 | |
| 147 // For bootstrapper. | |
| 148 | |
| 149 function IsPromise(x) { | |
| 150 return IS_SPEC_OBJECT(x) && HAS_DEFINED_PRIVATE(x, promiseStatusSymbol); | |
| 151 } | |
| 152 | |
| 153 function PromiseCreate() { | |
| 154 return new GlobalPromise(PromiseNopResolver) | |
| 155 } | |
| 156 | |
| 157 function PromiseResolve(promise, x) { | |
| 158 PromiseDone(promise, +1, x, promiseOnResolveSymbol) | |
| 159 } | |
| 160 | |
| 161 function PromiseReject(promise, r) { | |
| 162 // Check promise status to confirm that this reject has an effect. | |
| 163 // Call runtime for callbacks to the debugger or for unhandled reject. | |
| 164 if (GET_PRIVATE(promise, promiseStatusSymbol) == 0) { | |
| 165 var debug_is_active = DEBUG_IS_ACTIVE; | |
| 166 if (debug_is_active || | |
| 167 !HAS_DEFINED_PRIVATE(promise, promiseHasHandlerSymbol)) { | |
| 168 %PromiseRejectEvent(promise, r, debug_is_active); | |
| 169 } | |
| 170 } | |
| 171 PromiseDone(promise, -1, r, promiseOnRejectSymbol) | |
| 172 } | |
| 173 | |
| 174 // Convenience. | |
| 175 | |
| 176 function PromiseDeferred() { | |
| 177 if (this === GlobalPromise) { | |
| 178 // Optimized case, avoid extra closure. | |
| 179 var promise = PromiseInit(new GlobalPromise(promiseRawSymbol)); | |
| 180 return { | |
| 181 promise: promise, | |
| 182 resolve: function(x) { PromiseResolve(promise, x) }, | |
| 183 reject: function(r) { PromiseReject(promise, r) } | |
| 184 }; | |
| 185 } else { | |
| 186 var result = {promise: UNDEFINED, reject: UNDEFINED, resolve: UNDEFINED}; | |
| 187 result.promise = new this(function(resolve, reject) { | |
| 188 result.resolve = resolve; | |
| 189 result.reject = reject; | |
| 190 }); | |
| 191 return result; | |
| 192 } | |
| 193 } | |
| 194 | |
| 195 function PromiseResolved(x) { | |
| 196 if (this === GlobalPromise) { | |
| 197 // Optimized case, avoid extra closure. | |
| 198 return PromiseCreateAndSet(+1, x); | |
| 199 } else { | |
| 200 return new this(function(resolve, reject) { resolve(x) }); | |
| 201 } | |
| 202 } | |
| 203 | |
| 204 function PromiseRejected(r) { | |
| 205 var promise; | |
| 206 if (this === GlobalPromise) { | |
| 207 // Optimized case, avoid extra closure. | |
| 208 promise = PromiseCreateAndSet(-1, r); | |
| 209 // The debug event for this would always be an uncaught promise reject, | |
| 210 // which is usually simply noise. Do not trigger that debug event. | |
| 211 %PromiseRejectEvent(promise, r, false); | |
| 212 } else { | |
| 213 promise = new this(function(resolve, reject) { reject(r) }); | |
| 214 } | |
| 215 return promise; | |
| 216 } | |
| 217 | |
| 218 // Simple chaining. | |
| 219 | |
| 220 function PromiseChain(onResolve, onReject) { // a.k.a. flatMap | |
| 221 onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve; | |
| 222 onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject; | |
| 223 var deferred = %_CallFunction(this.constructor, PromiseDeferred); | |
| 224 switch (GET_PRIVATE(this, promiseStatusSymbol)) { | |
| 225 case UNDEFINED: | |
| 226 throw MakeTypeError(kNotAPromise, this); | |
| 227 case 0: // Pending | |
| 228 GET_PRIVATE(this, promiseOnResolveSymbol).push(onResolve, deferred); | |
| 229 GET_PRIVATE(this, promiseOnRejectSymbol).push(onReject, deferred); | |
| 230 break; | |
| 231 case +1: // Resolved | |
| 232 PromiseEnqueue(GET_PRIVATE(this, promiseValueSymbol), | |
| 233 [onResolve, deferred], | |
| 234 +1); | |
| 235 break; | |
| 236 case -1: // Rejected | |
| 237 if (!HAS_DEFINED_PRIVATE(this, promiseHasHandlerSymbol)) { | |
| 238 // Promise has already been rejected, but had no handler. | |
| 239 // Revoke previously triggered reject event. | |
| 240 %PromiseRevokeReject(this); | |
| 241 } | |
| 242 PromiseEnqueue(GET_PRIVATE(this, promiseValueSymbol), | |
| 243 [onReject, deferred], | |
| 244 -1); | |
| 245 break; | |
| 246 } | |
| 247 // Mark this promise as having handler. | |
| 248 SET_PRIVATE(this, promiseHasHandlerSymbol, true); | |
| 249 if (DEBUG_IS_ACTIVE) { | |
| 250 %DebugPromiseEvent({ promise: deferred.promise, parentPromise: this }); | |
| 251 } | |
| 252 return deferred.promise; | |
| 253 } | |
| 254 | |
| 255 function PromiseCatch(onReject) { | |
| 256 return this.then(UNDEFINED, onReject); | |
| 257 } | |
| 258 | |
| 259 // Multi-unwrapped chaining with thenable coercion. | |
| 260 | |
| 261 function PromiseThen(onResolve, onReject) { | |
| 262 onResolve = IS_CALLABLE(onResolve) ? onResolve : PromiseIdResolveHandler; | |
| 263 onReject = IS_CALLABLE(onReject) ? onReject : PromiseIdRejectHandler; | |
| 264 var that = this; | |
| 265 var constructor = this.constructor; | |
| 266 return %_CallFunction( | |
| 267 this, | |
| 268 function(x) { | |
| 269 x = PromiseCoerce(constructor, x); | |
| 270 if (x === that) { | |
| 271 DEBUG_PREPARE_STEP_IN_IF_STEPPING(onReject); | |
| 272 return onReject(MakeTypeError(kPromiseCyclic, x)); | |
| 273 } else if (IsPromise(x)) { | |
| 274 return x.then(onResolve, onReject); | |
| 275 } else { | |
| 276 DEBUG_PREPARE_STEP_IN_IF_STEPPING(onResolve); | |
| 277 return onResolve(x); | |
| 278 } | |
| 279 }, | |
| 280 onReject, | |
| 281 PromiseChain | |
| 282 ); | |
| 283 } | |
| 284 | |
| 285 // Combinators. | |
| 286 | |
| 287 function PromiseCast(x) { | |
| 288 if (IsPromise(x) && x.constructor === this) { | |
| 289 return x; | |
| 290 } else { | |
| 291 return new this(function(resolve) { resolve(x) }); | |
| 292 } | |
| 293 } | |
| 294 | |
| 295 function PromiseAll(iterable) { | |
| 296 var deferred = %_CallFunction(this, PromiseDeferred); | |
| 297 var resolutions = []; | |
| 298 try { | |
| 299 var count = 0; | |
| 300 var i = 0; | |
| 301 for (var value of iterable) { | |
| 302 this.resolve(value).then( | |
| 303 // Nested scope to get closure over current i. | |
| 304 // TODO(arv): Use an inner let binding once available. | |
| 305 (function(i) { | |
| 306 return function(x) { | |
| 307 resolutions[i] = x; | |
| 308 if (--count === 0) deferred.resolve(resolutions); | |
| 309 } | |
| 310 })(i), | |
| 311 function(r) { deferred.reject(r); }); | |
| 312 ++i; | |
| 313 ++count; | |
| 314 } | |
| 315 | |
| 316 if (count === 0) { | |
| 317 deferred.resolve(resolutions); | |
| 318 } | |
| 319 | |
| 320 } catch (e) { | |
| 321 deferred.reject(e) | |
| 322 } | |
| 323 return deferred.promise; | |
| 324 } | |
| 325 | |
| 326 function PromiseRace(iterable) { | |
| 327 var deferred = %_CallFunction(this, PromiseDeferred); | |
| 328 try { | |
| 329 for (var value of iterable) { | |
| 330 this.resolve(value).then( | |
| 331 function(x) { deferred.resolve(x) }, | |
| 332 function(r) { deferred.reject(r) }); | |
| 333 } | |
| 334 } catch (e) { | |
| 335 deferred.reject(e) | |
| 336 } | |
| 337 return deferred.promise; | |
| 338 } | |
| 339 | |
| 340 | |
| 341 // Utility for debugger | |
| 342 | |
| 343 function PromiseHasUserDefinedRejectHandlerRecursive(promise) { | |
| 344 var queue = GET_PRIVATE(promise, promiseOnRejectSymbol); | |
| 345 if (IS_UNDEFINED(queue)) return false; | |
| 346 for (var i = 0; i < queue.length; i += 2) { | |
| 347 if (queue[i] != PromiseIdRejectHandler) return true; | |
| 348 if (PromiseHasUserDefinedRejectHandlerRecursive(queue[i + 1].promise)) { | |
| 349 return true; | |
| 350 } | |
| 351 } | |
| 352 return false; | |
| 353 } | |
| 354 | |
| 355 // Return whether the promise will be handled by a user-defined reject | |
| 356 // handler somewhere down the promise chain. For this, we do a depth-first | |
| 357 // search for a reject handler that's not the default PromiseIdRejectHandler. | |
| 358 function PromiseHasUserDefinedRejectHandler() { | |
| 359 return PromiseHasUserDefinedRejectHandlerRecursive(this); | |
| 360 }; | |
| 361 | |
| 362 // ------------------------------------------------------------------- | |
| 363 // Install exported functions. | |
| 364 | |
| 365 %AddNamedProperty(global, 'Promise', GlobalPromise, DONT_ENUM); | |
| 366 %AddNamedProperty(GlobalPromise.prototype, toStringTagSymbol, "Promise", | |
| 367 DONT_ENUM | READ_ONLY); | |
| 368 | |
| 369 utils.InstallFunctions(GlobalPromise, DONT_ENUM, [ | |
| 370 "defer", PromiseDeferred, | |
| 371 "accept", PromiseResolved, | |
| 372 "reject", PromiseRejected, | |
| 373 "all", PromiseAll, | |
| 374 "race", PromiseRace, | |
| 375 "resolve", PromiseCast | |
| 376 ]); | |
| 377 | |
| 378 utils.InstallFunctions(GlobalPromise.prototype, DONT_ENUM, [ | |
| 379 "chain", PromiseChain, | |
| 380 "then", PromiseThen, | |
| 381 "catch", PromiseCatch | |
| 382 ]); | |
| 383 | |
| 384 %InstallToContext([ | |
| 385 "promise_catch", PromiseCatch, | |
| 386 "promise_chain", PromiseChain, | |
| 387 "promise_create", PromiseCreate, | |
| 388 "promise_has_user_defined_reject_handler", PromiseHasUserDefinedRejectHandler, | |
| 389 "promise_reject", PromiseReject, | |
| 390 "promise_resolve", PromiseResolve, | |
| 391 "promise_then", PromiseThen, | |
| 392 ]); | |
| 393 | |
| 394 // This allows extras to create promises quickly without building extra | |
| 395 // resolve/reject closures, and allows them to later resolve and reject any | |
| 396 // promise without having to hold on to those closures forever. | |
| 397 utils.InstallFunctions(extrasUtils, 0, [ | |
| 398 "createPromise", PromiseCreate, | |
| 399 "resolvePromise", PromiseResolve, | |
| 400 "rejectPromise", PromiseReject | |
| 401 ]); | |
| 402 | |
| 403 }) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1398733002:
Move builtin JavaScript sources into own directory. (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master