Allow observatory to distinguish between user-level and vm-level types.

runtime/bin/vmservice/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] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
   static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
@@ skipping 12 matching lines @@
   /// The [VM] which owns this [ServiceObject].
   @reflectable VM get vm => _owner.vm;
 
   /// The [Isolate] which owns this [ServiceObject].  May be null.
   @reflectable Isolate get isolate => _owner.isolate;
 
   /// The id of this object.
   @reflectable String get id => _id;
   String _id;
 
-  /// The service type of this object.
-  @reflectable String get serviceType => _serviceType;
-  String _serviceType;
+  /// The user-level type of this object.
+  @reflectable String get type => _type;
+  String _type;
+
+  /// The vm type of this object.
+  @reflectable String get vmType => _vmType;
+  String _vmType;
 
   /// The complete service url of this object.
   @reflectable String get link => _owner.relativeLink(_id);
 
   /// Has this object been fully loaded?
   bool get loaded => _loaded;
   bool _loaded = false;
   // TODO(turnidge): Make loaded observable and get rid of loading
   // from Isolate.
 
@@ skipping 80 matching lines @@
     return reload();
   }
 
   Future<ServiceObject> _inProgressReload;
 
   /// Reload [this]. Returns a future which completes to [this] or
   /// a [ServiceError].
   Future<ServiceObject> reload() {
     if (id == '') {
       // Errors don't have ids.
-      assert(serviceType == 'Error');
+      assert(type == 'Error');
       return new Future.value(this);
     }
     if (loaded && immutable) {
       return new Future.value(this);
     }
     if (_inProgressReload == null) {
       _inProgressReload = vm.getAsMap(link).then((ObservableMap map) {
           var mapType = _stripRef(map['type']);
-          if (mapType != _serviceType) {
+          if (mapType != _type) {
             // If the type changes, return a new object instead of
             // updating the existing one.
+            //
+            // TODO(turnidge): Check for vmType changing as well?
             assert(mapType == 'Error' || mapType == 'Null');
             return new ServiceObject._fromMap(owner, map);
           }
           update(map);
           return this;
       }).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) {
     assert(_isServiceMap(map));
 
     // Don't allow the type to change on an object update.
     // TODO(turnidge): Make this a ServiceError?
     var mapIsRef = _hasRef(map['type']);
     var mapType = _stripRef(map['type']);
-    assert(_serviceType == null || _serviceType == mapType);
+    assert(_type == null || _type == mapType);
 
     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'];
 
-    _serviceType = mapType;
+    _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);
 
   String relativeLink(String id) {
     assert(id != null);
     return "${link}/${id}";
   }
 }
 
 abstract class Coverage {
   // Following getters and functions will be provided by [ServiceObject].
   ServiceObjectOwner get owner;
-  String get serviceType;
+  String get type;
   VM get vm;
   String relativeLink(String id);
 
   /// Default handler for coverage data.
   void processCoverageData(List coverageData) {
     coverageData.forEach((scriptCoverage) {
       assert(scriptCoverage['script'] != null);
       scriptCoverage['script']._processHits(scriptCoverage['hits']);
     });
   }
 
   Future refreshCoverage() {
     return vm.getAsMap(relativeLink('coverage')).then((ObservableMap map) {
-      var coverageOwner = (serviceType == 'Isolate') ? this : owner;
+      var coverageOwner = (type == 'Isolate') ? this : owner;
       var coverage = new ServiceObject._fromMap(coverageOwner, map);
-      assert(coverage.serviceType == 'CodeCoverage');
+      assert(coverage.type == 'CodeCoverage');
       var coverageList = coverage['coverage'];
       assert(coverageList != null);
       processCoverageData(coverageList);
     });
   }
 }
 
 abstract class ServiceObjectOwner extends ServiceObject {
   /// Creates an empty [ServiceObjectOwner].
   ServiceObjectOwner._empty(ServiceObjectOwner owner) : super._empty(owner);
@@ skipping 404 matching lines @@
 
   static const TAG_ROOT_ID = 'code/tag-0';
 
   /// Returns the Code object for the root tag.
   Code tagRoot() {
     // TODO(turnidge): Use get() here instead?
     return _cache[TAG_ROOT_ID];
   }
 
   void processProfile(ServiceMap profile) {
-    assert(profile.serviceType == 'Profile');
+    assert(profile.type == 'Profile');
     var codeTable = new List<Code>();
     var codeRegions = profile['codes'];
     for (var codeRegion in codeRegions) {
       Code code = codeRegion['code'];
       assert(code != null);
       codeTable.add(code);
     }
     _resetProfileData();
     _updateProfileData(profile, codeTable);
     var exclusiveTrie = profile['exclusive_trie'];
@@ skipping 21 matching lines @@
   }
 
   /// Fetches and builds the class hierarchy for this isolate. Returns the
   /// Object class object.
   Future<Class> getClassHierarchy() {
     return get('classes').then(_loadClasses).then(_buildClassHierarchy);
   }
 
   /// Given the class list, loads each class.
   Future<List<Class>> _loadClasses(ServiceMap classList) {
-    assert(classList.serviceType == 'ClassList');
+    assert(classList.type == 'ClassList');
     var futureClasses = [];
     for (var cls in classList['members']) {
       // Skip over non-class classes.
       if (cls is Class) {
         futureClasses.add(cls.load());
       }
     }
     return Future.wait(futureClasses);
   }
 
@@ skipping 80 matching lines @@
     mainPort = map['mainPort'];
     name = map['name'];
     vmName = map['name'];
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     loading = false;
 
     reloadBreakpoints();
-
-    // Remap DebuggerEvent to ServiceEvent so that the observatory can
-    // work against 1.5 vms in the short term.
-    //
-    // TODO(turnidge): Remove this when no longer needed.
-    var pause = map['pauseEvent'];
-    if (pause != null) {
-      if (pause['type'] == 'DebuggerEvent') {
-        pause['type'] = 'ServiceEvent';
-      }
-    }
-
     _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'];
@@ skipping 290 matching lines @@
 
   String toString() => "Isolate($_id)";
 }
 
 /// A [ServiceObject] which implements [ObservableMap].
 class ServiceMap extends ServiceObject implements ObservableMap {
   final ObservableMap _map = new ObservableMap();
   static String objectIdRingPrefix = 'objects/';
 
   bool get canCache {
-    return (_serviceType == 'Class' ||
-            _serviceType == 'Function' ||
-            _serviceType == 'Field') &&
+    return (_type == 'Class' ||
+            _type == 'Function' ||
+            _type == 'Field') &&
            !_id.startsWith(objectIdRingPrefix);
   }
   bool get immutable => false;
 
   ServiceMap._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _upgradeValues() {
     assert(owner != null);
     _upgradeCollection(_map, owner);
   }
@@ skipping 1238 matching lines @@
       metric.reload().then((m) {
         m.addSample(new MetricSample(m.value));
       });
     }
   }
 }
 
 // Convert any ServiceMaps representing a null instance into an actual null.
 _convertNull(obj) {
   if (obj is ServiceMap &&
-      obj.serviceType == 'Null') {
+      obj.type == 'Null') {
     return null;
   }
   return obj;
 }
 
 // Returns true if [map] is a service map. i.e. it has the following keys:
 // 'id' and a 'type'.
 bool _isServiceMap(ObservableMap m) {
   return (m != null) && (m['id'] != null) && (m['type'] != null);
 }
@@ skipping 32 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);
     }
   }
 }