[debug-wrapper] Conditional breaks, locals, evaluate, scopes

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 101 matching lines @@
   };
 
   clearStepping() { %ClearStepping(); };
 
   // Returns the resulting breakpoint id.
   setBreakPoint(func, opt_line, opt_column, opt_condition) {
     assertTrue(%IsFunction(func));
     assertFalse(%FunctionIsAPIFunction(func));
 
     // TODO(jgruber): We handle only script breakpoints for now.
-    // TODO(jgruber): Handle conditions.
 
     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",
-        { location : { scriptId : scriptid.toString(),
-                       lineNumber : loc.line,
-                       columnNumber : loc.column
-                     }
-        });
+        "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;
   }
 
@@ skipping 82 matching lines @@
       case "block": return this.ScopeType.Block;
       case "script": return this.ScopeType.Script;
       default: %AbortJS("Unexpected scope type");
     }
   }
 
   // Returns an array of property descriptors of the scope object.
   // This is in contrast to the original API, which simply passed object
   // mirrors.
   execStateScopeObject(obj) {
-    const {msgid, msg} = this.createMessage(
-        "Runtime.getProperties", { objectId : obj.objectId });
-    this.sendMessage(msg);
-    const reply = this.takeReplyChecked(msgid);
-    return { value : () => reply.result.result };
+    const serialized_scope = this.getProperties(obj.objectId);
+    const scope = {}
+    const scope_tuples = serialized_scope.forEach((elem) => {
+      const key = elem.name;
+
+      let value;
+      if (elem.value) {
+        // Some properties (e.g. with getters/setters) don't have a value.
+        switch (elem.value.type) {
+          case "undefined": value = undefined; break;
+          default: value = elem.value.value; break;
+        }
+      }
+
+      scope[key] = value;
+    })
+
+    return { value : () => scope };
   }
 
   execStateScope(scope) {
     return { scopeType : () => this.execStateScopeType(scope.type),
              scopeObject : () => this.execStateScopeObject(scope.object)
            };
   }
 
+  getProperties(objectId) {
+    const {msgid, msg} = this.createMessage(
+        "Runtime.getProperties", { objectId : objectId });
+    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") {
+        return this.getProperties(scope.object.objectId);
+      }
+    }
+
+    return undefined;
+  }
+
+  execStateFrameLocalCount(frame) {
+    const scope_details = this.getLocalScopeDetails(frame);
+    return scope_details ? scope_details.length : 0;
+  }
+
+  execStateFrameLocalName(frame, index) {
+    const scope_details = this.getLocalScopeDetails(frame);
+    if (index < 0 || index >= scope_details.length) return undefined;
+    return scope_details[index].name;
+  }
+
+  execStateFrameLocalValue(frame, index) {
+    const scope_details = this.getLocalScopeDetails(frame);
+    if (index < 0 || index >= scope_details.length) return undefined;
+
+    const local = scope_details[index];
+
+    let localValue;
+    switch (local.value.type) {
+      case "undefined": localValue = undefined; break;
+      default: localValue = local.value.value; break;
+    }
+
+    return { value : () => localValue };
+  }
+
+  execStateFrameEvaluate(frame, expr) {
+    const frameid = frame.callFrameId;
+    const {msgid, msg} = this.createMessage(
+        "Debugger.evaluateOnCallFrame",
+        { callFrameId : frameid,
+          expression : expr
+        });
+    this.sendMessage(msg);
+    const reply = this.takeReplyChecked(msgid);
+
+    const result = reply.result.result;
+    if (result.subtype == "error") {
+      throw new Error(result.description);
+    }
+
+    return { value : () => result.value };
+  }
+
   execStateFrame(frame) {
     const scriptid = parseInt(frame.location.scriptId);
     const line = frame.location.lineNumber;
     const column = frame.location.columnNumber;
     const loc = %ScriptLocationFromLine2(scriptid, line, column, 0);
     const func = { name : () => frame.functionName };
     return { sourceLineText : () => loc.sourceText,
+             evaluate : (expr) => this.execStateFrameEvaluate(frame, expr),
              functionName : () => frame.functionName,
              func : () => func,
+             localCount : () => this.execStateFrameLocalCount(frame),
+             localName : (ix) => this.execStateFrameLocalName(frame, ix),
+             localValue: (ix) => this.execStateFrameLocalValue(frame, ix),
              scopeCount : () => frame.scopeChain.length,
              scope : (index) => this.execStateScope(frame.scopeChain[index]),
              allScopes : () => frame.scopeChain.map(
                  this.execStateScope.bind(this))
            };
   }
 
   // --- Message handlers. -----------------------------------------------------
 
   dispatchMessage(message) {
@@ skipping 67 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;
 }});