Revert "Fix remaining strong-mode warnings and errors in dart:io."

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 56 matching lines @@
    * socket as its address value.
    *
    * See [connect] for more information on the arguments.
    *
    */
   static Future<SecureSocket> secure(
       Socket socket,
       {host,
        SecurityContext context,
        bool onBadCertificate(X509Certificate certificate)}) {
-    return ((socket as dynamic/*_Socket*/)._detachRaw() as Future)
-        .then/*<RawSecureSocket>*/((detachedRaw) {
+    var completer = new Completer();
+    (socket as dynamic)._detachRaw()
+        .then((detachedRaw) {
           return RawSecureSocket.secure(
-            detachedRaw[0] as RawSocket,
-            subscription: detachedRaw[1] as StreamSubscription<RawSocketEvent>,
+            detachedRaw[0],
+            subscription: detachedRaw[1],
             host: host,
             context: context,
             onBadCertificate: onBadCertificate);
           })
-        .then/*<SecureSocket>*/((raw) => new SecureSocket._(raw));
- }
+        .then((raw) {
+          completer.complete(new SecureSocket._(raw));
+        });
+    return completer.future;
+  }
 
   /**
    * Takes an already connected [socket] and starts server side TLS
    * 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 going to start the 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 some of the data of the TLS handshake has already been read
    * from the socket this data can be passed in the [bufferedData]
    * parameter. This data will be processed before any other data
    * available on the socket.
    *
    * See [SecureServerSocket.bind] for more information on the
    * arguments.
    *
    */
   static Future<SecureSocket> secureServer(
       Socket socket,
       SecurityContext context,
       {List<int> bufferedData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        List<String> supportedProtocols}) {
-    return ((socket as dynamic/*_Socket*/)._detachRaw() as Future)
-        .then/*<RawSecureSocket>*/((detachedRaw) {
+    var completer = new Completer();
+    (socket as dynamic)._detachRaw()
+        .then((detachedRaw) {
           return RawSecureSocket.secureServer(
-            detachedRaw[0] as RawSocket,
+            detachedRaw[0],
             context,
-            subscription: detachedRaw[1] as StreamSubscription<RawSocketEvent>,
+            subscription: detachedRaw[1],
             bufferedData: bufferedData,
             requestClientCertificate: requestClientCertificate,
             requireClientCertificate: requireClientCertificate,
             supportedProtocols: supportedProtocols);
           })
-        .then/*<SecureSocket>*/((raw) => new SecureSocket._(raw));
+        .then((raw) {
+          completer.complete(new SecureSocket._(raw));
+        });
+    return completer.future;
   }
 
   /**
    * Get the peer certificate for a connected SecureSocket.  If this
    * SecureSocket is the server end of a secure socket connection,
    * [peerCertificate] will return the client certificate, or null, if no
    * client certificate was received.  If it is the client end,
    * [peerCertificate] will return the server's certificate.
    */
   X509Certificate get peerCertificate;
@@ skipping 90 matching lines @@
    * [host] passed is a [String] the [InternetAddress] for the
    * resulting [SecureSocket] will have this passed in [host] as its
    * host value and the internet address of the already connected
    * socket as its address value.
    *
    * See [connect] for more information on the arguments.
    *
    */
   static Future<RawSecureSocket> secure(
       RawSocket socket,
-      {StreamSubscription<RawSocketEvent> subscription,
+      {StreamSubscription subscription,
        host,
        SecurityContext context,
        bool onBadCertificate(X509Certificate certificate),
        List<String> supportedProtocols}) {
     socket.readEventsEnabled = false;
     socket.writeEventsEnabled = false;
     return  _RawSecureSocket.connect(
         host != null ? host : socket.address.host,
         socket.port,
         is_server: false,
@@ skipping 23 matching lines @@
    * parameter. This data will be processed before any other data
    * available on the socket.
    *
    * See [RawSecureServerSocket.bind] for more information on the
    * arguments.
    *
    */
   static Future<RawSecureSocket> secureServer(
       RawSocket socket,
       SecurityContext context,
-      {StreamSubscription<RawSocketEvent> subscription,
+      {StreamSubscription subscription,
        List<int> bufferedData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        List<String> supportedProtocols}) {
     socket.readEventsEnabled = false;
     socket.writeEventsEnabled = false;
     return _RawSecureSocket.connect(
         socket.address,
         socket.remotePort,
         context: context,
@@ skipping 96 matching lines @@
 
   var _status = HANDSHAKE;
   bool _writeEventsEnabled = true;
   bool _readEventsEnabled = true;
   int _pauseCount = 0;
   bool _pendingReadEvent = false;
   bool _socketClosedRead = false;  // The network socket is closed for reading.
   bool _socketClosedWrite = false;  // The network socket is closed for writing.
   bool _closedRead = false;  // The secure socket has fired an onClosed event.
   bool _closedWrite = false;  // The secure socket has been closed for writing.
-  // The network socket is gone.
-  Completer<RawSecureSocket> _closeCompleter = new Completer<RawSecureSocket>();
+  Completer _closeCompleter = new Completer();  // The network socket is gone.
   _FilterStatus _filterStatus = new _FilterStatus();
   bool _connectPending = true;
   bool _filterPending = false;
   bool _filterActive = false;
 
   _SecureFilter _secureFilter = new _SecureFilter();
   String _selectedProtocol;
 
   static Future<_RawSecureSocket> connect(
       dynamic/*String|InternetAddress*/ host,
       int requestedPort,
       {bool is_server,
        SecurityContext context,
        RawSocket socket,
-       StreamSubscription<RawSocketEvent> subscription,
+       StreamSubscription subscription,
        List<int> bufferedData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        bool onBadCertificate(X509Certificate certificate),
        List<String> supportedProtocols}) {
     _verifyFields(host, requestedPort, is_server,
                  requestClientCertificate, requireClientCertificate,
                  onBadCertificate);
     if (host is InternetAddress) host = host.host;
     InternetAddress address = socket.address;
@@ skipping 135 matching lines @@
   int available() {
     return _status != CONNECTED ? 0
                                 : _secureFilter.buffers[READ_PLAINTEXT].length;
   }
 
   Future<RawSecureSocket> close() {
     shutdown(SocketDirection.BOTH);
     return _closeCompleter.future;
   }
 
-  void _completeCloseCompleter([RawSocket dummy]) {
+  void _completeCloseCompleter([dummy]) {
     if (!_closeCompleter.isCompleted) _closeCompleter.complete(this);
   }
 
   void _close() {
     _closedWrite = true;
     _closedRead = true;
     if (_socket != null) {
       _socket.close().then(_completeCloseCompleter);
     } else {
       _completeCloseCompleter();
@@ skipping 465 matching lines @@
   }
 }
 
 
 /**
  * A circular buffer backed by an external byte array.  Accessed from
  * both C++ and Dart code in an unsynchronized way, with one reading
  * and one writing.  All updates to start and end are done by Dart code.
  */
 class _ExternalBuffer {
-  // This will be an ExternalByteArray, backed by C allocated data.
-  List<int> data;
+  List data;  // This will be a ExternalByteArray, backed by C allocated data.
   int start;
   int end;
   final size;
 
   _ExternalBuffer(this.size) {
     start = end = size ~/ 2;
   }
 
   void advanceStart(int bytes) {
     assert(start > end || start + bytes <= end);
@@ skipping 178 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);
 }