Fix strong mode 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;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
@@ skipping 111 matching lines @@
                             cancelOnError: cancelOnError);
   }
 
   Uri get uri => _incoming.uri;
 
   Uri get requestedUri {
     if (_requestedUri == null) {
       var proto = headers['x-forwarded-proto'];
       var scheme = proto != null ? proto.first :
           _httpConnection._socket is SecureSocket ? "https" : "http";
-      var host = headers['x-forwarded-host'];
-      if (host != null) {
-        host = host.first;
+      var hostList = headers['x-forwarded-host'];
+      String host;
+      if (hostList != null) {
+        host = hostList.first;
       } else {
-        host = headers['host'];
-        if (host != null) {
-          host = host.first;
+        hostList = headers['host'];
+        if (hostList != null) {
+          host = hostList.first;
         } else {
           host = "${_httpServer.address.host}:${_httpServer.port}";
         }
       }
       _requestedUri = Uri.parse("$scheme://$host$uri");
     }
     return _requestedUri;
   }
 
   String get method => _incoming.method;
@@ skipping 26 matching lines @@
 class _HttpClientResponse
     extends _HttpInboundMessage implements HttpClientResponse {
   List<RedirectInfo> get redirects => _httpRequest._responseRedirects;
 
   // The HttpClient this response belongs to.
   final _HttpClient _httpClient;
 
   // The HttpClientRequest of this response.
   final _HttpClientRequest _httpRequest;
 
-  List<Cookie> _cookies;
-
   _HttpClientResponse(_HttpIncoming _incoming, this._httpRequest,
                       this._httpClient) : super(_incoming) {
     // Set uri for potential exceptions.
     _incoming.uri = _httpRequest.uri;
   }
 
   int get statusCode => _incoming.statusCode;
   String get reasonPhrase => _incoming.reasonPhrase;
 
   X509Certificate get certificate {
-    // The peerCertificate isn't on a plain socket, so cast to dynamic.
     var socket = _httpRequest._httpClientConnection._socket;
-    return socket.peerCertificate;
+    if (socket is SecureSocket) return socket.peerCertificate;
+    throw new UnsupportedError("Socket is not a SecureSocket");
   }
 
   List<Cookie> get cookies {
     if (_cookies != null) return _cookies;
     _cookies = new List<Cookie>();
     List<String> values = headers[HttpHeaders.SET_COOKIE];
     if (values != null) {
       values.forEach((value) {
         _cookies.add(new Cookie.fromSetCookieValue(value));
       });
@@ skipping 652 matching lines @@
 // Used by _HttpOutgoing as a target of a chunked converter for gzip
 // compression.
 class _HttpGZipSink extends ByteConversionSink {
   final Function _consume;
   _HttpGZipSink(this._consume);
 
   void add(List<int> chunk) {
     _consume(chunk);
   }
 
-  void addSlice(Uint8List chunk, int start, int end, bool isLast) {
-    _consume(new Uint8List.view(chunk.buffer, start, end - start));
+  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 {
+      _consume(chunk.sublist(start, end - start));
+    }
   }
 
   void close() {}
 }
 
 
 // The _HttpOutgoing handles all of the following:
 //  - Buffering
 //  - GZip compressionm
 //  - Content-Length validation.
@@ skipping 45 matching lines @@
   Future writeHeaders({bool drainRequest: true, bool setOutgoing: true}) {
     Future write() {
       try {
         outbound._writeHeader();
       } catch (_) {
         // Headers too large.
         return new Future.error(new HttpException(
             "Headers size exceeded the of '$_OUTGOING_BUFFER_SIZE'"
             " bytes"));
       }
+      return null;
     }
+
     if (headersWritten) return null;
     headersWritten = true;
     Future drainFuture;
-    bool isServerSide = outbound is _HttpResponse;
     bool gzip = false;
-    if (isServerSide) {
-      var response = outbound;
+    if (outbound is _HttpResponse) {
+      // Server side.
+      _HttpResponse response = outbound;
       if (response._httpRequest._httpServer.autoCompress &&
           outbound.bufferOutput &&
           outbound.headers.chunkedTransferEncoding) {
         List acceptEncodings =
             response._httpRequest.headers[HttpHeaders.ACCEPT_ENCODING];
         List contentEncoding = outbound.headers[HttpHeaders.CONTENT_ENCODING];
         if (acceptEncodings != null &&
             acceptEncodings
                 .expand((list) => list.split(","))
                 .any((encoding) => encoding.trim().toLowerCase() == "gzip") &&
@@ skipping 531 matching lines @@
       String auth = _CryptoUtils.bytesToBase64(
           UTF8.encode("${proxy.username}:${proxy.password}"));
       request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
     }
     return request.close()
         .then((response) {
           if (response.statusCode != HttpStatus.OK) {
             throw "Proxy failed to establish tunnel "
                   "(${response.statusCode} ${response.reasonPhrase})";
           }
-          var socket = response._httpRequest._httpClientConnection._socket;
+          var socket = (response as _HttpClientResponse)._httpRequest
+              ._httpClientConnection._socket;
           return SecureSocket.secure(
               socket,
               host: host,
               context: _context,
               onBadCertificate: callback);
         })
         .then((secureSocket) {
           String key = _HttpClientConnection.makeKey(true, host, port);
           return new _HttpClientConnection(
               key, secureSocket, request._httpClient, true);
@@ skipping 113 matching lines @@
     if (client.maxConnectionsPerHost != null &&
         _active.length + _connecting >= client.maxConnectionsPerHost) {
       var completer = new Completer();
       _pending.add(() {
         connect(uriHost, uriPort, proxy, client)
             .then(completer.complete, onError: completer.completeError);
       });
       return completer.future;
     }
     var currentBadCertificateCallback = client._badCertificateCallback;
-    callback(X509Certificate certificate) =>
-        currentBadCertificateCallback == null ? false :
-        currentBadCertificateCallback(certificate, uriHost, uriPort);
+
+    bool callback(X509Certificate certificate) {
+      if (currentBadCertificateCallback == null) return false;
+      return currentBadCertificateCallback(certificate, uriHost, uriPort);
+    }
+
     Future socketFuture = (isSecure && proxy.isDirect
         ? SecureSocket.connect(host,
                                port,
                                context: context,
                                onBadCertificate: callback)
         : Socket.connect(host, port));
     _connecting++;
     return socketFuture.then((socket) {
         _connecting--;
         socket.setOption(SocketOption.TCP_NODELAY, true);
@@ skipping 12 matching lines @@
           return new _ConnectionInfo(connection, proxy);
         }
       }, onError: (error) {
         _connecting--;
         _checkPending();
         throw error;
       });
   }
 }
 
+typedef bool BadCertificateCallback(X509Certificate cr, String host, int port);
 
 class _HttpClient implements HttpClient {
   bool _closing = false;
   bool _closingForcefully = false;
   final Map<String, _ConnectionTarget> _connectionTargets
       = new HashMap<String, _ConnectionTarget>();
   final List<_Credentials> _credentials = [];
   final List<_ProxyCredentials> _proxyCredentials = [];
   final SecurityContext _context;
   Function _authenticate;
   Function _authenticateProxy;
   Function _findProxy = HttpClient.findProxyFromEnvironment;
   Duration _idleTimeout = const Duration(seconds: 15);
-  Function _badCertificateCallback;
+  BadCertificateCallback _badCertificateCallback;
 
   Duration get idleTimeout => _idleTimeout;
 
   int maxConnectionsPerHost;
 
   bool autoUncompress = true;
 
   String userAgent = _getHttpVersion();
 
   _HttpClient(SecurityContext this._context);
@@ skipping 36 matching lines @@
     String query = null;
     if (queryStart < fragmentStart) {
       query = path.substring(queryStart + 1, fragmentStart);
       path = path.substring(0, queryStart);
     }
     Uri uri = new Uri(scheme: "http", host: host, port: port,
                       path: path, query: query);
     return _openUrl(method, uri);
   }
 
-  Future<HttpClientRequest> openUrl(String method, Uri url) {
-    return _openUrl(method, url);
-  }
+  Future<HttpClientRequest> openUrl(String method, Uri url)
+      => _openUrl(method, url);
 
   Future<HttpClientRequest> get(String host, int port, String path)
       => open("get", host, port, path);
 
   Future<HttpClientRequest> getUrl(Uri url) => _openUrl("get", url);
 
   Future<HttpClientRequest> post(String host, int port, String path)
       => open("post", host, port, path);
 
   Future<HttpClientRequest> postUrl(Uri url) => _openUrl("post", url);
@@ skipping 42 matching lines @@
 
   void addProxyCredentials(String host,
                            int port,
                            String realm,
                            HttpClientCredentials cr) {
     _proxyCredentials.add(new _ProxyCredentials(host, port, realm, cr));
   }
 
   set findProxy(String f(Uri uri)) => _findProxy = f;
 
-  Future<HttpClientRequest> _openUrl(String method, Uri uri) {
+  Future<_HttpClientRequest> _openUrl(String method, Uri uri) {
     // Ignore any fragments on the request URI.
     uri = uri.removeFragment();
 
     if (method == null) {
       throw new ArgumentError(method);
     }
     if (method != "CONNECT") {
       if (uri.host.isEmpty) {
         throw new ArgumentError("No host specified in URI $uri");
       } else if (uri.scheme != "http" && uri.scheme != "https") {
@@ skipping 14 matching lines @@
     if (_findProxy != null) {
       // TODO(sgjesse): Keep a map of these as normally only a few
       // configuration strings will be used.
       try {
         proxyConf = new _ProxyConfiguration(_findProxy(uri));
       } catch (error, stackTrace) {
         return new Future.error(error, stackTrace);
       }
     }
     return _getConnection(uri.host, port, proxyConf, isSecure)
-        .then((info) {
-          send(info) {
+        .then((_ConnectionInfo info) {
+
+          _HttpClientRequest send(_ConnectionInfo info) {
             return info.connection.send(uri,
                                         port,
                                         method.toUpperCase(),
                                         info.proxy);
           }
+
           // If the connection was closed before the request was sent, create
           // and use another connection.
           if (info.connection.closed) {
             return _getConnection(uri.host, port, proxyConf, isSecure)
                 .then(send);
           }
           return send(info);
         });
   }
 
-  Future<HttpClientRequest> _openUrlFromRequest(String method,
+  Future<_HttpClientRequest> _openUrlFromRequest(String method,
                                                 Uri uri,
                                                 _HttpClientRequest previous) {
     // If the new URI is relative (to either '/' or some sub-path),
     // construct a full URI from the previous one.
     Uri resolved = previous.uri.resolveUri(uri);
-    return openUrl(method, resolved).then((_HttpClientRequest request) {
+    return _openUrl(method, resolved).then((_HttpClientRequest request) {
 
           request
               // Only follow redirects if initial request did.
               ..followRedirects = previous.followRedirects
               // Allow same number of redirects.
               ..maxRedirects = previous.maxRedirects;
           // Copy headers.
           for (var header in previous.headers._headers.keys) {
             if (request.headers[header] == null) {
               request.headers.set(header, previous.headers[header]);
@@ skipping 63 matching lines @@
     // 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(() => connect(new HttpException("No proxies given")));
   }
 
   _SiteCredentials _findCredentials(Uri url, [_AuthenticationScheme scheme]) {
     // Look for credentials.
     _SiteCredentials cr =
-        _credentials.fold(null, (prev, value) {
-          if (value.applies(url, scheme)) {
+        _credentials.fold(null, (_SiteCredentials prev, value) {
+          var siteCredentials = value as _SiteCredentials;
+          if (siteCredentials.applies(url, scheme)) {
             if (prev == null) return value;
-            return value.uri.path.length > prev.uri.path.length ? value : prev;
+            return siteCredentials.uri.path.length > prev.uri.path.length
+                ? siteCredentials
+                : prev;
           } else {
             return prev;
           }
         });
     return cr;
   }
 
   _ProxyCredentials _findProxyCredentials(_Proxy proxy,
                                           [_AuthenticationScheme scheme]) {
     // Look for credentials.
     var it = _proxyCredentials.iterator;
     while (it.moveNext()) {
       if (it.current.applies(proxy, scheme)) {
         return it.current;
       }
     }
+    return null;
   }
 
   void _removeCredentials(_Credentials cr) {
     int index = _credentials.indexOf(cr);
     if (index != -1) {
       _credentials.removeAt(index);
     }
   }
 
   void _removeProxyCredentials(_Credentials cr) {
@@ skipping 185 matching lines @@
   bool get _isIdle => _state == _IDLE;
   bool get _isClosing => _state == _CLOSING;
   bool get _isDetached => _state == _DETACHED;
 
   String get _serviceTypePath => 'io/http/serverconnections';
   String get _serviceTypeName => 'HttpServerConnection';
 
   Map _toJSON(bool ref) {
     var name = "${_socket.address.host}:${_socket.port} <-> "
         "${_socket.remoteAddress.host}:${_socket.remotePort}";
-    var r = {
+    var r = <String, dynamic>{
       'id': _servicePath,
       'type': _serviceType(ref),
       'name': name,
       'user_name': name,
     };
     if (ref) {
       return r;
     }
     r['server'] = _httpServer._toJSON(true);
     try {
@@ skipping 225 matching lines @@
     _idleConnections.forEach((_HttpConnection conn) {
       result.idle++;
       assert(conn._isIdle);
     });
     return result;
   }
 
   String get _serviceTypePath => 'io/http/servers';
   String get _serviceTypeName => 'HttpServer';
 
-  Map _toJSON(bool ref) {
-    var r = {
+  Map<String, dynamic> _toJSON(bool ref) {
+    var r = <String, dynamic>{
       'id': _servicePath,
       'type': _serviceType(ref),
       'name': '${address.host}:$port',
       'user_name': '${address.host}:$port',
     };
     if (ref) {
       return r;
     }
     try {
       r['socket'] = _serverSocket._toJSON(true);
@@ skipping 439 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)';
 }