Add Observatory support for UnlinkedCall, SingleTargetCache and SubtypeTestCache.

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 61 matching lines @@
 
 /// A NetworkRpcException is used to indicate that an rpc has
 /// been canceled due to network error.
 class NetworkRpcException extends RpcException
     implements M.ConnectionException {
   NetworkRpcException(String message) : super(message);
 
   String toString() => 'NetworkRpcException(${message})';
 }
 
-Future<ServiceObject> ignoreNetworkErrors(
-    Object error, [ServiceObject resultOnNetworkError = null]) {
+Future<ServiceObject> ignoreNetworkErrors(Object error,
+    [ServiceObject resultOnNetworkError = null]) {
   if (error is NetworkRpcException) {
     return new Future.value(resultOnNetworkError);
   }
   return new Future.error(error);
 }
 
 class MalformedResponseRpcException extends RpcException {
   MalformedResponseRpcException(String message, this.response) : super(message);
 
   Map response;
@@ skipping 160 matching lines @@
             break;
           case 'MegamorphicCache':
             obj = new MegamorphicCache._empty(owner);
             break;
           case 'ObjectPool':
             obj = new ObjectPool._empty(owner);
             break;
           case 'PcDescriptors':
             obj = new PcDescriptors._empty(owner);
             break;
+          case 'SingleTargetCache':
+            obj = new SingleTargetCache._empty(owner);
+            break;
+          case 'SubtypeTestCache':
+            obj = new SubtypeTestCache._empty(owner);
+            break;
           case 'TokenStream':
             obj = new TokenStream._empty(owner);
             break;
+          case 'UnlinkedCall':
+            obj = new UnlinkedCall._empty(owner);
+            break;
         }
         break;
       case 'Event':
         obj = new ServiceEvent._empty(owner);
         break;
       case 'Script':
         obj = new Script._empty(owner);
         break;
       case 'Socket':
         obj = new Socket._empty(owner);
@@ skipping 595 matching lines @@
 
   Future<ServiceObject> getFlagList() {
     return invokeRpc('getFlagList', {});
   }
 
   Future<ServiceObject> _streamListen(String streamId) {
     Map params = {
       'streamId': streamId,
     };
     // Ignore network errors on stream listen.
-    return invokeRpc('streamListen', params).catchError(
-        (e) => ignoreNetworkErrors(e));
+    return invokeRpc('streamListen', params)
+        .catchError((e) => ignoreNetworkErrors(e));
   }
 
   Future<ServiceObject> _streamCancel(String streamId) {
     Map params = {
       'streamId': streamId,
     };
     // Ignore network errors on stream cancel.
-    return invokeRpc('streamCancel', params).catchError(
-        (e) => ignoreNetworkErrors(e));
+    return invokeRpc('streamCancel', params)
+        .catchError((e) => ignoreNetworkErrors(e));
   }
 
   // A map from stream id to event stream state.
   Map<String, _EventStreamState> _eventStreams = {};
 
   // Well-known stream ids.
   static const kVMStream = 'VM';
   static const kIsolateStream = 'Isolate';
   static const kTimelineStream = 'Timeline';
   static const kDebugStream = 'Debug';
@@ skipping 439 matching lines @@
     }
     if (startPos != null) {
       params['tokenPos'] = startPos;
     }
     if (endPos != null) {
       params['endTokenPos'] = endPos;
     }
     return invokeRpc('getSourceReport', params);
   }
 
-  Future<ServiceMap> reloadSources(
-      {String rootLibUri,
-       bool pause}) {
+  Future<ServiceMap> reloadSources({String rootLibUri, bool pause}) {
     Map<String, dynamic> params = <String, dynamic>{};
     if (rootLibUri != null) {
       params['rootLibUri'] = rootLibUri;
     }
     if (pause != null) {
       params['pause'] = pause;
     }
     return invokeRpc('reloadSources', params).then((result) {
       _cache.clear();
       return result;
@@ skipping 188 matching lines @@
     _chunksInProgress = null;
 
     if (_snapshotFetch != null) {
       _snapshotFetch.add(new RawHeapSnapshot(loadedChunks, event.nodeCount));
       _snapshotFetch.close();
     }
   }
 
   static String _rootsToString(M.HeapSnapshotRoots roots) {
     switch (roots) {
-      case M.HeapSnapshotRoots.user: return "User";
-      case M.HeapSnapshotRoots.vm: return "VM";
+      case M.HeapSnapshotRoots.user:
+        return "User";
+      case M.HeapSnapshotRoots.vm:
+        return "VM";
     }
     return null;
   }
 
   Stream fetchHeapSnapshot(M.HeapSnapshotRoots roots, bool collectGarbage) {
     if (_snapshotFetch == null || _snapshotFetch.isClosed) {
       _snapshotFetch = new StreamController.broadcast();
       // isolate.vm.streamListen('_Graph');
       isolate.invokeRpcNoUpgrade('_requestHeapSnapshot',
-                                 {'roots': _rootsToString(roots),
-                                  'collectGarbage': collectGarbage});
+          {'roots': _rootsToString(roots), 'collectGarbage': collectGarbage});
     }
     return _snapshotFetch.stream;
   }
 
   void updateHeapsFromMap(Map map) {
     newSpace.update(map['new']);
     oldSpace.update(map['old']);
   }
 
   void _update(Map map, bool mapIsRef) {
@@ skipping 60 matching lines @@
     if (savedStartTime == null) {
       vm._buildIsolateList();
     }
 
     extensionRPCs.clear();
     if (map['extensionRPCs'] != null) {
       extensionRPCs.addAll(map['extensionRPCs']);
     }
 
     threads.clear();
-    if(map['_threads'] != null) {
+    if (map['_threads'] != null) {
       threads.addAll(map['_threads']);
     }
 
     int currentMemoryHighWatermark = 0;
     for (var i = 0; i < threads.length; i++) {
       currentMemoryHighWatermark += threads[i].memoryHighWatermark;
     }
 
     if (currentMemoryHighWatermark > _memoryHighWatermark) {
       _memoryHighWatermark = currentMemoryHighWatermark;
@@ skipping 1443 matching lines @@
 
   // TODO(bkonyi): zones will always be empty. See issue #28885.
   List<Zone> get zones => _zones;
   final List<Zone> _zones = new List<Zone>();
 
   Thread._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     String rawKind = map['kind'];
 
-    switch(rawKind) {
+    switch (rawKind) {
       case "kUnknownTask":
         _kind = M.ThreadKind.unknownTask;
         _kindString = 'unknown';
         break;
       case "kMutatorTask":
         _kind = M.ThreadKind.mutatorTask;
         _kindString = 'mutator';
         break;
       case "kCompilerTask":
         _kind = M.ThreadKind.compilerTask;
@@ skipping 629 matching lines @@
 class LocalVarDescriptor implements M.LocalVarDescriptorsRef {
   final String id;
   final String name;
   final int index;
   final int declarationPos;
   final int beginPos;
   final int endPos;
   final int scopeId;
   final String kind;
 
-  LocalVarDescriptor(this.id,
-                     this.name,
-                     this.index,
-                     this.declarationPos,
-                     this.beginPos,
-                     this.endPos,
-                     this.scopeId,
-                     this.kind);
+  LocalVarDescriptor(this.id, this.name, this.index, this.declarationPos,
+      this.beginPos, this.endPos, this.scopeId, this.kind);
 }
 
 class LocalVarDescriptors extends ServiceObject {
   Class clazz;
   int size;
   bool get immutable => true;
   final List<LocalVarDescriptor> descriptors = <LocalVarDescriptor>[];
   LocalVarDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map m, bool mapIsRef) {
@@ skipping 93 matching lines @@
     dartOwner = map['_owner'];
     selector = map['_selector'];
     if (mapIsRef) {
       return;
     }
     argumentsDescriptor = map['_argumentsDescriptor'];
     entries = map['_entries'];
   }
 }
 
+class UnlinkedCall extends HeapObject implements M.UnlinkedCall {
+  String selector;
+  Instance argumentsDescriptor;
+
+  bool get immutable => false;
+
+  UnlinkedCall._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  void _update(Map map, bool mapIsRef) {
+    _upgradeCollection(map, isolate);
+    super._update(map, mapIsRef);
+
+    selector = map['_selector'];
+    if (mapIsRef) {
+      return;
+    }
+    argumentsDescriptor = map['_argumentsDescriptor'];
+  }
+}
+
+class SingleTargetCache extends HeapObject implements M.SingleTargetCache {
+  Code target;
+  int lowerLimit;
+  int upperLimit;
+
+  bool get immutable => false;
+
+  SingleTargetCache._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  void _update(Map map, bool mapIsRef) {
+    _upgradeCollection(map, isolate);
+    super._update(map, mapIsRef);
+
+    target = map['_target'];
+    if (mapIsRef) {
+      return;
+    }
+    lowerLimit = map['_lowerLimit'];
+    upperLimit = map['_upperLimit'];
+  }
+}
+
+class SubtypeTestCache extends HeapObject implements M.SubtypeTestCache {
+  Instance cache;
+
+  bool get immutable => false;
+
+  SubtypeTestCache._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  void _update(Map map, bool mapIsRef) {
+    _upgradeCollection(map, isolate);
+    super._update(map, mapIsRef);
+
+    if (mapIsRef) {
+      return;
+    }
+    cache = map['_cache'];
+  }
+}
+
 class TypeArguments extends HeapObject implements M.TypeArguments {
   HeapObject dartOwner;
   String name;
   Iterable<Instance> types;
 
   TypeArguments._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
@@ skipping 527 matching lines @@
     this.location = map['location'];
     this.code = map['code'];
     this.variables = map['vars'] ?? [];
   }
 
   M.FrameKind _fromString(String frameKind) {
     if (frameKind == null) {
       return M.FrameKind.regular;
     }
     switch (frameKind) {
-      case 'Regular': return M.FrameKind.regular;
-      case 'AsyncCausal': return M.FrameKind.asyncCausal;
-      case 'AsyncSuspensionMarker': return M.FrameKind.asyncSuspensionMarker;
+      case 'Regular':
+        return M.FrameKind.regular;
+      case 'AsyncCausal':
+        return M.FrameKind.asyncCausal;
+      case 'AsyncSuspensionMarker':
+        return M.FrameKind.asyncSuspensionMarker;
       default:
         throw new UnsupportedError('Unknown FrameKind: $frameKind');
     }
   }
 
   String toString() {
     if (function != null) {
       return "Frame([$kind] ${function.qualifiedName} $location)";
     } else if (location != null) {
       return "Frame([$kind] $location)";
     } else {
       return "Frame([$kind])";
     }
   }
 
   Future<String> toUserString() async {
     if (function != null) {
       return "Frame([$kind] ${function.qualifiedName} "
-             "${await location.toUserString()})";
+          "${await location.toUserString()})";
     } else if (location != null) {
       return "Frame([$kind] ${await location.toUserString()}";
     } else {
       return "Frame([$kind])";
     }
   }
 }
 
 class ServiceMessage extends ServiceObject {
   int index;
@@ skipping 97 matching lines @@
     var v = list[i];
     if ((v is Map) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is List) {
       _upgradeList(v, owner);
     } else if (v is Map) {
       _upgradeMap(v, owner);
     }
   }
 }