Rework error handling in the service protocol and in Observatory.

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/app.dart';
@@ skipping 99 matching lines @@
     alias = 'p';
   }
 
   Future run(List<String> args) {
     if (args.length < 1) {
       debugger.console.print('print expects arguments');
       return new Future.value(null);
     }
     var expr = args.join('');
     return debugger.isolate.evalFrame(debugger.currentFrame, expr)
-      .then((response) {
-          if (response is DartError) {
-            debugger.console.print(response.message);
-          } else {
-            debugger.console.print('= ', newline:false);
-            debugger.console.printRef(response);
-          }
+      .then((ServiceObject response) {
+        if (response is DartError) {
+          debugger.console.print(response.message);
+        } else {
+          debugger.console.print('= ', newline:false);
+          debugger.console.printRef(response);
+        }
       });
   }
 
   String helpShort = 'Evaluate and print an expression in the current frame';
 
   String helpLong =
       'Evaluate and print an expression in the current frame.\n'
       '\n'
       'Syntax: print <expression>\n'
       '        p <expression>\n';
@@ skipping 225 matching lines @@
 
   String helpLong =
       'Continue running the isolate until the current function exits.\n'
       '\n'
       'Syntax: finish\n';
 }
 
 class BreakCommand extends DebuggerCommand {
   BreakCommand(Debugger debugger) : super(debugger, 'break', []);
 
-  Future run(List<String> args) {
+  Future run(List<String> args) async {
     if (args.length > 1) {
       debugger.console.print('not implemented');
       return new Future.value(null);
     }
     var arg = (args.length == 0 ? '' : args[0]);
-    return SourceLocation.parse(debugger, arg).then((loc) {
-      if (loc.valid) {
-        if (loc.function != null) {
-          return debugger.isolate.addBreakpointAtEntry(loc.function)
-            .then((result) => _handleBreakpointResult(loc, result));
-        } else {
-          assert(loc.script != null);
-          if (loc.col != null) {
-            // TODO(turnidge): Add tokenPos breakpoint support.
-            debugger.console.print(
-                'Ignoring column: '
-                'adding breakpoint at a specific column not yet implemented');
+    var loc = await SourceLocation.parse(debugger, arg);
+    if (loc.valid) {
+      if (loc.function != null) {
+        try {
+          await debugger.isolate.addBreakpointAtEntry(loc.function);
+        } on ServerRpcException catch(e) {
+          if (e.code == ServerRpcException.kNoBreakAtFunction) {
+            debugger.console.print('Unable to set breakpoint at ${loc}');
+          } else {
+            rethrow;
           }
-          return debugger.isolate.addBreakpoint(loc.script, loc.line)
-            .then((result) => _handleBreakpointResult(loc, result));
         }
       } else {
-        debugger.console.print(loc.errorMessage);
+        assert(loc.script != null);
+        if (loc.col != null) {
+          // TODO(turnidge): Add tokenPos breakpoint support.
+          debugger.console.print(
+              'Ignoring column: '
+              'adding breakpoint at a specific column not yet implemented');
+          }
+        try {
+          await debugger.isolate.addBreakpoint(loc.script, loc.line);
+        } on ServerRpcException catch(e) {
+          if (e.code == ServerRpcException.kNoBreakAtLine) {
+            debugger.console.print('Unable to set breakpoint at ${loc}');
+          } else {
+            rethrow;
+          }
+        }
       }
-    });
-  }
-
-  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.
+      debugger.console.print(loc.errorMessage);
     }
-    return new Future.value(null);
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
       return new Future.value([args.join('')]);
     }
     // TODO - fix SourceLocation complete
     return new Future.value(SourceLocation.complete(debugger, args[0]));
   }
 
@@ skipping 542 matching lines @@
       console.print('No current isolate');
     } else if (_isolate.idle) {
       console.print('Isolate is idle');
     } 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');
     }
+    warnOutOfDate();
   }
 
   void _reportPause(ServiceEvent event) {
     if (event.eventType == ServiceEvent.kPauseStart) {
       console.print(
           "Paused at isolate start (type 'continue' to start the isolate')");
     } 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}');
+          console.print('Paused at 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}');
+          console.print('Paused due to exception ${event.exception} at '
+                        '${script.name}:${line}:${col}');
         } else {
           console.print('Paused at ${script.name}:${line}:${col}');
         }
       });
     }
   }
 
   Future _reportBreakpointEvent(ServiceEvent event) {
     var bpt = event.breakpoint;
     var verb = null;
@@ skipping 134 matching lines @@
   String lastCommand;
 
   Future run(String command) {
     if (command == '' && lastCommand != null) {
       command = lastCommand;
     }
     console.printBold('\$ $command');
     return cmd.runCommand(command).then((_) {
       lastCommand = command;
     }).catchError((e, s) {
-      console.print('ERROR $e\n$s');
+      if (e is NetworkRpcException) {
+        console.printRed('Unable to execute command because the connection '
+                      'to the VM has been closed');
+      } else {
+        if (s != null) {
+          console.printRed('Internal error: $e\n$s');
+        } else {
+          console.printRed('Internal error: $e\n');
+        }
+      }
     });
   }
 
   String historyPrev(String command) {
     return cmd.historyPrev(command);
   }
 
   String historyNext(String command) {
     return cmd.historyNext(command);
   }
@@ skipping 185 matching lines @@
 
   Set<Script> activeScripts() {
     var s = new Set<Script>();
     List frameElements = $['frameList'].children;
     for (var frameElement in frameElements) {
       s.add(frameElement.children[0].script);
     }
     return s;
   }
 
-  doPauseIsolate(_) {
+  Future doPauseIsolate() {
     if (debugger != null) {
       return debugger.isolate.pause();
     } else {
       return new Future.value(null);
     }
   }
 
-  doRefreshStack(_) {
+  Future doRefreshStack() {
     if (debugger != null) {
       return debugger.refreshStack();
     } else {
       return new Future.value(null);
     }
   }
 
   DebuggerStackElement.created() : super.created();
 }
 
@@ skipping 192 matching lines @@
     var span = new SpanElement();
     span.classes.add('bold');
     span.appendText(line);
     if (newline) {
       span.appendText('\n');
     }
     $['consoleText'].children.add(span);
     span.scrollIntoView();
   }
 
+  void printRed(String line, { bool newline:true }) {
+    var span = new SpanElement();
+    span.classes.add('red');
+    span.appendText(line);
+    if (newline) {
+      span.appendText('\n');
+    }
+    $['consoleText'].children.add(span);
+    span.scrollIntoView();
+  }
+
   void printRef(Instance ref, { bool newline:true }) {
     var refElement = new Element.tag('instance-ref');
     refElement.ref = ref;
     $['consoleText'].children.add(refElement);
     if (newline) {
       this.newline();
     }
     refElement.scrollIntoView();
   }
 
@@ skipping 58 matching lines @@
           default:
             busy = false;
             break;
         }
       });
   }
 
   DebuggerInputElement.created() : super.created();
 }