Allow Observatory debugger to switch isolates.

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 12 matching lines @@
   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', []);
 
   String _nameAndAlias(Command cmd) {
     if (cmd.alias == null) {
-      return cmd.name;
+      return cmd.fullName;
     } else {
-      return '${cmd.name}, ${cmd.alias}';
+      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"
           "\n"
           "Command prefixes are accepted (e.g. 'h' for 'help')\n"
-          "Hit [TAB] to complete a command (try 'i[TAB][TAB]')\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));
       if (commands.isEmpty) {
         var line = args.join(' ');
         con.print("No command matches '${line}'");
@@ skipping 337 matching lines @@
     } else {
       // TODO(turnidge): Adding a duplicate breakpoint is
       // currently ignored.  May want to change the protocol to
       // inform us when this happens.
     }
     return new Future.value(null);
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
-      return new Future.value([]);
+      return new Future.value([args.join('')]);
     }
     // TODO - fix SourceLocation complete
     return new Future.value(SourceLocation.complete(debugger, args[0]));
   }
 
   String helpShort = 'Add a breakpoint by source location or function name';
 
   String helpLong =
       'Add a breakpoint by source location or function name.\n'
       '\n'
@@ skipping 63 matching lines @@
         }
         debugger.console.print('No breakpoint found at ${loc}');
       } else {
         debugger.console.print(loc.errorMessage);
       }
     });
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
-      return new Future.value([]);
+      return new Future.value([args.join('')]);
     }
     return new Future.value(SourceLocation.complete(debugger, args[0]));
   }
 
   String helpShort = 'Remove a breakpoint by source location or function name';
 
   String helpLong =
       'Remove a breakpoint by source location or function name.\n'
       '\n'
       'Syntax: clear                       '
@@ skipping 89 matching lines @@
   }
 
   String helpShort = 'List all breakpoints';
 
   String helpLong =
       'List all breakpoints.\n'
       '\n'
       'Syntax: info breakpoints\n';
 }
 
-class InfoIsolatesCommand extends DebuggerCommand {
-  InfoIsolatesCommand(Debugger debugger) : super(debugger, 'isolates', []);
+class InfoFrameCommand extends DebuggerCommand {
+  InfoFrameCommand(Debugger debugger) : super(debugger, 'frame', []);
 
   Future run(List<String> args) {
-    for (var isolate in debugger.isolate.vm.isolates) {
-      String current = (isolate == debugger.isolate ? ' *' : '');
-      debugger.console.print(
-          "Isolate ${isolate.id} '${isolate.name}'${current}");
+    if (args.length > 0) {
+      debugger.console.print('info frame expects no arguments');
+      return new Future.value(null);
+    }
+    debugger.console.print('frame = ${debugger.currentFrame}');
+    return new Future.value(null);
+  }
+
+  String helpShort = 'Show current frame';
+
+  String helpLong =
+      'Show current frame.\n'
+      '\n'
+      'Syntax: info frame\n';
+}
+
+class IsolateCommand extends DebuggerCommand {
+  IsolateCommand(Debugger debugger) : super(debugger, 'isolate', [
+    new IsolateListCommand(debugger),
+    new IsolateNameCommand(debugger),
+  ]) {
+    alias = 'i';
+  }
+
+  Future run(List<String> args) {
+    if (args.length != 1) {
+      debugger.console.print('isolate expects one argument');
+      return new Future.value(null);
+    }
+    var arg = args[0].trim();
+    var num = int.parse(arg, onError:(_) => null);
+
+    var candidate;
+    for (var isolate in debugger.vm.isolates) {
+      if (num != null && num == isolate.number) {
+        candidate = isolate;
+        break;
+      } else if (arg == isolate.name) {
+        if (candidate != null) {
+          debugger.console.print(
+              "Isolate identifier '${arg}' is ambiguous: "
+              'use the isolate number instead');
+          return new Future.value(null);
+        }
+        candidate = isolate;
+      }
+    }
+    if (candidate == null) {
+      debugger.console.print("Invalid isolate identifier '${arg}'");
+    } else {
+      if (candidate == debugger.isolate) {
+        debugger.console.print(
+            "Current isolate is already ${candidate.number} '${candidate.name}'");
+      } else {
+        debugger.console.print(
+            "Switching to isolate ${candidate.number} '${candidate.name}'");
+        debugger.isolate = candidate;
+      }
     }
     return new Future.value(null);
   }
+
+  Future<List<String>> complete(List<String> args) {
+    if (args.length != 1) {
+      return new Future.value([args.join('')]);
+    }
+    var isolates = debugger.vm.isolates.toList();
+    isolates.sort((a, b) => a.startTime.compareTo(b.startTime));
+    var result = [];
+    for (var isolate in isolates) {
+      var str = isolate.number.toString();
+      if (str.startsWith(args[0])) {
+        result.add('$str ');
+      }
+    }
+    for (var isolate in isolates) {
+      if (isolate.name.startsWith(args[0])) {
+        result.add('${isolate.name} ');
+      }
+    }
+    return new Future.value(result);
+  }
+  String helpShort = 'Switch the current isolate';
+
+  String helpLong =
+      'Switch the current isolate.\n'
+      '\n'
+      'Syntax: isolate <number>\n'
+      '        isolate <name>\n';
+}
+
+class IsolateListCommand extends DebuggerCommand {
+  IsolateListCommand(Debugger debugger) : super(debugger, 'list', []);
+
+  Future run(List<String> args) {
+    if (debugger.vm == null) {
+      debugger.console.print(
+          "Internal error: vm has not been set");
+      return new Future.value(null);
+    }
+    var isolates = debugger.vm.isolates.toList();
+    isolates.sort((a, b) => a.startTime.compareTo(b.startTime));
+    for (var isolate in isolates) {
+      String current = (isolate == debugger.isolate ? ' *' : '');
+      debugger.console.print(
+          "Isolate ${isolate.number} '${isolate.name}'${current}");
+    }
+    return new Future.value(null);
+  }
 
   String helpShort = 'List all isolates';
 
   String helpLong =
       'List all isolates.\n'
       '\n'
-      'Syntax: info isolates\n';
+      'Syntax: isolate list\n';
 }
 
-class InfoFrameCommand extends DebuggerCommand {
-  InfoFrameCommand(Debugger debugger) : super(debugger, 'frame', []);
+class IsolateNameCommand extends DebuggerCommand {
+  IsolateNameCommand(Debugger debugger) : super(debugger, 'name', []);
 
   Future run(List<String> args) {
-    if (args.length > 0) {
-      debugger.console.print('info frame expects 1 argument');
+    if (args.length != 1) {
+      debugger.console.print('isolate name expects one argument');
       return new Future.value(null);
     }
-    debugger.console.print('frame = ${debugger.currentFrame}');
-    return new Future.value(null);
+    return debugger.isolate.setName(args[0]);
   }
 
-  String helpShort = 'Show current frame';
+  String helpShort = 'Rename an isolate';
 
   String helpLong =
-      'Show current frame.\n'
+      'Rename an isolate.\n'
       '\n'
-      'Syntax: info frame\n';
+      'Syntax: isolate name <name>\n';
 }
 
 class InfoCommand extends DebuggerCommand {
   InfoCommand(Debugger debugger) : super(debugger, 'info', [
       new InfoBreakpointsCommand(debugger),
-      new InfoIsolatesCommand(debugger),
-      new InfoFrameCommand(debugger),
-  ]);
+      new InfoFrameCommand(debugger)]);
 
   Future run(List<String> args) {
     debugger.console.print("'info' expects a subcommand (see 'help info')");
     return new Future.value(null);
   }
 
   String helpShort = 'Show information on a variety of topics';
 
   String helpLong =
       'Show information on a variety of topics.\n'
@@ skipping 55 matching lines @@
 
   String helpLong =
       'Refresh debugging information of various sorts.\n'
       '\n'
       'Syntax: refresh <subcommand>\n';
 }
 
 // Tracks the state for an isolate debugging session.
 class ObservatoryDebugger extends Debugger {
   RootCommand cmd;
+  DebuggerPageElement page;
   DebuggerConsoleElement console;
   DebuggerStackElement stackElement;
   ServiceMap stack;
 
   int get currentFrame => _currentFrame;
   void set currentFrame(int value) {
     if (value != null && (value < 0 || value >= stackDepth)) {
       throw new RangeError.range(value, 0, stackDepth);
     }
     _currentFrame = value;
@@ skipping 14 matching lines @@
         new FrameCommand(this),
         new PauseCommand(this),
         new ContinueCommand(this),
         new NextCommand(this),
         new StepCommand(this),
         new FinishCommand(this),
         new BreakCommand(this),
         new ClearCommand(this),
         new DeleteCommand(this),
         new InfoCommand(this),
+        new IsolateCommand(this),
         new RefreshCommand(this),
     ]);
   }
 
-  void set isolate(Isolate iso) {
+  VM get vm => page.app.vm;
+
+  void updateIsolate(Isolate iso) {
     _isolate = iso;
     if (_isolate != null) {
-      _isolate.reload().then((_) {
+      _isolate.reload().then((response) {
         // TODO(turnidge): Currently the debugger relies on all libs
         // being loaded.  Fix this.
         var pending = [];
         for (var lib in _isolate.libraries) {
           if (!lib.loaded) {
             pending.add(lib.load());
           }
         }
         Future.wait(pending).then((_) {
-          _isolate.vm.events.stream.listen(_onEvent);
+          if (_subscription == null) {
+            _subscription = vm.events.stream.listen(_onEvent);
+          }
           _refreshStack(isolate.pauseEvent).then((_) {
             reportStatus();
           });
         });
       });
+    } else {
+      reportStatus();
     }
   }
+
+  void set isolate(Isolate iso) {
+    // Setting the page's isolate will trigger updateIsolate to be called.
+    //
+    // TODO(turnidge): Rework ownership of the ObservatoryDebugger in another
+    // change.
+    page.isolate = iso;
+  }
   Isolate get isolate => _isolate;
   Isolate _isolate;
+  var _subscription;
 
   void init() {
     console.newline();
     console.printBold("Type 'h' for help");
+    // Wait a bit and if polymer still hasn't set up the isolate,
+    // report this to the user.
+    new Timer(const Duration(seconds:1), () {
+      if (isolate == null) {
+        reportStatus();
+      }
+    });
   }
 
   Future refreshStack() {
     return _refreshStack(isolate.pauseEvent).then((_) {
-        reportStatus();
-      });
+      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 != null &&
             isolate.pauseEvent != null &&
             isolate.pauseEvent.eventType != ServiceEvent.kResume);
   }
@@ skipping 15 matching lines @@
       stackElement.updateStack(stack, pauseEvent);
       if (stack['frames'].length > 0) {
         currentFrame = 0;
       } else {
         currentFrame = null;
       }
     });
   }
 
   void reportStatus() {
-    if (_isolate.idle) {
+    if (_isolate == null) {
+      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');
     }
   }
 
@@ skipping 51 matching lines @@
         console.print(
             'Breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
       } else {
         console.print(
             'Future breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
       }
     });
   }
 
   void _onEvent(ServiceEvent event) {
-    if (event.owner != isolate) {
-      return;
-    }
     switch(event.eventType) {
-      case ServiceEvent.kIsolateExit:
-        console.print('Isolate shutdown');
-        isolate = null;
+      case ServiceEvent.kIsolateStart: {
+        var iso = event.owner;
+        console.print(
+            "Isolate ${iso.number} '${iso.name}' has been created");
+        break;
+      }
+
+      case ServiceEvent.kIsolateExit: {
+        var iso = event.owner;
+        if (iso == isolate) {
+          console.print("The current isolate has exited");
+        } else {
+          console.print(
+              "Isolate ${iso.number} '${iso.name}' has exited");
+        }
+        break;
+      }
+
+      case ServiceEvent.kIsolateUpdate:
+        var iso = event.owner;
+        console.print("Isolate ${iso.number} renamed to '${iso.name}'");
         break;
 
       case ServiceEvent.kPauseStart:
       case ServiceEvent.kPauseExit:
       case ServiceEvent.kPauseBreakpoint:
       case ServiceEvent.kPauseInterrupted:
       case ServiceEvent.kPauseException:
-        _refreshStack(event).then((_) {
-          _reportPause(event);
-        });
+        if (event.owner == isolate) {
+          _refreshStack(event).then((_) {
+            _reportPause(event);
+          });
+        }
         break;
 
       case ServiceEvent.kResume:
-        console.print('Continuing...');
+        if (event.owner == isolate) {
+          console.print('Continuing...');
+        }
         break;
 
       case ServiceEvent.kBreakpointAdded:
       case ServiceEvent.kBreakpointResolved:
       case ServiceEvent.kBreakpointRemoved:
-        _reportBreakpointEvent(event);
+        if (event.owner == isolate) {
+          _reportBreakpointEvent(event);
+        }
         break;
 
       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) {
     int pos = 0;
@@ skipping 53 matching lines @@
     return cmd.historyPrev(command);
   }
 
   String historyNext(String command) {
     return cmd.historyNext(command);
   }
 }
 
 @CustomTag('debugger-page')
 class DebuggerPageElement extends ObservatoryElement {
+  @published ObservatoryApplication app;
   @published Isolate isolate;
 
   isolateChanged(oldValue) {
     if (isolate != null) {
-      debugger.isolate = isolate;
+      debugger.updateIsolate(isolate);
     }
   }
   ObservatoryDebugger debugger = new ObservatoryDebugger();
 
-  DebuggerPageElement.created() : super.created();
+  DebuggerPageElement.created() : super.created() {
+    debugger.page = this;
+  }
 
   @override
   void attached() {
     super.attached();
 
     var navbarDiv = $['navbarDiv'];
     var stackDiv = $['stackDiv'];
     var splitterDiv = $['splitterDiv'];
     var cmdDiv = $['commandDiv'];
     var consoleDiv = $['consoleDiv'];
@@ skipping 315 matching lines @@
           default:
             busy = false;
             break;
         }
       });
   }
 
   DebuggerInputElement.created() : super.created();
 }