Rename the get* methods in preparation for removing them.

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 369 matching lines @@
         return;
       }
       if (map['type'] != 'ServiceEvent') {
         Logger.root.severe(
             "Expected 'ServiceEvent' but found '${map['type']}'");
         return;
       }
 
       // Extract the owning isolate from the event itself.
       String owningIsolateId = map['isolate']['id'];
-      _getIsolate(owningIsolateId).then((owningIsolate) {
+      getIsolate(owningIsolateId).then((owningIsolate) {
           if (owningIsolate == null) {
             // TODO(koda): Do we care about GC events in VM isolate?
             Logger.root.severe(
                 'Ignoring event with unknown isolate id: $owningIsolateId');
           } else {
             var event = new ServiceObject._fromMap(owningIsolate, map);
             events.add(event);
           }
       });
   }
@@ skipping 18 matching lines @@
     return id.substring(0, m.end);
   }
 
   Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
   Map<String,Isolate> _isolateCache = new Map<String,Isolate>();
 
   ServiceObject getFromMap(ObservableMap map) {
     throw new UnimplementedError();
   }
 
-  Future<ServiceObject> _getIsolate(String isolateId) {
+  // Note that this function does not reload the isolate if it found
+  // in the cache.
+  Future<ServiceObject> getIsolate(String isolateId) {
     if (isolateId == '') {
       return new Future.value(null);
     }
     Isolate isolate = _isolateCache[isolateId];
     if (isolate != null) {
       return new Future.value(isolate);
     }
     // The isolate is not in the cache.  Reload the vm and see if the
     // requested isolate is found.
+    //
+    // TODO(turnidge): We don't want to reload all isolates so much.
+    // Doesn't scale well.  Change this to be more fine-grained.
     return reload().then((result) {
         if (result is! VM) {
           return null;
         }
         assert(result == this);
         return _isolateCache[isolateId];
       });
   }
 
-  Future<ServiceObject> get(String id) {
+  Future<ServiceObject> getDeprecated(String id) {
     assert(id.startsWith('/') == false);
     // Isolates are handled specially, since they can cache sub-objects.
     if (id.startsWith(_isolatesPrefix)) {
       String isolateId = _parseIsolateId(id);
       String objectId = _parseObjectId(id);
-      return _getIsolate(isolateId).then((isolate) {
+      return getIsolate(isolateId).then((isolate) {
         if (isolate == null) {
           // The isolate does not exist.  Return the VM object instead.
           //
           // TODO(turnidge): Generate a service error?
           return this;
         }
         if (objectId == null) {
           return isolate.reload();
         } else {
-          return isolate.get(objectId);
+          return isolate.getDeprecated(objectId);
         }
       });
     }
 
     var obj = _cache[id];
     if (obj != null) {
       return obj.reload();
     }
 
     // Cache miss.  Get the object from the vm directly.
-    return getAsMap(id).then((ObservableMap map) {
+    return _getAsMapDeprecated(id).then((ObservableMap map) {
       var obj = new ServiceObject._fromMap(this, map);
       if (obj.canCache) {
         _cache.putIfAbsent(id, () => obj);
       }
       return obj;
     });
   }
 
   dynamic _reviver(dynamic key, dynamic value) {
     return value;
@@ skipping 44 matching lines @@
           'Observatory is still functioning and you should try your'
           ' action again.',
       'message': 'Could not decode JSON: $e',
     })));
   }
 
   /// Gets [id] as an [ObservableMap] from the service directly. If
   /// an error occurs, the future is completed as an error with a
   /// ServiceError or ServiceException. Therefore any chained then() calls
   /// will only receive a map encoding a valid ServiceObject.
-  Future<ObservableMap> getAsMap(String id) {
-    return getString(id).then((response) {
+  Future<ObservableMap> _getAsMapDeprecated(String id) {
+    return getStringDeprecated(id).then((response) {
       var map = _parseJSON(response);
       if (Tracer.current != null) {
         Tracer.current.trace("Received response for ${id}", map:map);
       }
       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);
   }
 
   /// Get [id] as a [String] from the service directly. See [getAsMap].
-  Future<String> getString(String id);
+  Future<String> getStringDeprecated(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;
+        if (obj.canCache) {
+          _cache.putIfAbsent(id, () => obj);
+        }
+        return obj;
     });
   }
 
   Future<ObservableMap> _fetchDirect() {
     return invokeRpcNoUpgrade('getVM', {});
   }
 
   /// Force the VM to disconnect.
   void disconnect();
   /// Completes when the VM first connects.
@@ skipping 149 matching lines @@
 
   HeapSnapshot(this.isolate, ByteData data) :
       graph = new ObjectGraph(new ReadStream(data)),
       timeStamp = new DateTime.now() {
   }
 
   List<Future<ServiceObject>> getMostRetained({int classId, int limit}) {
     var result = [];
     for (var v in graph.getMostRetained(classId: classId, limit: limit)) {
       var address = v.addressForWordSize(isolate.vm.architectureBits ~/ 8);
-      result.add(isolate.get(
+      result.add(isolate.getDeprecated(
           'address/${address.toRadixString(16)}?ref=true').then((obj) {
         obj.retainedSize = v.retainedSize;
         return new Future(() => obj);
       }));
     }
     return result;
   }
 
 
 }
@@ skipping 115 matching lines @@
       return obj;
     }
     // Build the object from the map directly.
     obj = new ServiceObject._fromMap(this, map);
     if (obj != null && obj.canCache) {
       _cache[id] = obj;
     }
     return obj;
   }
 
-  Future<ServiceObject> get(String id) {
+  Future<ServiceObject> getDeprecated(String id) {
     // Do not allow null ids or empty ids.
     assert(id != null && id != '');
     var obj = _cache[id];
     if (obj != null) {
       return obj.reload();
     }
     // Cache miss.  Get the object from the vm directly.
-    return vm.getAsMap(relativeLink(id)).then((ObservableMap map) {
+    return vm._getAsMapDeprecated(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);
+        var obj = new ServiceObject._fromMap(this, response);
+        if (obj.canCache) {
+          _cache.putIfAbsent(id, () => obj);
+        }
+        return obj;
     });
   }
 
+  Future<ServiceObject> getObject(String objectId) {
+    assert(objectId != null && objectId != '');
+    var obj = _cache[objectId];
+    if (obj != null) {
+      return obj.reload();
+    }
+    Map params = {
+      'objectId': objectId,
+    };
+    return isolate.invokeRpc('getObject', params);
+  }
+
   Future<ObservableMap> _fetchDirect() {
     return invokeRpcNoUpgrade('getIsolate', {});
   }
 
   @observable Class objectClass;
   @observable final rootClasses = new ObservableList<Class>();
 
   @observable Library rootLib;
   @observable ObservableList<Library> libraries =
       new ObservableList<Library>();
@@ skipping 382 matching lines @@
 
   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) {
+    return getDeprecated(id).then((result) {
       if (result is DartError) {
         // TODO(turnidge): Handle this more gracefully.
         Logger.root.severe(result.message);
         return null;
       }
       // Clear metrics map.
       metricsMap.clear();
       // Repopulate metrics map.
       var members = result['members'];
       for (var metric in members) {
@@ skipping 367 matching lines @@
   }
 
   void _addSubclass(Class subclass) {
     if (subclasses.contains(subclass)) {
       return;
     }
     subclasses.add(subclass);
     subclasses.sort(ServiceObject.LexicalSortName);
   }
 
-  Future<ServiceObject> get(String command) {
-    return isolate.get(id + "/$command");
-  }
-
   String toString() => 'Class($vmName)';
 }
 
 class Instance extends ServiceObject {
   @observable Class clazz;
   @observable int size;
   @observable int retainedSize;
   @observable String valueAsString;  // If primitive.
   @observable bool valueAsStringIsTruncated;
   @observable ServiceFunction closureFunc;  // If a closure.
@@ skipping 1079 matching lines @@
       new ObservableList<MetricSample>();
   int _sampleBufferSize = 100;
   int get sampleBufferSize => _sampleBufferSize;
   set sampleBufferSize(int size) {
     _sampleBufferSize = size;
     _removeOld();
   }
 
   Future<ObservableMap> _fetchDirect() {
     // TODO(johnmmccutchan): Make this use json rpc.
-    return vm.getAsMap(link);
+    return vm._getAsMapDeprecated(link);
   }
 
 
   void addSample(MetricSample sample) {
     samples.add(sample);
     _removeOld();
   }
 
   void _removeOld() {
     // TODO(johnmccutchan): If this becomes hot, consider using a circular
@@ skipping 104 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);
     }
   }
 }