Add support for multiple HTTP proxies

runtime/bin/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.
 
 class _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 2087 matching lines @@
   void _cancelEvictionTimer() {
     _evictionTimer.cancel();
     _evictionTimer = null;
   }
 
   String _connectionKey(String host, int port) {
     return "$host:$port";
   }
 
   HttpClientConnection _prepareHttpClientConnection(
-    String method,
-    Uri url,
-    [_HttpClientConnection connection]) {
+      String method,
+      Uri url,
+      [_HttpClientConnection connection]) {
 
+    void _establishConnection(String host,
+                              int port,
+                              _ProxyConfiguration proxyConfiguration,
+                              int proxyIndex) {
+
+      void _connectionOpened(_SocketConnection socketConn,
+                             _HttpClientConnection connection,
+                             bool usingProxy) {
+        connection._usingProxy = usingProxy;
+        connection._connectionEstablished(socketConn);
+        HttpClientRequest request = connection.open(method, url);
+        request.headers.host = host;
+        request.headers.port = port;
+        if (connection._onRequest != null) {
+          connection._onRequest(request);
+        } else {
+          request.outputStream.close();
+        }
+      }
+
+      assert(proxyIndex < proxyConfiguration.proxies.length);
+
+      // Determine the actual host to connect to.
+      String connectHost;
+      int connectPort;
+      _Proxy proxy = proxyConfiguration.proxies[proxyIndex];
+      if (proxy.isDirect) {
+        connectHost = host;
+        connectPort = port;
+      } else {
+        connectHost = proxy.host;
+        connectPort = proxy.port;
+      }
+
+      // If there are active connections for this key get the first one
+      // otherwise create a new one.
+      String key = _connectionKey(connectHost, connectPort);
+      Queue socketConnections = _openSockets[key];
+      if (socketConnections == null || socketConnections.isEmpty()) {
+        Socket socket = new Socket(connectHost, connectPort);
+        // Until the connection is established handle connection errors
+        // here as the HttpClientConnection object is not yet associated
+        // with the socket.
+        socket.onError = (e) {
+          proxyIndex++;
+          if (proxyIndex < proxyConfiguration.proxies.length) {
+            // Try the next proxy in the list.
+            _establishConnection(host, port, proxyConfiguration, proxyIndex);
+          } else {
+            // Report the error through the HttpClientConnection object to
+            // the client.
+            connection._onError(e);
+          }
+        };
+        socket.onConnect = () {
+          // When the connection is established, clear the error
+          // callback as it will now be handled by the
+          // HttpClientConnection object which will be associated with
+          // the connected socket.
+          socket.onError = null;
+          _SocketConnection socketConn =
+          new _SocketConnection(connectHost, connectPort, socket);
+          _activeSockets.add(socketConn);
+          _connectionOpened(socketConn, connection, !proxy.isDirect);
+        };
+      } else {
+        _SocketConnection socketConn = socketConnections.removeFirst();
+        _activeSockets.add(socketConn);
+        new Timer(0, (ignored) =>
+                  _connectionOpened(socketConn, connection, !proxy.isDirect));
+
+        // Get rid of eviction timer if there are no more active connections.
+        if (socketConnections.isEmpty()) _openSockets.remove(key);
+        if (_openSockets.isEmpty()) _cancelEvictionTimer();
+      }
+    }
+
+    // Find the TCP host and port.
     String host = url.domain;
     int port = url.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : url.port;
 
-    void _connectionOpened(_SocketConnection socketConn,
-                           _HttpClientConnection connection,
-                           bool usingProxy) {
-      connection._usingProxy = usingProxy;
-      connection._connectionEstablished(socketConn);
-      HttpClientRequest request = connection.open(method, url);
-      request.headers.host = host;
-      request.headers.port = port;
-      if (connection._onRequest != null) {
-        connection._onRequest(request);
-      } else {
-        request.outputStream.close();
-      }
-    }
-
-    // Create a new connection if we are not re-using an existing one.
+    // Create a new connection object if we are not re-using an existing one.
     if (connection == null) {
       connection = new _HttpClientConnection(this);
     }
     connection.onDetach = () => _activeSockets.remove(connection._socketConn);
 
     // Check to see if a proxy server should be used for this connection.
     _ProxyConfiguration proxyConfiguration = const _ProxyConfiguration.direct();
     if (_findProxy != null) {
       // TODO(sgjesse): Keep a map of these as normally only a few
       // configuration strings will be used.
       proxyConfiguration = new _ProxyConfiguration(_findProxy(url));
     }
 
-    // Determine the actual host to connect to.
-    String connectHost;
-    int connectPort;
-    _Proxy proxy = proxyConfiguration.proxies[0];
-    if (proxy.isDirect) {
-      connectHost = host;
-      connectPort = port;
-    } else {
-      connectHost = proxy.host;
-      connectPort = proxy.port;
-    }
-
-    // If there are active connections for this key get the first one
-    // otherwise create a new one.
-    String key = _connectionKey(connectHost, connectPort);
-    Queue socketConnections = _openSockets[key];
-    if (socketConnections == null || socketConnections.isEmpty()) {
-      Socket socket = new Socket(connectHost, connectPort);
-      // Until the connection is established handle connection errors
-      // here as the HttpClientConnection object is not yet associated
-      // with the socket.
-      socket.onError = (e) {
-        // Report the error through the HttpClientConnection object to
-        // the client.
-        connection._onError(e);
-      };
-      socket.onConnect = () {
-        // When the connection is established, clear the error
-        // callback as it will now be handled by the
-        // HttpClientConnection object which will be associated with
-        // the connected socket.
-        socket.onError = null;
-        _SocketConnection socketConn =
-            new _SocketConnection(connectHost, connectPort, socket);
-        _activeSockets.add(socketConn);
-        _connectionOpened(socketConn, connection, !proxy.isDirect);
-      };
-    } else {
-      _SocketConnection socketConn = socketConnections.removeFirst();
-      _activeSockets.add(socketConn);
-      new Timer(0, (ignored) =>
-                _connectionOpened(socketConn, connection, !proxy.isDirect));
-
-      // Get rid of eviction timer if there are no more active connections.
-      if (socketConnections.isEmpty()) _openSockets.remove(key);
-      if (_openSockets.isEmpty()) _cancelEvictionTimer();
-    }
+    // Establish the connection starting with the first proxy configured.
+    _establishConnection(host, port, proxyConfiguration, 0);
 
     return connection;
   }
 
   void _returnSocketConnection(_SocketConnection socketConn) {
     // 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) {
@@ skipping 72 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;
 }