Fix bug in HttpClient, introduced in r15450.

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 1821 matching lines @@
         Socket socket = secure ? new SecureSocket(connectHost, connectPort) :
                                  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, false);
+                host, port, proxyConfiguration, proxyIndex, false, secure);
           } 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
@@ skipping 10 matching lines @@
         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 out if we want a secure socket.
-    bool secure = (url.scheme == "https");
+    bool is_secure = (url.scheme == "https");
 
     // Find the TCP host and port.
     String host = url.domain;
     int port = url.port;
     if (port == 0) {
-      port = secure ?
+      port = is_secure ?
           HttpClient.DEFAULT_HTTPS_PORT :
           HttpClient.DEFAULT_HTTP_PORT;
     }
     // Create a new connection object if we are not re-using an existing one.
     var reusedConnection = false;
     if (connection == null) {
       connection = new _HttpClientConnection(this);
     } else {
       reusedConnection = true;
     }
     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));
     }
 
     // Establish the connection starting with the first proxy configured.
     _establishConnection(host,
                          port,
                          proxyConfiguration,
                          0,
                          reusedConnection,
-                         secure);
+                         is_secure);
 
     return connection;
   }
 
   void _returnSocketConnection(_SocketConnection socketConn) {
     // If the HTTP client is being shutdown don't return the connection.
     if (_shutdown) {
       socketConn._close();
       return;
     };
@@ skipping 208 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;
 }