Make the _ConnectionTarget responsible of doing the Socket connect.

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 1476 matching lines @@
     assert(_idleTimer == null);
     _idleTimer = new Timer(
         _httpClient.idleTimeout,
         () {
           _idleTimer = null;
           close();
         });
   }
 }
 
-class _ConnnectionInfo {
+class _ConnectionInfo {
   final _HttpClientConnection connection;
   final _Proxy proxy;
 
-  _ConnnectionInfo(this.connection, this.proxy);
+  _ConnectionInfo(this.connection, this.proxy);
 }
 
 
 class _ConnectionTarget {
   // Unique key for this connection target.
   final String key;
+  final String host;
+  final int port;
+  final bool isSecure;
   final Set<_HttpClientConnection> _idle = new HashSet();
   final Set<_HttpClientConnection> _active = new HashSet();
+  int _connecting = 0;
 
-  _ConnectionTarget(this.key);
+  _ConnectionTarget(this.key, this.host, this.port, this.isSecure);
 
-  bool get isEmpty => _idle.isEmpty && _active.isEmpty;
+  bool get isEmpty => _idle.isEmpty && _active.isEmpty && _connecting == 0;
 
   bool get hasIdle => _idle.isNotEmpty;
 
-  bool get hasActive => _active.isNotEmpty;
+  bool get hasActive => _active.isNotEmpty && _connecting > 0;
 
   _HttpClientConnection takeIdle() {
     assert(hasIdle);
     _HttpClientConnection connection = _idle.first;
     _idle.remove(connection);
     connection.stopTimer();
     _active.add(connection);
     return connection;
   }
 
@@ skipping 16 matching lines @@
   void close(bool force) {
     for (var c in _idle.toList()) {
       c.close();
     }
     if (force) {
       for (var c in _active.toList()) {
         c.destroy();
       }
     }
   }
+
+  Future<_ConnectionInfo> connect(String uriHost,
+                                   int uriPort,
+                                   _Proxy proxy,
+                                   _HttpClient client) {
+    if (hasIdle) {
+      var connection = takeIdle();
+      client._updateTimers();
+      return new Future.value(new _ConnectionInfo(connection, proxy));
+    }
+    var currentBadCertificateCallback = client._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));
+    _connecting++;
+    return socketFuture.then((socket) {
+        _connecting--;
+        socket.setOption(SocketOption.TCP_NODELAY, true);
+        var connection = new _HttpClientConnection(key, socket, client);
+        if (isSecure && !proxy.isDirect) {
+          connection._dispose = true;
+          return connection.createProxyTunnel(uriHost, uriPort, proxy, callback)
+              .then((tunnel) {
+                client._getConnectionTarget(uriHost, uriPort, true)
+                    .addNewActive(tunnel);
+                return new _ConnectionInfo(tunnel, proxy);
+              });
+        } else {
+          addNewActive(connection);
+          return new _ConnectionInfo(connection, proxy);
+        }
+      });
+  }
 }
 
 
 class _HttpClient implements HttpClient {
   bool _closing = false;
   final Map<String, _ConnectionTarget> _connectionTargets
       = new HashMap<String, _ConnectionTarget>();
   final List<_Credentials> _credentials = [];
   final List<_ProxyCredentials> _proxyCredentials = [];
   Function _authenticate;
@@ skipping 205 matching lines @@
             _closing = false;
           }
         });
       }
     } else if (_noActiveTimer != null) {
       _noActiveTimer.cancel();
       _noActiveTimer = null;
     }
   }
 
-  // Get a new _HttpClientConnection, either from the idle pool or created from
-  // a new Socket.
-  Future<_ConnnectionInfo> _getConnection(String uriHost,
+  _ConnectionTarget _getConnectionTarget(String host, int port, bool isSecure) {
+    String key = _HttpClientConnection.makeKey(isSecure, host, port);
+    return _connectionTargets.putIfAbsent(
+        key, () => new _ConnectionTarget(key, host, port, isSecure));
+  }
+
+  // Get a new _HttpClientConnection, from the matching _ConnectionTarget.
+  Future<_ConnectionInfo> _getConnection(String uriHost,
                                           int uriPort,
                                           _ProxyConfiguration proxyConf,
                                           bool isSecure) {
     Iterator<_Proxy> proxies = proxyConf.proxies.iterator;
 
-    Future<_ConnnectionInfo> connect(error) {
+    Future<_ConnectionInfo> connect(error) {
       if (!proxies.moveNext()) return new Future.error(error);
       _Proxy proxy = proxies.current;
       String host = proxy.isDirect ? uriHost: proxy.host;
       int port = proxy.isDirect ? uriPort: proxy.port;
-      String key = _HttpClientConnection.makeKey(isSecure, host, port);
-      var connectionTarget = _connectionTargets[key];
-      if (connectionTarget != null && connectionTarget.hasIdle) {
-        var connection = connectionTarget.takeIdle();
-        _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) {
-                  var connectionTarget = _connectionTargets
-                      .putIfAbsent(tunnel.key,
-                                   () => new _ConnectionTarget(tunnel.key));
-                  connectionTarget.addNewActive(tunnel);
-                  return new _ConnnectionInfo(tunnel, proxy);
-                });
-          } else {
-            var connectionTarget = _connectionTargets
-                .putIfAbsent(key, () => new _ConnectionTarget(key));
-            connectionTarget.addNewActive(connection);
-            return new _ConnnectionInfo(connection, proxy);
-          }
-        }, onError: (error) {
-          // Continue with next proxy.
-          return connect(error);
-        });
+      return _getConnectionTarget(host, port, isSecure)
+          .connect(uriHost, uriPort, proxy, this)
+          // On error, continue with next proxy.
+          .catchError(connect);
     }
     return connect(new HttpException("No proxies given"));
   }
 
   _SiteCredentials _findCredentials(Uri url, [_AuthenticationScheme scheme]) {
     // Look for credentials.
     _SiteCredentials cr =
         _credentials.fold(null, (prev, value) {
           if (value.applies(url, scheme)) {
             if (prev == null) return value;
@@ skipping 862 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)';
 }