anchor.diff:      if (gc != null) {
         params['gc'] = 'full';
       }
  -    return _connection
  -        .request('getAllocationProfile', params)
  -        .then((resp) => new AllocationProfile.fromJson(resp));
  -  }
  -
  -  Future getCoverage(String isolateId, {String targetId}) {
  +    var response = await _connection.request('getAllocationProfile', params);
  +    return new AllocationProfile.fromJson(response);
  +  }
  +
  +  Future getCoverage(String isolateId, {String targetId}) async {
       var params = {'isolateId': isolateId};
       if (targetId != null) {
         params['targetId'] = targetId;
       }
  -    return _connection
  -        .request('getCoverage', params)
  -        .then((resp) => new CodeCoverage.fromJson(resp));
  +    var response = await _connection.request('getCoverage', params);
  +    return new CodeCoverage.fromJson(response);
     }
   
     Future resume(String isolateId) =>
         _connection.request('resume', {'isolateId': isolateId});
   
  -  static Future<VMService> connect(String host, int port) {
  +  static Future<VMService> connect(String host, int port) async {
       _log.fine('Connecting to host $host on port $port');
   
       // For pre-1.9.0 VM versions attempt to detect if we're talking to a
       // Chromium remote debugging port or the VM observatory.
       var doDetect = new RegExp(r'^1\.[4-8]\.').hasMatch(Platform.version);
       if (doDetect) {
  -      return http.get('http://$host:$port/json').then((resp) {
  -        var json = JSON.decode(resp.body);
  -        if (json is List) {
  -          return connectToDevtools(host, port);
  -        }
  -        return connectToVM(host, port);
  -      });
  +      var response = await http.get('http://$host:$port/json');
  +      var json = JSON.decode(response.body);
  +      if (json is List) {
  +        return connectToDevtools(host, port);
  +      }
  +      return connectToVM(host, port);
       }
   
       // For VM versions >=1.9.0, always connect via websocket protocol.
       return connectToVMWebsocket(host, port);
     }
   
  -  static Future<VMService> connectToVM(String host, int port) {
  -    return _VMConnection.connect(host, port).then((c) => new VMService._(c));
  -  }
  -
  -  static Future<VMService> connectToVMWebsocket(String host, int port) {
  -    return _VMWebsocketConnection
  -        .connect(host, port)
  -        .then((c) => new VMService._(c));
  -  }
  -
  -  static Future<VMService> connectToDevtools(String host, int port) {
  -    return _DevtoolsConnection
  -        .connect(host, port)
  -        .then((c) => new VMService._(c));
  +  static Future<VMService> connectToVM(String host, int port) async {
  +    var connection = await _VMConnection.connect(host, port);
  +    return new VMService._(connection);
  +  }
  +
  +  static Future<VMService> connectToVMWebsocket(String host, int port) async {
  +    var connection = await _VMWebsocketConnection.connect(host, port);
  +    return new VMService._(connection);
  +  }
  +
  +  static Future<VMService> connectToDevtools(String host, int port) async {
  +    var connection = await _DevtoolsConnection.connect(host, port);
  +    return new VMService._(connection);
     }
   
     Future close() => _connection.close();
  
positive.code:     _socket.listen(_handleResponse);
    }
  
    static Future<_Connection> connect(String host, int port) {
      _log.fine('Connecting to VM via HTTP websocket protocol');
      var uri = 'ws://$host:$port/ws';
      return WebSocket
          .connect(uri)
          .then((socket) => new _VMWebsocketConnection(socket));
    }
  
    Future<Map> request(String method, [Map params = const {}]) {
  
negative.code:     _socket.listen(_handleResponse);
    }
  
    static Future<_Connection> connect(String host, int port) async {
      _log.fine('Connecting to VM via Chromium remote debugging protocol');
      var uri = 'http://$host:$port/json';
  
  