Begin migrating the vm service from a rest-style interface to a json-rpc style interface.

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;
 
 /// 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 280 matching lines @@
 
   /// 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 = (type == 'Isolate') ? this : owner;
-      var coverage = new ServiceObject._fromMap(coverageOwner, map);
-      assert(coverage.type == 'CodeCoverage');
-      var coverageList = coverage['coverage'];
-      assert(coverageList != null);
-      processCoverageData(coverageList);
-    });
+    Map params = {};
+    if (this is! Isolate) {
+      params['targetId'] = id;
+    }
+    return isolate.invokeRpcNoUpgrade('getCoverage', params).then(
+        (ObservableMap map) {
+          var coverageOwner = (type == 'Isolate') ? this : owner;
+          var coverage = new ServiceObject._fromMap(coverageOwner, map);
+          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);
 
   /// Builds a [ServiceObject] corresponding to the [id] from [map].
   /// The result may come from the cache.  The result will not necessarily
   /// be [loaded].
@@ skipping 167 matching lines @@
 
   Future<ObservableMap> _processMap(ObservableMap map) {
     // Verify that the top level response is a service map.
     if (!_isServiceMap(map)) {
       return new Future.error(
             new ServiceObject._fromMap(this, toObservable({
         'type': 'ServiceException',
         'id': '',
         'kind': 'FormatException',
         'response': map,
-        'message': 'Top level service responses must be service maps.',
+        'message': 'Top level service responses must be service maps: ${map}.',
       })));
     }
     // Preemptively capture ServiceError and ServiceExceptions.
     if (map['type'] == 'ServiceError') {
       return new Future.error(new ServiceObject._fromMap(this, map));
     } else if (map['type'] == 'ServiceException') {
       return new Future.error(new ServiceObject._fromMap(this, map));
     }
     // map is now guaranteed to be a non-error/exception ServiceObject.
     return new Future.value(map);
@@ skipping 31 matching lines @@
       return new Future.error(error);
     }, test: (e) => e is ServiceError).catchError((exception) {
       // ServiceException, forward to VM's ServiceException stream.
       exceptions.add(exception);
       return new Future.error(exception);
     }, test: (e) => e is ServiceException);
   }
 
   /// Get [id] as a [String] from the service directly. See [getAsMap].
   Future<String> getString(String id);
+
+  // Implemented in subclass.
+  Future<String> invokeRpcRaw(String method, Map params);
+
+  Future<ObservableMap> invokeRpcNoUpgrade(String method, Map params) {
+    return invokeRpcRaw(method, params).then((String response) {
+      var map = _parseJSON(response);
+      if (Tracer.current != null) {
+        Tracer.current.trace("Received response for ${method}/${params}}",
+                             map:map);
+      }
+
+      // Check for ill-formed responses.
+      return _processMap(map);
+    }).catchError((error) {
+
+      // ServiceError, forward to VM's ServiceError stream.
+      errors.add(error);
+      return new Future.error(error);
+    }, test: (e) => e is ServiceError).catchError((exception) {
+
+      // ServiceException, forward to VM's ServiceException stream.
+      exceptions.add(exception);
+      return new Future.error(exception);
+    }, test: (e) => e is ServiceException);
+  }
+
+  Future<ServiceObject> invokeRpc(String method, Map params) {
+    // TODO(turnidge): Once we start implementing "get" requests
+    // through the JsonRpc interface, we will need to start checking the
+    // cache before making the request here.  For now, we just make the
+    // request without bothering with the cache.
+    return invokeRpcNoUpgrade(method, params).then((ObservableMap response) {
+        var obj = new ServiceObject._fromMap(this, response);
+        // TODO(turnidge): Put the object into the cache if we can.
+        return obj;
+    });
+  }
+
   /// Force the VM to disconnect.
   void disconnect();
   /// Completes when the VM first connects.
   Future get onConnect;
   /// Completes when the VM disconnects or there was an error connecting.
   Future get onDisconnect;
 
   void _update(ObservableMap map, bool mapIsRef) {
     if (mapIsRef) {
       return;
@@ skipping 189 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.type == 'Profile');
+    assert(profile.type == 'CpuProfile');
     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 83 matching lines @@
     // Cache miss.  Get the object from the vm directly.
     return vm.getAsMap(relativeLink(id)).then((ObservableMap map) {
       var obj = new ServiceObject._fromMap(this, map);
       if (obj.canCache) {
         _cache.putIfAbsent(id, () => obj);
       }
       return obj;
     });
   }
 
+  Future<ObservableMap> invokeRpcNoUpgrade(String method, Map params) {
+    params['isolate'] = id;
+    return vm.invokeRpcNoUpgrade(method, params);
+  }
+
+
+  Future<ServiceObject> invokeRpc(String method, Map params) {
+    return invokeRpcNoUpgrade(method, params).then((ObservableMap response) {
+      // TODO - needs to cache!!! move to constructor?
+      return new ServiceObject._fromMap(this, response);
+    });
+  }
+
   @observable Class objectClass;
   @observable final rootClasses = new ObservableList<Class>();
 
   @observable Library rootLib;
   @observable ObservableList<Library> libraries =
       new ObservableList<Library>();
   @observable ObservableMap topFrame;
 
   @observable String name;
   @observable String vmName;
@@ skipping 12 matching lines @@
   @observable HeapSnapshot latestSnapshot;
   Completer<HeapSnapshot> _snapshotFetch;
 
   void loadHeapSnapshot(ServiceEvent event) {
     latestSnapshot = new HeapSnapshot(this, event.data);
     _snapshotFetch.complete(latestSnapshot);
   }
 
   Future<HeapSnapshot> fetchHeapSnapshot() {
     if (_snapshotFetch == null || _snapshotFetch.isCompleted) {
-      get('graph');
       _snapshotFetch = new Completer<HeapSnapshot>();
+      isolate.invokeRpcNoUpgrade('requestHeapSnapshot', {});
     }
     return _snapshotFetch.future;
   }
 
   void updateHeapsFromMap(ObservableMap map) {
     newSpace.update(map['new']);
     oldSpace.update(map['old']);
   }
 
   void _update(ObservableMap map, bool mapIsRef) {
@@ skipping 74 matching lines @@
     running = (!_isPaused && map['topFrame'] != null);
     idle = (!_isPaused && map['topFrame'] == null);
     error = map['error'];
 
     libraries.clear();
     libraries.addAll(map['libraries']);
     libraries.sort(ServiceObject.LexicalSortName);
   }
 
   Future<TagProfile> updateTagProfile() {
-    return vm.getAsMap(relativeLink('profile/tag')).then((ObservableMap m) {
-      var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
-      tagProfile._processTagProfile(seconds, m);
-      return tagProfile;
-    });
+    return isolate.invokeRpcNoUpgrade('getTagProfile', {}).then(
+      (ObservableMap map) {
+        var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
+        tagProfile._processTagProfile(seconds, map);
+        return tagProfile;
+      });
   }
 
   @reflectable CodeTrieNode profileTrieRoot;
   // The profile trie is serialized as a list of integers. Each node
   // is recreated by consuming some portion of the list. The format is as
   // follows:
   // [0] index into codeTable of code object.
   // [1] tick count (number of times this stack frame occured).
   // [2] child node count
   // Reading the trie is done by recursively reading the tree depth-first
@@ skipping 27 matching lines @@
     var children = _trieData[_trieDataCursor++];
     // Recursively read child nodes.
     for (var i = 0; i < children; i++) {
       var child = _readTrieNode(codeTable);
       node.children.add(child);
       node.summedChildCount += child.count;
     }
     return node;
   }
 
+  // TODO(turnidge): Make this an ObservableList instead.
   ServiceMap breakpoints;
 
   void _removeBreakpoint(ServiceMap bpt) {
     var script = bpt['location']['script'];
     var tokenPos = bpt['location']['tokenPos'];
     assert(tokenPos != null);
     if (script.loaded) {
       var line = script.tokenToLine(tokenPos);
       assert(line != null);
-      assert(script.lines[line - 1].bpt == bpt);
-      script.lines[line - 1].bpt = null;
+      if (script.lines[line - 1] != null) {
+        assert(script.lines[line - 1].bpt == bpt);
+        script.lines[line - 1].bpt = null;
+      }
     }
   }
 
   void _addBreakpoint(ServiceMap bpt) {
     var script = bpt['location']['script'];
     var tokenPos = bpt['location']['tokenPos'];
     assert(tokenPos != null);
     if (script.loaded) {
       var line = script.tokenToLine(tokenPos);
       assert(line != null);
@@ skipping 21 matching lines @@
     breakpoints = newBreakpoints;
   }
 
   Future<ServiceObject> _inProgressReloadBpts;
 
   Future reloadBreakpoints() {
     // TODO(turnidge): Can reusing the Future here ever cause us to
     // get stale breakpoints?
     if (_inProgressReloadBpts == null) {
       _inProgressReloadBpts =
-          get('debug/breakpoints').then((newBpts) {
+          invokeRpc('getBreakpoints', {}).then((newBpts) {
               _updateBreakpoints(newBpts);
           }).whenComplete(() {
               _inProgressReloadBpts = null;
           });
     }
     return _inProgressReloadBpts;
   }
 
-  Future<ServiceObject> setBreakpoint(Script script, int line) {
-    return get(script.id + "/setBreakpoint?line=${line}").then((result) {
-        if (result is DartError) {
+  Future<ServiceObject> addBreakpoint(Script script, int line) {
+    // TODO(turnidge): Pass line as an int instead of a string.
+    return invokeRpc('addBreakpoint',
+                     { 'script': script.id, 'line': '$line' }).then((result) {
+        if (result is ServiceMap &&
+            result.type == 'Breakpoint' &&
+            result['resolved'] &&
+            script.loaded &&
+            script.tokenToLine(result['location']['tokenPos']) != line) {
           // Unable to set a breakpoint at desired line.
           script.lines[line - 1].possibleBpt = false;
         }
-        return reloadBreakpoints();
+        // TODO(turnidge): Instead of reloading all of the breakpoints,
+        // rely on events to update the breakpoint list.
+        return reloadBreakpoints().then((_) {
+            return result;
+        });
       });
   }
 
-  Future clearBreakpoint(ServiceMap bpt) {
-    return get('${bpt.id}/clear').then((result) {
+  Future removeBreakpoint(ServiceMap bpt) {
+    return invokeRpc('removeBreakpoint',
+                     { 'breakpointId': bpt.id }).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
         if (pauseEvent != null &&
             pauseEvent.breakpoint != null &&
             (pauseEvent.breakpoint['id'] == bpt['id'])) {
           return isolate.reload();
         } else {
           return reloadBreakpoints();
         }
       });
   }
 
   Future pause() {
-    return get("debug/pause").then((result) {
+    return invokeRpc('pause', {}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
         return isolate.reload();
       });
   }
 
   Future resume() {
-    return get("debug/resume").then((result) {
+    return invokeRpc('resume', {}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
         return isolate.reload();
       });
   }
 
   Future stepInto() {
-    return get("debug/resume?step=into").then((result) {
+    return invokeRpc('resume', {'step': 'into'}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
         return isolate.reload();
       });
   }
 
   Future stepOver() {
-    return get("debug/resume?step=over").then((result) {
+    return invokeRpc('resume', {'step': 'over'}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
         return isolate.reload();
       });
   }
 
   Future stepOut() {
-    return get("debug/resume?step=out").then((result) {
+    return invokeRpc('resume', {'step': 'out'}).then((result) {
         if (result is DartError) {
           // TODO(turnidge): Handle this more gracefully.
           Logger.root.severe(result.message);
         }
         return isolate.reload();
       });
   }
 
+  Future<ServiceMap> getStack() {
+    return invokeRpc('getStack', {}).then((result) {
+        if (result is DartError) {
+          // TODO(turnidge): Handle this more gracefully.
+          Logger.root.severe(result.message);
+        }
+        return result;
+      });
+  }
+
+  Future<ServiceObject> eval(ServiceObject target,
+                             String expression) {
+    Map params = {
+      'targetId': target.id,
+      'expression': expression,
+    };
+    return invokeRpc('eval', params);
+  }
+
+  Future<ServiceObject> getRetainedSize(ServiceObject target) {
+    Map params = {
+      'targetId': target.id,
+    };
+    return invokeRpc('getRetainedSize', params);
+  }
+
+  Future<ServiceObject> getRetainingPath(ServiceObject target, var limit) {
+    Map params = {
+      'targetId': target.id,
+      'limit': limit.toString(),
+    };
+    return invokeRpc('getRetainingPath', params);
+  }
+
+  Future<ServiceObject> getInboundReferences(ServiceObject target, var limit) {
+    Map params = {
+      'targetId': target.id,
+      'limit': limit.toString(),
+    };
+    return invokeRpc('getInboundReferences', params);
+  }
+
+  Future<ServiceObject> getInstances(Class cls, var limit) {
+    Map params = {
+      'classId': cls.id,
+      'limit': limit.toString(),
+    };
+    return invokeRpc('getInstances', params);
+  }
+
   final ObservableMap<String, ServiceMetric> dartMetrics =
       new ObservableMap<String, ServiceMetric>();
 
   final ObservableMap<String, ServiceMetric> vmMetrics =
       new ObservableMap<String, ServiceMetric>();
 
   Future<ObservableMap<String, ServiceMetric>> _refreshMetrics(
       String id,
       ObservableMap<String, ServiceMetric> metricsMap) {
     return get(id).then((result) {
@@ skipping 1211 matching lines @@
 
 
   static String formatPercent(num a, num total) {
     var percent = 100.0 * (a / total);
     return '${percent.toStringAsFixed(2)}%';
   }
 
   void updateProfileData(Map profileData,
                          List<Code> codeTable,
                          int sampleCount) {
-    // Assert we have a CodeRegion entry.
-    assert(profileData['type'] == 'CodeRegion');
     // Assert we are handed profile data for this code object.
     assert(profileData['code'] == this);
     totalSamplesInProfile = sampleCount;
     inclusiveTicks = int.parse(profileData['inclusive_ticks']);
     exclusiveTicks = int.parse(profileData['exclusive_ticks']);
     _resolveCalls(callers, profileData['callers'], codeTable);
     _resolveCalls(callees, profileData['callees'], codeTable);
     var ticks = profileData['ticks'];
     if (ticks != null) {
       _processTicks(ticks);
@@ skipping 324 matching lines @@
 _convertNull(obj) {
   if (obj.isNull) {
     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);
+  return (m != null) && (m['type'] != null);
 }
 
 bool _hasRef(String type) => type.startsWith('@');
 String _stripRef(String type) => (_hasRef(type) ? type.substring(1) : type);
 
 /// Recursively upgrades all [ServiceObject]s inside [collection] which must
 /// be an [ObservableMap] or an [ObservableList]. Upgraded elements will be
 /// associated with [vm] and [isolate].
 void _upgradeCollection(collection, ServiceObjectOwner owner) {
   if (collection is ServiceMap) {
@@ skipping 23 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);
     }
   }
 }