Removed polymer & mirror from Observatory

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;
 
 // Some value smaller than the object ring, so requesting a large array
 // doesn't result in an expired ref because the elements lapped it in the
 // object ring.
 const int kDefaultFieldLimit = 100;
@@ skipping 75 matching lines @@
   String toString() => 'MalformedResponseRpcException(${message})';
 }
 
 class FakeVMRpcException extends RpcException {
   FakeVMRpcException(String message) : super(message);
 
   String toString() => 'FakeVMRpcException(${message})';
 }
 
 /// A [ServiceObject] represents a persistent object within the vm.
-abstract class ServiceObject extends Observable {
+abstract class ServiceObject {
   static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
     return o1.name.compareTo(o2.name);
   }
 
   List removeDuplicatesAndSortLexical(List<ServiceObject> list) {
     return list.toSet().toList()..sort(LexicalSortName);
   }
 
   /// The owner of this [ServiceObject].  This can be an [Isolate], a
   /// [VM], or null.
-  @reflectable ServiceObjectOwner get owner => _owner;
+  ServiceObjectOwner get owner => _owner;
   ServiceObjectOwner _owner;
 
   /// The [VM] which owns this [ServiceObject].
-  @reflectable VM get vm => _owner.vm;
+  VM get vm => _owner.vm;
 
   /// The [Isolate] which owns this [ServiceObject].  May be null.
-  @reflectable Isolate get isolate => _owner.isolate;
+  Isolate get isolate => _owner.isolate;
 
   /// The id of this object.
-  @reflectable String get id => _id;
+  String get id => _id;
   String _id;
 
   /// The user-level type of this object.
-  @reflectable String get type => _type;
+  String get type => _type;
   String _type;
 
   /// The vm type of this object.
-  @reflectable String get vmType => _vmType;
+  String get vmType => _vmType;
   String _vmType;
 
   bool get isICData => vmType == 'ICData';
   bool get isMegamorphicCache => vmType == 'MegamorphicCache';
   bool get isInstructions => vmType == 'Instructions';
   bool get isObjectPool => vmType == 'ObjectPool';
   bool get isContext => type == 'Context';
   bool get isError => type == 'Error';
   bool get isInstance => type == 'Instance';
   bool get isSentinel => type == 'Sentinel';
@@ skipping 24 matching lines @@
   // from Isolate.
 
   /// Is this object cacheable?  That is, is it impossible for the [id]
   /// of this object to change?
   bool _canCache;
   bool get canCache => _canCache;
 
   /// Is this object immutable after it is [loaded]?
   bool get immutable => false;
 
-  @observable String name;
-  @observable String vmName;
+  String name;
+  String vmName;
 
   /// Creates an empty [ServiceObject].
   ServiceObject._empty(this._owner);
 
   /// Creates a [ServiceObject] initialized from [map].
   factory ServiceObject._fromMap(ServiceObjectOwner owner,
-                                 ObservableMap map) {
+                                 Map map) {
     if (map == null) {
       return null;
     }
     if (!_isServiceMap(map)) {
       Logger.root.severe('Malformed service object: $map');
     }
     assert(_isServiceMap(map));
     var type = _stripRef(map['type']);
     var vmType = map['_vmType'] != null ? map['_vmType'] : type;
     var obj = null;
@@ skipping 102 matching lines @@
   Future<ServiceObject> load() {
     if (loaded) {
       return new Future.value(this);
     }
     // Call reload which will fill in the entire object.
     return reload();
   }
 
   Future<ServiceObject> _inProgressReload;
 
-  Future<ObservableMap> _fetchDirect({int count: kDefaultFieldLimit}) {
+  Future<Map> _fetchDirect({int count: kDefaultFieldLimit}) {
     Map params = {
       'objectId': id,
       'count': count,
     };
     return isolate.invokeRpcNoUpgrade('getObject', params);
   }
 
   /// Reload [this]. Returns a future which completes to [this] or
   /// an exception.
   Future<ServiceObject> reload({int count: kDefaultFieldLimit}) {
     // TODO(turnidge): Checking for a null id should be part of the
     // "immmutable" check.
     bool hasId = (id != null) && (id != '');
     bool isVM = this is VM;
     // We should always reload the VM.
     // We can't reload objects without an id.
     // We shouldn't reload an immutable and already loaded object.
     bool skipLoad = !isVM && (!hasId || (immutable && loaded));
     if (skipLoad) {
       return new Future.value(this);
     }
     if (_inProgressReload == null) {
       var completer = new Completer<ServiceObject>();
       _inProgressReload = completer.future;
-      _fetchDirect(count: count).then((ObservableMap map) {
+      _fetchDirect(count: count).then((Map map) {
         var mapType = _stripRef(map['type']);
         if (mapType == 'Sentinel') {
           // An object may have been collected, etc.
           completer.complete(new ServiceObject._fromMap(owner, map));
         } else {
           // TODO(turnidge): Check for vmType changing as well?
           assert(mapType == _type);
           update(map);
           completer.complete(this);
         }
 
       }).catchError((e, st) {
         Logger.root.severe("Unable to reload object: $e\n$st");
         _inProgressReload = null;
         completer.completeError(e, st);
       }).whenComplete(() {
         // This reload is complete.
         _inProgressReload = null;
       });
     }
     return _inProgressReload;
   }
 
   /// Update [this] using [map] as a source. [map] can be a reference.
-  void update(ObservableMap map) {
+  void update(Map map) {
     assert(_isServiceMap(map));
 
     // Don't allow the type to change on an object update.
     var mapIsRef = _hasRef(map['type']);
     var mapType = _stripRef(map['type']);
     assert(_type == null || _type == mapType);
 
     _canCache = map['fixedId'] == true;
     if (_id != null && _id != map['id']) {
       // It is only safe to change an id when the object isn't cacheable.
       assert(!canCache);
     }
     _id = map['id'];
 
     _type = mapType;
 
     // When the response specifies a specific vmType, use it.
     // Otherwise the vmType of the response is the same as the 'user'
     // type.
     if (map.containsKey('_vmType')) {
       _vmType = _stripRef(map['_vmType']);
     } else {
       _vmType = _type;
     }
 
     _update(map, mapIsRef);
   }
 
   // Updates internal state from [map]. [map] can be a reference.
-  void _update(ObservableMap map, bool mapIsRef);
+  void _update(Map map, bool mapIsRef);
 
   // Helper that can be passed to .catchError that ignores the error.
   _ignoreError(error, stackTrace) {
     // do nothing.
   }
 }
 
 abstract class HeapObject extends ServiceObject implements M.Object {
-  @observable Class clazz;
-  @observable int size;
-  @observable int retainedSize;
+  Class clazz;
+  int size;
+  int retainedSize;
 
   HeapObject._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     if (map['class'] != null) {
       // Sent with refs for some types. Load it if available, but don't clobber
       // it with null for kinds that only send if for full responses.
       clazz = map['class'];
     }
 
     // Load the full class object if the isolate is runnable.
     if (clazz != null) {
       if (clazz.isolate.runnable) {
         clazz.load();
@@ skipping 13 matching lines @@
   RetainingObject(this.object);
 }
 
 abstract class ServiceObjectOwner extends ServiceObject {
   /// Creates an empty [ServiceObjectOwner].
   ServiceObjectOwner._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   /// Builds a [ServiceObject] corresponding to the [id] from [map].
   /// The result may come from the cache.  The result will not necessarily
   /// be [loaded].
-  ServiceObject getFromMap(ObservableMap map);
+  ServiceObject getFromMap(Map map);
 }
 
 abstract class Location implements M.Location {
   Script get script;
   int get tokenPos;
 }
 
 /// A [SourceLocation] represents a location or range in the source code.
 class SourceLocation extends ServiceObject implements Location,
                                                       M.SourceLocation {
   Script script;
   int tokenPos;
   int endTokenPos;
 
   Future<int> getLine() async {
     await script.load();
     return script.tokenToLine(tokenPos);
   }
 
   Future<int> getColumn() async {
     await script.load();
     return script.tokenToCol(tokenPos);
   }
 
   SourceLocation._empty(ServiceObject owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     assert(!mapIsRef);
     _upgradeCollection(map, owner);
     script = map['script'];
     tokenPos = map['tokenPos'];
     endTokenPos = map['endTokenPos'];
 
     assert(script != null && tokenPos != null);
   }
 
   Future<String> toUserString() async {
@@ skipping 35 matching lines @@
     if (tokenPos != null) {
       await script.load();
       return script.tokenToCol(tokenPos);
     } else {
       return column;
     }
   }
 
   UnresolvedSourceLocation._empty(ServiceObject owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     assert(!mapIsRef);
     _upgradeCollection(map, owner);
     script = map['script'];
     scriptUri = map['scriptUri'];
     line = map['line'];
     column = map['column'];
     tokenPos = map['tokenPos'];
 
     assert(script != null || scriptUri != null);
     assert(line != null || tokenPos != null);
@@ skipping 88 matching lines @@
 
   void addEvent(ServiceEvent event) {
     for (var controller in _controllers) {
       controller.add(event);
     }
   }
 }
 
 /// State for a VM being inspected.
 abstract class VM extends ServiceObjectOwner implements M.VM {
-  @reflectable VM get vm => this;
-  @reflectable Isolate get isolate => null;
+  VM get vm => this;
+  Isolate get isolate => null;
 
   // TODO(turnidge): The connection should not be stored in the VM object.
   bool get isDisconnected;
 
   // Used for verbose logging.
   bool verbose = false;
 
   // 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>();
+  final Map<String,Isolate> _isolateCache = <String,Isolate>{};
 
   // The list of live isolates, ordered by isolate start time.
-  final ObservableList<Isolate> isolates = new ObservableList<Isolate>();
+  final List<Isolate> isolates = <Isolate>[];
 
-  @observable String version = 'unknown';
-  @observable String hostCPU;
-  @observable String targetCPU;
-  @observable int architectureBits;
-  @observable bool assertsEnabled = false;
-  @observable bool typeChecksEnabled = false;
-  @observable int pid = 0;
-  @observable int maxRSS = 0;
-  @observable bool profileVM = false;
-  @observable DateTime startTime;
-  @observable DateTime refreshTime;
-  @observable Duration get upTime {
+  String version = 'unknown';
+  String hostCPU;
+  String targetCPU;
+  int architectureBits;
+  bool assertsEnabled = false;
+  bool typeChecksEnabled = false;
+  int pid = 0;
+  int maxRSS = 0;
+  bool profileVM = false;
+  DateTime startTime;
+  DateTime refreshTime;
+  Duration get upTime {
     if (startTime == null) {
       return null;
     }
     return (new DateTime.now().difference(startTime));
   }
 
   VM() : super._empty(null) {
-    update(toObservable({'name':'vm', 'type':'@VM'}));
+    update({'name':'vm', 'type':'@VM'});
   }
 
   void postServiceEvent(String streamId, Map response, ByteData data) {
-    var map = toObservable(response);
+    var map = response;
     assert(!map.containsKey('_data'));
     if (data != null) {
       map['_data'] = data;
     }
     if (map['type'] != 'Event') {
       Logger.root.severe(
           "Expected 'Event' but found '${map['type']}'");
       return;
     }
 
@@ skipping 57 matching lines @@
       if (!newIsolateSet.contains(id)) {
         toRemove.add(id);
       }
     });
     toRemove.forEach((id) => _isolateCache.remove(id));
     _buildIsolateList();
   }
 
   static final String _isolateIdPrefix = 'isolates/';
 
-  ServiceObject getFromMap(ObservableMap map) {
+  ServiceObject getFromMap(Map map) {
     if (map == null) {
       return null;
     }
     var type = _stripRef(map['type']);
     if (type == 'VM') {
       // Update this VM object.
       update(map);
       return this;
     }
 
@@ skipping 28 matching lines @@
     if (!loaded) {
       // Trigger a VM load, then get the isolate.
       return load().then((_) => getIsolate(isolateId)).catchError(_ignoreError);
     }
     return new Future.value(_isolateCache[isolateId]);
   }
 
   // Implemented in subclass.
   Future<Map> invokeRpcRaw(String method, Map params);
 
-  Future<ObservableMap> invokeRpcNoUpgrade(String method, Map params) {
+  Future<Map> invokeRpcNoUpgrade(String method, Map params) {
     return invokeRpcRaw(method, params).then((Map response) {
-      var map = toObservable(response);
+      var map = response;
       if (Tracer.current != null) {
         Tracer.current.trace("Received response for ${method}/${params}}",
                              map:map);
       }
       if (!_isServiceMap(map)) {
         var exception =
             new MalformedResponseRpcException(
                 "Response is missing the 'type' field", map);
         return new Future.error(exception);
       }
       return new Future.value(map);
     }).catchError((e) {
       // Errors pass through.
       return new Future.error(e);
     });
   }
 
   Future<ServiceObject> invokeRpc(String method, Map params) {
-    return invokeRpcNoUpgrade(method, params).then((ObservableMap response) {
+    return invokeRpcNoUpgrade(method, params).then((Map response) {
       var obj = new ServiceObject._fromMap(this, response);
       if ((obj != null) && obj.canCache) {
         String objId = obj.id;
         _cache.putIfAbsent(objId, () => obj);
       }
       return obj;
     });
   }
 
   void _dispatchEventToIsolate(ServiceEvent event) {
     var isolate = event.isolate;
     if (isolate != null) {
       isolate._onEvent(event);
     }
   }
 
   Future restart() {
     return invokeRpc('_restartVM', {});
   }
 
-  Future<ObservableMap> _fetchDirect({int count: kDefaultFieldLimit}) async {
+  Future<Map> _fetchDirect({int count: kDefaultFieldLimit}) async {
     if (!loaded) {
       // The vm service relies on these events to keep the VM and
       // Isolate types up to date.
       try {
         await listenEventStream(kVMStream, _dispatchEventToIsolate);
         await listenEventStream(kIsolateStream, _dispatchEventToIsolate);
         await listenEventStream(kDebugStream, _dispatchEventToIsolate);
         await listenEventStream(_kGraphStream, _dispatchEventToIsolate);
       } on FakeVMRpcException catch (_) {
         // ignore FakeVMRpcExceptions here.
@@ skipping 52 matching lines @@
     return stream.listen(function);
   }
 
   /// Force the VM to disconnect.
   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) {
+  void _update(Map map, bool mapIsRef) {
     name = map['name'];
     vmName = map.containsKey('_vmName') ? map['_vmName'] : name;
     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'];
     hostCPU = map['hostCPU'];
     targetCPU = map['targetCPU'];
     architectureBits = map['architectureBits'];
     int startTimeMillis = map['startTime'];
     startTime = new DateTime.fromMillisecondsSinceEpoch(startTimeMillis);
     refreshTime = new DateTime.now();
-    notifyPropertyChange(#upTime, 0, 1);
     pid = map['pid'];
     maxRSS = map['_maxRSS'];
     profileVM = map['_profilerMode'] == 'VM';
     assertsEnabled = map['_assertsEnabled'];
     typeChecksEnabled = map['_typeChecksEnabled'];
     _removeDeadIsolates(map['isolates']);
   }
 
   // Reload all isolates.
   Future reloadIsolates() {
@@ skipping 122 matching lines @@
   final List<String> names = new List<String>();
   final List<TagProfileSnapshot> snapshots = new List<TagProfileSnapshot>();
   double get updatedAtSeconds => _seconds;
   double _seconds;
   TagProfileSnapshot _maxSnapshot;
   int _historySize;
   int _countersLength = 0;
 
   TagProfile(this._historySize);
 
-  void _processTagProfile(double seconds, ObservableMap tagProfile) {
+  void _processTagProfile(double seconds, Map tagProfile) {
     _seconds = seconds;
     var counters = tagProfile['counters'];
     if (names.length == 0) {
       // Initialization.
       names.addAll(tagProfile['names']);
       _countersLength = tagProfile['counters'].length;
       for (var i = 0; i < _historySize; i++) {
         var snapshot = new TagProfileSnapshot(0.0, _countersLength);
         snapshot.zero();
         snapshots.add(snapshot);
@@ skipping 101 matching lines @@
   final HeapObject object;
 
   WeakPersistentHandle(ServiceMap map)
     : externalSize = int.parse(map['externalSize']),
       peer = map['peer'],
       callbackSymbolName = map['callbackSymbolName'],
       callbackAddress = map['callbackAddress'],
       object = map['object'];
 }
 
-class HeapSpace extends Observable implements M.HeapSpace {
-  @observable int used = 0;
-  @observable int capacity = 0;
-  @observable int external = 0;
-  @observable int collections = 0;
-  @observable double totalCollectionTimeInSeconds = 0.0;
-  @observable double averageCollectionPeriodInMillis = 0.0;
+class HeapSpace implements M.HeapSpace {
+  int used = 0;
+  int capacity = 0;
+  int external = 0;
+  int collections = 0;
+  double totalCollectionTimeInSeconds = 0.0;
+  double averageCollectionPeriodInMillis = 0.0;
 
   Duration get avgCollectionTime {
     final mcs = totalCollectionTimeInSeconds * Duration.MICROSECONDS_PER_SECOND
                 / math.max(collections, 1);
     return new Duration(microseconds: mcs.ceil());
   }
 
   Duration get totalCollectionTime {
     final mcs = totalCollectionTimeInSeconds * Duration.MICROSECONDS_PER_SECOND;
     return new Duration(microseconds: mcs.ceil());
@@ skipping 19 matching lines @@
   final chunks;
   final count;
   RawHeapSnapshot(this.chunks, this.count);
 }
 
 /// State for a running isolate.
 class Isolate extends ServiceObjectOwner implements M.Isolate {
   static const kLoggingStream = '_Logging';
   static const kExtensionStream = 'Extension';
 
-  @reflectable VM get vm => owner;
-  @reflectable Isolate get isolate => this;
-  @observable int number;
-  @observable int originNumber;
-  @observable DateTime startTime;
-  @observable Duration get upTime {
+  VM get vm => owner;
+  Isolate get isolate => this;
+  int number;
+  int originNumber;
+  DateTime startTime;
+  Duration get upTime {
     if (startTime == null) {
       return null;
     }
     return (new DateTime.now().difference(startTime));
   }
 
-  @observable Map counters = {};
+  Map counters = {};
 
   void _updateRunState() {
     topFrame = M.topFrame(pauseEvent);
     paused = (pauseEvent != null &&
               !(pauseEvent is M.ResumeEvent));
     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 M.DebugEvent pauseEvent = null;
-  @observable bool paused = false;
-  @observable bool running = false;
-  @observable bool idle = false;
-  @observable bool loading = true;
-  @observable bool runnable = false;
-  @observable bool ioEnabled = false;
-  @observable bool reloading = false;
+  M.DebugEvent pauseEvent = null;
+  bool paused = false;
+  bool running = false;
+  bool idle = false;
+  bool loading = true;
+  bool runnable = false;
+  bool ioEnabled = false;
+  bool reloading = false;
   M.IsolateStatus get status {
     if (paused) {
       return M.IsolateStatus.paused;
     }
     if (running) {
       return M.IsolateStatus.running;
     }
     if (idle) {
       return M.IsolateStatus.idle;
     }
@@ skipping 115 matching lines @@
           (cls.library.uri == 'dart:core')) {
         objectClass = cls;
       }
     }
     assert(objectClass != null);
     return new Future.value(objectClass);
   }
 
   Class getClassByCid(int cid) => _classesByCid[cid];
 
-  ServiceObject getFromMap(ObservableMap map) {
+  ServiceObject getFromMap(Map 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) {
       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;
   }
 
-  Future<ObservableMap> invokeRpcNoUpgrade(String method, Map params) {
+  Future<Map> invokeRpcNoUpgrade(String method, Map params) {
     params['isolateId'] = id;
     return vm.invokeRpcNoUpgrade(method, params);
   }
 
   Future<ServiceObject> invokeRpc(String method, Map params) {
-    return invokeRpcNoUpgrade(method, params).then((ObservableMap response) {
+    return invokeRpcNoUpgrade(method, params).then((Map response) {
       return getFromMap(response);
     });
   }
 
   Future<ServiceObject> getObject(String objectId,
                                   {bool reload: true,
                                    int count: kDefaultFieldLimit}) {
     assert(objectId != null && objectId != '');
     var obj = _cache[objectId];
     if (obj != null) {
       if (reload) {
         return obj.reload(count: count);
       }
       // Returned cached object.
       return new Future.value(obj);
     }
     Map params = {
       'objectId': objectId,
       'count': count,
     };
     return isolate.invokeRpc('getObject', params);
   }
 
-  Future<ObservableMap> _fetchDirect({int count: kDefaultFieldLimit}) async {
+  Future<Map> _fetchDirect({int count: kDefaultFieldLimit}) async {
     return invokeRpcNoUpgrade('getIsolate', {});
   }
 
-  @observable Class objectClass;
-  @observable final rootClasses = new ObservableList<Class>();
+  Class objectClass;
+  final rootClasses = <Class>[];
   Map<int, Class> _classesByCid = new Map<int, Class>();
 
-  @observable Library rootLibrary;
-  @observable ObservableList<Library> libraries =
-      new ObservableList<Library>();
-  @observable Frame topFrame;
+  Library rootLibrary;
+  List<Library> libraries = <Library>[];
+  Frame topFrame;
 
-  @observable String name;
-  @observable String vmName;
-  @observable ServiceFunction entry;
+  String name;
+  String vmName;
+  ServiceFunction entry;
 
   final HeapSpace newSpace = new HeapSpace();
   final HeapSpace oldSpace = new HeapSpace();
 
-  @observable String fileAndLine;
+  String fileAndLine;
 
-  @observable DartError error;
+  DartError error;
   StreamController _snapshotFetch;
 
   List<ByteData> _chunksInProgress;
 
   void _loadHeapSnapshot(ServiceEvent event) {
     if (_snapshotFetch == null || _snapshotFetch.isClosed) {
       // No outstanding snapshot request. Presumably another client asked for a
       // snapshot.
       Logger.root.info("Dropping unsolicited heap snapshot chunk");
       return;
@@ skipping 25 matching lines @@
   Stream fetchHeapSnapshot(collectGarbage) {
     if (_snapshotFetch == null || _snapshotFetch.isClosed) {
       _snapshotFetch = new StreamController.broadcast();
       // isolate.vm.streamListen('_Graph');
       isolate.invokeRpcNoUpgrade('_requestHeapSnapshot',
                                  {'collectGarbage': collectGarbage});
     }
     return _snapshotFetch.stream;
   }
 
-  void updateHeapsFromMap(ObservableMap map) {
+  void updateHeapsFromMap(Map map) {
     newSpace.update(map['new']);
     oldSpace.update(map['old']);
   }
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     name = map['name'];
     vmName = map.containsKey('_vmName') ? map['_vmName'] : name;
     number = int.parse(map['number'], onError:(_) => null);
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     loading = false;
     runnable = map['runnable'] == true;
     _upgradeCollection(map, isolate);
     originNumber = int.parse(map['_originNumber'], onError:(_) => null);
     rootLibrary = map['rootLib'];
     if (map['entry'] != null) {
       entry = map['entry'];
     }
     var savedStartTime = startTime;
     int 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];
       }
       var _counters = {};
@@ skipping 34 matching lines @@
     }
 
     extensionRPCs.clear();
     if (map['extensionRPCs'] != null) {
       extensionRPCs.addAll(map['extensionRPCs']);
     }
   }
 
   Future<TagProfile> updateTagProfile() {
     return isolate.invokeRpcNoUpgrade('_getTagProfile', {}).then(
-      (ObservableMap map) {
+      (Map map) {
         var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
         tagProfile._processTagProfile(seconds, map);
         return tagProfile;
       });
   }
 
-  ObservableMap<int, Breakpoint> breakpoints = new ObservableMap();
+  Map<int, Breakpoint> breakpoints = <int, Breakpoint>{};
   String exceptionsPauseInfo;
 
   void _updateBreakpoints(List newBpts) {
     // 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, _) {
@@ skipping 215 matching lines @@
   }
 
   Future<ServiceObject> getObjectByAddress(String address, [bool ref=true]) {
     Map params = {
       'address': address,
       'ref': ref,
     };
     return invokeRpc('_getObjectByAddress', params);
   }
 
-  final ObservableMap<String, ServiceMetric> dartMetrics =
-      new ObservableMap<String, ServiceMetric>();
+  final Map<String, ServiceMetric> dartMetrics = <String, ServiceMetric>{};
 
-  final ObservableMap<String, ServiceMetric> nativeMetrics =
-      new ObservableMap<String, ServiceMetric>();
+  final Map<String, ServiceMetric> nativeMetrics = <String, ServiceMetric>{};
 
-  Future<ObservableMap<String, ServiceMetric>> _refreshMetrics(
+  Future<Map<String, ServiceMetric>> _refreshMetrics(
       String metricType,
-      ObservableMap<String, ServiceMetric> metricsMap) {
+      Map<String, ServiceMetric> metricsMap) {
     return invokeRpc('_getIsolateMetricList',
                      { 'type': metricType }).then((result) {
       // Clear metrics map.
       metricsMap.clear();
       // Repopulate metrics map.
       var metrics = result['metrics'];
       for (var metric in metrics) {
         metricsMap[metric.id] = metric;
       }
       return metricsMap;
     });
   }
 
-  Future<ObservableMap<String, ServiceMetric>> refreshDartMetrics() {
+  Future<Map<String, ServiceMetric>> refreshDartMetrics() {
     return _refreshMetrics('Dart', dartMetrics);
   }
 
-  Future<ObservableMap<String, ServiceMetric>> refreshNativeMetrics() {
+  Future<Map<String, ServiceMetric>> refreshNativeMetrics() {
     return _refreshMetrics('Native', nativeMetrics);
   }
 
   Future refreshMetrics() {
     return Future.wait([refreshDartMetrics(), refreshNativeMetrics()]);
   }
 
   String toString() => "Isolate($name)";
 }
 
 
 class NamedField implements M.NamedField {
   final String name;
   final M.ObjectRef value;
   NamedField(this.name, this.value);
 }
 
 
 class ObjectStore extends ServiceObject implements M.ObjectStore {
-  @observable List<NamedField> fields = new List<NamedField>();
+  List<NamedField> fields = new List<NamedField>();
 
   ObjectStore._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
 
     if (mapIsRef) {
       return;
     }
 
     fields.clear();
     map['fields'].forEach((key, value) {
       fields.add(new NamedField(key, value));
     });
     _loaded = true;
   }
 }
 
 
 /// A [ServiceObject] which implements [ObservableMap].
-class ServiceMap extends ServiceObject implements ObservableMap,
-                                                  M.UnknownObjectRef  {
-  final ObservableMap _map = new ObservableMap();
+class ServiceMap extends ServiceObject implements M.UnknownObjectRef  {
+  final Map _map = {};
   static String objectIdRingPrefix = 'objects/';
 
   bool get immutable => false;
 
   ServiceMap._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _loaded = !mapIsRef;
 
     _upgradeCollection(map, owner);
     // TODO(turnidge): Currently _map.clear() prevents us from
     // upgrading an already upgraded submap.  Is clearing really the
     // right thing to do here?
     _map.clear();
     _map.addAll(map);
 
     name = _map['name'];
@@ skipping 14 matching lines @@
   putIfAbsent(key, Function ifAbsent) => _map.putIfAbsent(key, ifAbsent);
   void remove(key) => _map.remove(key);
   operator [](k) => _map[k];
   operator []=(k, v) => _map[k] = v;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
   Iterable get keys => _map.keys;
   Iterable get values => _map.values;
   int get length => _map.length;
 
-  // Forward ChangeNotifier interface calls.
-  bool deliverChanges() => _map.deliverChanges();
-  void notifyChange(ChangeRecord record) => _map.notifyChange(record);
-  notifyPropertyChange(Symbol field, Object oldValue, Object newValue) =>
-      _map.notifyPropertyChange(field, oldValue, newValue);
-  void observed() => _map.observed();
-  void unobserved() => _map.unobserved();
-  Stream<List<ChangeRecord>> get changes => _map.changes;
-  bool get hasObservers => _map.hasObservers;
-
   String toString() => "ServiceMap($_map)";
 }
 
 M.ErrorKind stringToErrorKind(String value) {
   switch(value) {
     case 'UnhandledException': return M.ErrorKind.unhandledException;
     case 'LanguageError': return M.ErrorKind.unhandledException;
     case 'InternalError': return M.ErrorKind.internalError;
     case 'TerminationError': return M.ErrorKind.terminationError;
   }
   Logger.root.severe('Unrecognized error kind: $value');
   throw new FallThroughError();
 }
 
 /// A [DartError] is peered to a Dart Error object.
 class DartError extends ServiceObject implements M.Error {
   DartError._empty(ServiceObject owner) : super._empty(owner);
 
   M.ErrorKind kind;
   final M.ClassRef clazz = null;
   final int size = null;
-  @observable String message;
-  @observable Instance exception;
-  @observable Instance stacktrace;
+  String message;
+  Instance exception;
+  Instance stacktrace;
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     message = map['message'];
     kind = stringToErrorKind(map['kind']);
     exception = new ServiceObject._fromMap(owner, map['exception']);
     stacktrace = new ServiceObject._fromMap(owner, map['stacktrace']);
     name = 'DartError($message)';
     vmName = name;
   }
 
   String toString() => 'DartError($message)';
 }
@@ skipping 35 matching lines @@
   static const kConnectionClosed       = 'ConnectionClosed';
   static const kLogging                = '_Logging';
   static const kExtension              = 'Extension';
 
   ServiceEvent._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ServiceEvent.connectionClosed(this.reason) : super._empty(null) {
     kind = kConnectionClosed;
   }
 
-  @observable String kind;
-  @observable DateTime timestamp;
+  String kind;
+  DateTime timestamp;
   List<M.Breakpoint> pauseBreakpoints;
-  @observable Breakpoint breakpoint;
-  @observable Frame topFrame;
-  @observable DartError error;
-  @observable String extensionRPC;
-  @observable Instance exception;
-  @observable Instance reloadError;
-  @observable bool atAsyncSuspension;
-  @observable Instance inspectee;
-  @observable ByteData data;
-  @observable int count;
-  @observable String reason;
-  @observable String exceptions;
-  @observable String bytesAsString;
-  @observable Map logRecord;
-  @observable String extensionKind;
-  @observable Map extensionData;
-  @observable List timelineEvents;
-  @observable String spawnToken;
-  @observable String spawnError;
+  Breakpoint breakpoint;
+  Frame topFrame;
+  DartError error;
+  String extensionRPC;
+  Instance exception;
+  Instance reloadError;
+  bool atAsyncSuspension;
+  Instance inspectee;
+  ByteData data;
+  int count;
+  String reason;
+  String exceptions;
+  String bytesAsString;
+  Map logRecord;
+  String extensionKind;
+  Map extensionData;
+  List timelineEvents;
+  String spawnToken;
+  String spawnError;
 
   int chunkIndex, chunkCount, nodeCount;
 
-  @observable bool get isPauseEvent {
+  bool get isPauseEvent {
     return (kind == kPauseStart ||
             kind == kPauseExit ||
             kind == kPauseBreakpoint ||
             kind == kPauseInterrupted ||
             kind == kPauseException ||
             kind == kNone);
   }
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
 
     assert(map['isolate'] == null || owner == map['isolate']);
     timestamp =
         new DateTime.fromMillisecondsSinceEpoch(map['timestamp']);
     kind = map['kind'];
-    notifyPropertyChange(#isPauseEvent, 0, 1);
     name = 'ServiceEvent $kind';
     vmName = name;
     if (map['breakpoint'] != null) {
       breakpoint = map['breakpoint'];
     }
     if (map['pauseBreakpoints'] != null) {
       pauseBreakpoints = map['pauseBreakpoints'];
       if (pauseBreakpoints.length > 0) {
         breakpoint = pauseBreakpoints[0];
       }
@@ skipping 75 matching lines @@
   Breakpoint._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   final M.ClassRef clazz = null;
   final int size = null;
 
   // TODO(turnidge): Add state to track if a breakpoint has been
   // removed from the program.  Remove from the cache when deleted.
   bool get immutable => false;
 
   // A unique integer identifier for this breakpoint.
-  @observable int number;
+  int number;
 
   // Either SourceLocation or UnresolvedSourceLocation.
-  @observable Location location;
+  Location location;
 
   // The breakpoint is in a file which is not yet loaded.
-  @observable bool latent;
+  bool latent;
 
   // The breakpoint has been assigned to a final source location.
-  @observable bool resolved;
+  bool resolved;
 
   // The breakpoint was synthetically created as part of an
   // 'OverAsyncContinuation' resume request.
-  @observable bool isSyntheticAsyncContinuation;
+  bool isSyntheticAsyncContinuation;
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
 
     var newNumber = map['breakpointNumber'];
     // number never changes.
     assert((number == null) || (number == newNumber));
     number = newNumber;
     resolved = map['resolved'];
 
     var oldLocation = location;
@@ skipping 29 matching lines @@
         return 'Breakpoint ${number} at ${location}';
       }
     } else {
       return 'Uninitialized breakpoint';
     }
   }
 }
 
 
 class LibraryDependency implements M.LibraryDependency {
-  @reflectable final bool isImport;
-  @reflectable final bool isDeferred;
-  @reflectable final String prefix;
-  @reflectable final Library target;
+  final bool isImport;
+  final bool isDeferred;
+  final String prefix;
+  final Library target;
 
   bool get isExport => !isImport;
 
   LibraryDependency._(this.isImport, this.isDeferred, this.prefix, this.target);
 
   static _fromMap(map) => new LibraryDependency._(map["isImport"],
                                                   map["isDeferred"],
                                                   map["prefix"],
                                                   map["target"]);
 }
 
 
 class Library extends HeapObject implements M.Library {
-  @observable String uri;
-  @reflectable final dependencies = new ObservableList<LibraryDependency>();
-  @reflectable final scripts = new ObservableList<Script>();
-  @reflectable final classes = new ObservableList<Class>();
-  @reflectable final variables = new ObservableList<Field>();
-  @reflectable final functions = new ObservableList<ServiceFunction>();
+  String uri;
+  final dependencies = <LibraryDependency>[];
+  final scripts = <Script>[];
+  final classes = <Class>[];
+  final variables = <Field>[];
+  final functions = <ServiceFunction>[];
 
   bool get immutable => false;
 
   bool isDart(String libraryName) {
     return uri == 'dart:$libraryName';
   }
 
   Library._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     uri = map['uri'];
     var shortUri = uri;
     if (uri.startsWith('file://') ||
         uri.startsWith('http://')) {
       shortUri = uri.substring(uri.lastIndexOf('/') + 1);
     }
     name = map['name'];
@@ skipping 28 matching lines @@
   Script get rootScript {
     for (Script script in scripts) {
       if (script.uri == uri) return script;
     }
     return null;
   }
 
   String toString() => "Library($uri)";
 }
 
-class AllocationCount extends Observable implements M.AllocationCount {
-  @observable int instances = 0;
-  @observable int bytes = 0;
+class AllocationCount implements M.AllocationCount {
+  int instances = 0;
+  int bytes = 0;
 
   void reset() {
     instances = 0;
     bytes = 0;
   }
 
   bool get empty => (instances == 0) && (bytes == 0);
   bool get notEmpty => (instances != 0) || (bytes != 0);
 }
 
@@ skipping 16 matching lines @@
     accumulated.bytes = stats[ACCUMULATED_SIZE];
     current.instances = stats[LIVE_AFTER_GC] + stats[ALLOCATED_SINCE_GC];
     current.bytes = stats[LIVE_AFTER_GC_SIZE] + stats[ALLOCATED_SINCE_GC_SIZE];
   }
 
   bool get empty => accumulated.empty && current.empty;
   bool get notEmpty => accumulated.notEmpty || current.notEmpty;
 }
 
 class Class extends HeapObject implements M.Class {
-  @observable Library library;
+  Library library;
 
-  @observable bool isAbstract;
-  @observable bool isConst;
-  @observable bool isFinalized;
-  @observable bool isPatch;
-  @observable bool isImplemented;
+  bool isAbstract;
+  bool isConst;
+  bool isFinalized;
+  bool isPatch;
+  bool isImplemented;
 
-  @observable SourceLocation location;
+  SourceLocation location;
 
-  @observable DartError error;
-  @observable int vmCid;
+  DartError error;
+  int vmCid;
 
   final Allocations newSpace = new Allocations();
   final Allocations oldSpace = new Allocations();
   final AllocationCount promotedByLastNewGC = new AllocationCount();
 
-  @observable bool get hasAllocations => newSpace.notEmpty || oldSpace.notEmpty;
-  @observable bool get hasNoAllocations => newSpace.empty && oldSpace.empty;
-  @observable bool traceAllocations = false;
-  @reflectable final fields = new ObservableList<Field>();
-  @reflectable final functions = new ObservableList<ServiceFunction>();
+  bool get hasAllocations => newSpace.notEmpty || oldSpace.notEmpty;
+  bool get hasNoAllocations => newSpace.empty && oldSpace.empty;
+  bool traceAllocations = false;
+  final fields = <Field>[];
+  final functions = <ServiceFunction>[];
 
-  @observable Class superclass;
-  @reflectable final interfaces = new ObservableList<Instance>();
-  @reflectable final subclasses = new ObservableList<Class>();
+  Class superclass;
+  final interfaces = <Instance>[];
+  final subclasses = <Class>[];
 
-  @observable Instance superType;
-  @observable Instance mixin;
+  Instance superType;
+  Instance mixin;
 
   bool get immutable => false;
 
   Class._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     name = map['name'];
     vmName = (map.containsKey('_vmName') ? map['_vmName'] : name);
     if (vmName == '::') {
       name = 'top-level-class';  // Better than ''
     }
     var idPrefix = "classes/";
     assert(id.startsWith(idPrefix));
@@ skipping 49 matching lines @@
 
     error = map['error'];
 
     traceAllocations =
         (map['_traceAllocations'] != null) ? map['_traceAllocations'] : false;
 
     var allocationStats = map['_allocationStats'];
     if (allocationStats != null) {
       newSpace.update(allocationStats['new']);
       oldSpace.update(allocationStats['old']);
-      notifyPropertyChange(#hasNoAllocations, 0, 1);
       promotedByLastNewGC.instances = allocationStats['promotedInstances'];
       promotedByLastNewGC.bytes = allocationStats['promotedBytes'];
     }
   }
 
   void _addSubclass(Class subclass) {
     if (subclasses.contains(subclass)) {
       return;
     }
     subclasses.add(subclass);
@@ skipping 130 matching lines @@
 
 class MapAssociation implements M.MapAssociation {
   final Guarded<Instance> key;
   final Guarded<Instance> value;
   MapAssociation(key, value)
     : key = new Guarded(key),
       value = new Guarded(value);
 }
 
 class Instance extends HeapObject implements M.Instance {
-  @observable M.InstanceKind kind;
-  @observable String valueAsString;  // If primitive.
-  @observable bool valueAsStringIsTruncated;
-  @observable ServiceFunction closureFunction;  // If a closure.
-  @observable Context closureContext;  // If a closure.
-  @observable int length; // If a List, Map or TypedData.
+  M.InstanceKind kind;
+  String valueAsString;  // If primitive.
+  bool valueAsStringIsTruncated;
+  ServiceFunction closureFunction;  // If a closure.
+  Context closureContext;  // If a closure.
+  int length; // If a List, Map or TypedData.
   int count;
   int offset;
-  @observable Instance pattern;  // If a RegExp.
+  Instance pattern;  // If a RegExp.
 
-  @observable String name;
-  @observable Class typeClass;
-  @observable Class parameterizedClass;
-  @observable TypeArguments typeArguments;
-  @observable int parameterIndex;
-  @observable Instance targetType;
-  @observable Instance bound;
+  String name;
+  Class typeClass;
+  Class parameterizedClass;
+  TypeArguments typeArguments;
+  int parameterIndex;
+  Instance targetType;
+  Instance bound;
 
-  @observable Iterable<BoundField> fields;
-  @observable var nativeFields;
-  @observable Iterable<Guarded<HeapObject>> elements;  // If a List.
-  @observable Iterable<MapAssociation> associations;  // If a Map.
-  @observable Iterable<dynamic> typedElements;  // If a TypedData.
-  @observable HeapObject referent;  // If a MirrorReference.
-  @observable Instance key;  // If a WeakProperty.
-  @observable Instance value;  // If a WeakProperty.
-  @observable Breakpoint activationBreakpoint;  // If a Closure.
-  @observable ServiceFunction oneByteFunction;  // If a RegExp.
-  @observable ServiceFunction twoByteFunction;  // If a RegExp.
-  @observable ServiceFunction externalOneByteFunction;  // If a RegExp.
-  @observable ServiceFunction externalTwoByteFunction;  // If a RegExp.
-  @observable Instance oneByteBytecode;  // If a RegExp.
-  @observable Instance twoByteBytecode;  // If a RegExp.
-  @observable bool isCaseSensitive;  // If a RegExp.
-  @observable bool isMultiLine;  // If a RegExp.
+  Iterable<BoundField> fields;
+  var nativeFields;
+  Iterable<Guarded<HeapObject>> elements;  // If a List.
+  Iterable<MapAssociation> associations;  // If a Map.
+  Iterable<dynamic> typedElements;  // If a TypedData.
+  HeapObject referent;  // If a MirrorReference.
+  Instance key;  // If a WeakProperty.
+  Instance value;  // If a WeakProperty.
+  Breakpoint activationBreakpoint;  // If a Closure.
+  ServiceFunction oneByteFunction;  // If a RegExp.
+  ServiceFunction twoByteFunction;  // If a RegExp.
+  ServiceFunction externalOneByteFunction;  // If a RegExp.
+  ServiceFunction externalTwoByteFunction;  // If a RegExp.
+  Instance oneByteBytecode;  // If a RegExp.
+  Instance twoByteBytecode;  // If a RegExp.
+  bool isCaseSensitive;  // If a RegExp.
+  bool isMultiLine;  // If a RegExp.
 
   bool get isAbstractType => M.isAbstractType(kind);
   bool get isNull => kind == M.InstanceKind.vNull;
   bool get isBool => kind == M.InstanceKind.bool;
   bool get isDouble => kind == M.InstanceKind.double;
   bool get isString => kind == M.InstanceKind.string;
   bool get isInt => kind == M.InstanceKind.int;
   bool get isList => kind == M.InstanceKind.list;
   bool get isMap => kind == M.InstanceKind.map;
   bool get isTypedData {
@@ skipping 26 matching lines @@
     }
     return (clazz.name == 'OutOfMemoryError') && clazz.library.isDart('core');
   }
 
   // TODO(turnidge): Is this properly backwards compatible when new
   // instance kinds are added?
   bool get isPlainInstance => kind == 'PlainInstance';
 
   Instance._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     // Extract full properties.1
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     kind = stringToInstanceKind(map['kind']);
     valueAsString = map['valueAsString'];
     // Coerce absence to false.
     valueAsStringIsTruncated = map['valueAsStringIsTruncated'] == true;
     closureFunction = map['closureFunction'];
     closureContext = map['closureContext'];
@@ skipping 107 matching lines @@
 
   Future<ServiceObject> evaluate(String expression) {
     return isolate.eval(this, expression);
   }
 
   String toString() => 'Instance($shortName)';
 }
 
 
 class Context extends HeapObject implements M.Context {
-  @observable Context parentContext;
-  @observable int length;
-  @observable Iterable<ContextElement> variables;
+  Context parentContext;
+  int length;
+  Iterable<ContextElement> variables;
 
   Context._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     length = map['length'];
     parentContext = map['parent'];
 
     if (mapIsRef) {
       return;
     }
 
     variables = (map['variables'] ?? const []).map((element) =>
       new ContextElement(element));
 
     // We are fully loaded.
     _loaded = true;
   }
 
   String toString() => 'Context($length)';
 }
 
 class ContextElement extends M.ContextElement {
   final Guarded<Instance> value;
 
-  ContextElement(ObservableMap map)
+  ContextElement(Map map)
     : value = new Guarded<Instance>(map['value']);
 }
 
 M.FunctionKind stringToFunctionKind(String value) {
   switch(value) {
     case 'RegularFunction': return M.FunctionKind.regular;
     case 'ClosureFunction': return M.FunctionKind.closure;
     case 'GetterFunction': return M.FunctionKind.getter;
     case 'SetterFunction': return M.FunctionKind.setter;
     case 'Constructor': return M.FunctionKind.constructor;
@@ skipping 11 matching lines @@
     case 'Stub': return M.FunctionKind.stub;
     case 'Tag': return M.FunctionKind.tag;
     case 'SignatureFunction': return M.FunctionKind.signatureFunction;
   }
   Logger.root.severe('Unrecognized function kind: $value');
   throw new FallThroughError();
 }
 
 class ServiceFunction extends HeapObject implements M.Function {
   // owner is a Library, Class, or ServiceFunction.
-  @observable M.ObjectRef dartOwner;
-  @observable Library library;
-  @observable bool isStatic;
-  @observable bool isConst;
-  @observable SourceLocation location;
-  @observable Code code;
-  @observable Code unoptimizedCode;
-  @observable bool isOptimizable;
-  @observable bool isInlinable;
-  @observable bool hasIntrinsic;
-  @observable bool isRecognized;
-  @observable bool isNative;
-  @observable M.FunctionKind kind;
-  @observable int deoptimizations;
-  @observable String qualifiedName;
-  @observable int usageCounter;
-  @observable bool isDart;
-  @observable ProfileFunction profile;
-  @observable Instance icDataArray;
-  @observable Field field;
+  M.ObjectRef dartOwner;
+  Library library;
+  bool isStatic;
+  bool isConst;
+  SourceLocation location;
+  Code code;
+  Code unoptimizedCode;
+  bool isOptimizable;
+  bool isInlinable;
+  bool hasIntrinsic;
+  bool isRecognized;
+  bool isNative;
+  M.FunctionKind kind;
+  int deoptimizations;
+  String qualifiedName;
+  int usageCounter;
+  bool isDart;
+  ProfileFunction profile;
+  Instance icDataArray;
+  Field field;
 
   bool get immutable => false;
 
   ServiceFunction._empty(ServiceObject owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     name = map['name'];
     vmName = (map.containsKey('_vmName') ? map['_vmName'] : name);
 
     dartOwner = map['owner'];
     kind = stringToFunctionKind(map['_kind']);
     isDart = M.isDartFunction(kind);
 
@@ skipping 62 matching lines @@
   throw new FallThroughError();
 }
 
 class Sentinel extends ServiceObject implements M.Sentinel {
 
   M.SentinelKind kind;
   String valueAsString;
 
   Sentinel._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
 
     kind = stringToSentinelKind(map['kind']);
     valueAsString = map['valueAsString'];
     _loaded = true;
   }
 
   String toString() => 'Sentinel($kind)';
   String get shortName => valueAsString;
 }
 
 class Field extends HeapObject implements M.Field {
   // Library or Class.
-  @observable HeapObject dartOwner;
-  @observable Library library;
-  @observable Instance declaredType;
-  @observable bool isStatic;
-  @observable bool isFinal;
-  @observable bool isConst;
-  @observable Instance staticValue;
-  @observable String name;
-  @observable String vmName;
+  HeapObject dartOwner;
+  Library library;
+  Instance declaredType;
+  bool isStatic;
+  bool isFinal;
+  bool isConst;
+  Instance staticValue;
+  String name;
+  String vmName;
 
-  @observable bool guardNullable;
+  bool guardNullable;
   M.GuardClassKind guardClassKind;
-  @observable Class guardClass;
-  @observable String guardLength;
-  @observable SourceLocation location;
+  Class guardClass;
+  String guardLength;
+  SourceLocation location;
 
   Field._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     name = map['name'];
     vmName = (map.containsKey('_vmName') ? map['_vmName'] : name);
     dartOwner = map['owner'];
     declaredType = map['declaredType'];
     isStatic = map['static'];
     isFinal = map['final'];
@@ skipping 30 matching lines @@
 
     guardLength = map['_guardLength'];
     location = map['location'];
     _loaded = true;
   }
 
   String toString() => 'Field(${dartOwner.name}.$name)';
 }
 
 
-class ScriptLine extends Observable {
+class ScriptLine {
   final Script script;
   final int line;
   final String text;
-  @observable Set<Breakpoint> breakpoints;
+  Set<Breakpoint> breakpoints;
 
   ScriptLine(this.script, this.line, this.text);
 
   bool get isBlank {
     return text.isEmpty || text.trim().isEmpty;
   }
 
   bool _isTrivial = null;
   bool get isTrivial {
     if (_isTrivial == null) {
@@ skipping 109 matching lines @@
 
 /// The location of a local variable reference in a script.
 class LocalVarLocation {
   final int line;
   final int column;
   final int endColumn;
   LocalVarLocation(this.line, this.column, this.endColumn);
 }
 
 class Script extends HeapObject implements M.Script {
-  final lines = new ObservableList<ScriptLine>();
-  @observable String uri;
-  @observable String kind;
-  @observable DateTime loadTime;
-  @observable int firstTokenPos;
-  @observable int lastTokenPos;
-  @observable int lineOffset;
-  @observable int columnOffset;
-  @observable Library library;
+  final lines = <ScriptLine>[];
+  String uri;
+  String kind;
+  DateTime loadTime;
+  int firstTokenPos;
+  int lastTokenPos;
+  int lineOffset;
+  int columnOffset;
+  Library library;
 
   String source;
 
   bool get immutable => true;
 
   String _shortUri;
 
   Script._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ScriptLine getLine(int line) {
@@ skipping 66 matching lines @@
     if (c == 95) return true; // Underscore
     if (c == 36) return true; // Dollar
     return false;
   }
 
   static bool _isIdentifierChar(int c) {
     if (_isInitialIdentifierChar(c)) return true;
     return c >= 48 && c <= 75; // Digit
   }
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     uri = map['uri'];
     kind = map['_kind'];
     _shortUri = uri.substring(uri.lastIndexOf('/') + 1);
     name = _shortUri;
     vmName = uri;
     if (mapIsRef) {
       return;
@@ skipping 55 matching lines @@
     lines.clear();
     Logger.root.info('Adding ${sourceLines.length} source lines for ${uri}');
     for (var i = 0; i < sourceLines.length; i++) {
       lines.add(new ScriptLine(this, i + lineOffset + 1, sourceLines[i]));
     }
     for (var bpt in isolate.breakpoints.values) {
       if (bpt.location.script == this) {
         _addBreakpoint(bpt);
       }
     }
-
-    // Notify any Observers that this Script's state has changed.
-    notifyChange(null);
   }
 
   void _addBreakpoint(Breakpoint bpt) {
     var line;
     if (bpt.location.tokenPos != null) {
       line = tokenToLine(bpt.location.tokenPos);
     } else {
       UnresolvedSourceLocation loc = bpt.location;
       line = loc.line;
     }
@@ skipping 131 matching lines @@
           scanLineForLocalVariableLocations(pattern,
                                              name,
                                              lineContents,
                                              line,
                                              0));
     }
     return r;
   }
 }
 
-class PcDescriptor extends Observable {
+class PcDescriptor {
   final int pcOffset;
-  @reflectable final int deoptId;
-  @reflectable final int tokenPos;
-  @reflectable final int tryIndex;
-  @reflectable final String kind;
-  @observable Script script;
-  @observable String formattedLine;
+  final int deoptId;
+  final int tokenPos;
+  final int tryIndex;
+  final String kind;
+  Script script;
+  String formattedLine;
   PcDescriptor(this.pcOffset, this.deoptId, this.tokenPos, this.tryIndex,
                this.kind);
 
-  @reflectable String formattedDeoptId() {
+  String formattedDeoptId() {
     if (deoptId == -1) {
       return 'N/A';
     }
     return deoptId.toString();
   }
 
-  @reflectable String formattedTokenPos() {
+  String formattedTokenPos() {
     if (tokenPos == -1) {
       return '';
     }
     return tokenPos.toString();
   }
 
   void processScript(Script script) {
     this.script = null;
     if (tokenPos == -1) {
       return;
     }
     var line = script.tokenToLine(tokenPos);
     if (line == null) {
       return;
     }
     this.script = script;
     var scriptLine = script.getLine(line);
     formattedLine = scriptLine.text;
   }
 }
 
 class PcDescriptors extends ServiceObject implements M.PcDescriptorsRef {
-  @observable Class clazz;
-  @observable int size;
+  Class clazz;
+  int size;
   bool get immutable => true;
-  @reflectable final List<PcDescriptor> descriptors =
-      new ObservableList<PcDescriptor>();
+  final List<PcDescriptor> descriptors = <PcDescriptor>[];
 
   PcDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner) {
   }
 
-  void _update(ObservableMap m, bool mapIsRef) {
+  void _update(Map m, bool mapIsRef) {
     if (mapIsRef) {
       return;
     }
     _upgradeCollection(m, isolate);
     clazz = m['class'];
     size = m['size'];
     descriptors.clear();
     for (var descriptor in m['members']) {
       var pcOffset = int.parse(descriptor['pcOffset'], radix:16);
       var deoptId = descriptor['deoptId'];
       var tokenPos = descriptor['tokenPos'];
       var tryIndex = descriptor['tryIndex'];
       var kind = descriptor['kind'].trim();
       descriptors.add(
           new PcDescriptor(pcOffset, deoptId, tokenPos, tryIndex, kind));
     }
   }
 }
 
-class LocalVarDescriptor extends Observable
-                         implements M.LocalVarDescriptorsRef {
-  @reflectable final String id;
-  @reflectable final String name;
-  @reflectable final int index;
-  @reflectable final int beginPos;
-  @reflectable final int endPos;
-  @reflectable final int scopeId;
-  @reflectable final String kind;
+class LocalVarDescriptor implements M.LocalVarDescriptorsRef {
+  final String id;
+  final String name;
+  final int index;
+  final int beginPos;
+  final int endPos;
+  final int scopeId;
+  final String kind;
 
   LocalVarDescriptor(this.id, this.name, this.index, this.beginPos, this.endPos,
                      this.scopeId, this.kind);
 }
 
 class LocalVarDescriptors extends ServiceObject {
-  @observable Class clazz;
-  @observable int size;
+  Class clazz;
+  int size;
   bool get immutable => true;
-  @reflectable final List<LocalVarDescriptor> descriptors =
-        new ObservableList<LocalVarDescriptor>();
+  final List<LocalVarDescriptor> descriptors = <LocalVarDescriptor>[];
   LocalVarDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap m, bool mapIsRef) {
+  void _update(Map m, bool mapIsRef) {
     if (mapIsRef) {
       return;
     }
     _upgradeCollection(m, isolate);
     clazz = m['class'];
     size = m['size'];
     descriptors.clear();
     for (var descriptor in m['members']) {
       var id = descriptor['name'];
       var name = descriptor['name'];
       var index = descriptor['index'];
       var beginPos = descriptor['beginPos'];
       var endPos = descriptor['endPos'];
       var scopeId = descriptor['scopeId'];
       var kind = descriptor['kind'].trim();
       descriptors.add(
           new LocalVarDescriptor(id, name, index, beginPos, endPos, scopeId,
                                  kind));
     }
   }
 }
 
 class ObjectPool extends HeapObject implements M.ObjectPool {
   bool get immutable => false;
 
-  @observable int length;
-  @observable List<ObjectPoolEntry> entries;
+  int length;
+  List<ObjectPoolEntry> entries;
 
   ObjectPool._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     length = map['length'];
     if (mapIsRef) {
       return;
     }
     entries = map['_entries'].map((map) => new ObjectPoolEntry(map));
   }
 }
@@ skipping 29 matching lines @@
       return M.ObjectPoolEntryKind.object;
     case 'Immediate':
       return M.ObjectPoolEntryKind.immediate;
     case 'NativeEntry':
       return M.ObjectPoolEntryKind.nativeEntry;
   }
   throw new Exception('Unknown ObjectPoolEntryKind ($kind)');
 }
 
 class ICData extends HeapObject implements M.ICData {
-  @observable HeapObject dartOwner;
-  @observable String selector;
-  @observable Instance argumentsDescriptor;
-  @observable Instance entries;
+  HeapObject dartOwner;
+  String selector;
+  Instance argumentsDescriptor;
+  Instance entries;
 
   bool get immutable => false;
 
   ICData._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     dartOwner = map['_owner'];
     selector = map['_selector'];
     if (mapIsRef) {
       return;
     }
     argumentsDescriptor = map['_argumentsDescriptor'];
     entries = map['_entries'];
   }
 }
 
 class TypeArguments extends HeapObject implements M.TypeArguments {
   HeapObject dartOwner;
   String name;
   Iterable<Instance> types;
 
   TypeArguments._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     dartOwner = map['_owner'];
     name = map['name'];
     if (mapIsRef) {
       return;
     }
     types = map['types'];
   }
 }
 
 class InstanceSet extends HeapObject implements M.InstanceSet {
   HeapObject dartOwner;
   int count;
   Iterable<HeapObject> samples;
 
   InstanceSet._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     if (mapIsRef) {
       return;
     }
     count = map['totalCount'];
     samples = map['samples'];
   }
 }
 
 class MegamorphicCache extends HeapObject implements M.MegamorphicCache {
-  @observable int mask;
-  @observable Instance buckets;
-  @observable String selector;
-  @observable Instance argumentsDescriptor;
+  int mask;
+  Instance buckets;
+  String selector;
+  Instance argumentsDescriptor;
 
   bool get immutable => false;
 
   MegamorphicCache._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     selector = map['_selector'];
     if (mapIsRef) {
       return;
     }
 
     mask = map['_mask'];
     buckets = map['_buckets'];
     argumentsDescriptor = map['_argumentsDescriptor'];
   }
 }
 
 class TokenStream extends HeapObject implements M.TokenStreamRef {
   bool get immutable => true;
 
-  @observable String privateKey;
+  String privateKey;
 
   TokenStream._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     if (mapIsRef) {
       return;
     }
     privateKey = map['privateKey'];
   }
 }
 
-class CodeInstruction extends Observable {
-  @observable final int address;
-  @observable final int pcOffset;
-  @observable final String machine;
-  @observable final String human;
-  @observable final ServiceObject object;
-  @observable CodeInstruction jumpTarget;
-  @reflectable List<PcDescriptor> descriptors =
-      new ObservableList<PcDescriptor>();
+class CodeInstruction {
+  final int address;
+  final int pcOffset;
+  final String machine;
+  final String human;
+  final ServiceObject object;
+  CodeInstruction jumpTarget;
+  List<PcDescriptor> descriptors = <PcDescriptor>[];
 
   CodeInstruction(this.address,
                   this.pcOffset,
                   this.machine,
                   this.human,
                   this.object);
 
-  @reflectable bool get isComment => address == 0;
-  @reflectable bool get hasDescriptors => descriptors.length > 0;
+  bool get isComment => address == 0;
+  bool get hasDescriptors => descriptors.length > 0;
 
   bool _isJumpInstruction() {
     return human.startsWith('j');
   }
 
   int _getJumpAddress() {
     assert(_isJumpInstruction());
     var chunks = human.split(' ');
     if (chunks.length != 2) {
       // We expect jump instructions to be of the form 'j.. address'.
@@ skipping 51 matching lines @@
 
 class CodeInlineInterval {
   final int start;
   final int end;
   final List<ServiceFunction> functions = new List<ServiceFunction>();
   bool contains(int pc) => (pc >= start) && (pc < end);
   CodeInlineInterval(this.start, this.end);
 }
 
 class Code extends HeapObject implements M.Code {
-  @observable M.CodeKind kind;
-  @observable ObjectPool objectPool;
-  @observable ServiceFunction function;
-  @observable Script script;
-  @observable bool isOptimized;
-  @observable bool hasIntrinsic;
-  @observable bool isNative;
+  M.CodeKind kind;
+  ObjectPool objectPool;
+  ServiceFunction function;
+  Script script;
+  bool isOptimized;
+  bool hasIntrinsic;
+  bool isNative;
 
-  @reflectable int startAddress = 0;
-  @reflectable int endAddress = 0;
-  @reflectable final instructions = new ObservableList<CodeInstruction>();
+  int startAddress = 0;
+  int endAddress = 0;
+  final instructions = <CodeInstruction>[];
   List<CodeInstruction> instructionsByAddressOffset;
 
-  @observable ProfileCode profile;
-  final List<CodeInlineInterval> inlineIntervals =
-      new List<CodeInlineInterval>();
-  final ObservableList<ServiceFunction> inlinedFunctions =
-      new ObservableList<ServiceFunction>();
+  ProfileCode profile;
+  final List<CodeInlineInterval> inlineIntervals = <CodeInlineInterval>[];
+  final List<ServiceFunction> inlinedFunctions = <ServiceFunction>[];
 
   bool get immutable => true;
 
   Code._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _updateDescriptors(Script script) {
     this.script = script;
     for (var instruction in instructions) {
       for (var descriptor in instruction.descriptors) {
         descriptor.processScript(script);
@@ skipping 34 matching lines @@
   /// exception.
   Future<ServiceObject> reload({int count: kDefaultFieldLimit}) {
     assert(kind != null);
     if (isDartCode) {
       // We only reload Dart code.
       return super.reload(count: count);
     }
     return new Future.value(this);
   }
 
-  void _update(ObservableMap m, bool mapIsRef) {
+  void _update(Map m, bool mapIsRef) {
     name = m['name'];
     vmName = (m.containsKey('_vmName') ? m['_vmName'] : name);
     isOptimized = m['_optimized'];
     kind = stringToCodeKind(m['kind']);
     hasIntrinsic = m['_intrinsic'];
     isNative = m['_native'];
     if (mapIsRef) {
       return;
     }
     _loaded = true;
@@ skipping 58 matching lines @@
         if (inline_id < 0) {
           continue;
         }
         var function = inlinedFunctionsTable[inline_id];
         codeInlineInterval.functions.add(function);
       }
       inlineIntervals.add(codeInlineInterval);
     }
   }
 
-  @observable bool hasDisassembly = false;
+  bool hasDisassembly = false;
 
   void _processDisassembly(List disassembly) {
     assert(disassembly != null);
     instructions.clear();
     instructionsByAddressOffset = new List(endAddress - startAddress);
 
     assert((disassembly.length % 4) == 0);
     for (var i = 0; i < disassembly.length; i += 4) {
       var address = 0;  // Assume code comment.
       var machine = disassembly[i + 1];
@@ skipping 42 matching lines @@
           'Could not find instruction with pc descriptor address: $address');
       }
     }
   }
 
   /// Returns true if [address] is contained inside [this].
   bool contains(int address) {
     return (address >= startAddress) && (address < endAddress);
   }
 
-  @reflectable bool get isDartCode => (kind == M.CodeKind.dart) ||
+  bool get isDartCode => (kind == M.CodeKind.dart) ||
                                       (kind == M.CodeKind.stub);
 
   String toString() => 'Code($kind, $name)';
 }
 
 
 class SocketKind {
   final _value;
   const SocketKind._internal(this._value);
   String toString() => '$_value';
@@ skipping 12 matching lines @@
     throw new FallThroughError();
   }
   static const Listening = const SocketKind._internal('Listening');
   static const Normal = const SocketKind._internal('Normal');
   static const Pipe = const SocketKind._internal('Pipe');
   static const Internal = const SocketKind._internal('Internal');
 }
 
 /// A snapshot of statistics associated with a [Socket].
 class SocketStats {
-  @reflectable final int bytesRead;
-  @reflectable final int bytesWritten;
-  @reflectable final int readCalls;
-  @reflectable final int writeCalls;
-  @reflectable final int available;
+  final int bytesRead;
+  final int bytesWritten;
+  final int readCalls;
+  final int writeCalls;
+  final int available;
 
   SocketStats(this.bytesRead, this.bytesWritten,
               this.readCalls, this.writeCalls,
               this.available);
 }
 
 /// A peer to a Socket in dart:io. Sockets can represent network sockets or
 /// OS pipes. Each socket is owned by another ServceObject, for example,
 /// a process or an HTTP server.
 class Socket extends ServiceObject {
   Socket._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ServiceObject socketOwner;
 
-  @reflectable bool get isPipe => (kind == SocketKind.Pipe);
+  bool get isPipe => (kind == SocketKind.Pipe);
 
-  @observable SocketStats latest;
-  @observable SocketStats previous;
+  SocketStats latest;
+  SocketStats previous;
 
-  @observable SocketKind kind;
+  SocketKind kind;
 
-  @observable String protocol = '';
+  String protocol = '';
 
-  @observable bool readClosed = false;
-  @observable bool writeClosed = false;
-  @observable bool closing = false;
+  bool readClosed = false;
+  bool writeClosed = false;
+  bool closing = false;
 
   /// Listening for connections.
-  @observable bool listening = false;
+  bool listening = false;
 
-  @observable int fd;
+  int fd;
 
-  @observable String localAddress;
-  @observable int localPort;
-  @observable String remoteAddress;
-  @observable int remotePort;
+  String localAddress;
+  int localPort;
+  String remoteAddress;
+  int remotePort;
 
   // Updates internal state from [map]. [map] can be a reference.
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     name = map['name'];
     vmName = map['name'];
 
     kind = SocketKind.fromString(map['kind']);
 
     if (mapIsRef) {
       return;
     }
 
     _loaded = true;
@@ skipping 16 matching lines @@
     socketOwner = map['owner'];
   }
 }
 
 class ServiceMetric extends ServiceObject implements M.Metric {
   ServiceMetric._empty(ServiceObjectOwner owner) : super._empty(owner) {
   }
 
   bool get immutable => false;
 
-  Future<ObservableMap> _fetchDirect({int count: kDefaultFieldLimit}) {
+  Future<Map> _fetchDirect({int count: kDefaultFieldLimit}) {
     assert(owner is Isolate);
     return isolate.invokeRpcNoUpgrade('_getIsolateMetric', { 'metricId': id });
   }
 
-  @observable String description;
-  @observable double value = 0.0;
+  String description;
+  double value = 0.0;
   // Only a guage has a non-null min and max.
-  @observable double min;
-  @observable double max;
+  double min;
+  double max;
 
   bool get isGauge => (min != null) && (max != null);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     name = map['name'];
     description = map['description'];
     vmName = map['name'];
     value = map['value'];
     min = map['min'];
     max = map['max'];
   }
 
   String toString() => "ServiceMetric($_id)";
 }
 
 class Frame extends ServiceObject implements M.Frame {
-  @observable int index;
-  @observable ServiceFunction function;
-  @observable SourceLocation location;
-  @observable Code code;
-  @observable List<ServiceMap> variables = new ObservableList<ServiceMap>();
+  int index;
+  ServiceFunction function;
+  SourceLocation location;
+  Code code;
+  List<ServiceMap> variables = <ServiceMap>[];
 
   Frame._empty(ServiceObject owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     assert(!mapIsRef);
     _loaded = true;
     _upgradeCollection(map, owner);
     this.index = map['index'];
     this.function = map['function'];
     this.location = map['location'];
     this.code = map['code'];
     this.variables = map['vars'];
   }
 
   String toString() => "Frame(${function.qualifiedName} $location)";
 }
 
 
 class ServiceMessage extends ServiceObject {
-  @observable int index;
-  @observable String messageObjectId;
-  @observable int size;
-  @observable ServiceFunction handler;
-  @observable SourceLocation location;
+  int index;
+  String messageObjectId;
+  int size;
+  ServiceFunction handler;
+  SourceLocation location;
 
   ServiceMessage._empty(ServiceObject owner) : super._empty(owner);
 
-  void _update(ObservableMap map, bool mapIsRef) {
+  void _update(Map map, bool mapIsRef) {
     assert(!mapIsRef);
     _loaded = true;
     _upgradeCollection(map, owner);
     this.messageObjectId = map['messageObjectId'];
     this.index = map['index'];
     this.size = map['size'];
     this.handler = map['handler'];
     this.location = map['location'];
   }
 }
@@ skipping 36 matching lines @@
         }
       }
     }
   }
   return result;
 }
 
 
 // Returns true if [map] is a service map. i.e. it has the following keys:
 // 'id' and a 'type'.
-bool _isServiceMap(ObservableMap m) {
+bool _isServiceMap(Map m) {
   return (m != null) && (m['type'] != null);
 }
 
 bool _hasRef(String type) => type.startsWith('@');
 String _stripRef(String type) => (_hasRef(type) ? type.substring(1) : type);
 
 /// Recursively upgrades all [ServiceObject]s inside [collection] which must
 /// be an [ObservableMap] or an [ObservableList]. Upgraded elements will be
 /// associated with [vm] and [isolate].
 void _upgradeCollection(collection, ServiceObjectOwner owner) {
   if (collection is ServiceMap) {
     return;
   }
-  if (collection is ObservableMap) {
+  if (collection is Map) {
     _upgradeObservableMap(collection, owner);
-  } else if (collection is ObservableList) {
+  } else if (collection is List) {
     _upgradeObservableList(collection, owner);
   }
 }
 
-void _upgradeObservableMap(ObservableMap map, ServiceObjectOwner owner) {
+void _upgradeObservableMap(Map map, ServiceObjectOwner owner) {
   map.forEach((k, v) {
-    if ((v is ObservableMap) && _isServiceMap(v)) {
+    if ((v is Map) && _isServiceMap(v)) {
       map[k] = owner.getFromMap(v);
-    } else if (v is ObservableList) {
+    } else if (v is List) {
       _upgradeObservableList(v, owner);
-    } else if (v is ObservableMap) {
+    } else if (v is Map) {
       _upgradeObservableMap(v, owner);
     }
   });
 }
 
-void _upgradeObservableList(ObservableList list, ServiceObjectOwner owner) {
+void _upgradeObservableList(List list, ServiceObjectOwner owner) {
   for (var i = 0; i < list.length; i++) {
     var v = list[i];
-    if ((v is ObservableMap) && _isServiceMap(v)) {
+    if ((v is Map) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
-    } else if (v is ObservableList) {
+    } else if (v is List) {
       _upgradeObservableList(v, owner);
-    } else if (v is ObservableMap) {
+    } else if (v is Map) {
       _upgradeObservableMap(v, owner);
     }
   }
 }

[Cutch, 2016/09/07 19:12:52]

so nice to see all the @observable, @reflectable, ObservableList, ObservableMap
artifacts go away.

[cbernaschina, 2016/09/07 19:45:41]

Done.