Add support for TokenStream, LocalVarDescriptors, and PcDescriptors to service lib and generic obje…

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 105 matching lines @@
   factory ServiceObject._fromMap(ServiceObjectOwner owner,
                                  ObservableMap 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 ? _stripRef(map['_vmType']) : type;
     var obj = null;
     assert(type != 'VM');
     switch (type) {
       case 'Class':
         obj = new Class._empty(owner);
         break;
       case 'Code':
         obj = new Code._empty(owner);
         break;
       case 'Context':
@@ skipping 10 matching lines @@
         break;
       case 'Gauge':
         obj = new ServiceMetric._empty(owner);
         break;
       case 'Isolate':
         obj = new Isolate._empty(owner.vm);
         break;
       case 'Library':
         obj = new Library._empty(owner);
         break;
+      case 'Object':
+        switch (vmType) {
+          case 'PcDescriptors':
+            obj = new PcDescriptors._empty(owner);
+            break;
+          case 'LocalVarDescriptors':
+            obj = new LocalVarDescriptors._empty(owner);
+            break;
+          case 'TokenStream':
+            obj = new TokenStream._empty(owner);
+            break;
+        }
+        break;
       case 'ServiceError':
         obj = new ServiceError._empty(owner);
         break;
       case 'ServiceEvent':
         obj = new ServiceEvent._empty(owner);
         break;
       case 'ServiceException':
         obj = new ServiceException._empty(owner);
         break;
       case 'Script':
         obj = new Script._empty(owner);
         break;
       case 'Socket':
         obj = new Socket._empty(owner);
         break;
       default:
         if (_isInstanceType(type) ||
             type == 'Sentinel') {  // TODO(rmacnak): Separate this out.
           obj = new Instance._empty(owner);
-          break;
-        } else {
-          obj = new ServiceMap._empty(owner);
-          break;
         }
+        break;
+    }
+    if (obj == null) {
+      obj = new ServiceMap._empty(owner);
     }
     obj.update(map);
     return obj;
   }
 
   /// If [this] was created from a reference, load the full object
   /// from the service by calling [reload]. Else, return [this].
   Future<ServiceObject> load() {
     if (loaded) {
       return new Future.value(this);
@@ skipping 1695 matching lines @@
   }
 }
 
 class CodeTick {
   final int address;
   final int exclusiveTicks;
   final int inclusiveTicks;
   CodeTick(this.address, this.exclusiveTicks, this.inclusiveTicks);
 }
 
-
 class PcDescriptor extends Observable {
   final int address;
   @reflectable final int deoptId;
   @reflectable final int tokenPos;
   @reflectable final int tryIndex;
   @reflectable final String kind;
   @observable Script script;
   @observable String formattedLine;
   PcDescriptor(this.address, this.deoptId, this.tokenPos, this.tryIndex,
                this.kind);
@@ skipping 20 matching lines @@
     var line = script.tokenToLine(tokenPos);
     if (line == null) {
       return;
     }
     this.script = script;
     var scriptLine = script.getLine(line);
     formattedLine = scriptLine.text;
   }
 }
 
+class PcDescriptors extends ServiceObject {
+  @observable Class clazz;
+  @observable int size;
+  bool get canCache => false;
+  bool get immutable => true;
+  @reflectable final List<PcDescriptor> descriptors =
+      new ObservableList<PcDescriptor>();
+
+  PcDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner) {
+    print('created PcDescriptors.');
+  }
+
+  void _update(ObservableMap m, bool mapIsRef) {
+    if (mapIsRef) {
+      return;
+    }
+    _upgradeCollection(m, isolate);
+    clazz = m['class'];
+    size = m['size'];
+    descriptors.clear();
+    for (var descriptor in m['members']) {
+      var address = int.parse(descriptor['pc'], radix:16);
+      var deoptId = descriptor['deoptId'];
+      var tokenPos = descriptor['tokenPos'];
+      var tryIndex = descriptor['tryIndex'];
+      var kind = descriptor['kind'].trim();
+      descriptors.add(
+          new PcDescriptor(address, deoptId, tokenPos, tryIndex, kind));
+    }
+  }
+}
+
+class LocalVarDescriptor extends Observable {
+  @reflectable final String name;
+  @reflectable final int index;
+  @reflectable final int beginPos;
+  @reflectable final int endPos;
+  @reflectable final int scopeId;
+  @reflectable final String kind;
+
+  LocalVarDescriptor(this.name, this.index, this.beginPos, this.endPos,
+                     this.scopeId, this.kind);
+}
+
+class LocalVarDescriptors extends ServiceObject {
+  @observable Class clazz;
+  @observable int size;
+  bool get canCache => false;
+  bool get immutable => true;
+  @reflectable final List<LocalVarDescriptor> descriptors =
+        new ObservableList<LocalVarDescriptor>();
+  LocalVarDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  void _update(ObservableMap m, bool mapIsRef) {
+    if (mapIsRef) {
+      return;
+    }
+    _upgradeCollection(m, isolate);
+    clazz = m['class'];
+    size = m['size'];
+    descriptors.clear();
+    for (var descriptor in m['members']) {
+      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(name, index, beginPos, endPos, scopeId, kind));
+    }
+  }
+}
+
+class TokenStream extends ServiceObject {
+  @observable Class clazz;
+  @observable int size;
+  bool get canCache => false;
+  bool get immutable => true;
+
+  @observable String privateKey;
+
+  TokenStream._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  void _update(ObservableMap m, bool mapIsRef) {
+    if (mapIsRef) {
+      return;
+    }
+    _upgradeCollection(m, isolate);
+    clazz = m['class'];
+    size = m['size'];
+    privateKey = m['privateKey'];
+  }
+}
+
 class CodeInstruction extends Observable {
   @observable final int address;
   @observable final String machine;
   @observable final String human;
   @observable CodeInstruction jumpTarget;
   @reflectable List<PcDescriptor> descriptors =
       new ObservableList<PcDescriptor>();
 
   static String formatPercent(num a, num total) {
     var percent = 100.0 * (a / total);
@@ skipping 136 matching lines @@
   @reflectable final callers = new List<CodeCallCount>();
   @reflectable final callees = new List<CodeCallCount>();
   @reflectable final instructions = new ObservableList<CodeInstruction>();
   @reflectable final addressTicks = new ObservableMap<int, CodeTick>();
   @observable String formattedInclusiveTicks = '';
   @observable String formattedExclusiveTicks = '';
   @observable Instance objectPool;
   @observable ServiceFunction function;
   @observable Script script;
   @observable bool isOptimized = false;
-  String name;
-  String vmName;
 
   bool get canCache => true;
   bool get immutable => true;
 
   Code._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   // Reset all data associated with a profile.
   void resetProfileData() {
     totalSamplesInProfile = 0;
     exclusiveTicks = 0;
@@ skipping 457 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);
     }
   }
 }