Introduce more debug events for promises.

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 22 matching lines @@
 
 (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) {
-      %DebugPromiseEvent({ type : "new Promise",
+      %DebugPromiseEvent({ type : "new",
                            promise: this,
                            resolver: resolver });
     }
     try {
       %DebugPromiseHandlePrologue(function() { return promise });
       resolver(function(x) { PromiseResolve(promise, x) },
                function(r) { PromiseReject(promise, r) });
     } catch (e) {
       PromiseReject(promise, e);
     } finally {
@@ skipping 13 matching lines @@
 
   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), status);
       PromiseSet(promise, status, value);
+      if (DEBUG_IS_ACTIVE) {
+        %DebugPromiseEvent({ type: "update",
+                             promise: promise,
+                             status: status,
+                             value: value });
+      }
     }
   }
 
   function PromiseCoerce(constructor, x) {
     if (!IsPromise(x) && IS_SPEC_OBJECT(x)) {
       var then;
       try {
         then = x.then;
       } catch(r) {
         return %_CallFunction(constructor, r, PromiseRejected);
@@ skipping 98 matching lines @@
       var result = {};
       result.promise = new this(function(resolve, reject) {
         result.resolve = resolve;
         result.reject = reject;
       })
       return result;
     }
   }
 
   function PromiseResolved(x) {
+    var promise;
     if (this === $Promise) {
       // Optimized case, avoid extra closure.
-      return PromiseSet(new $Promise(promiseRaw), +1, x);
+      promise = PromiseSet(new $Promise(promiseRaw), +1, x);
     } else {
-      return new this(function(resolve, reject) { resolve(x) });
+      promise = new this(function(resolve, reject) { resolve(x) });
     }
+    if (DEBUG_IS_ACTIVE) {
+      %DebugPromiseEvent({ type: "update",
+                           promise: promise,
+                           status: 1,
+                           value: x });
+    }
+    return promise;
   }
 
   function PromiseRejected(r) {
+    var promise;
     if (this === $Promise) {
       // Optimized case, avoid extra closure.
-      return PromiseSet(new $Promise(promiseRaw), -1, r);
+      promise = PromiseSet(new $Promise(promiseRaw), -1, r);
     } else {
-      return new this(function(resolve, reject) { reject(r) });
+      promise = new this(function(resolve, reject) { reject(r) });
     }
+    if (DEBUG_IS_ACTIVE) {
+      %DebugPromiseEvent({ type: "update",

[aandrey, 2014/07/22 11:58:49]

now 3 update event calls instead of one doesn't look good. just revert to the
previous version and send the event "if (DEBUG_IS_ACTIVE && status)".

[Alexandra Mikhaylova, 2014/07/22 12:47:22]

Done.

+                           promise: promise,
+                           status: -1,
+                           value: r });
+    }
+    return promise;
   }
 
   // Simple chaining.
 
   PromiseChain = function PromiseChain(onResolve, onReject) {  // a.k.a.
                                                                // 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],
                        +1);
         break;
       case -1:  // Rejected
         PromiseEnqueue(GET_PRIVATE(this, promiseValue),
                        [onReject, deferred],
                        -1);
         break;
     }
+    if (DEBUG_IS_ACTIVE) {
+      %DebugPromiseEvent({ type: "chain",
+                           promise: deferred.promise,
+                           parentPromise: this });
+    }
     return deferred.promise;
   }
 
   PromiseCatch = function PromiseCatch(onReject) {
     return this.then(UNDEFINED, onReject);
   }
 
   // Multi-unwrapped chaining with thenable coercion.
 
   PromiseThen = function PromiseThen(onResolve, onReject) {
@@ skipping 87 matching lines @@
     "race", PromiseOne,
     "resolve", PromiseCast
   ]);
   InstallFunctions($Promise.prototype, DONT_ENUM, [
     "chain", PromiseChain,
     "then", PromiseThen,
     "catch", PromiseCatch
   ]);
 
 })();