Make _activeConnections in HttpClient sorted by key.

sdk/lib/io/http_impl.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 dart.io;
 
 const int _OUTGOING_BUFFER_SIZE = 8 * 1024;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
@@ skipping 1341 matching lines @@
     _streamFuture = outgoing.done
         .then((s) {
           // Request sent, set up response completer.
           _nextResponseCompleter = new Completer();
 
           // Listen for response.
           _nextResponseCompleter.future
               .then((incoming) {
                 _currentUri = null;
                 incoming.dataDone.then((closing) {
+                  if (closed) return;
                   if (!closing &&
                       !_dispose &&
                       incoming.headers.persistentConnection &&
                       request.persistentConnection) {
                     // Return connection, now we are done.
                     _httpClient._returnConnection(this);
                     _subscription.resume();
                   } else {
                     destroy();
                   }
@@ skipping 123 matching lines @@
 
 class _ConnnectionInfo {
   final _HttpClientConnection connection;
   final _Proxy proxy;
 
   _ConnnectionInfo(this.connection, this.proxy);
 }
 
 
 class _HttpClient implements HttpClient {
-  // TODO(ajohnsen): Use eviction timeout.
   bool _closing = false;
-
   final Map<String, Set<_HttpClientConnection>> _idleConnections
       = new HashMap<String, Set<_HttpClientConnection>>();
-  final Set<_HttpClientConnection> _activeConnections
-      = new HashSet<_HttpClientConnection>();
+  final Map<String, Set<_HttpClientConnection>> _activeConnections
+      = new HashMap<String, Set<_HttpClientConnection>>();
   final List<_Credentials> _credentials = [];
   final List<_ProxyCredentials> _proxyCredentials = [];
   Function _authenticate;
   Function _authenticateProxy;
   Function _findProxy = HttpClient.findProxyFromEnvironment;
   Duration _idleTimeout = const Duration(seconds: 15);
   Function _badCertificateCallback;
 
   Timer _noActiveTimer;
 
@@ skipping 70 matching lines @@
         [],
         (l, e) {
           l.addAll(e);
           return l;
         });
     idle.forEach((e) {
       e.close();
     });
     assert(_idleConnections.isEmpty);
     if (force) {
-      for (var connection in _activeConnections.toList()) {
+      for (var connection in
+           _activeConnections.values.expand((s) => s).toList()) {
         connection.destroy();
       }
       assert(_activeConnections.isEmpty);
       _activeConnections.clear();
     }
   }
 
   set authenticate(Future<bool> f(Uri url, String scheme, String realm)) {
     _authenticate = f;
   }
@@ skipping 83 matching lines @@
             }
           }
           return request
               ..headers.chunkedTransferEncoding = false
               ..contentLength = 0;
         });
   }
 
   // Return a live connection to the idle pool.
   void _returnConnection(_HttpClientConnection connection) {
-    _activeConnections.remove(connection);
+    var key = connection.key;
+    _activeConnections[key].remove(connection);
+    if (_activeConnections[key].isEmpty) {
+      _activeConnections.remove(key);
+    }
     if (_closing) {
       connection.close();
       return;
     }
-    if (!_idleConnections.containsKey(connection.key)) {
-      _idleConnections[connection.key] = new HashSet();
-    }
-    _idleConnections[connection.key].add(connection);
+    _idleConnections
+        .putIfAbsent(key, () => new HashSet())
+        .add(connection);
     connection.startTimer();
     _updateTimers();
   }
 
   // Remove a closed connnection from the active set.
   void _connectionClosed(_HttpClientConnection connection) {
     connection.stopTimer();
-    _activeConnections.remove(connection);
-    if (_idleConnections.containsKey(connection.key)) {
-      _idleConnections[connection.key].remove(connection);
-      if (_idleConnections[connection.key].isEmpty) {
-        _idleConnections.remove(connection.key);
+    var key = connection.key;
+    if (_activeConnections.containsKey(key)) {
+      _activeConnections[key].remove(connection);
+      if (_activeConnections[key].isEmpty) {
+        _activeConnections.remove(key);
+      }
+    }
+    if (_idleConnections.containsKey(key)) {
+      _idleConnections[key].remove(connection);
+      if (_idleConnections[key].isEmpty) {
+        _idleConnections.remove(key);
       }
     }
     _updateTimers();
   }
 
   void _updateTimers() {
     if (_activeConnections.isEmpty) {
       if (!_idleConnections.isEmpty && _noActiveTimer == null) {
         _noActiveTimer = new Timer(const Duration(milliseconds: 100), () {
           _noActiveTimer = null;
@@ skipping 23 matching lines @@
       String host = proxy.isDirect ? uriHost: proxy.host;
       int port = proxy.isDirect ? uriPort: proxy.port;
       String key = _HttpClientConnection.makeKey(isSecure, host, port);
       if (_idleConnections.containsKey(key)) {
         var connection = _idleConnections[key].first;
         _idleConnections[key].remove(connection);
         if (_idleConnections[key].isEmpty) {
           _idleConnections.remove(key);
         }
         connection.stopTimer();
-        _activeConnections.add(connection);
+        _activeConnections
+            .putIfAbsent(key, () => new HashSet())
+            .add(connection);
         _updateTimers();
         return new Future.value(new _ConnnectionInfo(connection, proxy));
       }
       var currentBadCertificateCallback = _badCertificateCallback;
       bool callback(X509Certificate certificate) =>
           currentBadCertificateCallback == null ? false :
           currentBadCertificateCallback(certificate, uriHost, uriPort);
       Future socketFuture = (isSecure && proxy.isDirect
           ? SecureSocket.connect(host,
                                  port,
                                  sendClientCertificate: true,
                                  onBadCertificate: callback)
           : Socket.connect(host, port));
       return socketFuture.then((socket) {
           socket.setOption(SocketOption.TCP_NODELAY, true);
           var connection = new _HttpClientConnection(key, socket, this);
           if (isSecure && !proxy.isDirect) {
             connection._dispose = true;
             return connection.createProxyTunnel(
                 uriHost, uriPort, proxy, callback)
                 .then((tunnel) {
-                  _activeConnections.add(tunnel);
+                  _activeConnections
+                      .putIfAbsent(tunnel.key, () => new HashSet())
+                      .add(tunnel);
                   return new _ConnnectionInfo(tunnel, proxy);
                 });
           } else {
-            _activeConnections.add(connection);
+            _activeConnections
+                .putIfAbsent(key, () => new HashSet())
+                .add(connection);
             return new _ConnnectionInfo(connection, proxy);
           }
         }, onError: (error) {
           // Continue with next proxy.
           return connect(error);
         });
     }
     return connect(new HttpException("No proxies given"));
   }
 
@@ skipping 814 matching lines @@
   const _RedirectInfo(this.statusCode, this.method, this.location);
 }
 
 String _getHttpVersion() {
   var version = Platform.version;
   // Only include major and minor version numbers.
   int index = version.indexOf('.', version.indexOf('.') + 1);
   version = version.substring(0, index);
   return 'Dart/$version (dart:io)';
 }