[promises] Move PromiseReactionJob to c++

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 172 matching lines @@
       } else {
         %_Call(deferred.reject, UNDEFINED, exception);
       }
     } catch (e) { }
   } finally {
     if (debug_is_active) %DebugPopPromise();
   }
 }
 
 function PromiseEnqueue(value, tasks, deferreds, status) {
-  var id, name, instrumenting = DEBUG_IS_ACTIVE;
-  %EnqueueMicrotask(function() {
-    if (instrumenting) {
-      %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
-    }
-    if (IS_ARRAY(tasks)) {
-      for (var i = 0; i < tasks.length; i += 2) {
-        PromiseHandle(value, tasks[i], tasks[i + 1]);
-      }
-    } else {
-      PromiseHandle(value, tasks, deferreds);
-    }
-    if (instrumenting) {
-      %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name });
-    }
-  });
+  var id, name, beforeDebug, afterDebug, 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 = PromiseNextMicrotaskID();
       name = status === kFulfilled ? "Promise.resolve" : "Promise.reject";
       %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
     }
+
+    beforeDebug = { type: "willHandle", id: id, name: name };
+    afterDebug = { type: "didHandle", id: id, name: name };
   }
+
+  %EnqueuePromiseReactionJob(value, tasks, deferreds, beforeDebug, afterDebug);
 }
 
 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, promiseDeferredReactionsSymbol, deferred);
   } else if (!IS_ARRAY(maybeResolveCallbacks)) {
@@ skipping 457 matching lines @@
   "then", PromiseThen,
   "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_then", PromiseThen,
+  "promise_handle", PromiseHandle
 ]);
 
 // 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.PromiseNextMicrotaskID = PromiseNextMicrotaskID;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })