Add Observatory support for UnlinkedCall, SingleTargetCache and SubtypeTestCache.

runtime/observatory/lib/src/service/object.dart

Index: runtime/observatory/lib/src/service/object.dart
diff --git a/runtime/observatory/lib/src/service/object.dart b/runtime/observatory/lib/src/service/object.dart
index 954f24e6a55799ead125c570499d447097bb3dcc..9e54b4aac7339c64025b3afc7f022bfcf5131590 100644
--- a/runtime/observatory/lib/src/service/object.dart
+++ b/runtime/observatory/lib/src/service/object.dart
@@ -79,8 +79,8 @@ class NetworkRpcException extends RpcException
   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);
   }
@@ -261,9 +261,18 @@ abstract class ServiceObject {
           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':
@@ -879,8 +888,8 @@ abstract class VM extends ServiceObjectOwner implements M.VM {
       '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) {
@@ -888,8 +897,8 @@ abstract class VM extends ServiceObjectOwner implements M.VM {
       '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.
@@ -1349,9 +1358,7 @@ class Isolate extends ServiceObjectOwner implements M.Isolate {
     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;
@@ -1560,8 +1567,10 @@ class Isolate extends ServiceObjectOwner implements M.Isolate {
 
   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;
   }
@@ -1571,8 +1580,7 @@ class Isolate extends ServiceObjectOwner implements M.Isolate {
       _snapshotFetch = new StreamController.broadcast();
       // isolate.vm.streamListen('_Graph');
       isolate.invokeRpcNoUpgrade('_requestHeapSnapshot',
-                                 {'roots': _rootsToString(roots),
-                                  'collectGarbage': collectGarbage});
+          {'roots': _rootsToString(roots), 'collectGarbage': collectGarbage});
     }
     return _snapshotFetch.stream;
   }
@@ -1653,7 +1661,7 @@ class Isolate extends ServiceObjectOwner implements M.Isolate {
     }
 
     threads.clear();
-    if(map['_threads'] != null) {
+    if (map['_threads'] != null) {
       threads.addAll(map['_threads']);
     }
 
@@ -3117,7 +3125,7 @@ class Thread extends ServiceObject implements M.Thread {
   void _update(Map map, bool mapIsRef) {
     String rawKind = map['kind'];
 
-    switch(rawKind) {
+    switch (rawKind) {
       case "kUnknownTask":
         _kind = M.ThreadKind.unknownTask;
         _kindString = 'unknown';
@@ -3767,14 +3775,8 @@ class LocalVarDescriptor implements M.LocalVarDescriptorsRef {
   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 {
@@ -3888,6 +3890,66 @@ class ICData extends HeapObject implements M.ICData {
   }
 }
 
+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;
@@ -4435,9 +4497,12 @@ class Frame extends ServiceObject implements M.Frame {
       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');
     }
@@ -4456,7 +4521,7 @@ class Frame extends ServiceObject implements M.Frame {
   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 {