Allow stepping into Promise handlers.

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 85 matching lines @@
         }
         return deferred.promise;
       }
     }
     return x;
   }
 
   function PromiseHandle(value, handler, deferred) {
     try {
       %DebugPushPromise(deferred.promise);
+      var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(handler);
+      if (stepping) %DebugPrepareStepInIfStepping(handler);
       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) {
       try { deferred.reject(exception); } catch (e) { }
     } finally {
@@ skipping 147 matching lines @@
     onResolve = IS_SPEC_FUNCTION(onResolve) ? onResolve
                                             : PromiseIdResolveHandler;
     onReject = IS_SPEC_FUNCTION(onReject) ? onReject
                                           : PromiseIdRejectHandler;
     var that = this;
     var constructor = this.constructor;
     return %_CallFunction(
       this,
       function(x) {
         x = PromiseCoerce(constructor, x);
-        return x === that ? onReject(MakeTypeError('promise_cyclic', [x])) :
-               IsPromise(x) ? x.then(onResolve, onReject) : onResolve(x);
+        if (x === that) {
+          if (DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(onReject)) {

[Yang, 2014/11/17 19:41:02]

This conditional is used in a lot of places now. Do we want to introduce its own
macro in macros.py?

+            %DebugPrepareStepInIfStepping(onReject);
+          }
+          return onReject(MakeTypeError('promise_cyclic', [x]));
+        } else if (IsPromise(x)) {
+          return x.then(onResolve, onReject);
+        } else {
+          if (DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(onResolve)) {
+            %DebugPrepareStepInIfStepping(onResolve);
+          }
+          return onResolve(x);
+        }
       },
       onReject,
       PromiseChain
     );
   }
 
   // Combinators.
 
   function PromiseCast(x) {
     // TODO(rossberg): cannot do better until we support @@create.
@@ skipping 90 matching lines @@
     "race", PromiseOne,
     "resolve", PromiseCast
   ]);
   InstallFunctions($Promise.prototype, DONT_ENUM, [
     "chain", PromiseChain,
     "then", PromiseThen,
     "catch", PromiseCatch
   ]);
 
 })();