[inspector] [wasm] Implement GetPossibleBreakpoints

test/inspector/debugger/wasm-get-breakable-locations.js

 // Copyright 2016 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.
 
 // Flags: --expose-wasm
 
 load('test/mjsunit/wasm/wasm-constants.js');
 load('test/mjsunit/wasm/wasm-module-builder.js');
 
 var builder = new WasmModuleBuilder();
@@ skipping 37 matching lines @@
   var instance = new WebAssembly.Instance(module, {'func': call_debugger});
 
   instance.exports.main(1);
 }
 
 InspectorTest.addScript(testFunction.toString());
 InspectorTest.addScript('var module_bytes = ' + JSON.stringify(module_bytes));
 
 Protocol.Debugger.enable();
 Protocol.Debugger.onScriptParsed(handleScriptParsed);
+Protocol.Debugger.onPaused(handlePaused);
 InspectorTest.log('Running testFunction...');
 Protocol.Runtime.evaluate({'expression': 'testFunction(module_bytes)'});
 
 var numScripts = 0;
+var wasmScripts = [];
 function handleScriptParsed(messageObject) {
   var scriptId = messageObject.params.scriptId;
   var url = messageObject.params.url;
   InspectorTest.log('Script nr ' + numScripts + ' parsed. URL: ' + url);
   ++numScripts;
 
   if (url.startsWith('wasm://')) {
-    InspectorTest.log('This is a wasm script. Requesting breakable locations.');
-    Protocol.Debugger
-        .getPossibleBreakpoints(
-            {start: {lineNumber: 0, columnNumber: 0, scriptId: scriptId}})
-        .then(InspectorTest.logMessage)
-        .then(InspectorTest.completeTest);
+    InspectorTest.log('This is a wasm script (nr ' + wasmScripts.length + ').');
+    wasmScripts.push(scriptId);
   }
 }
+
+function printBreakableLocations(message, expectedScriptId, source) {
+  if (!message.result || !message.result.locations) {
+    InspectorTest.logMessage(message);
+    return;
+  }
+  var lines = source.split('\n');
+  var locations = message.result.locations;
+  InspectorTest.log(locations.length + ' breakable location(s):');
+  for (var i = 0; i < locations.length; ++i) {
+    if (locations[i].scriptId != expectedScriptId) {
+      InspectorTest.log(
+          'SCRIPT ID MISMATCH!! ' + locations[i].scriptId + ' != ' +
+          expectedScriptId);
+    }
+    var line = locations[i].lineNumber < lines.length ?
+        lines[locations[i].lineNumber] :
+        '<illegal line number>';
+    InspectorTest.log(
+        '[' + i + '] ' + locations[i].lineNumber + ':' +
+        locations[i].columnNumber + ' || ' + line);
+  }
+}
+
+function getSourceFromMessage(message) {
+  if (!message.result || !message.result.scriptSource) {
+    InspectorTest.logMessage(message);
+    return '';
+  }
+  return message.result.scriptSource;
+}
+
+function checkGetBreakableLocations(wasmScriptNr) {

[kozy, 2016/11/30 17:38:16]

You can improve this test by adding two steps after getPossibleBreakpoints:
setBreakpoint by each possible location and then run wasm module and check that
execution actually was paused in reported locations.

[Clemens Hammacher, 2016/11/30 17:52:19]

Breakpoint support is not there yet, but is a P1 for Chrome 57 (where we will
launch WebAssembly). It is the main thing I will work on in the next weeks. I
want to finish it before Christmas.
Once we have breakpoint support, I will extend the test cases.

If you are uncomfortable with landing this as is, I can also wait with landing
until breakpoint support is there.
I just need to know that you are OK with the current implementation, such that I
can move on.

+  InspectorTest.log(
+      'Requesting all breakable locations in wasm script ' + wasmScriptNr);
+  var scriptId = wasmScripts[wasmScriptNr];
+  var source;
+  return Protocol.Debugger.getScriptSource({scriptId: scriptId})
+      .then((message) => source = getSourceFromMessage(message))
+      .then(
+          () => Protocol.Debugger.getPossibleBreakpoints(
+              {start: {lineNumber: 0, columnNumber: 0, scriptId: scriptId}}))
+      .then((message) => printBreakableLocations(message, scriptId, source))
+      .then(
+          () =>
+              InspectorTest.log('Requesting breakable locations up to line 2'))
+      .then(() => Protocol.Debugger.getPossibleBreakpoints({
+        start: {lineNumber: 0, columnNumber: 0, scriptId: scriptId},
+        end: {lineNumber: 3, columnNumber: 0, scriptId: scriptId}
+      }))
+      .then((message) => printBreakableLocations(message, scriptId, source))
+      .then(
+          () =>
+              InspectorTest.log('Requesting breakable locations in lines 3-4'))
+      .then(() => Protocol.Debugger.getPossibleBreakpoints({
+        start: {lineNumber: 3, columnNumber: 0, scriptId: scriptId},
+        end: {lineNumber: 5, columnNumber: 0, scriptId: scriptId}
+      }))
+      .then((message) => printBreakableLocations(message, scriptId, source));
+}
+
+function handlePaused() {
+  InspectorTest.log('Paused on \'debugger\'.');
+  var promise = Promise.resolve();
+  for (var wasmScriptNr = 0; wasmScriptNr < wasmScripts.length;
+       ++wasmScriptNr) {
+    promise = promise.then(checkGetBreakableLocations.bind(null, wasmScriptNr));
+  }
+  promise.then(() => InspectorTest.log('Finished!'))
+      .then(InspectorTest.completeTest);
+}