Revert of [debugger] flood function for stepping before calling it.

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 53 matching lines @@
   if (resolver === promiseRawSymbol) {
     return %NewObject(GlobalPromise, new.target);
   }
   if (IS_UNDEFINED(new.target)) throw MakeTypeError(kNotAPromise, this);
   if (!IS_CALLABLE(resolver))
     throw MakeTypeError(kResolverNotAFunction, resolver);
 
   var promise = PromiseInit(%NewObject(GlobalPromise, new.target));
 
   try {
-    %DebugPushPromise(promise, Promise);
+    %DebugPushPromise(promise, Promise, resolver);
     var callbacks = CreateResolvingFunctions(promise);
     resolver(callbacks.resolve, callbacks.reject);
   } catch (e) {
     PromiseReject(promise, e);
   } finally {
     %DebugPopPromise();
   }
 
   return promise;
 }
@@ skipping 47 matching lines @@
         deferred.reject(r);
       }
       return deferred.promise;
     }
   }
   return x;
 }
 
 function PromiseHandle(value, handler, deferred) {
   try {
-    %DebugPushPromise(deferred.promise, PromiseHandle);
+    %DebugPushPromise(deferred.promise, PromiseHandle, handler);
     var result = handler(value);
     if (result === deferred.promise)
       throw MakeTypeError(kPromiseCyclic, result);
     else if (IsPromise(result))
       %_Call(PromiseChain, result, deferred.resolve, deferred.reject);
     else
       deferred.resolve(result);
   } catch (exception) {
     try { deferred.reject(exception); } catch (e) { }
   } finally {
@@ skipping 180 matching lines @@
   onReject = IS_CALLABLE(onReject) ? onReject : PromiseIdRejectHandler;
   var that = this;
   var constructor = this.constructor;
   return %_Call(
     PromiseChainInternal,
     this,
     constructor,
     function(x) {
       x = PromiseCoerce(constructor, x);
       if (x === that) {
+        DEBUG_PREPARE_STEP_IN_IF_STEPPING(onReject);
         return onReject(MakeTypeError(kPromiseCyclic, x));
       } else if (IsPromise(x)) {
         return x.then(onResolve, onReject);
       } else {
+        DEBUG_PREPARE_STEP_IN_IF_STEPPING(onResolve);
         return onResolve(x);
       }
     },
     onReject
   );
 }
 
 // Combinators.
 
 function PromiseCast(x) {
@@ skipping 120 matching lines @@
 [PromiseChain, PromiseDeferred, PromiseResolved].forEach(
     fn => %FunctionRemovePrototype(fn));
 
 utils.Export(function(to) {
   to.PromiseChain = PromiseChain;
   to.PromiseDeferred = PromiseDeferred;
   to.PromiseResolved = PromiseResolved;
 });
 
 })