Introduce debug events for Microtask queue.

src/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.
 
 "use strict";
 
 // This file relies on the fact that the following declaration has been made
 // in runtime.js:
 // var $Object = global.Object
 // var $WeakMap = global.WeakMap
@@ skipping 11 matching lines @@
 // mirror-debugger.js currently uses builtins.promiseStatus. It would be nice
 // if we could move these property names into the closure below.
 // TODO(jkummerow/rossberg/yangguo): Find a better solution.
 
 // Status values: 0 = pending, +1 = resolved, -1 = rejected
 var promiseStatus = GLOBAL_PRIVATE("Promise#status");
 var promiseValue = GLOBAL_PRIVATE("Promise#value");
 var promiseOnResolve = GLOBAL_PRIVATE("Promise#onResolve");
 var promiseOnReject = GLOBAL_PRIVATE("Promise#onReject");
 var promiseRaw = GLOBAL_PRIVATE("Promise#raw");
+var lastMicrotaskId = 0;
 
 (function() {
 
   var $Promise = function Promise(resolver) {
     if (resolver === promiseRaw) return;
     if (!%_IsConstructCall()) throw MakeTypeError('not_a_promise', [this]);
     if (!IS_SPEC_FUNCTION(resolver))
       throw MakeTypeError('resolver_not_a_function', [resolver]);
     var promise = PromiseInit(this);
     if (DEBUG_IS_ACTIVE) {
@@ skipping 22 matching lines @@
     return promise;
   }
 
   function PromiseInit(promise) {
     return PromiseSet(
         promise, 0, UNDEFINED, new InternalArray, new InternalArray)
   }
 
   function PromiseDone(promise, status, value, promiseQueue) {
     if (GET_PRIVATE(promise, promiseStatus) === 0) {
-      PromiseEnqueue(value, GET_PRIVATE(promise, promiseQueue));
+      PromiseEnqueue(value, GET_PRIVATE(promise, promiseQueue), status);
       PromiseSet(promise, status, value);
     }
   }
 
   function PromiseCoerce(constructor, x) {
     if (!IsPromise(x) && IS_SPEC_OBJECT(x)) {
       var then;
       try {
         then = x.then;
       } catch(r) {
@@ skipping 31 matching lines @@
         %DebugPromiseHandlePrologue(function() { return deferred.promise });
         deferred.reject(exception);
       } catch (e) { } finally {
         %DebugPromiseHandleEpilogue();
       }
     } finally {
       %DebugPromiseHandleEpilogue();
     }
   }
 
-  function PromiseEnqueue(value, tasks) {
+  function PromiseEnqueue(value, tasks, status) {
+    var id, name, instrumenting = DEBUG_IS_ACTIVE;
     %EnqueueMicrotask(function() {
+      if (instrumenting) {
+        %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
+      }
       for (var i = 0; i < tasks.length; i += 2) {
         PromiseHandle(value, tasks[i], tasks[i + 1])
       }
+      if (instrumenting) {
+        %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name });
+      }
     });
+    if (instrumenting) {
+      id = ++lastMicrotaskId;
+      name = status > 0 ? "Promise.Resolved" : "Promise.Rejected";
+      %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
+    }
   }
 
   function PromiseIdResolveHandler(x) { return x }
   function PromiseIdRejectHandler(r) { throw r }
 
   function PromiseNopResolver() {}
 
   // -------------------------------------------------------------------
   // Define exported functions.
 
@@ skipping 50 matching lines @@
       // Optimized case, avoid extra closure.
       return PromiseSet(new $Promise(promiseRaw), -1, r);
     } else {
       return new this(function(resolve, reject) { reject(r) });
     }
   }
 
   // Simple chaining.
 
   PromiseChain = function PromiseChain(onResolve, onReject) {  // a.k.a.
-                                                                // flatMap
+                                                               // flatMap
     onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
     onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
     var deferred = %_CallFunction(this.constructor, PromiseDeferred);
     switch (GET_PRIVATE(this, promiseStatus)) {
       case UNDEFINED:
         throw MakeTypeError('not_a_promise', [this]);
       case 0:  // Pending
         GET_PRIVATE(this, promiseOnResolve).push(onResolve, deferred);
         GET_PRIVATE(this, promiseOnReject).push(onReject, deferred);
         break;
       case +1:  // Resolved
-        PromiseEnqueue(GET_PRIVATE(this, promiseValue), [onResolve, deferred]);
+        PromiseEnqueue(GET_PRIVATE(this, promiseValue),
+                       [onResolve, deferred],
+                       +1);
         break;
       case -1:  // Rejected
-        PromiseEnqueue(GET_PRIVATE(this, promiseValue), [onReject, deferred]);
+        PromiseEnqueue(GET_PRIVATE(this, promiseValue),
+                       [onReject, deferred],
+                       -1);
         break;
     }
     return deferred.promise;
   }
 
   PromiseCatch = function PromiseCatch(onReject) {
     return this.then(UNDEFINED, onReject);
   }
 
   // Multi-unwrapped chaining with thenable coercion.
@@ skipping 85 matching lines @@
     "race", PromiseOne,
     "resolve", PromiseCast
   ]);
   InstallFunctions($Promise.prototype, DONT_ENUM, [
     "chain", PromiseChain,
     "then", PromiseThen,
     "catch", PromiseCatch
   ]);
 
 })();