Generate an error for active connections when the HTTP client is shutdown

sdk/lib/io/http_impl.dart

 // Copyright (c) 2012, 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.
 
 // The close queue handles graceful closing of HTTP connections. When
 // a connection is added to the queue it will enter a wait state
 // waiting for all data written and possibly socket shutdown from
 // peer.
 class _CloseQueue {
   _CloseQueue() : _q = new Set<_HttpConnectionBase>();
@@ skipping 1445 matching lines @@
   DetachedSocket detachSocket() {
     return _detachSocket();
   }
 
   void _onClosed() {
     _state |= _HttpConnectionBase.READ_CLOSED;
     _checkSocketDone();
   }
 
   void _onError(e) {
-    // Socket is closed either due to an error or due to normal socket close.
+    if (_socketConn != null) {
+      _client._closeSocketConnection(_socketConn);
+    }
     if (_onErrorCallback != null) {
       _onErrorCallback(e);
     } else {
       throw e;
     }
     // Propagate the error to the streams.
     if (_response != null && _response._streamErrorHandler != null) {
        _response._streamErrorHandler(e);
     }
-    if (_socketConn != null) {
-      _client._closeSocketConnection(_socketConn);
-    }
   }
 
   void _onResponseReceived(int statusCode,
                            String reasonPhrase,
                            String version,
                            _HttpHeaders headers) {
     _response._onResponseReceived(statusCode, reasonPhrase, version, headers);
   }
 
   void _onDataReceived(List<int> data) {
     _response._onDataReceived(data);
   }
 
   void _onDataEnd(bool close) {
+    _state |= _HttpConnectionBase.RESPONSE_DONE;
     _response._onDataEnd();
-    _state |= _HttpConnectionBase.RESPONSE_DONE;
     _checkSocketDone();
   }
 
+  void _onClientShutdown() {
+    if (!_isResponseDone) {
+      _onError(new HttpException("Client shutdown"));
+    }
+  }
+
   void set onRequest(void handler(HttpClientRequest request)) {
     _onRequest = handler;
   }
 
   void set onResponse(void handler(HttpClientResponse response)) {
     _onResponse = handler;
   }
 
   void set onError(void callback(e)) {
     _onErrorCallback = callback;
@@ skipping 33 matching lines @@
   }
 
   void redirect([String method, Uri url]) {
     if (method == null) method = _method;
     if (url == null) {
       url = new Uri.fromString(_response.headers.value(HttpHeaders.LOCATION));
     }
     var redirect = new _RedirectInfo(_response.statusCode, method, url);
     // The actual redirect is postponed until both response and
     // request are done.
-    if (_isAllDone) {
-      _doRedirect(redirect);
-    } else {
-      // Prepare for redirect.
-      assert(_pendingRetry == null);
-      _pendingRedirect = redirect;
-    }
+    assert(_pendingRetry == null);
+    _pendingRedirect = redirect;
   }
 
   List<RedirectInfo> get redirects => _redirects;
 
   Function _onRequest;
   Function _onResponse;
   Function _onErrorCallback;
 
   _HttpClient _client;
   _SocketConnection _socketConn;
@@ skipping 19 matching lines @@
 class _SocketConnection {
   _SocketConnection(String this._host,
                     int this._port,
                     Socket this._socket);
 
   void _markReturned() {
     _socket.onData = null;
     _socket.onClosed = null;
     _socket.onError = null;
     _returnTime = new Date.now();
+    _httpClientConnection = null;
   }
 
   void _close() {
     _socket.onData = null;
     _socket.onClosed = null;
     _socket.onError = null;
+    _httpClientConnection = null;
     _socket.close();
   }
 
   Duration _idleTime(Date now) => now.difference(_returnTime);
 
   int get hashCode => _socket.hashCode;
 
   String _host;
   int _port;
   Socket _socket;
   Date _returnTime;
+  HttpClientConnection _httpClientConnection;
 }
 
 class _ProxyConfiguration {
   static const String PROXY_PREFIX = "PROXY ";
   static const String DIRECT_PREFIX = "DIRECT";
 
   _ProxyConfiguration(String configuration) : proxies = new List<_Proxy>() {
     if (configuration == null) {
       throw new HttpException("Invalid proxy configuration $configuration");
     }
@@ skipping 99 matching lines @@
     _authenticate = f;
   }
 
   void addCredentials(
       Uri url, String realm, HttpClientCredentials cr) {
     credentials.add(new _Credentials(url, realm, cr));
   }
 
   set findProxy(String f(Uri uri)) => _findProxy = f;
 
-  void shutdown() {
-    _closeQueue.shutdown();
+  void shutdown({bool force: false}) {
+    if (force) _closeQueue.shutdown();
     _openSockets.forEach((String key, Queue<_SocketConnection> connections) {
       while (!connections.isEmpty) {
         _SocketConnection socketConn = connections.removeFirst();
         socketConn._socket.close();
       }
     });
-    _activeSockets.forEach((_SocketConnection socketConn) {
-      socketConn._socket.close();
-    });
+    if (force) {
+      _activeSockets.forEach((_SocketConnection socketConn) {
+        socketConn._socket.close();
+        socketConn._httpClientConnection._onClientShutdown();
+      });
+    }
     if (_evictionTimer != null) _cancelEvictionTimer();
-     _shutdown = true;
+    _shutdown = true;
   }
 
   void _cancelEvictionTimer() {
     _evictionTimer.cancel();
     _evictionTimer = null;
   }
 
   String _connectionKey(String host, int port) {
     return "$host:$port";
   }
 
   HttpClientConnection _prepareHttpClientConnection(
       String method,
       Uri url,
       [_HttpClientConnection connection]) {
 
     void _establishConnection(String host,
                               int port,
                               _ProxyConfiguration proxyConfiguration,
                               int proxyIndex,
                               bool reusedConnection) {
 
       void _connectionOpened(_SocketConnection socketConn,
                              _HttpClientConnection connection,
                              bool usingProxy) {
+        socketConn._httpClientConnection = connection;
         connection._usingProxy = usingProxy;
         connection._connectionEstablished(socketConn);
         HttpClientRequest request = connection.open(method, url);
         request.headers.host = host;
         request.headers.port = port;
         if (url.userInfo != null && !url.userInfo.isEmpty) {
           // If the URL contains user information use that for basic
           // authorization
           _UTF8Encoder encoder = new _UTF8Encoder();
           String auth =
@@ skipping 94 matching lines @@
       proxyConfiguration = new _ProxyConfiguration(_findProxy(url));
     }
 
     // Establish the connection starting with the first proxy configured.
     _establishConnection(host, port, proxyConfiguration, 0, reusedConnection);
 
     return connection;
   }
 
   void _returnSocketConnection(_SocketConnection socketConn) {
+    // If the HTTP client is being shutdown don't return the connection.
+    if (_shutdown) {
+      socketConn._close();
+      return;
+    };
+
     // Mark socket as returned to unregister from the old connection.
     socketConn._markReturned();
 
-    // If the HTTP client is beeing shutdown don't return the connection.
-    if (_shutdown) {
-      socketConn._socket.close();
-      return;
-    };
-
     String key = _connectionKey(socketConn._host, socketConn._port);
 
     // Get or create the connection list for this key.
     Queue sockets = _openSockets[key];
     if (sockets == null) {
       sockets = new Queue();
       _openSockets[key] = sockets;
     }
 
     // If there is currently no eviction timer start one.
@@ skipping 194 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }