Do not JSON encode the 'result' of a service rpc.

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] represents a persistent object within the vm.
 abstract class ServiceObject extends Observable {
   static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
     return o1.name.compareTo(o2.name);
@@ skipping 351 matching lines @@
     update(toObservable({'id':'vm', 'type':'@VM'}));
   }
 
   final StreamController<ServiceException> exceptions =
       new StreamController.broadcast();
   final StreamController<ServiceError> errors =
       new StreamController.broadcast();
   final StreamController<ServiceEvent> events =
       new StreamController.broadcast();
 
-  void postServiceEvent(String response, ByteData data) {
-    var map;
-    try {
-      map = _parseJSON(response);
-      assert(!map.containsKey('_data'));
-      if (data != null) {
-        map['_data'] = data;
-      }
-    } catch (_) {
-      Logger.root.severe('Ignoring malformed event response: ${response}');
-      return;
+  void postServiceEvent(Map response, ByteData data) {
+    var map = toObservable(response);
+    assert(!map.containsKey('_data'));
+    if (data != null) {
+      map['_data'] = data;
     }
     if (map['type'] != 'ServiceEvent') {
       Logger.root.severe(
           "Expected 'ServiceEvent' but found '${map['type']}'");
       return;
     }
 
     var eventIsolate = map['isolate'];
     if (eventIsolate == null) {
       var event = new ServiceObject._fromMap(vm, map);
@@ skipping 65 matching lines @@
   // Note that this function does not reload the isolate if it found
   // in the cache.
   Future<ServiceObject> getIsolate(String isolateId) {
     if (!loaded) {
       // Trigger a VM load, then get the isolate.
       return load().then((_) => getIsolate(isolateId)).catchError(_ignoreError);
     }
     return new Future.value(_isolateCache[isolateId]);
   }
 
-  dynamic _reviver(dynamic key, dynamic value) {
-    return value;
-  }
-
-  ObservableMap _parseJSON(String response) {
-    var map;
-    try {
-      var decoder = new JsonDecoder(_reviver);
-      map = decoder.convert(response);
-    } catch (e) {
-      return toObservable({
-        'type': 'ServiceException',
-        'kind': 'JSONDecodeException',
-        'response': map,
-        'message': 'Could not decode JSON: $e',
-      });
-    }
-    return toObservable(map);
-  }
-
   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',
         'kind': 'ResponseFormatException',
         'response': map,
         'message': 'Top level service responses must be service maps: ${map}.',

[Cutch, 2015/04/21 23:38:53]

Drop the ${map} it is included as 'response'.

'message': 'Top level service response missing 'type' field.'

[turnidge, 2015/04/23 17:51:59]

Done.

       })));
     }
     // 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);
   }
 
   // Implemented in subclass.
-  Future<String> invokeRpcRaw(String method, Map params);
+  Future<Map> invokeRpcRaw(String method, Map params);
 
   Future<ObservableMap> invokeRpcNoUpgrade(String method, Map params) {
-    return invokeRpcRaw(method, params).then((String response) {
-      var map = _parseJSON(response);
+    return invokeRpcRaw(method, params).then((Map response) {
+      var map = toObservable(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.
@@ skipping 877 matching lines @@
   static const kPauseExit          = 'PauseExit';
   static const kPauseBreakpoint    = 'PauseBreakpoint';
   static const kPauseInterrupted   = 'PauseInterrupted';
   static const kPauseException     = 'PauseException';
   static const kResume             = 'Resume';
   static const kBreakpointAdded    = 'BreakpointAdded';
   static const kBreakpointResolved = 'BreakpointResolved';
   static const kBreakpointRemoved  = 'BreakpointRemoved';
   static const kGraph              = '_Graph';
   static const kGC                 = 'GC';
-  static const kVMDisconnected     = 'VMDisconnected';
+  static const kConnectionClosed   = 'ConnectionClosed';
 
   ServiceEvent._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  ServiceEvent.vmDisconencted() : super._empty(null) {
-    eventType = kVMDisconnected;
+  ServiceEvent.connectionClosed(this.reason) : super._empty(null) {
+    eventType = kConnectionClosed;
   }
 
   @observable String eventType;
   @observable Breakpoint breakpoint;
   @observable ServiceMap topFrame;
   @observable ServiceMap exception;
   @observable ByteData data;
   @observable int count;
+  @observable String reason;
 
   void _update(ObservableMap map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
     assert(map['isolate'] == null || owner == map['isolate']);
     eventType = map['eventType'];
     name = 'ServiceEvent $eventType';
     vmName = name;
     if (map['breakpoint'] != null) {
       breakpoint = map['breakpoint'];
@@ skipping 1509 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);
     }
   }
 }