[debug-wrapper] clearAllBreakPoints and several scripts functions

test/debugger/test-api.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.
 
 "use strict";
 
 // If true, prints all messages sent and received by inspector.
 const printProtocolMessages = false;
 
 // The active wrapper instance.
@@ skipping 27 matching lines @@
                         AsyncTaskEvent: 7
                       };
 
     // The different types of steps.
     this.StepAction = { StepOut: 0,
                         StepNext: 1,
                         StepIn: 2,
                         StepFrame: 3,
                       };
 
+    // The different types of scripts matching enum ScriptType in objects.h.
+    this.ScriptType = { Native: 0,
+                        Extension: 1,
+                        Normal: 2,
+                        Wasm: 3};
+
     // A copy of the scope types from runtime-debug.cc.
     // NOTE: these constants should be backward-compatible, so
     // add new ones to the end of this list.
     this.ScopeType = { Global:  0,
                        Local:   1,
                        With:    2,
                        Closure: 3,
                        Catch:   4,
                        Block:   5,
                        Script:  6,
@@ skipping 13 matching lines @@
     };
 
     // The different script break point types.
     this.ScriptBreakPointType = { ScriptId: 0,
                                   ScriptName: 1,
                                   ScriptRegExp: 2 };
 
     // Store the current script id so we can skip corresponding break events.
     this.thisScriptId = %FunctionGetScriptId(receive);
 
+    // Stores all set breakpoints.
+    this.breakpoints = new Set();
+
     // Register as the active wrapper.
     assertTrue(activeWrapper === undefined);
     activeWrapper = this;
   }
 
   enable() { this.sendMessageForMethodChecked("Debugger.enable"); }
   disable() { this.sendMessageForMethodChecked("Debugger.disable"); }
 
   setListener(listener) { this.listener = listener; }
 
@@ skipping 38 matching lines @@
   setBreakPoint(func, opt_line, opt_column, opt_condition) {
     assertTrue(%IsFunction(func));
     assertFalse(%FunctionIsAPIFunction(func));
 
     const scriptid = %FunctionGetScriptId(func);
     assertTrue(scriptid != -1);
 
     const offset = %FunctionGetScriptSourcePosition(func);
     const loc =
       %ScriptLocationFromLine2(scriptid, opt_line, opt_column, offset);
-
-    const params = { location :
-                       { scriptId : scriptid.toString(),
-                         lineNumber : loc.line,
-                         columnNumber : loc.column,
-                       }};
-    if (!!opt_condition) {
-      params.condition = opt_condition;
-    }
-
-    const {msgid, msg} = this.createMessage("Debugger.setBreakpoint", params);
-    this.sendMessage(msg);
-
-    const reply = this.takeReplyChecked(msgid);
-    assertTrue(reply.result !== undefined);
-    const breakid = reply.result.breakpointId;
-    assertTrue(breakid !== undefined);
-
-    return breakid;
+    return this.setBreakPointAtLocation(scriptid, loc, opt_condition);
   }
 
   setScriptBreakPoint(type, scriptid, opt_line, opt_column, opt_condition) {
     // Only sets by script id are supported for now.
     assertEquals(this.ScriptBreakPointType.ScriptId, type);
     return this.setScriptBreakPointById(scriptid, opt_line, opt_column,
                                         opt_condition);
   }
 
   setScriptBreakPointById(scriptid, opt_line, opt_column, opt_condition) {
     const loc = %ScriptLocationFromLine2(scriptid, opt_line, opt_column, 0);
-
-    const params = { location :
-                       { scriptId : scriptid.toString(),
-                         lineNumber : loc.line,
-                         columnNumber : loc.column,
-                       }};
-    if (!!opt_condition) {
-      params.condition = opt_condition;
-    }
-
-    const {msgid, msg} = this.createMessage("Debugger.setBreakpoint", params);
-    this.sendMessage(msg);
-
-    const reply = this.takeReplyChecked(msgid);
-    assertTrue(reply.result !== undefined);
-    const breakid = reply.result.breakpointId;
-    assertTrue(breakid !== undefined);
-
-    return breakid;
+    return this.setBreakPointAtLocation(scriptid, loc, opt_condition);
   }
 
   clearBreakPoint(breakid) {
+    assertTrue(this.breakpoints.has(breakid));
     const {msgid, msg} = this.createMessage(
         "Debugger.removeBreakpoint", { breakpointId : breakid });
     this.sendMessage(msg);
     this.takeReplyChecked(msgid);
+    this.breakpoints.delete(breakid);
+  }
+
+  clearAllBreakPoints() {
+    for (let breakid of this.breakpoints) {
+      this.clearBreakPoint(breakid);
+    }
+    this.breakpoints.clear();
   }
 
   showBreakPoints(f, opt_position_alignment) {
     if (!%IsFunction(f)) throw new Error("Not passed a Function");
 
     const source = %FunctionGetSourceCode(f);
     const offset = %FunctionGetScriptSourcePosition(f);
     const position_alignment = opt_position_alignment === undefined
         ? this.BreakPositionAlignment.Statement : opt_position_alignment;
     const locations = %GetBreakLocations(f, position_alignment);
@@ skipping 24 matching lines @@
                 { setValue : (enabled) => this.setBreakPointsActive(enabled) }
            };
   }
 
   scripts() {
     // Collect all scripts in the heap.
     return %DebugGetLoadedScripts();
   }
 
   // Returns a Script object. If the parameter is a function the return value
-  // is the script in which the function is defined. If the parameter is a string
-  // the return value is the script for which the script name has that string
-  // value.  If it is a regexp and there is a unique script whose name matches
-  // we return that, otherwise undefined.
+  // is the script in which the function is defined. If the parameter is a
+  // string the return value is the script for which the script name has that
+  // string value.  If it is a regexp and there is a unique script whose name
+  // matches we return that, otherwise undefined.
   findScript(func_or_script_name) {
     if (%IsFunction(func_or_script_name)) {
       return %FunctionGetScript(func_or_script_name);
     } else if (%IsRegExp(func_or_script_name)) {
       var scripts = this.scripts();
       var last_result = null;
       var result_count = 0;
       for (var i in scripts) {
         var script = scripts[i];
         if (func_or_script_name.test(script.name)) {
           last_result = script;
           result_count++;
         }
       }
       // Return the unique script matching the regexp.  If there are more
       // than one we don't return a value since there is no good way to
       // decide which one to return.  Returning a "random" one, say the
       // first, would introduce nondeterminism (or something close to it)
       // because the order is the heap iteration order.
       if (result_count == 1) {
         return last_result;
       } else {
         return undefined;
       }
     } else {
       return %GetScript(func_or_script_name);
     }
   }
 
+  // Returns the script source. If the parameter is a function the return value
+  // is the script source for the script in which the function is defined. If the
+  // parameter is a string the return value is the script for which the script
+  // name has that string value.
+  scriptSource(func_or_script_name) {
+    return this.findScript(func_or_script_name).source;
+  };
+
   sourcePosition(f) {
     if (!%IsFunction(f)) throw new Error("Not passed a Function");
     return %FunctionGetScriptSourcePosition(f);
   };
 
+  // Returns the character position in a script based on a line number and an
+  // optional position within that line.
+  findScriptSourcePosition(script, opt_line, opt_column) {
+    var location = %ScriptLocationFromLine(script, opt_line, opt_column, 0);
+    return location ? location.position : null;
+  };
+
+  findFunctionSourceLocation(func, opt_line, opt_column) {
+    var script = %FunctionGetScript(func);
+    var script_offset = %FunctionGetScriptSourcePosition(func);
+    return %ScriptLocationFromLine(script, opt_line, opt_column, script_offset);
+  }
+
   setBreakPointsActive(enabled) {
     const {msgid, msg} = this.createMessage(
         "Debugger.setBreakpointsActive", { active : enabled });
     this.sendMessage(msg);
     this.takeReplyChecked(msgid);
   }
 
   get LiveEdit() {
     return %GetLiveEditAPIObject();
   }
@@ skipping 36 matching lines @@
     this.takeReplyChecked(msgid);
   }
 
   takeReplyChecked(msgid) {
     const reply = this.receivedMessages.get(msgid);
     assertTrue(reply !== undefined);
     this.receivedMessages.delete(msgid);
     return reply;
   }
 
+  setBreakPointAtLocation(scriptid, loc, opt_condition) {
+    const params = { location :
+                       { scriptId : scriptid.toString(),
+                         lineNumber : loc.line,
+                         columnNumber : loc.column,
+                       },
+                     condition : opt_condition,
+                   };
+
+    const {msgid, msg} = this.createMessage("Debugger.setBreakpoint", params);
+    this.sendMessage(msg);
+
+    const reply = this.takeReplyChecked(msgid);
+    assertTrue(reply.result !== undefined);
+    const breakid = reply.result.breakpointId;
+    assertTrue(breakid !== undefined);
+
+    this.breakpoints.add(breakid);
+
+    return breakid;
+  }
+
   execStatePrepareStep(action) {
     switch(action) {
       case this.StepAction.StepOut: this.stepOut(); break;
       case this.StepAction.StepNext: this.stepOver(); break;
       case this.StepAction.StepIn: this.stepInto(); break;
       default: %AbortJS("Unsupported StepAction"); break;
     }
   }
 
   execStateScopeType(type) {
@@ skipping 344 matching lines @@
     debug.instance = new DebugWrapper();
     debug.instance.enable();
   }
   return debug.instance;
 }});
 
 Object.defineProperty(debug, 'ScopeType', { get: function() {
   const instance = debug.Debug;
   return instance.ScopeType;
 }});