Revert "Trigger exception debug event for promises at the throw site."

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 17 matching lines @@
   return IS_SPEC_OBJECT(x) && %HasLocalProperty(x, promiseStatus);
 }
 
 function Promise(resolver) {
   if (resolver === promiseRaw) return;
   if (!%_IsConstructCall()) throw MakeTypeError('not_a_promise', [this]);
   if (typeof resolver !== 'function')
     throw MakeTypeError('resolver_not_a_function', [resolver]);
   var promise = PromiseInit(this);
   try {
-    %DebugPromiseHandlePrologue(function() { return promise });
     resolver(function(x) { PromiseResolve(promise, x) },
              function(r) { PromiseReject(promise, r) });
   } catch (e) {
     PromiseReject(promise, e);
-  } finally {
-    %DebugPromiseHandleEpilogue();
   }
 }
 
 function PromiseSet(promise, status, value, onResolve, onReject) {
   SET_PRIVATE(promise, promiseStatus, status);
   SET_PRIVATE(promise, promiseValue, value);
   SET_PRIVATE(promise, promiseOnResolve, onResolve);
   SET_PRIVATE(promise, promiseOnReject, onReject);
   return promise;
 }
@@ skipping 102 matching lines @@
     for (var i = 0; i < tasks.length; i += 2) {
       PromiseHandle(value, tasks[i], tasks[i + 1])
     }
   });
 
   %SetMicrotaskPending(true);
 }
 
 function PromiseHandle(value, handler, deferred) {
   try {
-    %DebugPromiseHandlePrologue(
-        function() {
-          var queue = GET_PRIVATE(deferred.promise, promiseOnReject);
-          return (queue && queue.length == 0) ? deferred.promise : UNDEFINED;
-        });
     var result = handler(value);
     if (result === deferred.promise)
       throw MakeTypeError('promise_cyclic', [result]);
     else if (IsPromise(result))
       %_CallFunction(result, deferred.resolve, deferred.reject, PromiseChain);
     else
       deferred.resolve(result);
   } catch (exception) {
+    var uncaught = false;
+    var reject_queue = GET_PRIVATE(deferred.promise, promiseOnReject);
+    if (reject_queue && reject_queue.length == 0) {
+      // The deferred promise may get a reject handler attached later.
+      // For now, we consider the exception to be (for the moment) uncaught.
+      uncaught = true;
+    }
     try {
-      %DebugPromiseHandleEpilogue();  // Match the previous prologue.
-      %DebugPromiseHandlePrologue(function() { return deferred.promise });
       deferred.reject(exception);
-    } catch (e) { }
-  } finally {
-    %DebugPromiseHandleEpilogue();
+    } catch (e) {
+      // The reject handler can only throw for a custom deferred promise.
+      // We consider the original exception to be uncaught.
+      uncaught = true;
+    }
+    if (uncaught) %DebugPendingExceptionInPromise(exception, deferred.promise);
   }
 }
 
 
 // Multi-unwrapped chaining with thenable coercion.
 
 function PromiseThen(onResolve, onReject) {
   onResolve =
     IS_NULL_OR_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
   onReject =
@@ skipping 117 matching lines @@
   ]);
 }
 
 SetUpPromise();
 
 // Functions to expose promise details to the debugger.
 function GetPromiseStatus(promise) {
   return GET_PRIVATE(promise, promiseStatus);
 }
 
+function GetPromiseOnResolve(promise) {
+  return GET_PRIVATE(promise, promiseOnResolve);
+}
+
+function GetPromiseOnReject(promise) {
+  return GET_PRIVATE(promise, promiseOnReject);
+}
+
 function GetPromiseValue(promise) {
   return GET_PRIVATE(promise, promiseValue);
 }