[inspector] introduced stepIntoAsync for chained callbacks

test/inspector/debugger/async-step-into-for-promise.js

Index: test/inspector/debugger/async-step-into-for-promise.js
diff --git a/test/inspector/debugger/async-step-into-for-promise.js b/test/inspector/debugger/async-step-into-for-promise.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d071c432599852de7d6758b3583335e1a3414d9
--- /dev/null
+++ b/test/inspector/debugger/async-step-into-for-promise.js
@@ -0,0 +1,311 @@
+// Copyright 2017 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.
+
+print('Checks Protocol.Debugger.stepIntoAsync() for promises');
+
+InspectorTest.addScript(`
+function foo1() {
+}
+
+function foo2() {
+}
+
+function promiseThen() {
+  var resolve1;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  debugger;
+  var p2 = p1.then(foo1);
+  resolve1();
+  return p2;
+}
+
+function promiseThenWithoutAssignment() {
+  var nextTest;
+  var testPromise = new Promise(resolve => nextTest = resolve);
+
+  var resolve1;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  debugger;
+  p1.then(foo1).then(nextTest);
+  resolve1();
+  return testPromise;
+}
+
+function promiseAll() {
+  var resolve1;
+  var resolve2;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  var p2 = new Promise(resolve => resolve2 = resolve);
+  debugger;
+  var p3 = Promise.all([ p1, p2 ]).then(foo1);
+  resolve1();
+  resolve2();
+  return p3;
+}
+
+function promiseAllWithoutAssignment() {
+  var nextTest;
+  var testPromise = new Promise(resolve => nextTest = resolve);
+
+  var resolve1;
+  var resolve2;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  var p2 = new Promise(resolve => resolve2 = resolve);
+
+  debugger;
+  Promise.all([ p1, p2 ]).then(foo1).then(nextTest);
+  resolve1();
+  resolve2();
+  return testPromise;
+}
+
+function promise() {
+  debugger;
+  var resolve;
+  var p1 = new Promise(r => resolve = r);
+  var p2 = p1.then(foo1);
+  resolve();
+  return p2;
+}
+
+function promiseResolvedBySetTimeout() {
+  var resolve;
+  var p1 = new Promise(r => resolve = r);
+  debugger;
+  var p2 = p1.then(foo1);
+  setTimeout(resolve, 0);
+  return p2;
+}
+
+function promiseAllWithPrimitiveValues() {
+  debugger;
+  return Promise.all([ 1, 2 ]).then(foo1);
+}
+
+function promiseAllReverseOrder() {
+  var resolve1;
+  var resolve2;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  var p2 = new Promise(resolve => resolve2 = resolve);
+  debugger;
+  var p3 = Promise.all([ p1, p2 ]).then(foo1);
+  resolve2();
+  resolve1();
+  return p3;
+}
+
+function promiseRace() {
+  var resolve1;
+  var resolve2;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  var p2 = new Promise(resolve => resolve2 = resolve);
+  debugger;
+  var p3 = Promise.race([ p1, p2 ]).then(foo1);
+  resolve1();
+  resolve2();
+  return p3;
+}
+
+function twoChainedCallbacks() {
+  var resolve1;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  debugger;
+  var p2 = p1.then(foo1).then(foo2);
+  resolve1();
+  return p2;
+}
+
+function promiseResolve() {
+  debugger;
+  return Promise.resolve().then(foo1).then(foo2);
+}
+
+function thenableJobResolvedInSetTimeout() {
+  function thenableJob() {
+    var resolve2;
+    var p2 = new Promise(resolve => resolve2 = resolve);
+    setTimeout(resolve2, 0);
+    return p2;
+  }
+  var resolve1;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  debugger;
+  var p3 = p1.then(() => thenableJob()).then(foo1);
+  resolve1();
+  return p3;
+}
+
+function thenableJobResolvedByPromise() {
+  function thenableJob() {
+    var resolve2;
+    var p2 = new Promise(resolve => resolve2 = resolve);
+    Promise.resolve().then(resolve2);
+    return p2;
+  }
+  var resolve1;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  debugger;
+  var p3 = p1.then(() => thenableJob()).then(foo1);
+  resolve1();
+  return p3;
+}
+
+function lateThenCallback() {
+  var resolve1;
+  var p1 = new Promise(resolve => resolve1 = resolve);
+  resolve1();
+  debugger;
+  return p1.then(foo1);
+}
+
+function complex() {
+  var testResolve;
+  var testPromise = new Promise(resolve => testResolve = resolve);
+
+  function foo1() {
+  }
+
+  function foo2() {
+    var resolve20;
+    function inner2() {
+      resolve20();
+    }
+    var p20 = new Promise(resolve => resolve20 = resolve);
+    Promise.resolve().then(inner2);
+    return p20;
+  }
+
+  function foo3() {
+    var resolve17;
+    function inner3() {
+      resolve17();
+    }
+    var p17 = new Promise(resolve => resolve17 = resolve);
+    setTimeout(inner3, 0);
+    return p17;
+  }
+
+  function foo4() {
+    function inner4() {
+      return;
+    }
+    return inner4();
+  }
+
+  function foo5() {
+    return Promise.all([ Promise.resolve(), Promise.resolve() ])
+      .then(() => 42);
+  }
+
+  function foo6() {
+    return Promise.race([ Promise.resolve(), Promise.resolve()])
+      .then(() => 42);
+  }
+
+  debugger;
+  var p = Promise.resolve()
+    .then(foo6)
+    .then(foo5)
+    .then(foo4)
+    .then(foo3)
+    .then(foo2)
+    .then(foo1);
+
+  return testPromise;
+}
+
+function reject() {
+  debugger;
+  return Promise.reject().catch(foo1);
+}
+
+//# sourceURL=test.js`, 7, 26);
+
+InspectorTest.setupScriptMap();
+var testActions = [];
+Protocol.Debugger.onPaused(message => {
+  InspectorTest.log('reason: ' + message.params.reason);
+  InspectorTest.logCallFrames(message.params.callFrames);
+  InspectorTest.logAsyncStackTrace(message.params.asyncStackTrace);
+  var action = testActions.shift() || 'resume';
+  InspectorTest.log('executing ' + action);
+  Protocol.Debugger[action]().then(message => {
+    if (!message.error) return;
+    InspectorTest.logMessage(message);
+    Protocol.Debugger.resume();
+  });
+  InspectorTest.log('');
+});
+
+Protocol.Debugger.enable();
+Protocol.Debugger.setAsyncCallStackDepth({ maxDepth: 128 });
+var testListWithoutAsync = [
+  [ 'promiseThen', 2 ],
+  [ 'promiseThenWithoutAssignment', 2 ],
+  [ 'promiseAll', 4 ],
+  [ 'promiseAllWithoutAssignment', 2 ],
+];
+var testListWithAsync = [
+  [ 'promiseThen', 2 ],
+  [ 'promiseThenWithoutAssignment', 2 ],
+  [ 'promiseAll', 6 ],
+  [ 'promiseAllWithoutAssignment', 4 ],
+/*
+  [ 'promise', 5 ],
+  [ 'promiseResolvedBySetTimeout', 2 ],
+  [ 'promiseAllReverseOrder', 4 ],
+  [ 'promiseAllWithPrimitiveValues', 2 ],
+  [ 'promiseRace', 4 ],
+  [ 'twoChainedCallbacks', 3 ],
+  [ 'twoChainedCallbacks', 5 ],
+  [ 'promiseResolve', 2 ],
+  [ 'promiseResolve', 3 ],
+  [ 'thenableJobResolvedInSetTimeout', 5 ],
+  [ 'thenableJobResolvedByPromise', 5 ],
+  [ 'lateThenCallback', 2 ],
+  [ 'reject', 2 ],
+  // [ 'complex', 1 ],
+*/
+];
+
+var testsWithoutAsync = testListWithoutAsync.map(test => {
+  var name = test[0];
+  var stepIntoBeforeAsync = test[1];
+  return eval(`
+  (function test${capitalize(name)}(next) {
+    runTestSuite('${name}()', ${stepIntoBeforeAsync}, next);
+  })
+  `);
+});
+
+var testsWithAsync = testListWithAsync.map(test => {
+  var name = test[0];
+  var stepIntoBeforeAsync = test[1];
+  return eval(`
+  (function test${capitalize(name)}(next) {
+    runTestSuite('${name}()', ${stepIntoBeforeAsync}, next);
+  })
+  `);
+});
+
+InspectorTest.runTestSuite(testsWithAsync.concat([
+  function switchAsyncOff(next) {
+    Protocol.Debugger.setAsyncCallStackDepth({ maxDepth: 0 })
+      .then(next);
+  }
+]).concat(testsWithoutAsync));
+
+function runTestSuite(expression, stepIntoBeforeAsync, next) {
+  testActions = [];
+  for (var i = 0; i < stepIntoBeforeAsync; ++i)
+    testActions.push('stepInto');
+  testActions.push('stepIntoAsync');
+  Protocol.Runtime.evaluate({
+    expression: expression + '//# sourceURL=expr.js',
+    awaitPromise: true }).then(next);
+}
+
+function capitalize(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}