Improve Code object support in service and observatory

runtime/bin/vmservice/client/lib/src/observatory/request_manager.dart

 // Copyright (c) 2013, 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 observatory;
 
 /// A request response interceptor is called for each response.
 typedef void RequestResponseInterceptor();
 
 abstract class RequestManager extends Observable {
   ObservatoryApplication _application;
   ObservatoryApplication get application => _application;
   RequestResponseInterceptor interceptor;
 
   /// The default request prefix is 127.0.0.1 on port 8181.
   @observable String prefix = 'http://127.0.0.1:8181';
   /// List of responses.
   @observable List<Map> responses = toObservable([]);
 
+  /// Decode [response] into a map.
+  Map decodeResponse(String response) {
+    var m;
+    try {
+      m = JSON.decode(response);
+    } catch (e, st) {
+      setResponseError('$e $st');

[turnidge, 2014/01/17 19:30:21]

What if we returned the error response and checked the type of the response in
the caller instead of checking for null?

[Cutch, 2014/01/17 21:15:42]

I'm going to punt on this because I plan on revisiting this code post summit.

+    };
+    return m;
+  }
+
   /// Parse
   void parseResponses(String responseString) {
-    var r;
-    try {
-      r = JSON.decode(responseString);
-    } catch (e) {
-      setResponseError(e.message);
+    var r = decodeResponse(responseString);
+    if (r == null) {
+      return;
     }
     if (r is Map) {
       setResponses([r]);
     } else {
       setResponses(r);
     }
   }
 
   void setResponses(List<Map> r) {
     responses = toObservable(r);
     if (interceptor != null) {
       interceptor();
     }
   }
 
   void setResponseRequestError(HttpRequest request) {
     String error = '${request.status} ${request.statusText}';
     if (request.status == 0) {
       error = 'No service found. Did you run with --enable-vm-service ?';
     }
     setResponses([{
-      'type': 'RequestError',
+      'type': 'Error',
+      'errorType': 'RequestError',
       'error': error
     }]);
   }
 
   void setResponseError(String message) {
     setResponses([{
       'type': 'Error',
+      'errorType': 'ResponseError',
       'text': message
     }]);
+    Logger.root.severe(message);
   }
 
-  /// Request [requestString] from the VM service. Updates [responses].
+  static final RegExp _codeMatcher = new RegExp(r'/isolates/\d+/code/');
+  static bool isCodeRequest(url) => _codeMatcher.hasMatch(url);
+  static int codeAddressFromRequest(String url) {
+    Match m = _codeMatcher.matchAsPrefix(url);
+    if (m == null) {
+      return 0;
+    }
+    try {
+      var a = int.parse(m.input.substring(m.end), radix: 16);
+      return a;
+    } catch (e) {
+      return 0;
+    }
+  }
+
+  static final RegExp _isolateMatcher = new RegExp(r"/isolates/\d+");
+  static String isolatePrefixFromRequest(String url) {
+    Match m = _isolateMatcher.matchAsPrefix(url);
+    if (m == null) {
+      return null;
+    }
+    return m.input.substring(m.start, m.end);
+  }
+
+  static String isolateIdFromRequest(String url) {
+    var prefix = isolatePrefixFromRequest(url);
+    if (prefix == null) {
+      return null;
+    }
+    // Chop off the '/'.
+    return prefix.substring(1);
+  }
+
+  void _setModelResponse(String type, String modelName, dynamic model) {
+    var response = {
+      'type': type,
+      modelName: model
+    };
+    setResponses([response]);
+  }
+
+  /// Handle 'Code' requests
+  void _getCode(String requestString) {
+    var isolateId = isolateIdFromRequest(requestString);
+    if (isolateId == null) {
+      setResponseError('$isolateId is not an isolate id.');
+      return;
+    }
+    var isolate = _application.isolateManager.getIsolate(isolateId);
+    if (isolate == null) {
+      setResponseError('$isolateId could not be found.');
+      return;
+    }
+    var address = codeAddressFromRequest(requestString);
+    if (address == 0) {
+      setResponseError('$requestString is not a valid code request.');
+      return;
+    }
+    var code = isolate.findCodeByAddress(address);
+    if (code != null) {
+      Logger.root.info(
+          'Found code with 0x${address.toRadixString(16)} in isolate.');
+      _setModelResponse('Code', 'code', code);
+      return;
+    }
+    request(requestString).then((responseString) {
+      var map = decodeResponse(responseString);
+      if (map == null) {
+        return;
+      }
+      assert(map['type'] == 'Code');
+      var code = new Code.fromMap(map);
+      Logger.root.info(
+          'Added code with 0x${address.toRadixString(16)} to isolate.');
+      isolate.codes.add(code);
+      _setModelResponse('Code', 'code', code);
+    }).catchError(_requestCatchError);
+  }
+
+  void _requestCatchError(e, st) {
+    if (e is HttpRequest) {
+      setResponseRequestError(e.target);
+    } else {
+      setResponseError('$e $st');
+    }
+  }
+
+  /// Request [request] from the VM service. Updates [responses].
   /// Will trigger [interceptor] if one is set.
   void get(String requestString) {
+    if (isCodeRequest(requestString)) {
+      _getCode(requestString);
+      return;
+    }
     request(requestString).then((responseString) {
       parseResponses(responseString);
-    }).catchError((e) {
-      setResponseRequestError(e.target);
-      return null;
-    });
+    }).catchError(_requestCatchError);
   }
 
   /// Abstract method. Given the [requestString], return a String in the
   /// future which contains the reply from the VM service.
   Future<String> request(String requestString);
+
+  Future<Map> requestMap(String requestString) {
+    return request(requestString).then((response) {
+      var m = JSON.decode(response);

[turnidge, 2014/01/17 19:30:21]

We don't check for JSON decoding errors as we do above. 

[Cutch, 2014/01/17 21:15:42]

Done.

+      return m;
+    });
+  }
 }
 
 
 class HttpRequestManager extends RequestManager {
   Future<String> request(String requestString) {
+    Logger.root.info('Requesting $requestString');
     return HttpRequest.getString(prefix + requestString);
   }
 }
 
 class PostMessageRequestManager extends RequestManager {
   final Map _outstandingRequests = new Map();
   int _requestSerial = 0;
   PostMessageRequestManager() {
     window.onMessage.listen(_messageHandler);
   }
@@ skipping 24 matching lines @@
     message['query'] = requestString;
     _requestSerial++;
 
     var completer = new Completer();
     _outstandingRequests[idString] = completer;
 
     window.parent.postMessage(JSON.encode(message), '*');
     return completer.future;
   }
 }