Converted Observatory class-view element

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 249 matching lines @@
         break;
       case 'Script':
         obj = new Script._empty(owner);
         break;
       case 'Socket':
         obj = new Socket._empty(owner);
         break;
       case 'Sentinel':
         obj = new Sentinel._empty(owner);
         break;
+      case 'InstanceSet':
+        obj = new InstanceSet._empty(owner);
+        break;
       case 'TypeArguments':
         obj = new TypeArguments._empty(owner);
         break;
       case 'Instance':
         obj = new Instance._empty(owner);
         break;
       default:
         break;
     }
     if (obj == null) {
@@ skipping 124 matching lines @@
       }
     }
 
     if (mapIsRef) {
       return;
     }
     size = map['size'];
   }
 }
 
+class RetainingObject implements M.RetainingObject {
+  int get retainedSize => object.retainedSize;
+  final HeapObject object;
+  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);
 }
 
@@ skipping 1893 matching lines @@
 class AllocationCount extends Observable implements M.AllocationCount {
   @observable int instances = 0;
   @observable int bytes = 0;
 
   void reset() {
     instances = 0;
     bytes = 0;
   }
 
   bool get empty => (instances == 0) && (bytes == 0);
+  bool get notEmpty => (instances != 0) || (bytes != 0);
 }
 
-class Allocations implements M.Allocations{
+class Allocations implements M.Allocations {
   // Indexes into VM provided array. (see vm/class_table.h).
   static const ALLOCATED_BEFORE_GC = 0;
   static const ALLOCATED_BEFORE_GC_SIZE = 1;
   static const LIVE_AFTER_GC = 2;
   static const LIVE_AFTER_GC_SIZE = 3;
   static const ALLOCATED_SINCE_GC = 4;
   static const ALLOCATED_SINCE_GC_SIZE = 5;
   static const ACCUMULATED = 6;
   static const ACCUMULATED_SIZE = 7;
 
   final AllocationCount accumulated = new AllocationCount();
   final AllocationCount current = new AllocationCount();
 
   void update(List stats) {
     accumulated.instances = stats[ACCUMULATED];
     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;
 
   @observable bool isAbstract;
   @observable bool isConst;
   @observable bool isFinalized;
   @observable bool isPatch;
   @observable bool isImplemented;
 
   @observable SourceLocation location;
 
   @observable DartError error;
   @observable 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>();
 
   @observable Class superclass;
   @reflectable final interfaces = new ObservableList<Instance>();
   @reflectable final subclasses = new ObservableList<Class>();
 
   @observable Instance superType;
@@ skipping 641 matching lines @@
     _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'];
     isConst = map['const'];
-    staticValue = map['staticValue'];
 
     if (dartOwner is Class) {
       Class ownerClass = dartOwner;
       library = ownerClass.library;
 
     } else {
       library = dartOwner;
     }
 
     if (mapIsRef) {
       return;
     }
+    staticValue = map['staticValue'];
 
     guardNullable = map['_guardNullable'];
     if (map['_guardClass'] is Class) {
         guardClass = map['_guardClass'];
         guardClassKind = M.GuardClassKind.single;
     } else {
       switch (map['_guardClass']) {
         case 'various':
           guardClassKind = M.GuardClassKind.dynamic;
           break;
@@ skipping 681 matching lines @@
 
     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) {
+    _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;
 
   bool get immutable => false;
 
   MegamorphicCache._empty(ServiceObjectOwner owner) : super._empty(owner);
 
@@ skipping 664 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);
     }
   }
 }