Major rework of vm service events.

runtime/observatory/lib/src/elements/debugger.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.
 
 library debugger_page_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
 import 'package:observatory/cli.dart';
@@ skipping 124 matching lines @@
       '\n'
       'Syntax: continue\n';
 }
 
 class NextCommand extends DebuggerCommand {
   NextCommand(Debugger debugger) : super(debugger, 'next', []);
 
   Future run(List<String> args) {
     if (debugger.isolatePaused()) {
       var event = debugger.isolate.pauseEvent;
-      if (event.eventType == 'IsolateCreated') {
+      if (event.eventType == ServiceEvent.kPauseStart) {
         debugger.console.print("Type 'continue' to start the isolate");
         return new Future.value(null);
       }
-      if (event.eventType == 'IsolateShutdown') {
+      if (event.eventType == ServiceEvent.kPauseExit) {
         debugger.console.print("Type 'continue' to exit the isolate");
         return new Future.value(null);
       }
       return debugger.isolate.stepOver();
     } else {
       debugger.console.print('The program is already running');
       return new Future.value(null);
     }
   }
 
   String helpShort =
       'Continue running the isolate until it reaches the next source location '
       'in the current function';
 
   String helpLong =
       'Continue running the isolate until it reaches the next source location '
       'in the current function.\n'
       '\n'
       'Syntax: next\n';
 }
 
 class StepCommand extends DebuggerCommand {
   StepCommand(Debugger debugger) : super(debugger, 'step', []);
 
   Future run(List<String> args) {
     if (debugger.isolatePaused()) {
       var event = debugger.isolate.pauseEvent;
-      if (event.eventType == 'IsolateCreated') {
+      if (event.eventType == ServiceEvent.kPauseStart) {
         debugger.console.print("Type 'continue' to start the isolate");
         return new Future.value(null);
       }
-      if (event.eventType == 'IsolateShutdown') {
+      if (event.eventType == ServiceEvent.kPauseExit) {
         debugger.console.print("Type 'continue' to exit the isolate");
         return new Future.value(null);
       }
       return debugger.isolate.stepInto();
     } else {
       debugger.console.print('The program is already running');
       return new Future.value(null);
     }
   }
 
@@ skipping 59 matching lines @@
     });
   }
 
   Future _handleBreakpointResult(loc, result) {
     if (result is DartError) {
       debugger.console.print('Unable to set breakpoint at ${loc}');
     } else {
       // TODO(turnidge): Adding a duplicate breakpoint is
       // currently ignored.  May want to change the protocol to
       // inform us when this happens.
-
-      // The BreakpointResolved event prints resolved
-      // breakpoints already.  Just print the unresolved ones here.
-      Breakpoint bpt = result;
-      if (!bpt.resolved) {
-        return debugger._reportBreakpointAdded(bpt);
-      }
     }
     return new Future.value(null);
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
       return new Future.value([]);
     }
     // TODO - fix SourceLocation complete
     return new Future.value(SourceLocation.complete(debugger, args[0]));
@@ skipping 45 matching lines @@
               'Function entry breakpoints not yet implemented');
           return null;
         }
         if (loc.col != null) {
           // TODO(turnidge): Add tokenPos clear support.
           debugger.console.print(
               'Ignoring column: '
               'clearing breakpoint at a specific column not yet implemented');
         }
 
-        for (var bpt in debugger.isolate.breakpoints) {
+        for (var bpt in debugger.isolate.breakpoints.values) {
           var script = bpt.script;
           if (script.id == loc.script.id) {
             assert(script.loaded);
             var line = script.tokenToLine(bpt.tokenPos);
             if (line == loc.line) {
               return debugger.isolate.removeBreakpoint(bpt).then((result) {
                 if (result is DartError) {
                   debugger.console.print(
                       'Unable to clear breakpoint at ${loc}: ${result.message}');
                   return;
-                } else {
-                  // TODO(turnidge): Add a BreakpointRemoved event to
-                  // the service instead of printing here.
-                  var bpId = bpt.number;
-                  debugger.console.print('Breakpoint ${bpId} removed at ${loc}');
-                  return;
                 }
               });
             }
           }
         }
         debugger.console.print('No breakpoint found at ${loc}');
       } else {
         debugger.console.print(loc.errorMessage);
       }
     });
@@ skipping 41 matching lines @@
 
   Future run(List<String> args) {
     if (args.length < 1) {
       debugger.console.print('delete expects one or more arguments');
       return new Future.value(null);
     }
     List toRemove = [];
     for (var arg in args) {
       int id = int.parse(arg);
       var bptToRemove = null;
-      for (var bpt in debugger.isolate.breakpoints) {
+      for (var bpt in debugger.isolate.breakpoints.values) {
         if (bpt.number == id) {
           bptToRemove = bpt;
           break;
         }
       }
       if (bptToRemove == null) {
         debugger.console.print("Invalid breakpoint id '${id}'");
         return new Future.value(null);
       }
       toRemove.add(bptToRemove);
     }
     List pending = [];
     for (var bpt in toRemove) {
-      pending.add(debugger.isolate.removeBreakpoint(bpt).then((_) {
-            var id = bpt.number;
-            debugger.console.print("Removed breakpoint $id");
-          }));
+      pending.add(debugger.isolate.removeBreakpoint(bpt));
     }
     return Future.wait(pending);
   }
 
   String helpShort = 'Remove a breakpoint by breakpoint id';
 
   String helpLong =
       'Remove a breakpoint by breakpoint id.\n'
       '\n'
       'Syntax: delete <bp-id>\n'
       '        delete <bp-id> <bp-id> ...\n';
 }
 
 class InfoBreakpointsCommand extends DebuggerCommand {
   InfoBreakpointsCommand(Debugger debugger)
       : super(debugger, 'breakpoints', []);
 
   Future run(List<String> args) {
-    return debugger.isolate.reloadBreakpoints().then((_) {
-      if (debugger.isolate.breakpoints.isEmpty) {
-        debugger.console.print('No breakpoints');
+    if (debugger.isolate.breakpoints.isEmpty) {
+      debugger.console.print('No breakpoints');
+    }
+    List bpts = debugger.isolate.breakpoints.values.toList();
+    bpts.sort((a, b) => a.number - b.number);
+    for (var bpt in bpts) {
+      var bpId = bpt.number;
+      var script = bpt.script;
+      var tokenPos = bpt.tokenPos;
+      var line = script.tokenToLine(tokenPos);
+      var col = script.tokenToCol(tokenPos);
+      if (!bpt.resolved) {
+        debugger.console.print(
+            'Future breakpoint ${bpId} at ${script.name}:${line}:${col}');
+      } else {
+        debugger.console.print(
+            'Breakpoint ${bpId} at ${script.name}:${line}:${col}');
       }
-      for (var bpt in debugger.isolate.breakpoints) {
-        var bpId = bpt.number;
-        var script = bpt.script;
-        var tokenPos = bpt.tokenPos;
-        var line = script.tokenToLine(tokenPos);
-        var col = script.tokenToCol(tokenPos);
-        var extras = new StringBuffer();
-        if (!bpt.resolved) {
-          extras.write(' unresolved');
-        }
-        if (!bpt.enabled) {
-          extras.write(' disabled');
-        }
-        debugger.console.print(
-            'Breakpoint ${bpId} at ${script.name}:${line}:${col}${extras}');
-      }
-    });
+    }
+    return new Future.value(null);
   }
 
   String helpShort = 'List all breakpoints';
 
   String helpLong =
       'List all breakpoints.\n'
       '\n'
       'Syntax: info breakpoints\n';
 }
 
@@ skipping 150 matching lines @@
   Future refreshStack() {
     return _refreshStack(isolate.pauseEvent).then((_) {
         reportStatus();
       });
   }
 
   bool isolatePaused() {
     // TODO(turnidge): Stop relying on the isolate to track the last
     // pause event.  Since we listen to events directly in the
     // debugger, this could introduce a race.
-    return isolate.pauseEvent != null;
+    return (isolate.pauseEvent != null &&
+            isolate.pauseEvent.eventType != ServiceEvent.kResume);
   }
 
   void warnOutOfDate() {
     // Wait a bit, then tell the user that the stack may be out of date.
     new Timer(const Duration(seconds:2), () {
       if (!isolatePaused()) {
         stackElement.isSampled = true;
       }
     });
   }
@@ skipping 13 matching lines @@
     } else if (_isolate.running) {
       console.print("Isolate is running (type 'pause' to interrupt)");
     } else if (_isolate.pauseEvent != null) {
       _reportPause(_isolate.pauseEvent);
     } else {
       console.print('Isolate is in unknown state');
     }
   }
 
   void _reportPause(ServiceEvent event) {
-    if (event.eventType == 'IsolateCreated') {
+    if (event.eventType == ServiceEvent.kPauseStart) {
       console.print(
           "Paused at isolate start (type 'continue' to start the isolate')");
-    } else if (event.eventType == 'IsolateShutdown') {
+    } else if (event.eventType == ServiceEvent.kPauseExit) {
       console.print(
           "Paused at isolate exit (type 'continue' to exit the isolate')");
     }
     if (stack['frames'].length > 0) {
       var frame = stack['frames'][0];
       var script = frame['script'];
       script.load().then((_) {
         var line = script.tokenToLine(frame['tokenPos']);
         var col = script.tokenToCol(frame['tokenPos']);
         if (event.breakpoint != null) {
           var bpId = event.breakpoint.number;
           console.print('Breakpoint ${bpId} at ${script.name}:${line}:${col}');
         } else if (event.exception != null) {
           // TODO(turnidge): Test this.
           console.print(
               'Exception ${event.exception} at ${script.name}:${line}:${col}');
         } else {
           console.print('Paused at ${script.name}:${line}:${col}');
         }
       });
     }
   }
 
-  Future _reportBreakpointAdded(Breakpoint bpt) {
+  Future _reportBreakpointEvent(ServiceEvent event) {
+    var bpt = event.breakpoint;
+    var verb = null;
+    switch (event.eventType) {
+      case ServiceEvent.kBreakpointAdded:
+        verb = 'added';
+        break;
+      case ServiceEvent.kBreakpointResolved:
+        verb = 'resolved';
+        break;
+      case ServiceEvent.kBreakpointRemoved:
+        verb = 'removed';
+        break;
+      default:
+        break;
+    }
     var script = bpt.script;
     return script.load().then((_) {
       var bpId = bpt.number;
       var tokenPos = bpt.tokenPos;
       var line = script.tokenToLine(tokenPos);
       var col = script.tokenToCol(tokenPos);
       if (bpt.resolved) {
-        // TODO(turnidge): If this was a future breakpoint before, we
-        // should change the message to say that the breakpoint was 'resolved',
-        // rather than 'added'.
         console.print(
-            'Breakpoint ${bpId} added at ${script.name}:${line}:${col}');
+            'Breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
       } else {
         console.print(
-            'Future breakpoint ${bpId} added at ${script.name}:${line}:${col}');
+            'Future breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
       }
     });
   }
 
   void _onEvent(ServiceEvent event) {
     if (event.owner != isolate) {
       return;
     }
     switch(event.eventType) {
-      case 'IsolateShutdown':
+      case ServiceEvent.kIsolateExit:
         console.print('Isolate shutdown');
         isolate = null;
         break;
 
-      case 'BreakpointReached':
-      case 'IsolateInterrupted':
-      case 'ExceptionThrown':
+      case ServiceEvent.kPauseStart:
+      case ServiceEvent.kPauseExit:
+      case ServiceEvent.kPauseBreakpoint:
+      case ServiceEvent.kPauseInterrupted:
+      case ServiceEvent.kPauseException:
         _refreshStack(event).then((_) {
           _reportPause(event);
         });
         break;
 
-      case 'IsolateResumed':
+      case ServiceEvent.kResume:
         console.print('Continuing...');
         break;
 
-      case 'BreakpointResolved':
-        _reportBreakpointAdded(event.breakpoint);
+      case ServiceEvent.kBreakpointAdded:
+      case ServiceEvent.kBreakpointResolved:
+      case ServiceEvent.kBreakpointRemoved:
+        _reportBreakpointEvent(event);
         break;
 
-      case '_Graph':
-      case 'IsolateCreated':
-      case 'GC':
+      case ServiceEvent.kIsolateStart:
+      case ServiceEvent.kGraph:
+      case ServiceEvent.kGC:
         // Ignore these events for now.
         break;
 
       default:
         console.print('Unrecognized event: $event');
         break;
     }
   }
 
   static String _commonPrefix(String a, String b) {
@@ skipping 346 matching lines @@
           default:
             busy = false;
             break;
         }
       });
   }
 
   DebuggerInputElement.created() : super.created();
 }