Merge three PromiseEvent's into one.

This also adds missing instrumentation and removes resolver tracking.

BUG=v8:3093
LOG=N
R=aandrey@chromium.org, yangguo@chromium.org

Review URL: https://codereview.chromium.org/416213004

Patch from Alexandra Mikhaylova <amikhaylova@google.com>.

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22846 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/debug-debugger.js

@@ -1202,68 +1202,35 @@ function MakeScriptObject_(script, include_source) {
 
 
 function MakePromiseEvent(event_data) {
-  if (event_data.type == "new") {
-    return new NewPromiseEvent(event_data);
-  }
-  if (event_data.type == "update") {
-    return new UpdatePromiseStatusEvent(event_data);
-  }
-  if (event_data.type == "chain") {
-    return new UpdatePromiseParentEvent(event_data);
-  }
-}
-
-
-function PromiseGetter() {
-  return MakeMirror(this.promise_);
-}
-
-
-function NewPromiseEvent(event_data) {
-  this.resolver_ = event_data.resolver;
-  this.promise_ = event_data.promise;
-}
-
-
-NewPromiseEvent.prototype.promise = PromiseGetter;
-
-
-NewPromiseEvent.prototype.resolver = function() {
-  return MakeMirror(this.resolver_);
+  return new PromiseEvent(event_data);
 }
 
 
-function UpdatePromiseStatusEvent(event_data) {
+function PromiseEvent(event_data) {
   this.promise_ = event_data.promise;
+  this.parentPromise_ = event_data.parentPromise;
   this.status_ = event_data.status;
   this.value_ = event_data.value;
 }
 
 
-UpdatePromiseStatusEvent.prototype.promise = PromiseGetter;
-
-
-UpdatePromiseStatusEvent.prototype.status = function() {
-  return this.status_;
+PromiseEvent.prototype.promise = function() {
+  return MakeMirror(this.promise_);
 }
 
 
-UpdatePromiseStatusEvent.prototype.value = function() {
-  return MakeMirror(this.value_);
+PromiseEvent.prototype.parentPromise = function() {
+  return MakeMirror(this.parentPromise_);
 }
 
 
-function UpdatePromiseParentEvent(event_data) {
-  this.promise_ = event_data.promise;
-  this.parentPromise_ = event_data.parentPromise;
+PromiseEvent.prototype.status = function() {
+  return this.status_;
 }
 
 
-UpdatePromiseParentEvent.prototype.promise = PromiseGetter;
-
-
-UpdatePromiseParentEvent.prototype.parentPromise = function() {
-  return MakeMirror(this.parentPromise_);
+PromiseEvent.prototype.value = function() {
+  return MakeMirror(this.value_);
 }
 
 

src/promise.js

@@ -39,11 +39,6 @@ var lastMicrotaskId = 0;
     if (!IS_SPEC_FUNCTION(resolver))
       throw MakeTypeError('resolver_not_a_function', [resolver]);
     var promise = PromiseInit(this);
-    if (DEBUG_IS_ACTIVE) {
-      %DebugPromiseEvent({ type : "new",
-                           promise: this,
-                           resolver: resolver });
-    }
     try {
       %DebugPromiseHandlePrologue(function() { return promise });
       resolver(function(x) { PromiseResolve(promise, x) },
@@ -62,11 +57,8 @@ var lastMicrotaskId = 0;
     SET_PRIVATE(promise, promiseValue, value);
     SET_PRIVATE(promise, promiseOnResolve, onResolve);
     SET_PRIVATE(promise, promiseOnReject, onReject);
-    if (DEBUG_IS_ACTIVE && status !== 0) {
-      %DebugPromiseEvent({ type: "update",
-                           promise: promise,
-                           status: status,
-                           value: value });
+    if (DEBUG_IS_ACTIVE) {
+      %DebugPromiseEvent({ promise: promise, status: status, value: value });
     }
     return promise;
   }
@@ -241,9 +233,7 @@ var lastMicrotaskId = 0;
         break;
     }
     if (DEBUG_IS_ACTIVE) {
-      %DebugPromiseEvent({ type: "chain",
-                           promise: deferred.promise,
-                           parentPromise: this });
+      %DebugPromiseEvent({ promise: deferred.promise, parentPromise: this });
     }
     return deferred.promise;
   }

test/mjsunit/es6/debug-promise-events.js

+// Copyright 2014 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.
+
+// Flags: --allow-natives-syntax --expose-debug-as debug
+
+Debug = debug.Debug;
+
+var eventsExpected = 16;
+var exception = null;
+var result = [];
+
+function updatePromise(promise, parentPromise, status, value) {
+  var i;
+  for (i = 0; i < result.length; ++i) {
+    if (result[i].promise === promise) {
+      result[i].parentPromise = parentPromise || result[i].parentPromise;
+      result[i].status = status || result[i].status;
+      result[i].value = value || result[i].value;
+      break;
+    }
+  }
+  assertTrue(i < result.length);
+}
+
+function listener(event, exec_state, event_data, data) {
+  if (event != Debug.DebugEvent.PromiseEvent) return;
+  try {
+    eventsExpected--;
+    assertTrue(event_data.promise().isPromise());
+    if (event_data.status() === 0) {
+      // New promise.
+      assertEquals("pending", event_data.promise().status());
+      result.push({ promise: event_data.promise().value(), status: 0 });
+    } else if (event_data.status() !== undefined) {
+      // Resolve/reject promise.
+      updatePromise(event_data.promise().value(),
+                    undefined,
+                    event_data.status(),
+                    event_data.value().value());
+    } else {
+      // Chain promises.
+      assertTrue(event_data.parentPromise().isPromise());
+      updatePromise(event_data.promise().value(),
+                    event_data.parentPromise().value());
+    }
+  } catch (e) {
+    print(e + e.stack)
+    exception = e;
+  }
+}
+
+Debug.setListener(listener);
+
+function resolver(resolve, reject) {
+  resolve();
+}
+
+var p1 = new Promise(resolver);
+var p2 = p1.then().then();
+var p3 = new Promise(function(resolve, reject) { reject("rejected"); });
+var p4 = p3.then();
+var p5 = p1.then();
+
+function assertAsync(b, s) {
+  if (b) {
+    print(s, "succeeded");
+  } else {
+    %AbortJS(s + " FAILED!");
+  }
+}
+
+function testDone(iteration) {
+  function checkResult() {
+    if (eventsExpected === 0) {
+      assertAsync(result.length === 6, "result.length");
+
+      assertAsync(result[0].promise === p1, "result[0].promise");
+      assertAsync(result[0].parentPromise === undefined,
+                  "result[0].parentPromise");
+      assertAsync(result[0].status === 1, "result[0].status");
+      assertAsync(result[0].value === undefined, "result[0].value");
+
+      assertAsync(result[1].parentPromise === p1,
+                  "result[1].parentPromise");
+      assertAsync(result[1].status === 1, "result[1].status");
+
+      assertAsync(result[2].promise === p2, "result[2].promise");
+
+      assertAsync(result[3].promise === p3, "result[3].promise");
+      assertAsync(result[3].parentPromise === undefined,
+                  "result[3].parentPromise");
+      assertAsync(result[3].status === -1, "result[3].status");
+      assertAsync(result[3].value === "rejected", "result[3].value");
+
+      assertAsync(result[4].promise === p4, "result[4].promise");
+      assertAsync(result[4].parentPromise === p3,
+                  "result[4].parentPromise");
+      assertAsync(result[4].status === -1, "result[4].status");
+      assertAsync(result[4].value === "rejected", "result[4].value");
+
+      assertAsync(result[5].promise === p5, "result[5].promise");
+      assertAsync(result[5].parentPromise === p1,
+                  "result[5].parentPromise");
+      assertAsync(result[5].status === 1, "result[5].status");
+
+      assertAsync(exception === null, "exception === null");
+      Debug.setListener(null);
+    } else if (iteration > 10) {
+      %AbortJS("Not all events were received!");
+    } else {
+      testDone(iteration + 1);
+    }
+  }
+
+  var iteration = iteration || 0;
+  var dummy = {};
+  Object.observe(dummy, checkResult);
+  dummy.dummy = dummy;
+}
+
+testDone();

test/mjsunit/es6/debug-promises-new-event.js

-// Copyright 2014 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.
-
-// Flags: --expose-debug-as debug
-
-Debug = debug.Debug;
-
-var exception = null;
-var new_promise;
-
-function listener(event, exec_state, event_data, data) {
-  if (!(event_data instanceof debug.NewPromiseEvent)) return;
-  try {
-    assertTrue(event_data.resolver().isFunction());
-    assertEquals(resolver, event_data.resolver().value());
-    assertTrue(event_data.resolver().resolved());
-    assertEquals("resolver", event_data.resolver().name());
-    assertTrue(event_data.resolver().source().indexOf("Token") > 0);
-
-    assertTrue(event_data.promise().isPromise());
-    new_promise = event_data.promise().value();
-    assertEquals("pending", event_data.promise().status());
-  } catch (e) {
-    print(e + e.stack)
-    exception = e;
-  }
-}
-
-Debug.setListener(listener);
-
-function resolver(resolve, reject) {
-  resolve();  // Token
-}
-
-var p = new Promise(resolver);
-assertEquals(new_promise, p);
-
-assertNull(exception);
-Debug.setListener(null);

tools/generate-runtime-tests.py

@@ -51,7 +51,7 @@ EXPECTED_FUNCTION_COUNT = 425
 EXPECTED_FUZZABLE_COUNT = 328
 EXPECTED_CCTEST_COUNT = 7
 EXPECTED_UNKNOWN_COUNT = 16
-EXPECTED_BUILTINS_COUNT = 816
+EXPECTED_BUILTINS_COUNT = 813
 
 
 # Don't call these at all.