[debug-wrapper] LiveEdit, frame.restart(), breakpoints

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 52 matching lines @@
     this.ExceptionBreak = { Caught : 0,
                             Uncaught: 1 };
 
     // The different types of breakpoint position alignments.
     // Must match BreakPositionAlignment in debug.h.
     this.BreakPositionAlignment = {
       Statement: 0,
       BreakPosition: 1
     };
 
+    // 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);
 
     // Register as the active wrapper.
     assertTrue(activeWrapper === undefined);
     activeWrapper = this;
   }
 
   enable() { this.sendMessageForMethodChecked("Debugger.enable"); }
   disable() { this.sendMessageForMethodChecked("Debugger.disable"); }
@@ skipping 51 matching lines @@
 
     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);
+    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;
+  }
+
+  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;
   }
 
   clearBreakPoint(breakid) {
     const {msgid, msg} = this.createMessage(
         "Debugger.removeBreakpoint", { breakpointId : breakid });
@@ skipping 81 matching lines @@
     return %FunctionGetScriptSourcePosition(f);
   };
 
   setBreakPointsActive(enabled) {
     const {msgid, msg} = this.createMessage(
         "Debugger.setBreakpointsActive", { active : enabled });
     this.sendMessage(msg);
     this.takeReplyChecked(msgid);
   }
 
+  get LiveEdit() {
+    const debugContext = %GetDebugContext();
+    return debugContext.Debug.LiveEdit;
+  }
+
   // --- Internal methods. -----------------------------------------------------
 
   getNextMessageId() {
     return this.nextMessageId++;
   }
 
   createMessage(method, params) {
     const id = this.getNextMessageId();
     const msg = JSON.stringify({
       id: id,
@@ skipping 196 matching lines @@
         for (let i = 0; i < props.length; i++) {
           array[i] = props[i];
         }
         value = array;
       }
     }
 
     return { value : () => value,
              isUndefined : () => obj.type == "undefined"
            };
-
   }
 
   evaluateOnCallFrame(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;
     return this.reconstructRemoteObject(result);
   }
 
+  execStateFrameRestart(frame) {
+    const frameid = frame.callFrameId;
+    const {msgid, msg} = this.createMessage(
+        "Debugger.restartFrame", { callFrameId : frameid });
+    this.sendMessage(msg);
+    this.takeReplyChecked(msgid);
+  }
+
   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 };
 
     function allScopes() {
       const scopes = [];
       for (let i = 0; i < frame.scopeChain.length; i++) {
         scopes.push(this.execStateScope(frame, i));
       }
       return scopes;
     };
 
     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),
+             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;
@@ skipping 124 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;
 }});