Add support for https scheme in dart:io HttpClient.

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 1686 matching lines @@
     return _prepareHttpClientConnection(method, uri, connection);
   }
 
   HttpClientConnection openUrl(String method, Uri url) {
     return _openUrl(method, url);
   }
 
   HttpClientConnection _openUrl(String method,
                                 Uri url,
                                 [_HttpClientConnection connection]) {
-    if (url.scheme != "http") {
+    if (url.scheme != "http" && url.scheme != "https") {
       throw new HttpException("Unsupported URL scheme ${url.scheme}");
     }
     return _open(method, url, connection);
   }
 
   HttpClientConnection get(String host, int port, String path) {
     return open("GET", host, port, path);
   }
 
   HttpClientConnection getUrl(Uri url) => _openUrl("GET", url);
@@ skipping 44 matching lines @@
 
   HttpClientConnection _prepareHttpClientConnection(
       String method,
       Uri url,
       [_HttpClientConnection connection]) {
 
     void _establishConnection(String host,
                               int port,
                               _ProxyConfiguration proxyConfiguration,
                               int proxyIndex,
-                              bool reusedConnection) {
+                              bool reusedConnection,
+                              bool secure) {
 
       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;
@@ skipping 30 matching lines @@
         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];

[Søren Gjesse, 2012/11/28 12:36:30]

How about removing all incompatible sockets here?

while (socketConnections != null &&
       !socketConnections.isEmpty &&
       secure != (socketConnections.first._socket is SecureSocket)) {
socketConnections.removeFirst()._close();

}

[Bill Hesse, 2012/11/28 14:11:23]

Done.

[Bill Hesse, 2012/11/28 14:11:23]

Done.

       if (socketConnections == null || socketConnections.isEmpty) {
-        Socket socket = new Socket(connectHost, connectPort);
+        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);
           } 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);
+              new _SocketConnection(connectHost, connectPort, socket);
           _activeSockets.add(socketConn);
           _connectionOpened(socketConn, connection, !proxy.isDirect);
         };
       } else {
         _SocketConnection socketConn = socketConnections.removeFirst();
+        if (secure != (socketConn._socket is SecureSocket)) {

[Søren Gjesse, 2012/11/28 12:36:30]

If you get rid of incompatible connections above this is not needed.

[Bill Hesse, 2012/11/28 14:11:23]

Done.

+          // TODO(whesse): Clear the socketConnections for this key, and retry.
+          connection._onError(new SocketIOException(
+              "Secure and insecure connection made to the same host and port",
+              null));
+        }
         _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 out if we want a secure socket.
+    bool secure = (url.scheme == "https");
+
     // Find the TCP host and port.
     String host = url.domain;
-    int port = url.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : url.port;
-
+    int port = url.port;
+    if (port == 0) {
+      port = 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);
+    _establishConnection(host,
+                         port,
+                         proxyConfiguration,
+                         0,
+                         reusedConnection,
+                         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;
 }