Add HTTP proxy tunnel support

sdk/lib/io/secure_socket.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;
 
 /**
  * A high-level class for communicating securely over a TCP socket, using
  * TLS and SSL. The [SecureSocket] exposes both a [Stream] and an
  * [IOSink] interface, making it ideal for using together with
@@ skipping 42 matching lines @@
    * handshake to make the communication secure. When the returned
    * future completes the [SecureSocket] has completed the TLS
    * handshake. Using this function requires that the other end of the
    * connection is prepared for TLS handshake.
    *
    * If the [socket] already has a subscription, this subscription
    * will no longer receive and events. In most cases calling
    * [:pause:] on this subscription before starting TLS handshake is
    * the right thing to do.
    *
+   * If the [host] argument is passed it will be used as the host name
+   * for the TLS handshake. If [host] is not passed the host name from
+   * the [socket] will be used. The [host] can be either a [String] or
+   * an [InternetAddress].
+   *
    * See [connect] for more information on the arguments.
    *
    */
   static Future<SecureSocket> secure(
       Socket socket,
-      {bool sendClientCertificate: false,
+      {host,
+       bool sendClientCertificate: false,
        String certificateName,
        bool onBadCertificate(X509Certificate certificate)}) {
     var completer = new Completer();
     (socket as dynamic)._detachRaw()
         .then((detachedRaw) {
           return RawSecureSocket.secure(
             detachedRaw[0],
             subscription: detachedRaw[1],
+            host: host,
             sendClientCertificate: sendClientCertificate,
             onBadCertificate: onBadCertificate);
           })
         .then((raw) {
           completer.complete(new SecureSocket._(raw));
         });
     return completer.future;
   }
 
   /**
@@ skipping 146 matching lines @@
    * subscription in the [subscription] parameter. The secure socket
    * will take over the subscription and process any subsequent
    * events.
    *
    * See [connect] for more information on the arguments.
    *
    */
   static Future<RawSecureSocket> secure(
       RawSocket socket,
       {StreamSubscription subscription,
+       host,
        bool sendClientCertificate: false,
        String certificateName,
        bool onBadCertificate(X509Certificate certificate)}) {
     return  _RawSecureSocket.connect(
-        socket.address,
+        host != null ? host : socket.address,
         socket.port,
         certificateName,
         is_server: false,
         socket: socket,
         subscription: subscription,
         sendClientCertificate: sendClientCertificate,
         onBadCertificate: onBadCertificate);
   }
 
   /**
@@ skipping 184 matching lines @@
         // create a new one.
         _socketSubscription = _socket.listen(_eventDispatcher,
                                              onError: _errorHandler,
                                              onDone: _doneHandler);
       } else {
         _socketSubscription.onData(_eventDispatcher);
         _socketSubscription.onError(_errorHandler);
         _socketSubscription.onDone(_doneHandler);
       }
       _connectPending = true;
-      _secureFilter.connect(rawSocket.address.host,
+      _secureFilter.connect(address.host,
                             port,
                             is_server,
                             certificateName,
                             requestClientCertificate ||
                                 requireClientCertificate,
                             requireClientCertificate,
                             sendClientCertificate);
       _status = HANDSHAKE;
       _secureHandshake();
     })
@@ skipping 490 matching lines @@
   void destroy();
   void handshake();
   void init();
   X509Certificate get peerCertificate;
   int processBuffer(int bufferIndex);
   void registerBadCertificateCallback(Function callback);
   void registerHandshakeCompleteCallback(Function handshakeCompleteHandler);
 
   List<_ExternalBuffer> get buffers;
 }