[inspector] removed call break location from for-of loop

test/inspector/debugger/for-of-loops.js

Index: test/inspector/debugger/for-of-loops.js
diff --git a/test/inspector/debugger/for-of-loops.js b/test/inspector/debugger/for-of-loops.js
new file mode 100644
index 0000000000000000000000000000000000000000..0bc9af6d3300345ce9fda6dabf5ae5e657fc900f
--- /dev/null
+++ b/test/inspector/debugger/for-of-loops.js
@@ -0,0 +1,104 @@
+// 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.
+
+let {session, contextGroup, Protocol} =
+  InspectorTest.start('Tests breakable locations in for-of loops.');
+
+let source = `
+function testFunction() {
+  var obj = {a : 1};
+  var arr = [1];
+  var all = [];
+  for (var k in arr) { all.push(k); }
+  for (var k of arr) { all.push(k); }
+  for (var k in obj) { all.push(k); }
+  for (let k in arr) { all.push(k); }
+  for (let k of arr) { all.push(k); }
+  for (let k in obj) { all.push(k); }
+
+  var iterable = {
+    [Symbol.iterator]() {
+      return {
+        i: 0,
+        next() {
+          if (this.i < 1) {
+            return { value: this.i++, done: false };
+          }
+          return { value: undefined, done: true };
+        }
+      };
+    }
+  };
+  for (var k of iterable) { all.push(k); }
+  iterable.i = 0;
+  for (let k of iterable) { all.push(k); }
+}
+//# sourceURL=test.js`;
+
+contextGroup.addScript(source);
+session.setupScriptMap();
+
+InspectorTest.runAsyncTestSuite([
+  async function testBreakLocations() {
+    Protocol.Debugger.enable();
+    let {params:{scriptId}} = await Protocol.Debugger.onceScriptParsed();
+    let {result:{locations}} = await Protocol.Debugger.getPossibleBreakpoints({
+      start: {lineNumber: 0, columnNumber : 0, scriptId}});
+    dumpAllLocations(locations);
+  },
+
+  async function testStepInto() {
+    Protocol.Debugger.pause();
+    let fin = Protocol.Runtime.evaluate({
+      expression: 'testFunction()//# sourceURL=expr.js'}).then(() => false);
+    let result;
+    while (result = await Promise.race([fin, Protocol.Debugger.oncePaused()])) {
+      let {params:{callFrames}} = result;
+      session.logCallFrames(callFrames);
+      session.logSourceLocation(callFrames[0].location);
+      Protocol.Debugger.stepInto();
+    }
+    Protocol.Runtime.evaluate({expression: '42'});
+    await Protocol.Debugger.oncePaused();
+    await Protocol.Debugger.resume();
+  },
+
+  async function testStepIntoAfterBreakpoint() {
+    Protocol.Debugger.setBreakpointByUrl({lineNumber: 25, url: 'test.js'});
+    Protocol.Runtime.evaluate({
+      expression: 'testFunction()//# sourceURL=expr.js'});
+    await awaitPausedAndDump();
+    Protocol.Debugger.stepInto();
+    await awaitPausedAndDump();
+    await Protocol.Debugger.resume();
+
+    async function awaitPausedAndDump() {
+      let {params:{callFrames}} = await Protocol.Debugger.oncePaused();
+      session.logCallFrames(callFrames);
+      session.logSourceLocation(callFrames[0].location);
+    }
+  }
+]);
+
+function dumpAllLocations(locations) {
+  var lines = source.split('\n');
+  var locations = locations.sort((loc1, loc2) => {
+    if (loc2.lineNumber !== loc1.lineNumber) return loc2.lineNumber - loc1.lineNumber;
+    return loc2.columnNumber - loc1.columnNumber;
+  });
+  for (var location of locations) {
+    var line = lines[location.lineNumber];
+    line = line.slice(0, location.columnNumber) + locationMark(location.type) + line.slice(location.columnNumber);
+    lines[location.lineNumber] = line;
+  }
+  lines = lines.filter(line => line.indexOf('//# sourceURL=') === -1);
+  InspectorTest.log(lines.join('\n') + '\n');
+}
+
+function locationMark(type) {
+  if (type === 'return') return '|R|';
+  if (type === 'call') return '|C|';
+  if (type === 'debuggerStatement') return '|D|';
+  return '|_|';
+}