Add breakpoints and single-stepping to Observatory.

runtime/bin/vmservice/client/lib/src/service/object.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of service;
 
 /// A [ServiceObject] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
   static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
@@ skipping 245 matching lines @@
         map = _parseJSON(eventMessage);
       } catch (e, st) {
         Logger.root.severe('Ignoring malformed event message: ${eventMessage}');
         return;
       }
       if (map['type'] != 'ServiceEvent') {
         Logger.root.severe(
             "Expected 'ServiceEvent' but found '${map['type']}'");
         return;
       }
+
       // Extract the owning isolate from the event itself.
       String owningIsolateId = map['isolate']['id'];
       _getIsolate(owningIsolateId).then((owningIsolate) {
           var event = new ServiceObject._fromMap(owningIsolate, map);
           events.add(event);
       });
   }
 
   static final RegExp _currentIsolateMatcher = new RegExp(r'isolates/\d+');
   static final RegExp _currentObjectMatcher = new RegExp(r'isolates/\d+/');
@@ skipping 466 matching lines @@
   void _update(ObservableMap map, bool mapIsRef) {
     mainPort = map['mainPort'];
     name = map['name'];
     vmName = map['name'];
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     loading = false;
 
+    reloadBreakpoints();
+
     // Remap DebuggerEvent to ServiceEvent so that the observatory can
     // work against 1.5 vms in the short term.
     //
     // TODO(turnidge): Remove this when no longer needed.
     var pause = map['pauseEvent'];
     if (pause != null) {
       if (pause['type'] == 'DebuggerEvent') {
         pause['type'] = 'ServiceEvent';
       }
     }
@@ skipping 116 matching lines @@
     // Number of children.
     var children = _trieData[_trieDataCursor++];
     // Recursively read child nodes.
     for (var i = 0; i < children; i++) {
       var child = _readTrieNode(codeTable);
       node.children.add(child);
       node.summedChildCount += child.count;
     }
     return node;
   }
+
+  ServiceMap breakpoints;
+
+  void _removeBreakpoint(ServiceMap bpt) {
+    var script = bpt['location']['script'];
+    var tokenPos = bpt['location']['tokenPos'];
+    assert(tokenPos != null);
+    if (script.loaded) {
+      var line = script.tokenToLine(tokenPos);
+      assert(line != null);
+      assert(script.lines[line - 1].bpt == bpt);
+      script.lines[line - 1].bpt = null;
+    }
+  }
+
+  void _addBreakpoint(ServiceMap bpt) {
+    var script = bpt['location']['script'];
+    var tokenPos = bpt['location']['tokenPos'];
+    assert(tokenPos != null);
+    if (script.loaded) {
+      var line = script.tokenToLine(tokenPos);
+      assert(line != null);
+      assert(script.lines[line - 1].bpt == null);
+      script.lines[line - 1].bpt = bpt;
+    } else {
+      // Load the script and then plop in the breakpoint.
+      script.load().then((_) {
+          _addBreakpoint(bpt);
+      });
+    }
+  }
+
+  void _updateBreakpoints(ServiceMap newBreakpoints) {
+    // Remove all of the old breakpoints from the Script lines.
+    if (breakpoints != null) {
+      for (var bpt in breakpoints['breakpoints']) {
+        _removeBreakpoint(bpt);
+      }
+    }
+    // Add all of the new breakpoints to the Script lines.
+    for (var bpt in newBreakpoints['breakpoints']) {
+      _addBreakpoint(bpt);
+    }
+    breakpoints = newBreakpoints;
+  }
+
+  Future<ServiceObject> _inProgressReloadBpts;
+
+  Future reloadBreakpoints() {
+    // TODO(turnidge): Can reusing the Future here ever cause us to
+    // get stale breakpoints?
+    if (_inProgressReloadBpts == null) {
+      _inProgressReloadBpts =
+          get('debug/breakpoints').then((newBpts) {
+              _updateBreakpoints(newBpts);
+          }).whenComplete(() {
+              _inProgressReloadBpts = null;
+          });
+    }
+    return _inProgressReloadBpts;
+  }
+
+  Future<ServiceObject> setBreakpoint(Script script, int line) {
+    return get(script.id + "/setBreakpoint?line=${line}").then((result) {
+        if (result is DartError) {
+          // Unable to set a breakpoint at desired line.
+          script.lines[line - 1].possibleBpt = false;
+        }
+        return reloadBreakpoints();
+      });
+  }
+
+  Future clearBreakpoint(ServiceMap bpt) {
+    return get('${bpt.id}/clear').then((result) {
+        if (result is DartError) {
+          // TODO(turnidge): Handle this more gracefully.
+          Logger.root.severe(result.message);
+        }
+        if (pauseEvent != null &&
+            pauseEvent.breakpoint != null &&
+            (pauseEvent.breakpoint['id'] == bpt['id'])) {
+          return isolate.reload();
+        } else {
+          return reloadBreakpoints();
+        }
+      });
+  }
+
+  Future pause() {
+    return get("debug/pause").then((result) {
+        if (result is DartError) {
+          // TODO(turnidge): Handle this more gracefully.
+          Logger.root.severe(result.message);
+        }
+        return isolate.reload();
+      });
+  }
+
+  Future resume() {
+    return get("debug/resume").then((result) {
+        if (result is DartError) {
+          // TODO(turnidge): Handle this more gracefully.
+          Logger.root.severe(result.message);
+        }
+        return isolate.reload();
+      });
+  }
+
+  Future stepInto() {
+    print('isolate.stepInto');
+    return get("debug/resume?step=into").then((result) {
+        if (result is DartError) {
+          // TODO(turnidge): Handle this more gracefully.
+          Logger.root.severe(result.message);
+        }
+        return isolate.reload();
+      });
+  }
+
+  Future stepOver() {
+    return get("debug/resume?step=over").then((result) {
+        if (result is DartError) {
+          // TODO(turnidge): Handle this more gracefully.
+          Logger.root.severe(result.message);
+        }
+        return isolate.reload();
+      });
+  }
+
+  Future stepOut() {
+    return get("debug/resume?step=out").then((result) {
+        if (result is DartError) {
+          // TODO(turnidge): Handle this more gracefully.
+          Logger.root.severe(result.message);
+        }
+        return isolate.reload();
+      });
+  }
 }
 
 /// A [ServiceObject] which implements [ObservableMap].
 class ServiceMap extends ServiceObject implements ObservableMap {
   final ObservableMap _map = new ObservableMap();
   static String objectIdRingPrefix = 'objects/';
 
   bool get canCache {
     return (_serviceType == 'Class' ||
             _serviceType == 'Function' ||
@@ skipping 313 matching lines @@
     }
     children.add(cls);
   }
 
   Future<ServiceObject> get(String command) {
     return isolate.get(id + "/$command");
   }
 }
 
 class ScriptLine extends Observable {
+  final Script script;
   final int line;
   final String text;
   @observable int hits;
-  ScriptLine(this.line, this.text);
+  @observable ServiceMap bpt;
+  @observable bool possibleBpt = true;
+
+  static bool _isTrivialToken(String token) {
+    if (token == 'else') {
+      return true;
+    }
+    for (var c in token.split('')) {
+      switch (c) {
+        case '{':
+        case '}':
+        case '(':
+        case ')':
+        case ';':
+          break;
+        default:
+          return false;
+      }
+    }
+    return true;
+  }
+
+  static bool _isTrivialLine(String text) {
+    var wsTokens = text.split(new RegExp(r"(\s)+"));
+    for (var wsToken in wsTokens) {
+      var tokens = wsToken.split(new RegExp(r"(\b)"));
+      for (var token in tokens) {
+        if (!_isTrivialToken(token)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  ScriptLine(this.script, this.line, this.text) {
+    possibleBpt = !_isTrivialLine(text);
+    
+    // TODO(turnidge): This is not so efficient.  Consider improving.
+    for (var bpt in this.script.isolate.breakpoints['breakpoints']) {
+      var bptScript = bpt['location']['script'];
+      var bptTokenPos = bpt['location']['tokenPos'];
+      if (bptScript == this.script &&
+          bptScript.tokenToLine(bptTokenPos) == line) {
+        this.bpt = bpt;
+      }
+    }
+  }
 }
 
 class Script extends ServiceObject with Coverage {
   final lines = new ObservableList<ScriptLine>();
   final _hits = new Map<int, int>();
   @observable String kind;
   @observable int firstTokenPos;
   @observable int lastTokenPos;
   bool get canCache => true;
   bool get immutable => true;
@@ skipping 27 matching lines @@
   }
 
   void _parseTokenPosTable(List<List<int>> table) {
     if (table == null) {
       return;
     }
     _tokenToLine.clear();
     _tokenToCol.clear();
     firstTokenPos = null;
     lastTokenPos = null;
+    var lineSet = new Set();
+
     for (var line in table) {
       // Each entry begins with a line number...
       var lineNumber = line[0];
+      lineSet.add(lineNumber);
       for (var pos = 1; pos < line.length; pos += 2) {
         // ...and is followed by (token offset, col number) pairs.
         var tokenOffset = line[pos];
         var colNumber = line[pos+1];
         if (firstTokenPos == null) {
           // Mark first token position.
           firstTokenPos = tokenOffset;
           lastTokenPos = tokenOffset;
         } else {
           // Keep track of max and min token positions.
           firstTokenPos = (firstTokenPos <= tokenOffset) ?
               firstTokenPos : tokenOffset;
           lastTokenPos = (lastTokenPos >= tokenOffset) ?
               lastTokenPos : tokenOffset;
         }
         _tokenToLine[tokenOffset] = lineNumber;
         _tokenToCol[tokenOffset] = colNumber;
       }
     }
+
+    for (var line in lines) {
+      // Remove possible breakpoints on lines with no tokens.
+      if (!lineSet.contains(line.line)) {
+        line.possibleBpt = false;
+      }
+    }
   }
 
   void _processHits(List scriptHits) {
     // Update hits table.
     for (var i = 0; i < scriptHits.length; i += 2) {
       var line = scriptHits[i];
       var hit = scriptHits[i + 1]; // hit status.
       assert(line >= 1); // Lines start at 1.
       var oldHits = _hits[line];
       if (oldHits != null) {
@@ skipping 12 matching lines @@
     }
     var sourceLines = source.split('\n');
     if (sourceLines.length == 0) {
       return;
     }
     // We have the source to the script. This is now loaded.
     _loaded = true;
     lines.clear();
     Logger.root.info('Adding ${sourceLines.length} source lines for ${_url}');
     for (var i = 0; i < sourceLines.length; i++) {
-      lines.add(new ScriptLine(i + 1, sourceLines[i]));
+      lines.add(new ScriptLine(this, i + 1, sourceLines[i]));
     }
     _applyHitsToLines();
   }
 
   void _applyHitsToLines() {
-    if (lines.length == 0) {
-      return;
-    }
     for (var line in lines) {
       var hits = _hits[line.line];
       line.hits = hits;
     }
   }
 }
 
 class CodeTick {
   final int address;
   final int exclusiveTicks;
@@ skipping 571 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }