[promises] remove PromiseEnqueue

src/js/promise.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 128 matching lines @@
 }
 
 function PromiseInit(promise) {
   return PromiseSet(promise, kPending, UNDEFINED);
 }
 
 function FulfillPromise(promise, status, value, promiseQueue) {
   var tasks = GET_PRIVATE(promise, promiseQueue);
   if (!IS_UNDEFINED(tasks)) {
     var deferred = GET_PRIVATE(promise, promiseDeferredReactionSymbol);
-    PromiseEnqueue(value, tasks, deferred, status);
+    %EnqueuePromiseReactionJob(value, tasks, deferred, status);
   }
   PromiseSet(promise, status, value);
 }
 
 function PromiseHandle(value, handler, deferred) {
   var debug_is_active = DEBUG_IS_ACTIVE;
   try {
     if (debug_is_active) %DebugPushPromise(deferred.promise);
     var result = handler(value);
     if (IS_UNDEFINED(deferred.resolve)) {
       ResolvePromise(deferred.promise, result);
     } else {
       %_Call(deferred.resolve, UNDEFINED, result);
     }
   } %catch (exception) {  // Natives syntax to mark this catch block.
     try {
       if (IS_UNDEFINED(deferred.reject)) {
         // Pass false for debugEvent so .then chaining does not trigger
         // redundant ExceptionEvents.
         RejectPromise(deferred.promise, exception, false);
       } else {
         %_Call(deferred.reject, UNDEFINED, exception);
       }
     } catch (e) { }
   } finally {
     if (debug_is_active) %DebugPopPromise();
   }
 }
 
-function PromiseEnqueue(value, tasks, deferreds, status) {
+function PromiseDebugGetInfo(deferreds, status) {
   var id, name, instrumenting = DEBUG_IS_ACTIVE;
 
   if (instrumenting) {
     // In an async function, reuse the existing stack related to the outer
     // Promise. Otherwise, e.g. in a direct call to then, save a new stack.
     // Promises with multiple reactions with one or more of them being async
     // functions will not get a good stack trace, as async functions require
     // different stacks from direct Promise use, but we save and restore a
     // stack once for all reactions. TODO(littledan): Improve this case.
     if (!IS_UNDEFINED(deferreds) &&
         HAS_PRIVATE(deferreds.promise, promiseHandledBySymbol) &&
         HAS_PRIVATE(GET_PRIVATE(deferreds.promise, promiseHandledBySymbol),
                     promiseAsyncStackIDSymbol)) {
       id = GET_PRIVATE(GET_PRIVATE(deferreds.promise, promiseHandledBySymbol),
                        promiseAsyncStackIDSymbol);
       name = "async function";
     } else {
       id = %DebugNextMicrotaskId();
       name = status === kFulfilled ? "Promise.resolve" : "Promise.reject";
       %DebugAsyncTaskEvent("enqueue", id, name);
     }
   }
-  %EnqueuePromiseReactionJob(value, tasks, deferreds, id, name);
+  return [id, name];
 }
 
 function PromiseAttachCallbacks(promise, deferred, onResolve, onReject) {
   var maybeResolveCallbacks =
       GET_PRIVATE(promise, promiseFulfillReactionsSymbol);
   if (IS_UNDEFINED(maybeResolveCallbacks)) {
     SET_PRIVATE(promise, promiseFulfillReactionsSymbol, onResolve);
     SET_PRIVATE(promise, promiseRejectReactionsSymbol, onReject);
     SET_PRIVATE(promise, promiseDeferredReactionSymbol, deferred);
   } else if (!IS_ARRAY(maybeResolveCallbacks)) {
@@ skipping 168 matching lines @@
 function PerformPromiseThen(promise, onResolve, onReject, resultCapability) {
   if (!IS_CALLABLE(onResolve)) onResolve = PromiseIdResolveHandler;
   if (!IS_CALLABLE(onReject)) onReject = PromiseIdRejectHandler;
 
   var status = GET_PRIVATE(promise, promiseStateSymbol);
   switch (status) {
     case kPending:
       PromiseAttachCallbacks(promise, resultCapability, onResolve, onReject);
       break;
     case kFulfilled:
-      PromiseEnqueue(GET_PRIVATE(promise, promiseResultSymbol),
-                     onResolve, resultCapability, kFulfilled);
+      %EnqueuePromiseReactionJob(GET_PRIVATE(promise, promiseResultSymbol),
+                                 onResolve, resultCapability, kFulfilled);
       break;
     case kRejected:
       if (!HAS_DEFINED_PRIVATE(promise, promiseHasHandlerSymbol)) {
         // Promise has already been rejected, but had no handler.
         // Revoke previously triggered reject event.
         %PromiseRevokeReject(promise);
       }
-      PromiseEnqueue(GET_PRIVATE(promise, promiseResultSymbol),
-                     onReject, resultCapability, kRejected);
+      %EnqueuePromiseReactionJob(GET_PRIVATE(promise, promiseResultSymbol),
+                                 onReject, resultCapability, kRejected);
       break;
   }
 
   // Mark this promise as having handler.
   SET_PRIVATE(promise, promiseHasHandlerSymbol, true);
   return resultCapability.promise;
 }
 
 // ES#sec-promise.prototype.then
 // Promise.prototype.then ( onFulfilled, onRejected )
@@ skipping 238 matching lines @@
   "catch", PromiseCatch
 ]);
 
 %InstallToContext([
   "promise_catch", PromiseCatch,
   "promise_create", PromiseCreate,
   "promise_has_user_defined_reject_handler", PromiseHasUserDefinedRejectHandler,
   "promise_reject", DoRejectPromise,
   "promise_resolve", ResolvePromise,
   "promise_then", PromiseThen,
-  "promise_handle", PromiseHandle
+  "promise_handle", PromiseHandle,
+  "promise_debug_get_info", PromiseDebugGetInfo
 ]);
 
 // This allows extras to create promises quickly without building extra
 // resolve/reject closures, and allows them to later resolve and reject any
 // promise without having to hold on to those closures forever.
 utils.InstallFunctions(extrasUtils, 0, [
   "createPromise", PromiseCreate,
   "resolvePromise", ResolvePromise,
   "rejectPromise", DoRejectPromise
 ]);
 
 utils.Export(function(to) {
   to.IsPromise = IsPromise;
   to.PromiseCreate = PromiseCreate;
   to.PromiseThen = PromiseThen;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })