Allow Observatory debugger to switch isolates.

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 329 matching lines @@
   // TODO(johnmccutchan): Ensure that isolates do not end up in _cache.
   Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
   final ObservableMap<String,Isolate> _isolateCache =
       new ObservableMap<String,Isolate>();
 
   @reflectable Iterable<Isolate> get isolates => _isolateCache.values;
 
   @observable String version = 'unknown';
   @observable String targetCPU;
   @observable int architectureBits;
-  @observable double uptime = 0.0;
   @observable bool assertsEnabled = false;
   @observable bool typeChecksEnabled = false;
   @observable String pid = '';
-  @observable DateTime lastUpdate;
+  @observable DateTime startTime;
+  @observable DateTime refreshTime;
+  @observable Duration get upTime =>
+      (new DateTime.now().difference(startTime));
 
   VM() : super._empty(null) {
     name = 'vm';
     vmName = 'vm';
     _cache['vm'] = this;
     update(toObservable({'id':'vm', 'type':'@VM'}));
   }
 
   final StreamController<ServiceException> exceptions =
       new StreamController.broadcast();
   final StreamController<ServiceError> errors =
       new StreamController.broadcast();
   final StreamController<ServiceEvent> events =
       new StreamController.broadcast();
 
-  bool _isIsolateLifecycleEvent(String eventType) {
-    return _isIsolateExitEvent(eventType) ||
-           _isIsolateStartEvent(eventType);
-  }
-
-  bool _isIsolateExitEvent(String eventType) {
-    return (eventType == ServiceEvent.kIsolateExit);
-  }
-
-  bool _isIsolateStartEvent(String eventType) {
-    return (eventType == ServiceEvent.kIsolateStart);
-  }
-
   void postServiceEvent(String response, ByteData data) {
     var map;
     try {
       map = _parseJSON(response);
       assert(!map.containsKey('_data'));
       if (data != null) {
         map['_data'] = data;
       }
     } catch (e, st) {
       Logger.root.severe('Ignoring malformed event response: ${response}');
       return;
     }
     if (map['type'] != 'ServiceEvent') {
       Logger.root.severe(
           "Expected 'ServiceEvent' but found '${map['type']}'");
       return;
     }
 
-    var eventType = map['eventType'];
-
-    if (_isIsolateLifecycleEvent(eventType)) {
-      String isolateId = map['isolate']['id'];
-      var event;
-      if (_isIsolateStartEvent(eventType)) {
-        _onIsolateStart(map['isolate']);
-        // By constructing the event *after* adding the isolate to the
-        // isolate cache, the call to getFromMap will use the cached Isolate.
-        event = new ServiceObject._fromMap(this, map);
-      } else {
-        assert(_isIsolateExitEvent(eventType));
-        // By constructing the event *before* removing the isolate from the
-        // isolate cache, the call to getFromMap will use the cached Isolate.
-        event = new ServiceObject._fromMap(this, map);
-        _onIsolateExit(isolateId);
+    var eventIsolate = map['isolate'];
+    if (eventIsolate == null) {
+      var event = new ServiceObject._fromMap(vm, map);
+      events.add(event);
+    } else {
+      // getFromMap creates the Isolate if it hasn't been seen already.
+      var isolate = getFromMap(map['isolate']);
+      var event = new ServiceObject._fromMap(isolate, map);
+      if (event.eventType == ServiceEvent.kIsolateExit) {
+        _removeIsolate(isolate.id);
       }
-      assert(event != null);
+      isolate._onEvent(event);
       events.add(event);
-      return;
     }
-
-    // Extract the owning isolate from the event itself.
-    String owningIsolateId = map['isolate']['id'];
-    getIsolate(owningIsolateId).then((owningIsolate) {
-        if (owningIsolate == null) {
-          // TODO(koda): Do we care about GC events in VM isolate?
-          Logger.root.severe('Ignoring event with unknown isolate id: '
-                             '$owningIsolateId');
-          return;
-        }
-        var event = new ServiceObject._fromMap(owningIsolate, map);
-        owningIsolate._onEvent(event);
-        events.add(event);
-    });
   }
 
-  Isolate _onIsolateStart(Map isolateMap) {
-    var isolateId = isolateMap['id'];
-    assert(!_isolateCache.containsKey(isolateId));
-    Isolate isolate = new ServiceObject._fromMap(this, isolateMap);
-    _isolateCache[isolateId] = isolate;
-    notifyPropertyChange(#isolates, true, false);
-    // Eagerly load the isolate.
-    isolate.load().catchError((e) {
-      Logger.root.info('Eagerly loading an isolate failed: $e');
-    });
-    return isolate;
-  }
-
-  void _onIsolateExit(String isolateId) {
+  void _removeIsolate(String isolateId) {
     assert(_isolateCache.containsKey(isolateId));
     _isolateCache.remove(isolateId);
     notifyPropertyChange(#isolates, true, false);
   }
 
-  void _updateIsolatesFromList(List isolateList) {
-    var shutdownIsolates = <String>[];
-    var createdIsolates = <Map>[];
-    var isolateStillExists = <String, bool>{};
+  void _removeDeadIsolates(List newIsolates) {
+    // Build a set of new isolates.
+    var newIsolateSet = new Set();
+    newIsolates.forEach((iso) => newIsolateSet.add(iso.id));
 
-    // Start with the assumption that all isolates are gone.
-    for (var isolateId in _isolateCache.keys) {
-      isolateStillExists[isolateId] = false;
-    }
-
-    // Find created isolates and mark existing isolates as living.
-    for (var isolateMap in isolateList) {
-      var isolateId = isolateMap['id'];
-      if (!_isolateCache.containsKey(isolateId)) {
-        createdIsolates.add(isolateMap);
-      } else {
-        isolateStillExists[isolateId] = true;
-      }
-    }
-
-    // Find shutdown isolates.
-    isolateStillExists.forEach((isolateId, exists) {
-      if (!exists) {
-        shutdownIsolates.add(isolateId);
+    // Remove any old isolates which no longer exist.
+    List toRemove = [];
+    _isolateCache.forEach((id, _) {
+      if (!newIsolateSet.contains(id)) {
+        toRemove.add(id);
       }
     });
-
-    // Process shutdown.
-    for (var isolateId in shutdownIsolates) {
-      _onIsolateExit(isolateId);
-    }
-
-    // Process creation.
-    for (var isolateMap in createdIsolates) {
-      _onIsolateStart(isolateMap);
-    }
+    toRemove.forEach((id) => _removeIsolate(id));
+    notifyPropertyChange(#isolates, true, false);
   }
 
   static final String _isolateIdPrefix = 'isolates/';
 
   ServiceObject getFromMap(ObservableMap map) {
     if (map == null) {
       return null;
     }
     String id = map['id'];
     if (!id.startsWith(_isolateIdPrefix)) {
       // Currently the VM only supports upgrading Isolate ServiceObjects.
       throw new UnimplementedError();
     }
 
     // Check cache.
     var isolate = _isolateCache[id];
     if (isolate == null) {
-      // We should never see an unknown isolate here.
-      throw new UnimplementedError();
-    }
-    var mapIsRef = _hasRef(map['type']);
-    if (!mapIsRef) {
+      // Add new isolate to the cache.
+      isolate = new ServiceObject._fromMap(this, map);
+      _isolateCache[id] = isolate;
+      notifyPropertyChange(#isolates, true, false);
+
+      // Eagerly load the isolate.
+      isolate.load().catchError((e, stack) {
+        Logger.root.info('Eagerly loading an isolate failed: $e\n$stack');
+      });
+    } else {
       isolate.update(map);
     }
     return isolate;
   }
 
   // Note that this function does not reload the isolate if it found
   // in the cache.
   Future<ServiceObject> getIsolate(String isolateId) {
     if (!loaded) {
       // Trigger a VM load, then get the isolate.
@@ skipping 92 matching lines @@
   void disconnect();
   /// Completes when the VM first connects.
   Future get onConnect;
   /// Completes when the VM disconnects or there was an error connecting.
   Future get onDisconnect;
 
   void _update(ObservableMap map, bool mapIsRef) {
     if (mapIsRef) {
       return;
     }
+    // Note that upgrading the collection creates any isolates in the
+    // isolate list which are new.
+    _upgradeCollection(map, vm);
+
     _loaded = true;
     version = map['version'];
     targetCPU = map['targetCPU'];
     architectureBits = map['architectureBits'];
-    uptime = map['uptime'];
-    var dateInMillis = int.parse(map['date']);
-    lastUpdate = new DateTime.fromMillisecondsSinceEpoch(dateInMillis);
+    var startTimeMillis = map['startTime'];
+    startTime = new DateTime.fromMillisecondsSinceEpoch(startTimeMillis);
+    var refreshTimeMillis = map['refreshTime'];
+    refreshTime = new DateTime.fromMillisecondsSinceEpoch(refreshTimeMillis);
+    notifyPropertyChange(#upTime, 0, 1);
     assertsEnabled = map['assertsEnabled'];
     pid = map['pid'];
     typeChecksEnabled = map['typeChecksEnabled'];
-    _updateIsolatesFromList(map['isolates']);
+    _removeDeadIsolates(map['isolates']);
   }
 
   // Reload all isolates.
   Future reloadIsolates() {
     var reloads = [];
     for (var isolate in isolates) {
       var reload = isolate.reload().catchError((e) {
         Logger.root.info('Bulk reloading of isolates failed: $e');
       });
       reloads.add(reload);
@@ skipping 125 matching lines @@
     return result;
   }
 
 
 }
 
 /// State for a running isolate.
 class Isolate extends ServiceObjectOwner with Coverage {
   @reflectable VM get vm => owner;
   @reflectable Isolate get isolate => this;
+  @observable int number;
+  @observable DateTime startTime;
+  @observable Duration get upTime =>
+      (new DateTime.now().difference(startTime));
+
   @observable ObservableMap counters = new ObservableMap();
 
-  @observable ServiceEvent pauseEvent = null;
-
   void _updateRunState() {
     topFrame = (pauseEvent != null ? pauseEvent.topFrame : null);
     paused = (pauseEvent != null &&
               pauseEvent.eventType != ServiceEvent.kResume);
     running = (!paused && topFrame != null);
     idle = (!paused && topFrame == null);
     notifyPropertyChange(#topFrame, 0, 1);
     notifyPropertyChange(#paused, 0, 1);
     notifyPropertyChange(#running, 0, 1);
     notifyPropertyChange(#idle, 0, 1);
   }
 
+  @observable ServiceEvent pauseEvent = null;
   @observable bool paused = false;
   @observable bool running = false;
   @observable bool idle = false;
   @observable bool loading = true;
 
   @observable bool ioEnabled = false;
 
   Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
   final TagProfile tagProfile = new TagProfile(20);
 
@@ skipping 47 matching lines @@
       }
     }
     assert(objectClass != null);
     return new Future.value(objectClass);
   }
 
   ServiceObject getFromMap(ObservableMap map) {
     if (map == null) {
       return null;
     }
+    var mapType = _stripRef(map['type']);
+    if (mapType == 'Isolate') {
+      // There are sometimes isolate refs in ServiceEvents.
+      return vm.getFromMap(map);
+    }
     String mapId = map['id'];
     var obj = (mapId != null) ? _cache[mapId] : null;
     if (obj != null) {
-      var mapIsRef = _hasRef(map['type']);
-      if (!mapIsRef) {
-        obj.update(map);
-      }
+      obj.update(map);
       return obj;
     }
     // Build the object from the map directly.
     obj = new ServiceObject._fromMap(this, map);
     if ((obj != null) && obj.canCache) {
       _cache[mapId] = obj;
     }
     return obj;
   }
 
@@ skipping 27 matching lines @@
   @observable Class objectClass;
   @observable final rootClasses = new ObservableList<Class>();
 
   @observable Library rootLib;
   @observable ObservableList<Library> libraries =
       new ObservableList<Library>();
   @observable ObservableMap topFrame;
 
   @observable String name;
   @observable String vmName;
-  @observable String mainPort;
   @observable ServiceFunction entry;
 
   @observable final Map<String, double> timers =
       toObservable(new Map<String, double>());
 
   final HeapSpace newSpace = new HeapSpace();
   final HeapSpace oldSpace = new HeapSpace();
 
   @observable String fileAndLine;
 
@@ skipping 15 matching lines @@
     }
     return _snapshotFetch.future;
   }
 
   void updateHeapsFromMap(ObservableMap map) {
     newSpace.update(map['new']);
     oldSpace.update(map['old']);
   }
 
   void _update(ObservableMap map, bool mapIsRef) {
-    mainPort = map['mainPort'];
     name = map['name'];
     vmName = map['name'];
+    number = int.parse(map['number'], onError:(_) => null);
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     loading = false;
 
     _upgradeCollection(map, isolate);
     if (map['rootLib'] == null ||
         map['timers'] == null ||
         map['heaps'] == null) {
       Logger.root.severe("Malformed 'Isolate' response: $map");
       return;
     }
     rootLib = map['rootLib'];
     if (map['entry'] != null) {
       entry = map['entry'];
     }
-
+    var startTimeInMillis = map['startTime'];
+    startTime = new DateTime.fromMillisecondsSinceEpoch(startTimeInMillis);
+    notifyPropertyChange(#upTime, 0, 1);
     var countersMap = map['tagCounters'];
     if (countersMap != null) {
       var names = countersMap['names'];
       var counts = countersMap['counters'];
       assert(names.length == counts.length);
       var sum = 0;
       for (var i = 0; i < counts.length; i++) {
         sum += counts[i];
       }
       // TODO: Why does this not work without this?
@@ skipping 47 matching lines @@
       (ObservableMap map) {
         var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
         tagProfile._processTagProfile(seconds, map);
         return tagProfile;
       });
   }
 
   ObservableMap<int, Breakpoint> breakpoints = new ObservableMap();
 
   void _updateBreakpoints(List newBpts) {
-    // Build a map of new breakpoints.
-    var newBptMap = {};
-    newBpts.forEach((bpt) => (newBptMap[bpt.number] = bpt));
+    // Build a set of new breakpoints.
+    var newBptSet = new Set();
+    newBpts.forEach((bpt) => newBptSet.add(bpt.number));
 
     // Remove any old breakpoints which no longer exist.
     List toRemove = [];
     breakpoints.forEach((key, _) {
-      if (!newBptMap.containsKey(key)) {
+      if (!newBptSet.contains(key)) {
         toRemove.add(key);
       }
     });
     toRemove.forEach((key) => breakpoints.remove(key));
 
     // Add all new breakpoints.
-    breakpoints.addAll(newBptMap);
+    newBpts.forEach((bpt) => (breakpoints[bpt.number] = bpt));
   }
 
   void _addBreakpoint(Breakpoint bpt) {
     breakpoints[bpt.number] = bpt;
   }
 
   void _removeBreakpoint(Breakpoint bpt) {
     breakpoints.remove(bpt.number);
     bpt.remove();
   }
 
   void _onEvent(ServiceEvent event) {
-    assert(event.eventType != ServiceEvent.kIsolateStart &&
-           event.eventType != ServiceEvent.kIsolateExit);
     switch(event.eventType) {
+      case ServiceEvent.kIsolateStart:
+      case ServiceEvent.kIsolateExit:
+        // Handled elsewhere.
+        break;
+
       case ServiceEvent.kBreakpointAdded:
         _addBreakpoint(event.breakpoint);
         break;
 
+      case ServiceEvent.kIsolateUpdate:
       case ServiceEvent.kBreakpointResolved:
         // Update occurs as side-effect of caching.
         break;
 
       case ServiceEvent.kBreakpointRemoved:
         _removeBreakpoint(event.breakpoint);
         break;
 
       case ServiceEvent.kPauseStart:
       case ServiceEvent.kPauseExit:
@@ skipping 50 matching lines @@
     return invokeRpc('removeBreakpoint',
                      { 'breakpointId': bpt.id });
   }
 
   Future pause() {
     return invokeRpc('pause', {}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
+        return result;
       });
   }
 
   Future resume() {
     return invokeRpc('resume', {}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
+        return result;
       });
   }
 
   Future stepInto() {
     return invokeRpc('resume', {'step': 'into'}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
+        return result;
       });
   }
 
   Future stepOver() {
     return invokeRpc('resume', {'step': 'over'}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
+        return result;
       });
   }
 
   Future stepOut() {
     return invokeRpc('resume', {'step': 'out'}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
+        return result;
       });
   }
 
+  Future setName(String newName) {
+    Map params = {
+      'name': newName,
+    };
+    return invokeRpc('setName', params);
+  }
+
   Future<ServiceMap> getStack() {
     return invokeRpc('getStack', {}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
         return result;
       });
   }
 
@@ skipping 222 matching lines @@
   }
 
   String toString() => 'ServiceException($message)';
 }
 
 /// A [ServiceEvent] is an asynchronous event notification from the vm.
 class ServiceEvent extends ServiceObject {
   /// The possible 'eventType' values.
   static const kIsolateStart       = 'IsolateStart';
   static const kIsolateExit        = 'IsolateExit';
+  static const kIsolateUpdate      = 'IsolateUpdate';
   static const kPauseStart         = 'PauseStart';
   static const kPauseExit          = 'PauseExit';
   static const kPauseBreakpoint    = 'PauseBreakpoint';
   static const kPauseInterrupted   = 'PauseInterrupted';
   static const kPauseException     = 'PauseException';
   static const kResume             = 'Resume';
   static const kBreakpointAdded    = 'BreakpointAdded';
   static const kBreakpointResolved = 'BreakpointResolved';
   static const kBreakpointRemoved  = 'BreakpointRemoved';
   static const kGraph              = '_Graph';
   static const kGC                 = 'GC';
   static const kVMDisconnected     = 'VMDisconnected';
 
   ServiceEvent._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ServiceEvent.vmDisconencted() : super._empty(null) {
     eventType = kVMDisconnected;
   }
 
   @observable String eventType;
   @observable Breakpoint breakpoint;
   @observable ServiceMap topFrame;
   @observable ServiceMap exception;
   @observable ByteData data;
   @observable int count;
 
   void _update(ObservableMap map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
+    assert(map['isolate'] == null || owner == map['isolate']);
     eventType = map['eventType'];
     name = 'ServiceEvent $eventType';
     vmName = name;
     if (map['breakpoint'] != null) {
       breakpoint = map['breakpoint'];
     }
     if (map['topFrame'] != null) {
       topFrame = map['topFrame'];
     }
     if (map['exception'] != null) {
@@ skipping 393 matching lines @@
       case 'kIrregexpFunction': return kIrregexpFunction;
       case 'kStaticInitializer': return kStaticInitializer;
       case 'kMethodExtractor': return kMethodExtractor;
       case 'kNoSuchMethodDispatcher': return kNoSuchMethodDispatcher;
       case 'kInvokeFieldDispatcher': return kInvokeFieldDispatcher;
       case 'Collected': return kCollected;
       case 'Native': return kNative;
       case 'Stub': return kStub;
       case 'Tag': return kTag;
     }
-    print('did not understand $value');
+    Logger.root.severe('Unrecognized function kind: $value');
     throw new FallThroughError();
   }
 
   static FunctionKind kRegularFunction = new FunctionKind._internal('function');
   static FunctionKind kClosureFunction = new FunctionKind._internal('closure function');
   static FunctionKind kGetterFunction = new FunctionKind._internal('getter function');
   static FunctionKind kSetterFunction = new FunctionKind._internal('setter function');
   static FunctionKind kConstructor = new FunctionKind._internal('constructor');
   static FunctionKind kImplicitGetterFunction = new FunctionKind._internal('implicit getter function');
   static FunctionKind kImplicitSetterFunction = new FunctionKind._internal('implicit setter function');
@@ skipping 605 matching lines @@
       return Native;
     } else if (s == 'Dart') {
       return Dart;
     } else if (s == 'Collected') {
       return Collected;
     } else if (s == 'Tag') {
       return Tag;
     } else if (s == 'Stub') {
       return Stub;
     }
-    print('do not understand code kind $s');
+    Logger.root.severe('Unrecognized code kind: $s');
     throw new FallThroughError();
   }
   static const Collected = const CodeKind._internal('Collected');
   static const Dart = const CodeKind._internal('Dart');
   static const Native = const CodeKind._internal('Native');
   static const Stub = const CodeKind._internal('Stub');
   static const Tag = const CodeKind._internal('Tag');
 }
 
 class CodeInlineInterval {
@@ skipping 453 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);
     }
   }
 }