[debug-wrapper] Adapt tests, breakpoint.actual_location

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 31 matching lines @@
     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};
+                        Wasm: 3,
+                        Inspector: 4,
+                      };
 
     // 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,
@@ skipping 90 matching lines @@
     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);
     return this.setBreakPointAtLocation(scriptid, loc, opt_condition);
   }
 
-  clearBreakPoint(breakid) {
-    assertTrue(this.breakpoints.has(breakid));
+  setBreakPointByScriptIdAndPosition(scriptid, position) {
+    const loc = %ScriptPositionInfo2(scriptid, position, false);
+    return this.setBreakPointAtLocation(scriptid, loc, undefined);
+  }
+
+  clearBreakPoint(breakpoint) {
+    assertTrue(this.breakpoints.has(breakpoint));
+    const breakid = breakpoint.id;
     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);
+    for (let breakpoint of this.breakpoints) {
+      this.clearBreakPoint(breakpoint);
     }
     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
@@ skipping 155 matching lines @@
                          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;
+    const result = reply.result;
+    assertTrue(result !== undefined);
+    const breakid = result.breakpointId;
     assertTrue(breakid !== undefined);
 
-    this.breakpoints.add(breakid);
+    const actualLoc = %ScriptLocationFromLine2(scriptid,
+        result.actualLocation.lineNumber, result.actualLocation.columnNumber,
+        0);
 
-    return breakid;
+    const breakpoint = { id : result.breakpointId,
+                         actual_position : actualLoc.position,
+                       }
+
+    this.breakpoints.add(breakpoint);
+    return breakpoint;
   }
 
   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;
     }
   }
@@ skipping 44 matching lines @@
   setVariableValue(frame, scope_index, name, value) {
     const frameid = frame.callFrameId;
     const {msgid, msg} = this.createMessage(
         "Debugger.setVariableValue",
         { callFrameId : frameid,
           scopeNumber : scope_index,
           variableName : name,
           newValue : { value : value }
         });
     this.sendMessage(msg);
-    this.takeReplyChecked(msgid);
+    const reply = this.takeReplyChecked(msgid);
+    if (reply.error) {
+      throw new Error("Failed to set variable value");
+    }
   }
 
   execStateScope(frame, scope_index) {
     const scope = frame.scopeChain[scope_index];
     return { scopeType : () => this.execStateScopeType(scope.type),
              scopeObject : () => this.execStateScopeObject(scope.object),
              setVariableValue :
                 (name, value) => this.setVariableValue(frame, scope_index,
                                                        name, value)
            };
@@ skipping 16 matching lines @@
       }
 
       obj[key] = value;
     })
 
     return obj;
   }
 
   getProperties(objectId) {
     const {msgid, msg} = this.createMessage(
-        "Runtime.getProperties", { objectId : objectId });
+        "Runtime.getProperties", { objectId : objectId, ownProperties: true });
     this.sendMessage(msg);
     const reply = this.takeReplyChecked(msgid);
     return reply.result.result;
   }
 
   getLocalScopeDetails(frame) {
     const scopes = frame.scopeChain;
     for (let i = 0; i < scopes.length; i++) {
       const scope = scopes[i]
       if (scope.type == "local") {
@@ skipping 25 matching lines @@
     switch (local.value.type) {
       case "undefined": localValue = undefined; break;
       default: localValue = local.value.value; break;
     }
 
     return { value : () => localValue };
   }
 
   reconstructRemoteObject(obj) {
     let value = obj.value;
-    if (obj.type == "object") {
-      if (obj.subtype == "error") {
-        const desc = obj.description;
-        switch (obj.className) {
-          case "EvalError": throw new EvalError(desc);
-          case "RangeError": throw new RangeError(desc);
-          case "ReferenceError": throw new ReferenceError(desc);
-          case "SyntaxError": throw new SyntaxError(desc);
-          case "TypeError": throw new TypeError(desc);
-          case "URIError": throw new URIError(desc);
-          default: throw new Error(desc);
+    let isUndefined = false;
+
+    switch (obj.type) {
+      case "object": {
+        switch (obj.subtype) {
+          case "error": {
+            const desc = obj.description;
+            switch (obj.className) {
+              case "EvalError": throw new EvalError(desc);
+              case "RangeError": throw new RangeError(desc);
+              case "ReferenceError": throw new ReferenceError(desc);
+              case "SyntaxError": throw new SyntaxError(desc);
+              case "TypeError": throw new TypeError(desc);
+              case "URIError": throw new URIError(desc);
+              default: throw new Error(desc);
+            }
+            break;
+          }
+          case "array": {
+            const array = [];
+            const props = this.propertiesToObject(
+                this.getProperties(obj.objectId));
+            for (let i = 0; i < props.length; i++) {
+              array[i] = props[i];
+            }
+            value = array;
+            break;
+          }
+          case "null": {
+            value = null;
+            break;
+          }
+          default: {
+            value = this.propertiesToObject(this.getProperties(obj.objectId));
+            break;
+          }
         }
-      } else if (obj.subtype == "array") {
-        const array = [];
-        const props = this.propertiesToObject(
-            this.getProperties(obj.objectId));
-        for (let i = 0; i < props.length; i++) {
-          array[i] = props[i];
-        }
-        value = array;
+        break;
+      }
+      case "undefined": {
+        value = undefined;
+        isUndefined = true;
+        break;
+      }
+      case "string":
+      case "number":
+      case "boolean": {
+        break;
+      }
+      default: {
+        break;
       }
     }
 
     return { value : () => value,
-             isUndefined : () => obj.type == "undefined"
+             isUndefined : () => isUndefined
            };
   }
 
   evaluateOnCallFrame(frame, expr) {
     const frameid = frame.callFrameId;
     const {msgid, msg} = this.createMessage(
         "Debugger.evaluateOnCallFrame",
         { callFrameId : frameid,
           expression : expr
         });
@@ skipping 29 matching lines @@
 
     return { sourceColumn : () => loc.column,
              sourceLine : () => loc.line + 1,
              sourceLineText : () => loc.sourceText,
              evaluate : (expr) => this.evaluateOnCallFrame(frame, expr),
              functionName : () => frame.functionName,
              func : () => func,
              localCount : () => this.execStateFrameLocalCount(frame),
              localName : (ix) => this.execStateFrameLocalName(frame, ix),
              localValue: (ix) => this.execStateFrameLocalValue(frame, ix),
+             receiver : () => this.evaluateOnCallFrame(frame, "this"),
              restart : () => this.execStateFrameRestart(frame),
              scopeCount : () => frame.scopeChain.length,
              scope : (index) => this.execStateScope(frame, index),
              allScopes : allScopes.bind(this)
            };
   }
 
   eventDataException(params) {
     switch (params.data.type) {
       case "string": {
         return params.data.value;
       }
       case "object": {
         const props = this.getProperties(params.data.objectId);
         return this.propertiesToObject(props);
       }
       default: {
         return undefined;
       }
     }
   }
 
   eventDataScriptSource(id) {
     const {msgid, msg} = this.createMessage(
-        "Debugger.getScriptSource", { scriptId : id });
+        "Debugger.getScriptSource", { scriptId : String(id) });
     this.sendMessage(msg);
     const reply = this.takeReplyChecked(msgid);
     return reply.result.scriptSource;
   }
 
   eventDataScriptSetSource(id, src) {
     const {msgid, msg} = this.createMessage(
         "Debugger.setScriptSource", { scriptId : id, scriptSource : src });
     this.sendMessage(msg);
     this.takeReplyChecked(msgid);
   }
 
   eventDataScript(params) {
-    const id = params.scriptId;
+    const id = parseInt(params.scriptId);
     const name = params.url ? params.url : undefined;
 
     return { id : () => id,
              name : () => name,
              source : () => this.eventDataScriptSource(id),
              setSource : (src) => this.eventDataScriptSetSource(id, src)
            };
   }
 
   // --- Message handlers. -----------------------------------------------------
@@ skipping 86 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;
 }});