Add hotkeys to Observatory debugger.

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';
 import 'package:observatory/debugger.dart';
 import 'package:observatory/service.dart';
 import 'package:logging/logging.dart';
 import 'package:polymer/polymer.dart';
 
 // TODO(turnidge): Move Debugger, DebuggerCommand to debugger library.
 abstract class DebuggerCommand extends Command {
   ObservatoryDebugger debugger;
 
   DebuggerCommand(this.debugger, name, children)
       : super(name, children);
 
   String get helpShort;
   String get helpLong;
 }
 
 // TODO(turnidge): Rewrite HelpCommand so that it is a general utility
 // provided by the cli library.
 class HelpCommand extends DebuggerCommand {
-  HelpCommand(Debugger debugger) : super(debugger, 'help', []);
+  HelpCommand(Debugger debugger) : super(debugger, 'help', [
+    new HelpHotkeysCommand(debugger),
+  ]);
 
   String _nameAndAlias(Command cmd) {
     if (cmd.alias == null) {
       return cmd.fullName;
     } else {
       return '${cmd.fullName}, ${cmd.alias}';
     }
   }
 
   Future run(List<String> args) {
     var con = debugger.console;
     if (args.length == 0) {
       // Print list of all top-level commands.
       var commands = debugger.cmd.matchCommand([], false);
       commands.sort((a, b) => a.name.compareTo(b.name));
       con.print('List of commands:\n');
       for (var command in commands) {
         con.print('${_nameAndAlias(command).padRight(12)} '
                   '- ${command.helpShort}');
       }
       con.print(
           "\nFor more information on a specific command type 'help <command>'\n"
+          "For a list of hotkeys type 'help hotkeys'\n"
           "\n"
           "Command prefixes are accepted (e.g. 'h' for 'help')\n"
           "Hit [TAB] to complete a command (try 'is[TAB][TAB]')\n"
           "Hit [ENTER] to repeat the last command\n"
           "Use up/down arrow for command history\n");
       return new Future.value(null);
     } else {
       // Print any matching commands.
       var commands = debugger.cmd.matchCommand(args, true);
       commands.sort((a, b) => a.name.compareTo(b.name));
@@ skipping 35 matching lines @@
 
   String helpShort = 'List commands or provide details about a specific command';
 
   String helpLong =
       'List commands or provide details about a specific command.\n'
       '\n'
       'Syntax: help            - Show a list of all commands\n'
       '        help <command>  - Help for a specific command\n';
 }
 
+class HelpHotkeysCommand extends DebuggerCommand {
+  HelpHotkeysCommand(Debugger debugger) : super(debugger, 'hotkeys', []);
+
+  Future run(List<String> args) {
+    var con = debugger.console;
+    con.print("List of hotkeys:\n"
+              "\n"
+              "[TAB]        - complete a command\n"
+              "[Up Arrow]   - history previous\n"
+              "[Down Arrow] - history next\n"
+              "\n"
+              "[Page Up]    - move up one frame\n"
+              "[Page Down]  - move down one frame\n"
+              "\n"
+              "[F7]         - continue execution of the current isolate\n"
+              "[Ctrl ;]     - pause execution of the current isolate\n"
+              "\n"
+              "[F8]         - toggle breakpoint at current location\n"
+              "[F9]         - next\n"
+              "[F10]        - step\n"
+              "\n");
+    return new Future.value(null);
+  }
+
+  String helpShort = 'Provide a list of hotkeys';
+
+  String helpLong =
+      'Provide a list of key hotkeys.\n'
+      '\n'
+      'Syntax: help hotkeys\n';
+}
+
 class PrintCommand extends DebuggerCommand {
   PrintCommand(Debugger debugger) : super(debugger, 'print', []) {
     alias = 'p';
   }
 
   Future run(List<String> args) async {
     if (args.length < 1) {
       debugger.console.print('print expects arguments');
       return;
     }
@@ skipping 30 matching lines @@
       count = int.parse(args[0]);
     } else if (args.length > 1) {
       debugger.console.print('down expects 0 or 1 argument');
       return new Future.value(null);
     }
     if (debugger.currentFrame == null) {
       debugger.console.print('No stack');
       return new Future.value(null);
     }
     try {
-      debugger.currentFrame -= count;
+      debugger.currentFrame += count;
       debugger.console.print('frame = ${debugger.currentFrame}');
     } catch (e) {
       debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
     }
     return new Future.value(null);
   }
 
-  String helpShort = 'Move down one or more frames';
+  String helpShort = 'Move down one or more frames (hotkey: [Page Down])';
 
   String helpLong =
       'Move down one or more frames.\n'
       '\n'
+      'Hotkey: [Page Down]\n'
+      '\n'
       'Syntax: down\n'
       '        down <count>\n';
 }
 
 class UpCommand extends DebuggerCommand {
   UpCommand(Debugger debugger) : super(debugger, 'up', []);
 
   Future run(List<String> args) {
     int count = 1;
     if (args.length == 1) {
       count = int.parse(args[0]);
     } else if (args.length > 1) {
       debugger.console.print('up expects 0 or 1 argument');
       return new Future.value(null);
     }
     if (debugger.currentFrame == null) {
       debugger.console.print('No stack');
       return new Future.value(null);
     }
     try {
-      debugger.currentFrame += count;
+      debugger.currentFrame -= count;
       debugger.console.print('frame = ${debugger.currentFrame}');
     } on RangeError catch (e) {
       debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
     }
     return new Future.value(null);
   }
 
-  String helpShort = 'Move up one or more frames';
+  String helpShort = 'Move up one or more frames (hotkey: [Page Up])';
 
   String helpLong =
       'Move up one or more frames.\n'
       '\n'
+      'Hotkey: [Page Up]\n'
+      '\n'
       'Syntax: up\n'
       '        up <count>\n';
 }
 
 class FrameCommand extends DebuggerCommand {
   FrameCommand(Debugger debugger) : super(debugger, 'frame', []) {
     alias = 'f';
   }
 
   Future run(List<String> args) {
@@ skipping 23 matching lines @@
       'Set the current frame.\n'
       '\n'
       'Syntax: frame <number>\n'
       '        f <count>\n';
 }
 
 class PauseCommand extends DebuggerCommand {
   PauseCommand(Debugger debugger) : super(debugger, 'pause', []);
 
   Future run(List<String> args) {
-    if (!debugger.isolatePaused()) {
-      return debugger.isolate.pause();
-    } else {
-      debugger.console.print('The program is already paused');
-      return new Future.value(null);
-    }
+    return debugger.pause();
   }
 
-  String helpShort = 'Pause the isolate';
+  String helpShort = 'Pause the isolate (hotkey: [Ctrl ;])';
 
   String helpLong =
       'Pause the isolate.\n'
       '\n'
+      'Hotkey: [Ctrl ;]\n'
+      '\n'
       'Syntax: pause\n';
 }
 
 class ContinueCommand extends DebuggerCommand {
   ContinueCommand(Debugger debugger) : super(debugger, 'continue', []) {
     alias = 'c';
   }
 
   Future run(List<String> args) {
-    if (debugger.isolatePaused()) {
-      return debugger.isolate.resume().then((_) {
-          debugger.warnOutOfDate();
-        });
-    } else {
-      debugger.console.print('The program must be paused');
-      return new Future.value(null);
-    }
+    debugger.resume();
   }
 
-  String helpShort = 'Resume execution of the isolate';
+  String helpShort = 'Resume execution of the isolate (hotkey: [F7])';
 
   String helpLong =
       'Continue running the isolate.\n'
       '\n'
+      'Hotkey: [F7]\n'
+      '\n'
       'Syntax: continue\n'
       '        c\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.kind == ServiceEvent.kPauseStart) {
-        debugger.console.print("Type 'continue' to start the isolate");
-        return new Future.value(null);
-      }
-      if (event.kind == 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);
-    }
+    return debugger.next();
   }
 
   String helpShort =
       'Continue running the isolate until it reaches the next source location '
-      'in the current function';
+      'in the current function (hotkey: [F9])';
 
   String helpLong =
       'Continue running the isolate until it reaches the next source location '
       'in the current function.\n'
       '\n'
+      'Hotkey: [F9]\n'
+      '\n'
       'Syntax: next\n';
 }
 
 class StepCommand extends DebuggerCommand {
   StepCommand(Debugger debugger) : super(debugger, 'step', []) {
     alias = 's';
   }
 
   Future run(List<String> args) {
-    if (debugger.isolatePaused()) {
-      var event = debugger.isolate.pauseEvent;
-      if (event.kind == ServiceEvent.kPauseStart) {
-        debugger.console.print("Type 'continue' to start the isolate");
-        return new Future.value(null);
-      }
-      if (event.kind == 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);
-    }
+    return debugger.step();
   }
 
   String helpShort =
-      'Continue running the isolate until it reaches the next source location';
+      'Continue running the isolate until it reaches the next source location'
+      ' (hotkey: [F10]';
 
   String helpLong =
       'Continue running the isolate until it reaches the next source '
       'location.\n'
       '\n'
+      'Hotkey: [F10]\n'
+      '\n'
       'Syntax: step\n';
 }
 
+class ClsCommand extends DebuggerCommand {
+  ClsCommand(Debugger debugger) : super(debugger, 'cls', []) {}
+
+  Future run(List<String> args) {
+    debugger.console.clear();
+    debugger.console.newline();
+    return new Future.value(null);
+  }
+
+  String helpShort = 'Clear the console';
+
+  String helpLong =
+      'Clear the console.\n'
+      '\n'
+      'Syntax: cls\n';
+}
+
 class LogCommand extends DebuggerCommand {
   LogCommand(Debugger debugger) : super(debugger, 'log', []);
 
   Future run(List<String> args) async {
     if (args.length == 0) {
       debugger.console.print(
           'Current log level: '
           '${debugger._consolePrinter._minimumLogLevel.name}');
       return new Future.value(null);
     }
@@ skipping 178 matching lines @@
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
       return new Future.value([args.join('')]);
     }
     // TODO - fix DebuggerLocation complete
     return new Future.value(DebuggerLocation.complete(debugger, args[0]));
   }
 
-  String helpShort = 'Add a breakpoint by source location or function name';
+  String helpShort = 'Add a breakpoint by source location or function name'
+      ' (hotkey: [F8])';
 
   String helpLong =
       'Add a breakpoint by source location or function name.\n'
       '\n'
+      'Hotkey: [F8]\n'
+      '\n'
       'Syntax: break                       '
       '# Break at the current position\n'
       '        break <line>                '
       '# Break at a line in the current script\n'
       '                                    '
       '  (e.g \'break 11\')\n'
       '        break <line>:<col>          '
       '# Break at a line:col in the current script\n'
       '                                    '
       '  (e.g \'break 11:8\')\n'
@@ skipping 58 matching lines @@
     });
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
       return new Future.value([args.join('')]);
     }
     return new Future.value(DebuggerLocation.complete(debugger, args[0]));
   }
 
-  String helpShort = 'Remove a breakpoint by source location or function name';
+  String helpShort = 'Remove a breakpoint by source location or function name'
+      ' (hotkey: [F8])';
 
   String helpLong =
       'Remove a breakpoint by source location or function name.\n'
       '\n'
+      'Hotkey: [F8]\n'
+      '\n'
       'Syntax: clear                       '
       '# Clear at the current position\n'
       '        clear <line>                '
       '# Clear at a line in the current script\n'
       '                                    '
       '  (e.g \'clear 11\')\n'
       '        clear <line>:<col>          '
       '# Clear at a line:col in the current script\n'
       '                                    '
       '  (e.g \'clear 11:8\')\n'
@@ skipping 410 matching lines @@
         new AsyncNextCommand(this),
         new FinishCommand(this),
         new BreakCommand(this),
         new SetCommand(this),
         new ClearCommand(this),
         new DeleteCommand(this),
         new InfoCommand(this),
         new IsolateCommand(this),
         new RefreshCommand(this),
         new LogCommand(this),
+        new ClsCommand(this),
     ]);
     _consolePrinter = new _ConsoleStreamPrinter(this);
   }
 
   VM get vm => page.app.vm;
 
   void updateIsolate(Isolate iso) {
     _isolate = iso;
     if (_isolate != null) {
       if ((exceptions != iso.exceptionsPauseInfo) &&
@@ skipping 100 matching lines @@
       _reportPause(_isolate.pauseEvent);
     } else {
       console.print('Isolate is in unknown state');
     }
     warnOutOfDate();
   }
 
   void _reportPause(ServiceEvent event) {
     if (event.kind == ServiceEvent.kPauseStart) {
       console.print(
-          "Paused at isolate start (type 'continue' to start the isolate')");
+          "Paused at isolate start (type 'continue' or [F7] to start the isolate')");
     } else if (event.kind == ServiceEvent.kPauseExit) {
       console.print(
-          "Paused at isolate exit (type 'continue' to exit the isolate')");
+          "Paused at isolate exit (type 'continue' or [F7] to exit the isolate')");
     }
     if (stack['frames'].length > 0) {
       Frame frame = stack['frames'][0];
       var script = frame.location.script;
       script.load().then((_) {
         var line = script.tokenToLine(frame.location.tokenPos);
         var col = script.tokenToCol(frame.location.tokenPos);
         if (event.breakpoint != null) {
           var bpId = event.breakpoint.number;
           console.print('Paused at breakpoint ${bpId} at '
@@ skipping 202 matching lines @@
     });
   }
 
   String historyPrev(String command) {
     return cmd.historyPrev(command);
   }
 
   String historyNext(String command) {
     return cmd.historyNext(command);
   }
+
+  Future pause() {
+    if (!isolatePaused()) {
+      return isolate.pause();
+    } else {
+      console.print('The program is already paused');
+      return new Future.value(null);
+    }
+  }
+
+  Future resume() {
+    if (isolatePaused()) {
+      return isolate.resume().then((_) {
+          warnOutOfDate();
+        });
+    } else {
+      console.print('The program must be paused');
+      return new Future.value(null);
+    }
+  }
+
+  Future toggleBreakpoint() async {
+    var loc = await DebuggerLocation.parse(this, '');
+    var script = loc.script;
+    var line = loc.line;
+    if (script != null && line != null) {
+      var bpts = script.getLine(line).breakpoints;
+      if (bpts == null || bpts.isEmpty) {
+        // Set a new breakpoint.
+        // TODO(turnidge): Set this breakpoint at current column.
+        await isolate.addBreakpoint(script, line);
+      } else {
+        // TODO(turnidge): Clear this breakpoint at current column.
+        var pending = [];
+        for (var bpt in bpts) {
+          pending.add(isolate.removeBreakpoint(bpt));
+        }
+        await Future.wait(pending);
+      }
+    }
+    return new Future.value(null);
+  }
+
+  Future next() {
+    if (isolatePaused()) {
+      var event = isolate.pauseEvent;
+      if (event.kind == ServiceEvent.kPauseStart) {
+        console.print("Type 'continue' or [F7] to start the isolate");
+        return new Future.value(null);
+      }
+      if (event.kind == ServiceEvent.kPauseExit) {
+        console.print("Type 'continue' or [F7] to exit the isolate");
+        return new Future.value(null);
+      }
+      return isolate.stepOver();
+    } else {
+      console.print('The program is already running');
+      return new Future.value(null);
+    }
+  }
+
+  Future step() {
+    if (isolatePaused()) {
+      var event = isolate.pauseEvent;
+      if (event.kind == ServiceEvent.kPauseStart) {
+        console.print("Type 'continue' or [F7] to start the isolate");
+        return new Future.value(null);
+      }
+      if (event.kind == ServiceEvent.kPauseExit) {
+        console.print("Type 'continue' or [F7] to exit the isolate");
+        return new Future.value(null);
+      }
+      return isolate.stepInto();
+    } else {
+      console.print('The program is already running');
+      return new Future.value(null);
+    }
+  }
 }
 
 @CustomTag('debugger-page')
 class DebuggerPageElement extends ObservatoryElement {
   @published Isolate isolate;
 
   isolateChanged(oldValue) {
     if (isolate != null) {
       debugger.updateIsolate(isolate);
     }
@@ skipping 512 matching lines @@
     refElement.ref = ref;
     _append(refElement);
     if (newline) {
       this.newline();
     }
   }
 
   void newline() {
     _append(new BRElement());
   }
+
+  void clear() {
+    var consoleTextElement = $['consoleText'];
+    consoleTextElement.children.clear();
+  }
 }
 
 @CustomTag('debugger-input')
 class DebuggerInputElement extends ObservatoryElement {
   @published Isolate isolate;
   @published String text = '';
   @observable ObservatoryDebugger debugger;
   @observable bool busy = false;
 
   @override
@@ skipping 33 matching lines @@
             text = debugger.historyPrev(text);
             busy = false;
             break;
 
           case KeyCode.DOWN:
             e.preventDefault();
             text = debugger.historyNext(text);
             busy = false;
             break;
 
+          case KeyCode.PAGE_UP:
+            e.preventDefault();
+            try {
+              debugger.currentFrame -= 1;
+            } on RangeError catch (e) {
+              // Ignore.
+            }
+            busy = false;
+            break;
+
+          case KeyCode.PAGE_DOWN:
+            e.preventDefault();
+            try {
+              debugger.currentFrame += 1;
+            } on RangeError catch (e) {
+              // Ignore.
+            }
+            busy = false;
+            break;
+
+          case KeyCode.F7:
+            e.preventDefault();
+            debugger.resume().whenComplete(() {
+              busy = false;
+            });
+            break;
+
+          case KeyCode.F8:
+            e.preventDefault();
+            debugger.toggleBreakpoint().whenComplete(() {
+              busy = false;
+            });
+            break;
+
+          case KeyCode.F9:
+            e.preventDefault();
+            debugger.next().whenComplete(() {
+              busy = false;
+            });
+            break;
+
+          case KeyCode.F10:
+            e.preventDefault();
+            debugger.step().whenComplete(() {
+              busy = false;
+            });
+            break;
+
+          case KeyCode.SEMICOLON:
+            if (e.ctrlKey) {
+              e.preventDefault();
+              debugger.console.printRed('^;');
+              debugger.pause().whenComplete(() {
+                busy = false;
+              });
+            } else {
+              busy = false;
+            }
+            break;
+
           default:
             busy = false;
             break;
         }
       });
   }
 
   void focus() {
     $['textBox'].focus();
   }
 
   DebuggerInputElement.created() : super.created();
 }