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

sdk/lib/io/http_impl.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;
 
 const int _OUTGOING_BUFFER_SIZE = 8 * 1024;
 
-typedef void _BytesConsumer(List<int> bytes);
-
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
 
   bool fullBodyRead = false;
 
   // Common properties.
   final _HttpHeaders headers;
   bool upgraded = false;
@@ skipping 240 matching lines @@
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
     if (_incoming.upgraded) {
       // If upgraded, the connection is already 'removed' form the client.
       // Since listening to upgraded data is 'bogus', simply close and
       // return empty stream subscription.
       _httpRequest._httpClientConnection.destroy();
-      return new Stream<List<int>>.empty().listen(null, onDone: onDone);
+      return new Stream.fromIterable([]).listen(null, onDone: onDone);
     }
     var stream = _incoming;
     if (_httpClient.autoUncompress &&
         headers.value(HttpHeaders.CONTENT_ENCODING) == "gzip") {
       stream = stream.transform(GZIP.decoder);
     }
     return stream.listen(onData,
                          onError: onError,
                          onDone: onDone,
                          cancelOnError: cancelOnError);
@@ skipping 474 matching lines @@
   }
 
   HttpConnectionInfo get connectionInfo => _httpClientConnection.connectionInfo;
 
   void _onIncoming(_HttpIncoming incoming) {
     var response = new _HttpClientResponse(incoming, this, _httpClient);
     Future<HttpClientResponse> future;
     if (followRedirects && response.isRedirect) {
       if (response.redirects.length < maxRedirects) {
         // Redirect and drain response.
-        future = response.drain()
-            .then/*<HttpClientResponse>*/((_) => response.redirect());
+        future = response.drain().then((_) => response.redirect());
       } else {
         // End with exception, too many redirects.
         future = response.drain()
-            .then/*<HttpClientResponse>*/((_) {
-          return new Future<HttpClientResponse>.error(
-              new RedirectException("Redirect limit exceeded",
-                  response.redirects));
-        });
+            .then((_) => new Future.error(
+                new RedirectException("Redirect limit exceeded",
+                                      response.redirects)));
       }
     } else if (response._shouldAuthenticateProxy) {
       future = response._authenticate(true);
     } else if (response._shouldAuthenticate) {
       future = response._authenticate(false);
     } else {
       future = new Future<HttpClientResponse>.value(response);
     }
     future.then(
         (v) => _responseCompleter.complete(v),
@@ skipping 73 matching lines @@
     offset = headers._write(buffer, offset);
     buffer[offset++] = _CharCode.CR;
     buffer[offset++] = _CharCode.LF;
     _outgoing.setHeader(buffer, offset);
   }
 }
 
 // Used by _HttpOutgoing as a target of a chunked converter for gzip
 // compression.
 class _HttpGZipSink extends ByteConversionSink {
-  final _BytesConsumer _consume;
+  final Function _consume;
   _HttpGZipSink(this._consume);
 
   void add(List<int> chunk) {
     _consume(chunk);
   }
 
   void addSlice(List<int> chunk, int start, int end, bool isLast) {
     if (chunk is Uint8List) {
       _consume(new Uint8List.view(chunk.buffer, start, end - start));
     } else {
@@ skipping 14 matching lines @@
 // Most notable is the GZip compression, that uses a double-buffering system,
 // one before gzip (_gzipBuffer) and one after (_buffer).
 class _HttpOutgoing implements StreamConsumer<List<int>> {
   static const List<int> _footerAndChunk0Length =
       const [_CharCode.CR, _CharCode.LF, 0x30, _CharCode.CR, _CharCode.LF,
              _CharCode.CR, _CharCode.LF];
 
   static const List<int> _chunk0Length =
       const [0x30, _CharCode.CR, _CharCode.LF, _CharCode.CR, _CharCode.LF];
 
-  final Completer<Socket> _doneCompleter = new Completer<Socket>();
+  final Completer _doneCompleter = new Completer();
   final Socket socket;
 
   bool ignoreBody = false;
   bool headersWritten = false;
 
   Uint8List _buffer;
   int _length = 0;
 
   Future _closeFuture;
 
   bool chunked = false;
   int _pendingChunkedFooter = 0;
 
   int contentLength;
   int _bytesWritten = 0;
 
   bool _gzip = false;
   ByteConversionSink _gzipSink;
   // _gzipAdd is set iff the sink is being added to. It's used to specify where
   // gzipped data should be taken (sometimes a controller, sometimes a socket).
-  _BytesConsumer _gzipAdd;
+  Function _gzipAdd;
   Uint8List _gzipBuffer;
   int _gzipBufferLength = 0;
 
   bool _socketError = false;
 
   _HttpOutboundMessage outbound;
 
   _HttpOutgoing(this.socket);
 
   // Returns either a future or 'null', if it was able to write headers
@@ skipping 64 matching lines @@
       return new Future.value(outbound);
     }
     if (ignoreBody) {
       stream.drain().catchError((_) {});
       var future = writeHeaders();
       if (future != null) {
         return future.then((_) => close());
       }
       return close();
     }
-    StreamSubscription<List<int>> sub;
+    var sub;
     // Use new stream so we are able to pause (see below listen). The
     // alternative is to use stream.extand, but that won't give us a way of
     // pausing.
-    var controller = new StreamController<List<int>>(
+    var controller = new StreamController(
         onPause: () => sub.pause(),
         onResume: () => sub.resume(),
         sync: true);
 
-    void onData(List<int> data) {
+    void onData(data) {
       if (_socketError) return;
       if (data.length == 0) return;
       if (chunked) {
         if (_gzip) {
           _gzipAdd = controller.add;
           _addGZipChunk(data, _gzipSink.add);
           _gzipAdd = null;
           return;
         }
         _addChunk(_chunkHeader(data.length), controller.add);
@@ skipping 119 matching lines @@
         });
     }
 
     var future = writeHeaders();
     if (future != null) {
       return _closeFuture = future.whenComplete(finalize);
     }
     return _closeFuture = finalize();
   }
 
-  Future<Socket> get done => _doneCompleter.future;
+  Future get done => _doneCompleter.future;
 
   void setHeader(List<int> data, int length) {
     assert(_length == 0);
     assert(data.length == _OUTGOING_BUFFER_SIZE);
     _buffer = data;
     _length = length;
   }
 
   void set gzip(bool value) {
     _gzip = value;
     if (_gzip) {
       _gzipBuffer = new Uint8List(_OUTGOING_BUFFER_SIZE);
       assert(_gzipSink == null);
       _gzipSink = new ZLibEncoder(gzip: true)
           .startChunkedConversion(
               new _HttpGZipSink((data) {
                 // We are closing down prematurely, due to an error. Discard.
                 if (_gzipAdd == null) return;
                 _addChunk(_chunkHeader(data.length), _gzipAdd);
                 _pendingChunkedFooter = 2;
                 _addChunk(data, _gzipAdd);
               }));
     }
   }
 
   bool _ignoreError(error)
     => (error is SocketException || error is TlsException) &&
        outbound is HttpResponse;
 
-  void _addGZipChunk(List<int> chunk, void add(List<int> data)) {
+  void _addGZipChunk(chunk, void add(List<int> data)) {
     if (!outbound.bufferOutput) {
       add(chunk);
       return;
     }
     if (chunk.length > _gzipBuffer.length - _gzipBufferLength) {
       add(new Uint8List.view(
           _gzipBuffer.buffer, 0, _gzipBufferLength));
       _gzipBuffer = new Uint8List(_OUTGOING_BUFFER_SIZE);
       _gzipBufferLength = 0;
     }
     if (chunk.length > _OUTGOING_BUFFER_SIZE) {
       add(chunk);
     } else {
       _gzipBuffer.setRange(_gzipBufferLength,
                            _gzipBufferLength + chunk.length,
                            chunk);
       _gzipBufferLength += chunk.length;
     }
   }
 
-  void _addChunk(List<int> chunk, void add(List<int> data)) {
+  void _addChunk(chunk, void add(List<int> data)) {
     if (!outbound.bufferOutput) {
       if (_buffer != null) {
         // If _buffer is not null, we have not written the header yet. Write
         // it now.
         add(new Uint8List.view(_buffer.buffer, 0, _length));
         _buffer = null;
         _length = 0;
       }
       add(chunk);
       return;
@@ skipping 48 matching lines @@
   final SecurityContext _context;
   final _HttpParser _httpParser;
   StreamSubscription _subscription;
   final _HttpClient _httpClient;
   bool _dispose = false;
   Timer _idleTimer;
   bool closed = false;
   Uri _currentUri;
 
   Completer<_HttpIncoming> _nextResponseCompleter;
-  Future<Socket> _streamFuture;
+  Future _streamFuture;
 
   _HttpClientConnection(this.key, this._socket, this._httpClient,
                         [this._proxyTunnel = false, this._context])
       : _httpParser = new _HttpParser.responseParser() {
     _httpParser.listenToStream(_socket);
 
     // Set up handlers on the parser here, so we are sure to get 'onDone' from
     // the parser.
     _subscription = _httpParser.listen(
         (incoming) {
@@ skipping 94 matching lines @@
       // Look for credentials.
       creds = _httpClient._findCredentials(uri);
       if (creds != null) {
         creds.authorize(request);
       }
     }
     // Start sending the request (lazy, delayed until the user provides
     // data).
     _httpParser.isHead = method == "HEAD";
     _streamFuture = outgoing.done
-        .then/*<Socket>*/((Socket s) {
+        .then((s) {
           // Request sent, set up response completer.
           _nextResponseCompleter = new Completer();
 
           // Listen for response.
           _nextResponseCompleter.future
               .then((incoming) {
                 _currentUri = null;
                 incoming.dataDone.then((closing) {
                   if (incoming.upgraded) {
                     _httpClient._connectionClosed(this);
@@ skipping 74 matching lines @@
   }
 
   void close() {
     closed = true;
     _httpClient._connectionClosed(this);
     _streamFuture
           // TODO(ajohnsen): Add timeout.
         .then((_) => _socket.destroy());
   }
 
-  Future<_HttpClientConnection> createProxyTunnel(String host, int port,
-      _Proxy proxy, bool callback(X509Certificate certificate)) {
+  Future<_HttpClientConnection> createProxyTunnel(host, port, proxy, callback) {
     _HttpClientRequest request =
         send(new Uri(host: host, port: port),
              port,
              "CONNECT",
              proxy);
     if (proxy.isAuthenticated) {
       // If the proxy configuration contains user information use that
       // for proxy basic authorization.
       String auth = _CryptoUtils.bytesToBase64(
           UTF8.encode("${proxy.username}:${proxy.password}"));
@@ skipping 125 matching lines @@
                                   int uriPort,
                                   _Proxy proxy,
                                   _HttpClient client) {
     if (hasIdle) {
       var connection = takeIdle();
       client._connectionsChanged();
       return new Future.value(new _ConnectionInfo(connection, proxy));
     }
     if (client.maxConnectionsPerHost != null &&
         _active.length + _connecting >= client.maxConnectionsPerHost) {
-      var completer = new Completer<_ConnectionInfo>();
+      var completer = new Completer();
       _pending.add(() {
-        completer.complete(connect(uriHost, uriPort, proxy, client));
+        connect(uriHost, uriPort, proxy, client)
+            .then(completer.complete, onError: completer.completeError);
       });
       return completer.future;
     }
     var currentBadCertificateCallback = client._badCertificateCallback;
 
     bool callback(X509Certificate certificate) {
       if (currentBadCertificateCallback == null) return false;
       return currentBadCertificateCallback(certificate, uriHost, uriPort);
     }
 
@@ skipping 295 matching lines @@
       int port = proxy.isDirect ? uriPort: proxy.port;
       return _getConnectionTarget(host, port, isSecure)
           .connect(uriHost, uriPort, proxy, this)
           // On error, continue with next proxy.
           .catchError(connect);
     }
     // Make sure we go through the event loop before taking a
     // connection from the pool. For long-running synchronous code the
     // server might have closed the connection, so this lowers the
     // probability of getting a connection that was already closed.
-    return new Future<_ConnectionInfo>(
-        () => connect(new HttpException("No proxies given")));
+    return new Future(() => connect(new HttpException("No proxies given")));
   }
 
   _SiteCredentials _findCredentials(Uri url, [_AuthenticationScheme scheme]) {
     // Look for credentials.
     _SiteCredentials cr =
         _credentials.fold(null, (_SiteCredentials prev, value) {
           var siteCredentials = value as _SiteCredentials;
           if (siteCredentials.applies(url, scheme)) {
             if (prev == null) return value;
             return siteCredentials.uri.path.length > prev.uri.path.length
@@ skipping 107 matching lines @@
     extends LinkedListEntry<_HttpConnection> with _ServiceObject {
   static const _ACTIVE = 0;
   static const _IDLE = 1;
   static const _CLOSING = 2;
   static const _DETACHED = 3;
 
   // Use HashMap, as we don't need to keep order.
   static Map<int, _HttpConnection> _connections =
       new HashMap<int, _HttpConnection>();
 
-  final /*_ServerSocket*/ _socket;
+  final _socket;
   final _HttpServer _httpServer;
   final _HttpParser _httpParser;
   int _state = _IDLE;
   StreamSubscription _subscription;
   bool _idleMark = false;
   Future _streamFuture;
 
   _HttpConnection(this._socket, this._httpServer)
       : _httpParser = new _HttpParser.requestParser() {
     try { _socket._owner = this; } catch (_) { print(_); }
     _connections[_serviceId] = this;
-    _httpParser.listenToStream(_socket as Object/*=Socket*/);
+    _httpParser.listenToStream(_socket);
     _subscription = _httpParser.listen(
         (incoming) {
           _httpServer._markActive(this);
           // If the incoming was closed, close the connection.
           incoming.dataDone.then((closing) {
             if (closing) destroy();
           });
           // Only handle one incoming request at the time. Keep the
           // stream paused until the request has been send.
           _subscription.pause();
@@ skipping 355 matching lines @@
     return r;
   }
 
   _HttpSessionManager _sessionManagerInstance;
 
   // Indicated if the http server has been closed.
   bool closed = false;
 
   // The server listen socket. Untyped as it can be both ServerSocket and
   // SecureServerSocket.
-  final dynamic/*ServerSocket|SecureServerSocket*/ _serverSocket;
+  final _serverSocket;
   final bool _closeServer;
 
   // Set of currently connected clients.
   final LinkedList<_HttpConnection> _activeConnections
       = new LinkedList<_HttpConnection>();
   final LinkedList<_HttpConnection> _idleConnections
       = new LinkedList<_HttpConnection>();
   StreamController<HttpRequest> _controller;
 }
 
@@ skipping 94 matching lines @@
           ..remotePort = socket.remotePort
           ..localPort = socket.port;
     } catch (e) { }
     return null;
   }
 }
 
 
 class _DetachedSocket extends Stream<List<int>> implements Socket {
   final Stream<List<int>> _incoming;
-  final Socket _socket;
+  final _socket;
 
   _DetachedSocket(this._socket, this._incoming);
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
     return _incoming.listen(onData,
                             onError: onError,
                             onDone: onDone,
@@ skipping 14 matching lines @@
 
   void writeAll(Iterable objects, [String separator = ""]) {
     _socket.writeAll(objects, separator);
   }
 
   void add(List<int> bytes) { _socket.add(bytes); }
 
   void addError(error, [StackTrace stackTrace]) =>
       _socket.addError(error, stackTrace);
 
-  Future addStream(Stream<List<int>> stream) {
+  Future<Socket> addStream(Stream<List<int>> stream) {
     return _socket.addStream(stream);
   }
 
   void destroy() { _socket.destroy(); }
 
   Future flush() => _socket.flush();
 
-  Future<Socket> close() => _socket.close();
+  Future close() => _socket.close();
 
   Future<Socket> get done => _socket.done;
 
   int get port => _socket.port;
 
   InternetAddress get address => _socket.address;
 
   InternetAddress get remoteAddress => _socket.remoteAddress;
 
   int get remotePort => _socket.remotePort;
 
   bool setOption(SocketOption option, bool enabled) {
     return _socket.setOption(option, enabled);
   }
 
-  Map _toJSON(bool ref) {
-    return (_socket as dynamic)._toJSON(ref);
-  }
-  void set _owner(owner) {
-    (_socket as dynamic)._owner = owner;
-  }
+  Map _toJSON(bool ref) => _socket._toJSON(ref);
+  void set _owner(owner) { _socket._owner = owner; }
 }
 
 
 class _AuthenticationScheme {
   final int _scheme;
 
   static const UNKNOWN = const _AuthenticationScheme(-1);
   static const BASIC = const _AuthenticationScheme(0);
   static const DIGEST = const _AuthenticationScheme(1);
 
@@ skipping 230 matching lines @@
   const _RedirectInfo(this.statusCode, this.method, this.location);
 }
 
 String _getHttpVersion() {
   var version = Platform.version;
   // Only include major and minor version numbers.
   int index = version.indexOf('.', version.indexOf('.') + 1);
   version = version.substring(0, index);
   return 'Dart/$version (dart:io)';
 }