Add Breakpoint class to Observatory.

runtime/observatory/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] represents a persistent object within the vm.
 abstract class ServiceObject extends Observable {
   static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
     return o1.name.compareTo(o2.name);
@@ skipping 105 matching lines @@
     }
     if (!_isServiceMap(map)) {
       Logger.root.severe('Malformed service object: $map');
     }
     assert(_isServiceMap(map));
     var type = _stripRef(map['type']);
     var vmType = map['_vmType'] != null ? _stripRef(map['_vmType']) : type;
     var obj = null;
     assert(type != 'VM');
     switch (type) {
+      case 'Breakpoint':
+        obj = new Breakpoint._empty(owner);
+        break;
       case 'Class':
         obj = new Class._empty(owner);
         break;
       case 'Code':
         obj = new Code._empty(owner);
         break;
       case 'Context':
         obj = new Context._empty(owner);
         break;
       case 'Counter':
@@ skipping 878 matching lines @@
     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;
   }
 
-  ObservableList breakpoints = new ObservableList();
+  ObservableList<Breakpoint> breakpoints = new ObservableList();
 
-  void _removeBreakpoint(ServiceMap bpt) {
-    var script = bpt['location']['script'];
-    var tokenPos = bpt['location']['tokenPos'];
+  void _removeBreakpoint(Breakpoint bpt) {
+    var script = bpt.script;
+    var tokenPos = bpt.tokenPos;
     assert(tokenPos != null);
     if (script.loaded) {
       var line = script.tokenToLine(tokenPos);
       assert(line != null);
       if (script.lines[line - 1] != 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'];
+  void _addBreakpoint(Breakpoint bpt) {
+    var script = bpt.script;
+    var tokenPos = bpt.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) {
         _removeBreakpoint(bpt);
       }
     }
     // Add all of the new breakpoints to the Script lines.
     for (var bpt in newBreakpoints['breakpoints']) {
       _addBreakpoint(bpt);
     }
     breakpoints.clear();
     breakpoints.addAll(newBreakpoints['breakpoints']);
 
     // Sort the breakpoints by breakpointNumber.
-    breakpoints.sort((a, b) => (a['breakpointNumber'] - b['breakpointNumber']));
+    breakpoints.sort((a, b) => (a.number - b.number));
   }
 
   Future<ServiceObject> _inProgressReloadBpts;
 
   Future reloadBreakpoints() {
     // TODO(turnidge): Can reusing the Future here ever cause us to
     // get stale breakpoints?
     if (_inProgressReloadBpts == null) {
       _inProgressReloadBpts =
           invokeRpc('getBreakpoints', {}).then((newBpts) {
               _updateBreakpoints(newBpts);
           }).whenComplete(() {
               _inProgressReloadBpts = null;
           });
     }
     return _inProgressReloadBpts;
   }
 
   Future<ServiceObject> addBreakpoint(Script script, int line) {
     // TODO(turnidge): Pass line as an int instead of a string.
-    return invokeRpc('addBreakpoint',
-                     { 'script': script.id, 'line': '$line' }).then((result) {
-        if (result is ServiceMap &&
-            result.type == 'Breakpoint' &&
-            result['resolved'] &&
-            script.loaded &&
-            script.tokenToLine(result['location']['tokenPos']) != line) {
-          // Unable to set a breakpoint at desired line.
-          script.lines[line - 1].possibleBpt = false;
-        }
-        // TODO(turnidge): Instead of reloading all of the breakpoints,
-        // rely on events to update the breakpoint list.
-        return reloadBreakpoints().then((_) {
-            return result;
-        });
+    Map params = {
+      'script': script.id,
+      'line': '$line',
+    };
+    return invokeRpc('addBreakpoint', params).then((result) {
+      if (result is DartError) {
+        return result;
+      }
+      Breakpoint bpt = result;
+      if (bpt.resolved &&
+          script.loaded &&
+          script.tokenToLine(result.tokenPos) != line) {
+        // Unable to set a breakpoint at desired line.
+        script.lines[line - 1].possibleBpt = false;
+      }
+      // TODO(turnidge): Instead of reloading all of the breakpoints,
+      // rely on events to update the breakpoint list.
+      return reloadBreakpoints().then((_) {
+        return result;
       });
+    });
   }
 
-  Future removeBreakpoint(ServiceMap bpt) {
+  Future removeBreakpoint(Breakpoint bpt) {
     return invokeRpc('removeBreakpoint',
                      { 'breakpointId': bpt.id }).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
+          return result;
         }
         if (pauseEvent != null &&
             pauseEvent.breakpoint != null &&
-            (pauseEvent.breakpoint['id'] == bpt['id'])) {
+            (pauseEvent.breakpoint.id == bpt.id)) {

[rmacnak, 2015/02/13 19:00:42]

As discussed, just noting id versus number weirdness.

           return isolate.reload();
         } else {
           return reloadBreakpoints();
         }
       });
   }
 
   // TODO(turnidge): If the user invokes pause (or other rpcs) twice,
   // they could get a race.  Consider returning an "in progress"
   // future to avoid this.
@@ skipping 282 matching lines @@
 
 /// A [ServiceEvent] is an asynchronous event notification from the vm.
 class ServiceEvent extends ServiceObject {
   ServiceEvent._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ServiceEvent.vmDisconencted() : super._empty(null) {
     eventType = 'VMDisconnected';
   }
 
   @observable String eventType;
-  @observable ServiceMap breakpoint;
+  @observable Breakpoint breakpoint;
   @observable ServiceMap exception;
   @observable ByteData data;
   @observable int count;
 
   void _update(ObservableMap map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
     eventType = map['eventType'];
     name = 'ServiceEvent $eventType';
     vmName = name;
@@ skipping 10 matching lines @@
       count = map['count'];
     }
   }
 
   String toString() {
     return 'ServiceEvent of type $eventType with '
         '${data == null ? 0 : data.lengthInBytes} bytes of binary data';
   }
 }
 
+class Breakpoint extends ServiceObject {
+  Breakpoint._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  // TODO(turnidge): Add state to track if a breakpoint has been
+  // removed from the program.  Remove from the cache when deleted.
+  bool get canCache => true;
+  bool get immutable => false;
+
+  // A unique integer identifier for this breakpoint.
+  @observable int number;
+
+  // Source location information.
+  @observable Script script;
+  @observable int tokenPos;
+
+  // The breakpoint has been assigned to a final source location.
+  @observable bool resolved;
+
+  // The breakpoint is active.
+  @observable bool enabled;
+
+  void _update(ObservableMap map, bool mapIsRef) {
+    _loaded = true;
+    _upgradeCollection(map, owner);
+
+    number = map['breakpointNumber'];
+    script = map['location']['script'];
+    tokenPos = map['location']['tokenPos'];
+
+    resolved = map['resolved'];
+    enabled = map['enabled'];
+  }
+
+  String toString() {
+    if (number != null) {
+      return 'Breakpoint ${number} at ${script.name}(token:${tokenPos})';
+    } else {
+      return 'Uninitialized breakpoint';
+    }
+  }
+}
+
 class Library extends ServiceObject with Coverage {
   @observable String url;
   @reflectable final imports = new ObservableList<Library>();
   @reflectable final scripts = new ObservableList<Script>();
   @reflectable final classes = new ObservableList<Class>();
   @reflectable final variables = new ObservableList<Field>();
   @reflectable final functions = new ObservableList<ServiceFunction>();
 
   bool get canCache => true;
   bool get immutable => false;
@@ skipping 425 matching lines @@
 
   String toString() => 'Field(${owner.name}.$name)';
 }
 
 
 class ScriptLine extends Observable {
   final Script script;
   final int line;
   final String text;
   @observable int hits;
-  @observable ServiceMap bpt;
+  @observable Breakpoint bpt;
   @observable bool possibleBpt = true;
 
   bool get isBlank {
     // Compute isBlank on demand.
     if (_isBlank == null) {
       _isBlank = text.trim().isEmpty;
     }
     return _isBlank;
   }
   bool _isBlank;
@@ skipping 28 matching lines @@
       }
     }
     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) {
-      var bptScript = bpt['location']['script'];
-      var bptTokenPos = bpt['location']['tokenPos'];
-      if (bptScript == this.script &&
-          bptScript.tokenToLine(bptTokenPos) == line) {
+      if (bpt.script == this.script &&
+          bpt.script.tokenToLine(bpt.tokenPos) == line) {
         this.bpt = bpt;
       }
     }
   }
 }
 
 class Script extends ServiceObject with Coverage {
   final lines = new ObservableList<ScriptLine>();
   final _hits = new Map<int, int>();
   @observable String kind;
@@ skipping 896 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);
     }
   }
 }