Clean up secure socket connect.

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 240 matching lines @@
         port,
         certificateName,
         false,
         false,
         false,
         sendClientCertificate,
         onBadCertificate);
     return RawSocket.connect(host, port)
         .then((socket) {
           return secure(socket,
-                        host: host,
                         sendClientCertificate: sendClientCertificate,
                         certificateName: certificateName,
                         onBadCertificate: onBadCertificate);
         });
   }
 
   /**
    * Takes an already connected [socket] and starts client side TLS
    * handshake to make the communication secure. When the returned
    * future completes the [RawSecureSocket] has completed the TLS
@@ skipping 24 matching lines @@
   static Future<RawSecureSocket> secure(
       RawSocket socket,
       {StreamSubscription subscription,
        host,
        bool sendClientCertificate: false,
        String certificateName,
        bool onBadCertificate(X509Certificate certificate)}) {
     socket.readEventsEnabled = false;
     socket.writeEventsEnabled = false;
     return  _RawSecureSocket.connect(
-        host != null ? host : socket.address,
+        host != null ? host : socket.address.host,
         socket.port,
         certificateName,
         is_server: false,
         socket: socket,
         subscription: subscription,
         sendClientCertificate: sendClientCertificate,
         onBadCertificate: onBadCertificate);
   }
 
   /**
@@ skipping 149 matching lines @@
       int requestedPort,
       String certificateName,
       {bool is_server,
        RawSocket socket,
        StreamSubscription subscription,
        List<int> bufferedData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        bool sendClientCertificate: false,
        bool onBadCertificate(X509Certificate certificate)}) {
-    var future;
     _verifyFields(host, requestedPort, certificateName, is_server,
                  requestClientCertificate, requireClientCertificate,
                  sendClientCertificate, onBadCertificate);
-    if (host is String) {
-      if (socket != null) {
-        future = new Future.value(
-            (socket.address as dynamic)._cloneWithNewHost(host));
-      } else {
-        future = InternetAddress.lookup(host).then((addrs) => addrs.first);
-      }
-    } else {
-      future = new Future.value(host);
-    }
-    return future.then((addr) {
-     return new _RawSecureSocket(addr,
-                                 requestedPort,
-                                 certificateName,
-                                 is_server,
-                                 socket,
-                                 subscription,
-                                 bufferedData,
-                                 requestClientCertificate,
-                                 requireClientCertificate,
-                                 sendClientCertificate,
-                                 onBadCertificate)
-         ._handshakeComplete.future;
-    });
+    if (host is InternetAddress) host = host.host;
+    var address = socket.address;
+    if (host != null) address =  address._cloneWithNewHost(host);
+    return new _RawSecureSocket(address,
+                                requestedPort,
+                                certificateName,
+                                is_server,
+                                socket,
+                                subscription,
+                                bufferedData,
+                                requestClientCertificate,
+                                requireClientCertificate,
+                                sendClientCertificate,
+                                onBadCertificate)
+        ._handshakeComplete.future;
   }
 
   _RawSecureSocket(
       this.address,
       int requestedPort,
       this.certificateName,
       this.is_server,
-      RawSocket socket,
+      RawSocket this._socket,
       this._socketSubscription,
       this._bufferedData,
       this.requestClientCertificate,
       this.requireClientCertificate,
       this.sendClientCertificate,
       this.onBadCertificate(X509Certificate certificate)) {
     _controller = new StreamController<RawSocketEvent>(
         sync: true,
         onListen: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange,
         onCancel: _onSubscriptionStateChange);
     _stream = _controller.stream;
     // Throw an ArgumentError if any field is invalid.  After this, all
     // errors will be reported through the future or the stream.
     _secureFilter.init();
     _filterPointer = _secureFilter._pointer();
     _secureFilter.registerHandshakeCompleteCallback(
         _secureHandshakeCompleteHandler);
     if (onBadCertificate != null) {
       _secureFilter.registerBadCertificateCallback(_onBadCertificateWrapper);
     }
-    var futureSocket;
-    if (socket == null) {
-      futureSocket = RawSocket.connect(address, requestedPort);
+    _socket.readEventsEnabled = true;
+    _socket.writeEventsEnabled = false;
+    if (_socketSubscription == null) {
+      // If a current subscription is provided use this otherwise
+      // create a new one.
+      _socketSubscription = _socket.listen(_eventDispatcher,
+                                           onError: _reportError,
+                                           onDone: _doneHandler);
     } else {
-      futureSocket = new Future.value(socket);
+      if (_socketSubscription.isPaused) {
+        _socket.close();
+        throw new ArgumentError(
+            "Subscription passed to TLS upgrade is paused");
+      }
+      _socketSubscription
+          ..onData(_eventDispatcher)
+          ..onError(_reportError)
+          ..onDone(_doneHandler);
     }
-    futureSocket.then((rawSocket) {
-      _socket = rawSocket;
-      _socket.readEventsEnabled = true;
-      _socket.writeEventsEnabled = false;
-      if (_socketSubscription == null) {
-        // If a current subscription is provided use this otherwise
-        // create a new one.
-        _socketSubscription = _socket.listen(_eventDispatcher,
-                                             onError: _reportError,
-                                             onDone: _doneHandler);
-      } else {
-        if (_socketSubscription.isPaused) {
-          throw new StateError("Subscription passed to TLS upgrade is paused");
-        }
-        _socketSubscription
-            ..onData(_eventDispatcher)
-            ..onError(_reportError)
-            ..onDone(_doneHandler);
-      }
+    try {
       _secureFilter.connect(address.host,
                             (address as dynamic)._in_addr,
                             port,
                             is_server,
                             certificateName,
                             requestClientCertificate ||
                                 requireClientCertificate,
                             requireClientCertificate,
                             sendClientCertificate);
       _secureHandshake();
-    })
-    .catchError(_reportError);
+    } catch (e, s) {
+      _reportError(e, s);
+    }
   }
 
   StreamSubscription listen(void onData(RawSocketEvent data),
                             {Function onError,
                              void onDone(),
                              bool cancelOnError}) {
     _sendWriteEvent();
     return _stream.listen(onData,
                           onError: onError,
                           onDone: onDone,
@@ skipping 697 matching lines @@
 /**
  * An exception that happens in the handshake phase of establishing
  * a secure network connection, when looking up or verifying a
  * certificate.
  */
 class CertificateException extends TlsException {
   const CertificateException([String message = "",
                             OSError osError = null])
      : super._("CertificateException", message, osError);
 }