Improve VM connection flow in Observatory

runtime/observatory/lib/service_common.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.
 
 library service_common;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:typed_data';
 
@@ skipping 70 matching lines @@
 abstract class CommonWebSocketVM extends VM {
   final Completer _connected = new Completer();
   final Completer _disconnected = new Completer<String>();
   final WebSocketVMTarget target;
   final Map<String, _WebSocketRequest> _delayedRequests =
         new Map<String, _WebSocketRequest>();
   final Map<String, _WebSocketRequest> _pendingRequests =
       new Map<String, _WebSocketRequest>();
   int _requestSerial = 0;
   bool _hasInitiatedConnect = false;
-  bool _hasFinishedConnect = false;
   Utf8Decoder _utf8Decoder = const Utf8Decoder();
 
   String get displayName => '${name}@${target.name}';
 
   CommonWebSocket _webSocket;
 
   CommonWebSocketVM(this.target, this._webSocket) {
     assert(target != null);
   }
 
   void _notifyConnect() {
-    _hasFinishedConnect = true;
     if (!_connected.isCompleted) {
       Logger.root.info('WebSocketVM connection opened: ${target.networkAddress}');
       _connected.complete(this);
     }
   }
   Future get onConnect => _connected.future;
+  bool get wasOrIsConnected => _connected.isCompleted;
+  bool get isConnected => wasOrIsConnected && !isDisconnected;
   void _notifyDisconnect(String reason) {
-    if (!_hasFinishedConnect) {
-      return;
-    }
     if (!_disconnected.isCompleted) {
       Logger.root.info('WebSocketVM connection error: ${target.networkAddress}');
       _disconnected.complete(reason);
     }
   }
   Future get onDisconnect => _disconnected.future;
   bool get isDisconnected => _disconnected.isCompleted;
 
   void disconnect({String reason : 'WebSocket closed'}) {
     if (_hasInitiatedConnect) {
-      _webSocket.close();
+      if (_webSocket != null) {
+        _webSocket.close();
+      }
     }
     // We don't need to cancel requests and notify here.  These
     // functions will be called again when the onClose callback
     // fires. However, we may have a better 'reason' string now, so
     // let's take care of business.
     _cancelAllRequests(reason);
     _notifyDisconnect(reason);
   }
 
   Future<Map> invokeRpcRaw(String method, Map params) {
     if (!_hasInitiatedConnect) {
       _hasInitiatedConnect = true;
-      _webSocket.connect(
-          target.networkAddress, _onOpen, _onMessage, _onError, _onClose);
+      try {
+        _webSocket.connect(
+            target.networkAddress, _onOpen, _onMessage, _onError, _onClose);
+      } catch (_) {
+        _webSocket = null;
+        var exception = new NetworkRpcException('WebSocket closed');
+        return new Future.error(exception);
+      }
     }
     if (_disconnected.isCompleted) {
       // This connection was closed already.
       var exception = new NetworkRpcException('WebSocket closed');
       return new Future.error(exception);
     }
     String serial = (_requestSerial++).toString();
     var request = new _WebSocketRequest(method, params);
-    if (_webSocket.isOpen) {
+    if ((_webSocket != null) && _webSocket.isOpen) {
       // Already connected, send request immediately.
       _sendRequest(serial, request);
     } else {
       // Not connected yet, add to delayed requests.
       _delayedRequests[serial] = request;
     }
     return request.completer.future;
   }
 
   void _onClose() {
@@ skipping 100 matching lines @@
   void _onMessage(dynamic data) {
     if (data is! String) {
       _onBinaryMessage(data);
     } else {
       _onStringMessage(data);
     }
   }
 
   void _cancelRequests(Map<String,_WebSocketRequest> requests,
                        String message) {
-    requests.forEach((_, _WebSocketRequest request) {
-      var exception = new NetworkRpcException(message);
+    requests.forEach((String serial, _WebSocketRequest request) {
+      var exception = new NetworkRpcException(message +
+          '(id: $serial method: ${request.method} params: ${request.params})');
       request.completer.completeError(exception);
     });
     requests.clear();
   }
 
   /// Cancel all pending and delayed requests by completing them with an error.
   void _cancelAllRequests(String reason) {
     String message = 'Canceling request: $reason';
     if (_pendingRequests.length > 0) {
       Logger.root.info('Canceling all pending requests.');
@@ skipping 42 matching lines @@
     }
     if (request.method != 'getTagProfile' &&
         request.method != 'getIsolateMetric' &&
         request.method != 'getVMMetric') {
       Logger.root.info(
           'GET [${serial}] ${request.method}(${request.params}) from ${target.networkAddress}');
     }
     // Send message.
     _webSocket.send(message);
   }
+
+  String toString() => displayName;
 }