Sundry service protocol cleanups before version 1.0.

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;
 
 /// An RpcException represents an exceptional event that happened
 /// while invoking an rpc.
 abstract class RpcException implements Exception {
   RpcException(this.message);
@@ skipping 1235 matching lines @@
 
   Future<ServiceObject> _eval(ServiceObject target,
                               String expression) {
     Map params = {
       'targetId': target.id,
       'expression': expression,
     };
     return invokeRpc('evaluate', params);
   }
 
-  Future<ServiceObject> evalFrame(int framePos,
+  Future<ServiceObject> evalFrame(int frameIndex,
                                   String expression) {
     Map params = {
-      'frame': framePos,
+      'frameIndex': frameIndex,
       'expression': expression,
     };
     return invokeRpc('evaluateInFrame', params);
   }
 
   Future<ServiceObject> getRetainedSize(ServiceObject target) {
     Map params = {
       'targetId': target.id,
     };
     return invokeRpc('_getRetainedSize', params);
@@ skipping 135 matching lines @@
   Stream<List<ChangeRecord>> get changes => _map.changes;
   bool get hasObservers => _map.hasObservers;
 
   String toString() => "ServiceMap($_map)";
 }
 
 /// A [DartError] is peered to a Dart Error object.
 class DartError extends ServiceObject {
   DartError._empty(ServiceObject owner) : super._empty(owner);
 
-  @observable String kind;
   @observable String message;
   @observable Instance exception;
   @observable Instance stacktrace;
 
   void _update(ObservableMap map, bool mapIsRef) {
-    kind = map['kind'];
     message = map['message'];
     exception = new ServiceObject._fromMap(owner, map['exception']);
     stacktrace = new ServiceObject._fromMap(owner, map['stacktrace']);
-    name = 'DartError $kind';
+    name = 'DartError($message)';
     vmName = name;
   }
 
   String toString() => 'DartError($message)';
 }
 
 /// A [ServiceEvent] is an asynchronous event notification from the vm.
 class ServiceEvent extends ServiceObject {
   /// The possible 'eventType' values.
   static const kIsolateStart       = 'IsolateStart';
@@ skipping 295 matching lines @@
     if (map['library'] is Library) {
       library = map['library'];
     } else {
       library = null;
     }
 
     script = map['script'];
 
     isAbstract = map['abstract'];
     isConst = map['const'];
-    isFinalized = map['finalized'];
-    isPatch = map['patch'];
-    isImplemented = map['implemented'];
+    isFinalized = map['_finalized'];
+    isPatch = map['_patch'];
+    isImplemented = map['_implemented'];
 
     tokenPos = map['tokenPos'];
     endTokenPos = map['endTokenPos'];
 
     subclasses.clear();
     subclasses.addAll(map['subclasses']);
     subclasses.sort(ServiceObject.LexicalSortName);
 
     interfaces.clear();
     interfaces.addAll(map['interfaces']);
     interfaces.sort(ServiceObject.LexicalSortName);
 
     fields.clear();
     fields.addAll(map['fields']);
     fields.sort(ServiceObject.LexicalSortName);
 
     functions.clear();
     functions.addAll(map['functions']);
     functions.sort(ServiceObject.LexicalSortName);
 
     superclass = map['super'];
     // Work-around Object not tracking its subclasses in the VM.
     if (superclass != null && superclass.name == "Object") {
       superclass._addSubclass(this);
     }
     error = map['error'];
 
-    var allocationStats = map['allocationStats'];
+    var allocationStats = map['_allocationStats'];
     if (allocationStats != null) {
       newSpace.update(allocationStats['new']);
       oldSpace.update(allocationStats['old']);
       notifyPropertyChange(#hasNoAllocations, 0, 1);
       promotedByLastNewGC.instances = allocationStats['promotedInstances'];
       promotedByLastNewGC.bytes = allocationStats['promotedBytes'];
     }
   }
 
   void _addSubclass(Class subclass) {
@@ skipping 46 matching lines @@
     valueAsStringIsTruncated = map['valueAsStringIsTruncated'] == true;
     function = map['function'];
     context = map['context'];
     name = map['name'];
     length = map['length'];
 
     if (mapIsRef) {
       return;
     }
 
-    nativeFields = map['nativeFields'];
+    nativeFields = map['_nativeFields'];
     fields = map['fields'];
     elements = map['elements'];
     typeClass = map['type_class'];
     userName = map['user_name'];
     referent = map['referent'];
     key = map['key'];
     value = map['value'];
 
     // We are fully loaded.
     _loaded = true;
@@ skipping 128 matching lines @@
 
   ServiceFunction._empty(ServiceObject owner) : super._empty(owner);
 
   void _update(ObservableMap map, bool mapIsRef) {
     name = map['name'];
     vmName = (map.containsKey('vmName') ? map['vmName'] : name);
 
     _upgradeCollection(map, isolate);
 
     dartOwner = map['owner'];
-    kind = FunctionKind.fromJSON(map['kind']);
+    kind = FunctionKind.fromJSON(map['_kind']);
     isDart = !kind.isSynthetic();
 
     if (dartOwner is ServiceFunction) {
       ServiceFunction ownerFunction = dartOwner;
       library = ownerFunction.library;
       qualifiedName = "${ownerFunction.qualifiedName}.${name}";
 
     } else if (dartOwner is Class) {
       Class ownerClass = dartOwner;
       library = ownerClass.library;
@@ skipping 25 matching lines @@
 
 
 class Field extends ServiceObject {
   // Library or Class.
   @observable ServiceObject dartOwner;
   @observable Library library;
   @observable Instance declaredType;
   @observable bool isStatic;
   @observable bool isFinal;
   @observable bool isConst;
-  @observable Instance value;
+  @observable Instance staticValue;
   @observable String name;
   @observable String vmName;
 
   @observable bool guardNullable;
   @observable String guardClass;
   @observable String guardLength;
   @observable Script script;
   @observable int tokenPos;
 
   Field._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(ObservableMap map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
 
     name = map['name'];
     vmName = (map.containsKey('vmName') ? map['vmName'] : name);
     dartOwner = map['owner'];
     declaredType = map['declaredType'];
     isStatic = map['static'];
     isFinal = map['final'];
     isConst = map['const'];
-    value = map['value'];
+    staticValue = map['staticValue'];
 
     if (dartOwner is Class) {
       Class ownerClass = dartOwner;
       library = ownerClass.library;
 
     } else {
       library = dartOwner;
     }
 
     if (mapIsRef) {
@@ skipping 1092 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);
     }
   }
 }