[promises] Move async debug event creation 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 167 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, beforeDebug, afterDebug, instrumenting = DEBUG_IS_ACTIVE;
+  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 = PromiseNextMicrotaskID();
       name = status === kFulfilled ? "Promise.resolve" : "Promise.reject";
-      %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
+      %DebugAsyncTaskEvent("enqueue", id, name);
     }
-
-    beforeDebug = { type: "willHandle", id: id, name: name };
-    afterDebug = { type: "didHandle", id: id, name: name };
   }
-
-  %EnqueuePromiseReactionJob(value, tasks, deferreds, beforeDebug, afterDebug);
+  %EnqueuePromiseReactionJob(value, tasks, deferreds, 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 73 matching lines @@
         }
         // Don't cause a debug event as this case is forwarding a rejection
         RejectPromise(promise, thenableValue, false);
         SET_PRIVATE(resolution, promiseHasHandlerSymbol, true);
         return;
       }
     }
 
     if (IS_CALLABLE(then)) {
       var callbacks = CreateResolvingFunctions(promise, false);
-      var id, before_debug_event, after_debug_event;
-      var instrumenting = DEBUG_IS_ACTIVE;
+      var id, name, instrumenting = DEBUG_IS_ACTIVE;
       if (instrumenting) {
         if (IsPromise(resolution)) {
           // Mark the dependency of the new promise on the resolution
           SET_PRIVATE(resolution, promiseHandledBySymbol, promise);
         }
         id = PromiseNextMicrotaskID();
-        before_debug_event = {
-          type: "willHandle",
-          id: id,
-          name: "PromiseResolveThenableJob"
-        };
-        after_debug_event = {
-          type: "didHandle",
-          id: id,
-          name: "PromiseResolveThenableJob"
-        };
-        %DebugAsyncTaskEvent({
-          type: "enqueue",
-          id: id,
-          name: "PromiseResolveThenableJob"
-        });
+        name = "PromiseResolveThenableJob";
+        %DebugAsyncTaskEvent("enqueue", id, name);
       }
       %EnqueuePromiseResolveThenableJob(
-          resolution, then, callbacks.resolve, callbacks.reject,
-          before_debug_event, after_debug_event);
+          resolution, then, callbacks.resolve, callbacks.reject, id, name);
       return;
     }
   }
   FulfillPromise(promise, kFulfilled, resolution,
                  promiseFulfillReactionsSymbol);
 }
 
 // ES#sec-rejectpromise
 // RejectPromise ( promise, reason )
 function RejectPromise(promise, reason, debugEvent) {
@@ skipping 364 matching lines @@
   to.PromiseNextMicrotaskID = PromiseNextMicrotaskID;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })