Allow users to see more elements of a list/map in Observatory.

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 269 matching lines @@
   Future<ServiceObject> load() {
     if (loaded) {
       return new Future.value(this);
     }
     // Call reload which will fill in the entire object.
     return reload();
   }
 
   Future<ServiceObject> _inProgressReload;
 
-  Future<ObservableMap> _fetchDirect() {
+  Future<ObservableMap> _fetchDirect({int count: kDefaultFieldLimit}) {
     Map params = {
       'objectId': id,
-      'count': kDefaultFieldLimit,
+      'count': count,
     };
     return isolate.invokeRpcNoUpgrade('getObject', params);
   }
 
   /// Reload [this]. Returns a future which completes to [this] or
   /// an exception.
-  Future<ServiceObject> reload() {
+  Future<ServiceObject> reload({int count: kDefaultFieldLimit}) {
     // TODO(turnidge): Checking for a null id should be part of the
     // "immmutable" check.
     bool hasId = (id != null) && (id != '');
     bool isVM = this is VM;
     // We should always reload the VM.
     // We can't reload objects without an id.
     // We shouldn't reload an immutable and already loaded object.
     bool skipLoad = !isVM && (!hasId || (immutable && loaded));
     if (skipLoad) {
       return new Future.value(this);
     }
     if (_inProgressReload == null) {
       var completer = new Completer<ServiceObject>();
       _inProgressReload = completer.future;
-      _fetchDirect().then((ObservableMap map) {
+      _fetchDirect(count: count).then((ObservableMap map) {
         var mapType = _stripRef(map['type']);
         if (mapType == 'Sentinel') {
           // An object may have been collected, etc.
           completer.complete(new ServiceObject._fromMap(owner, map));
         } else {
           // TODO(turnidge): Check for vmType changing as well?
           assert(mapType == _type);
           update(map);
           completer.complete(this);
         }
@@ skipping 473 matching lines @@
     var isolate = event.isolate;
     if (isolate != null) {
       isolate._onEvent(event);
     }
   }
 
   Future restart() {
     return invokeRpc('_restartVM', {});
   }
 
-  Future<ObservableMap> _fetchDirect() async {
+  Future<ObservableMap> _fetchDirect({int count: kDefaultFieldLimit}) async {
     if (!loaded) {
       // The vm service relies on these events to keep the VM and
       // Isolate types up to date.
       try {
         await listenEventStream(kVMStream, _dispatchEventToIsolate);
         await listenEventStream(kIsolateStream, _dispatchEventToIsolate);
         await listenEventStream(kDebugStream, _dispatchEventToIsolate);
         await listenEventStream(_kGraphStream, _dispatchEventToIsolate);
       } on FakeVMRpcException catch (_) {
         // ignore FakeVMRpcExceptions here.
@@ skipping 461 matching lines @@
     params['isolateId'] = id;
     return vm.invokeRpcNoUpgrade(method, params);
   }
 
   Future<ServiceObject> invokeRpc(String method, Map params) {
     return invokeRpcNoUpgrade(method, params).then((ObservableMap response) {
       return getFromMap(response);
     });
   }
 
-  Future<ServiceObject> getObject(String objectId, {bool reload: true}) {
+  Future<ServiceObject> getObject(String objectId,
+                                  {bool reload: true,
+                                   int count: kDefaultFieldLimit}) {
     assert(objectId != null && objectId != '');
     var obj = _cache[objectId];
     if (obj != null) {
       if (reload) {
-        return obj.reload();
+        return obj.reload(count: count);
       }
       // Returned cached object.
       return new Future.value(obj);
     }
     Map params = {
       'objectId': objectId,
-      'count': kDefaultFieldLimit,
+      'count': count,
     };
     return isolate.invokeRpc('getObject', params);
   }
 
-  Future<ObservableMap> _fetchDirect() {
+  Future<ObservableMap> _fetchDirect({int count: kDefaultFieldLimit}) async {
     return invokeRpcNoUpgrade('getIsolate', {});
   }
 
   @observable Class objectClass;
   @observable final rootClasses = new ObservableList<Class>();
   Map<int, Class> _classesByCid = new Map<int, Class>();
 
   @observable Library rootLibrary;
   @observable ObservableList<Library> libraries =
       new ObservableList<Library>();
@@ skipping 2234 matching lines @@
         script.load().then(_updateDescriptors);
       });
       return;
     }
     // Load the script and then update descriptors.
     function.location.script.load().then(_updateDescriptors);
   }
 
   /// Reload [this]. Returns a future which completes to [this] or an
   /// exception.
-  Future<ServiceObject> reload() {
+  Future<ServiceObject> reload({int count: kDefaultFieldLimit}) {
     assert(kind != null);
     if (isDartCode) {
       // We only reload Dart code.
-      return super.reload();
+      return super.reload(count: count);
     }
     return new Future.value(this);
   }
 
   void _update(ObservableMap m, bool mapIsRef) {
     name = m['name'];
     vmName = (m.containsKey('_vmName') ? m['_vmName'] : name);
     isOptimized = m['_optimized'];
     kind = CodeKind.fromString(m['kind']);
     hasIntrinsic = m['_intrinsic'];
@@ skipping 260 matching lines @@
 
   final ObservableList<MetricSample> samples =
       new ObservableList<MetricSample>();
   int _sampleBufferSize = 100;
   int get sampleBufferSize => _sampleBufferSize;
   set sampleBufferSize(int size) {
     _sampleBufferSize = size;
     _removeOld();
   }
 
-  Future<ObservableMap> _fetchDirect() {
+  Future<ObservableMap> _fetchDirect({int count: kDefaultFieldLimit}) {
     assert(owner is Isolate);
     return isolate.invokeRpcNoUpgrade('_getIsolateMetric', { 'metricId': id });
   }
 
 
   void addSample(MetricSample sample) {
     samples.add(sample);
     _removeOld();
   }
 
@@ skipping 186 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);
     }
   }
 }