Code cleanup (mostly io lib and some http lib).

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 _HEADERS_BUFFER_SIZE = 8 * 1024;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
@@ skipping 15 matching lines @@
   Uri uri;
 
   bool hasSubscriber = false;
 
   // The transfer length if the length of the message body as it
   // appears in the message (RFC 2616 section 4.4). This can be -1 if
   // the length of the massage body is not known due to transfer
   // codings.
   int get transferLength => _transferLength;
 
-  _HttpIncoming(_HttpHeaders this.headers,
-                int this._transferLength,
-                Stream<List<int>> this._stream) {
-  }
+  _HttpIncoming(this.headers, this._transferLength, this._stream);
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
     hasSubscriber = true;
     return _stream
         .handleError((error) {
           throw new HttpException(error.message, uri: uri);
         })
@@ skipping 10 matching lines @@
     fullBodyRead = true;
     hasSubscriber = true;
     _dataCompleter.complete(closing);
   }
 }
 
 abstract class _HttpInboundMessage extends Stream<List<int>> {
   final _HttpIncoming _incoming;
   List<Cookie> _cookies;
 
-  _HttpInboundMessage(_HttpIncoming this._incoming);
+  _HttpInboundMessage(this._incoming);
 
   List<Cookie> get cookies {
     if (_cookies != null) return _cookies;
     return _cookies = headers._parseCookies();
   }
 
   _HttpHeaders get headers => _incoming.headers;
   String get protocolVersion => headers.protocolVersion;
   int get contentLength => headers.contentLength;
   bool get persistentConnection => headers.persistentConnection;
 }
 
 
 class _HttpRequest extends _HttpInboundMessage implements HttpRequest {
   final HttpResponse response;
 
   final _HttpServer _httpServer;
 
   final _HttpConnection _httpConnection;
 
   _HttpSession _session;
 
-  _HttpRequest(_HttpResponse this.response,
-               _HttpIncoming _incoming,
-               _HttpServer this._httpServer,
-               _HttpConnection this._httpConnection)
-      : super(_incoming) {
+  _HttpRequest(this.response, _HttpIncoming _incoming, this._httpServer,
+               this._httpConnection) : super(_incoming) {
     if (headers.protocolVersion == "1.1") {
-      response.headers.chunkedTransferEncoding = true;
-      response.headers.persistentConnection = headers.persistentConnection;
+      response.headers
+          ..chunkedTransferEncoding = true
+          ..persistentConnection = headers.persistentConnection;
     }
 
     if (_httpServer._sessionManagerInstance != null) {
       // Map to session if exists.
       var sessionIds = cookies
           .where((cookie) => cookie.name.toUpperCase() == _DART_SESSION_ID)
           .map((cookie) => cookie.value);
       for (var sessionId in sessionIds) {
         _session = _httpServer._sessionManager.getSession(sessionId);
         if (_session != null) {
@@ skipping 48 matching lines @@
   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,
-                      _HttpClientRequest this._httpRequest,
-                      _HttpClient this._httpClient)
-      : super(_incoming) {
+  _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 {
-    var socket = _httpRequest._httpClientConnection._socket;
-    return socket.peerCertificate;
-  }
+  X509Certificate get certificate =>
+    _httpRequest._httpClientConnection._socket.peerCertificate;
 
   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 33 matching lines @@
     if (followLoops != true) {
       for (var redirect in redirects) {
         if (redirect.location == url) {
           return new Future.error(
               new RedirectException("Redirect loop detected", redirects));
         }
       }
     }
     return _httpClient._openUrlFromRequest(method, url, _httpRequest)
         .then((request) {
-          request._responseRedirects.addAll(this.redirects);
-          request._responseRedirects.add(new _RedirectInfo(statusCode,
-                                                           method,
-                                                           url));
+          request._responseRedirects
+              ..addAll(this.redirects)
+              ..add(new _RedirectInfo(statusCode, method, url));
           return request.close();
         });
   }
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
     var stream = _incoming;
     if (headers.value(HttpHeaders.CONTENT_ENCODING) == "gzip") {
@@ skipping 31 matching lines @@
       // Drain body and retry.
       return drain().then((_) {
           return _httpClient._openUrlFromRequest(_httpRequest.method,
                                                  _httpRequest.uri,
                                                  _httpRequest)
               .then((request) => request.close());
           });
     }
 
     List<String> authChallenge() {
-      if (proxyAuth) {
-        return headers[HttpHeaders.PROXY_AUTHENTICATE];
-      } else {
-        return headers[HttpHeaders.WWW_AUTHENTICATE];
-      }
+      return proxyAuth ? headers[HttpHeaders.PROXY_AUTHENTICATE]
+                       : headers[HttpHeaders.WWW_AUTHENTICATE];
     }
 
     _Credentials findCredentials(_AuthenticationScheme scheme) {
-      if (proxyAuth) {
-        return  _httpClient._findProxyCredentials(_httpRequest._proxy, scheme);
-      } else {
-        return _httpClient._findCredentials(_httpRequest.uri, scheme);
-      }
+      return proxyAuth ? _httpClient._findProxyCredentials(_httpRequest._proxy, scheme)
+                       : _httpClient._findCredentials(_httpRequest.uri, scheme);
     }
 
     void removeCredentials(_Credentials cr) {
       if (proxyAuth) {
         _httpClient._removeProxyCredentials(cr);
       } else {
         _httpClient._removeCredentials(cr);
       }
     }
 
@@ skipping 37 matching lines @@
       }
 
       // Digest authentication only supports the MD5 algorithm.
       if (cr.scheme == _AuthenticationScheme.DIGEST &&
           (header.parameters["algorithm"] == null ||
            header.parameters["algorithm"].toLowerCase() == "md5")) {
         if (cr.nonce == null || cr.nonce == header.parameters["nonce"]) {
           // If the nonce is not set then this is the first authenticate
           // response for these credentials. Set up authentication state.
           if (cr.nonce == null) {
-            cr.nonce = header.parameters["nonce"];
-            cr.algorithm = "MD5";
-            cr.qop = header.parameters["qop"];
-            cr.nonceCount = 0;
+            cr..nonce = header.parameters["nonce"]
+              ..algorithm = "MD5"
+              ..qop = header.parameters["qop"]
+              ..nonceCount = 0;
           }
           // Credentials where found, prepare for retrying the request.
           return retry();
         } else if (header.parameters["stale"] != null &&
                    header.parameters["stale"].toLowerCase() == "true") {
           // If stale is true retry with new nonce.
           cr.nonce = header.parameters["nonce"];
           // Credentials where found, prepare for retrying the request.
           return retry();
         }
@@ skipping 28 matching lines @@
   bool _asGZip = false;
 
   IOSink _headersSink;
   IOSink _dataSink;
 
   final _HttpOutgoing _outgoing;
   final Uri _uri;
 
   final _HttpHeaders headers;
 
-  _HttpOutboundMessage(Uri this._uri,
+  _HttpOutboundMessage(this._uri,
                        String protocolVersion,
                        _HttpOutgoing outgoing)
       : _outgoing = outgoing,
         _headersSink = new IOSink(outgoing, encoding: ASCII),
         headers = new _HttpHeaders(protocolVersion) {
     _dataSink = new IOSink(new _HttpOutboundConsumer(this));
   }
 
   int get contentLength => headers.contentLength;
   void set contentLength(int contentLength) {
@@ skipping 37 matching lines @@
   void writeCharCode(int charCode) {
     if (!_headersWritten) _dataSink.encoding = encoding;
     _dataSink.writeCharCode(charCode);
   }
 
   void add(List<int> data) {
     if (data.length == 0) return;
     _dataSink.add(data);
   }
 
-  void addError(error, [StackTrace stackTrace]) {
-    _dataSink.addError(error, stackTrace);
-  }
+  void addError(error, [StackTrace stackTrace]) =>
+      _dataSink.addError(error, stackTrace);
 
-  Future<T> addStream(Stream<List<int>> stream) {
-    return _dataSink.addStream(stream);
-  }
+  Future<T> addStream(Stream<List<int>> stream) => _dataSink.addStream(stream);
 
-  Future flush() {
-    return _dataSink.flush();
-  }
+  Future flush() => _dataSink.flush();
 
-  Future close() {
-    return _dataSink.close();
-  }
+  Future close() => _dataSink.close();
 
   Future<T> get done => _dataSink.done;
 
   Future _writeHeaders({bool drainRequest: true}) {
     void write() {
       try {
         _writeHeader();
       } catch (error) {
         // Headers too large.
         throw new HttpException(
@@ skipping 75 matching lines @@
 
 
 class _HttpOutboundConsumer implements StreamConsumer {
   final _HttpOutboundMessage _outbound;
   StreamController _controller;
   StreamSubscription _subscription;
   Completer _closeCompleter = new Completer();
   Completer _completer;
   bool _socketError = false;
 
-  _HttpOutboundConsumer(_HttpOutboundMessage this._outbound);
+  _HttpOutboundConsumer(this._outbound);
 
   void _cancel() {
     if (_subscription != null) {
       StreamSubscription subscription = _subscription;
       _subscription = null;
       subscription.cancel();
     }
   }
 
   bool _ignoreError(error)
@@ skipping 217 matching lines @@
     buffer[offset++] = _CharCode.LF;
 
     var session = _httpRequest._session;
     if (session != null && !session._destroyed) {
       // Mark as not new.
       session._isNew = false;
       // Make sure we only send the current session id.
       bool found = false;
       for (int i = 0; i < cookies.length; i++) {
         if (cookies[i].name.toUpperCase() == _DART_SESSION_ID) {
-          cookies[i].value = session.id;
-          cookies[i].httpOnly = true;
-          cookies[i].path = "/";
+          cookies[i]
+              ..value = session.id
+              ..httpOnly = true
+              ..path = "/";
           found = true;
         }
       }
       if (!found) {
         var cookie = new Cookie(_DART_SESSION_ID, session.id);
-        cookie.httpOnly = true;
-        cookie.path = "/";
-        cookies.add(cookie);
+        cookies.add(cookie
+            ..httpOnly = true
+            ..path = "/");
       }
     }
     // Add all the cookies set to the headers.
     if (_cookies != null) {
       _cookies.forEach((cookie) {
         headers.add(HttpHeaders.SET_COOKIE, cookie);
       });
     }
 
     headers._finalize();
@@ skipping 79 matching lines @@
 
   Future<HttpClientResponse> _response;
 
   // TODO(ajohnsen): Get default value from client?
   bool _followRedirects = true;
 
   int _maxRedirects = 5;
 
   List<RedirectInfo> _responseRedirects = [];
 
-  _HttpClientRequest(_HttpOutgoing outgoing,
-                     Uri uri,
-                     String this.method,
-                     _Proxy this._proxy,
-                     _HttpClient this._httpClient,
-                     _HttpClientConnection this._httpClientConnection)
+  _HttpClientRequest(_HttpOutgoing outgoing, Uri uri, this.method, this._proxy,
+                     this._httpClient, this._httpClientConnection)
       : super(uri, "1.1", outgoing),
         uri = uri {
     // GET and HEAD have 'content-length: 0' by default.
     if (method == "GET" || method == "HEAD") {
       contentLength = 0;
     } else {
       headers.chunkedTransferEncoding = true;
     }
   }
 
@@ skipping 19 matching lines @@
 
   bool get followRedirects => _followRedirects;
   void set followRedirects(bool followRedirects) {
     if (_headersWritten) throw new StateError("Request already sent");
     _followRedirects = followRedirects;
   }
 
   HttpConnectionInfo get connectionInfo => _httpClientConnection.connectionInfo;
 
   void _onIncoming(_HttpIncoming incoming) {
-    var response = new _HttpClientResponse(incoming,
-                                           this,
-                                          _httpClient);
+    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((_) => response.redirect());
+        future = response.drain().then((_) => response.redirect());
       } else {
         // End with exception, too many redirects.
         future = response.drain()
             .then((_) => new Future.error(
                 new RedirectException("Redirect limit exceeded",
                                       response.redirects)));
       }
     } else if (response._shouldAuthenticateProxy) {
       future = response._authenticate(true);
     } else if (response._shouldAuthenticate) {
@@ skipping 65 matching lines @@
     // Write HTTP/1.1.
     write(_Const.HTTP11);
     buffer[offset++] = _CharCode.CR;
     buffer[offset++] = _CharCode.LF;
 
     // Add the cookies to the headers.
     if (!cookies.isEmpty) {
       StringBuffer sb = new StringBuffer();
       for (int i = 0; i < cookies.length; i++) {
         if (i > 0) sb.write("; ");
-        sb.write(cookies[i].name);
-        sb.write("=");
-        sb.write(cookies[i].value);
+        sb..write(cookies[i].name)..write("=")..write(cookies[i].value);
       }
       headers.add(HttpHeaders.COOKIE, sb.toString());
     }
 
     headers._finalize();
 
     // Write headers.
     offset = headers._write(buffer, offset);
     buffer[offset++] = _CharCode.CR;
     buffer[offset++] = _CharCode.LF;
@@ skipping 74 matching lines @@
 
 // Transformer that validates the content length.
 class _ContentLengthValidator
     implements StreamTransformer<List<int>, List<int>>, EventSink<List<int>> {
   final int expectedContentLength;
   final Uri uri;
   int _bytesWritten = 0;
 
   EventSink<List<int>> _outSink;
 
-  _ContentLengthValidator(int this.expectedContentLength, Uri this.uri);
+  _ContentLengthValidator(this.expectedContentLength, this.uri);
 
   Stream<List<int>> bind(Stream<List<int>> stream) {
     return new Stream.eventTransformed(
         stream,
         (EventSink sink) {
           if (_outSink != null) {
             throw new StateError("Validator transformer already used");
           }
           _outSink = sink;
           return this;
@@ skipping 30 matching lines @@
     _outSink.close();
   }
 }
 
 
 // Extends StreamConsumer as this is an internal type, only used to pipe to.
 class _HttpOutgoing implements StreamConsumer<List<int>> {
   final Completer _doneCompleter = new Completer();
   final Socket socket;
 
-  _HttpOutgoing(Socket this.socket);
+  _HttpOutgoing(this.socket);
 
   Future addStream(Stream<List<int>> stream) {
     return socket.addStream(stream)
         .catchError((error) {
           _doneCompleter.completeError(error);
           throw error;
         });
   }
 
   Future close() {
@@ skipping 13 matching lines @@
   final _HttpClient _httpClient;
   bool _dispose = false;
   Timer _idleTimer;
   bool closed = false;
   Uri _currentUri;
   final Uint8List _headersBuffer = new Uint8List(_HEADERS_BUFFER_SIZE);
 
   Completer<_HttpIncoming> _nextResponseCompleter;
   Future _streamFuture;
 
-  _HttpClientConnection(String this.key,
-                        Socket this._socket,
-                        _HttpClient this._httpClient,
+  _HttpClientConnection(this.key, this._socket, this._httpClient,
                         [this._proxyTunnel = false])
       : _httpParser = new _HttpParser.responseParser() {
     _socket.pipe(_httpParser);
 
     // Set up handlers on the parser here, so we are sure to get 'onDone' from
     // the parser.
     _subscription = _httpParser.listen(
         (incoming) {
           // Only handle one incoming response at the time. Keep the
           // stream paused until the response have been processed.
@@ skipping 35 matching lines @@
     _ProxyCredentials proxyCreds;  // Credentials used to authorize proxy.
     _SiteCredentials creds;  // Credentials used to authorize this request.
     var outgoing = new _HttpOutgoing(_socket);
     // Create new request object, wrapping the outgoing connection.
     var request = new _HttpClientRequest(outgoing,
                                          uri,
                                          method,
                                          proxy,
                                          _httpClient,
                                          this);
-    request.headers.host = uri.host;
-    request.headers.port = port;
-    request.headers._add(HttpHeaders.ACCEPT_ENCODING, "gzip");
+    request.headers
+        ..host = uri.host
+        ..port = port
+        .._add(HttpHeaders.ACCEPT_ENCODING, "gzip");
     if (_httpClient.userAgent != null) {
       request.headers._add('user-agent', _httpClient.userAgent);
     }
     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}"));
       request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
     } else if (!proxy.isDirect && _httpClient._proxyCredentials.length > 0) {
@@ skipping 155 matching lines @@
     _idleTimer = new Timer(
         _httpClient.idleTimeout,
         () {
           _idleTimer = null;
           close();
         });
   }
 }
 
 class _ConnnectionInfo {
-  _ConnnectionInfo(_HttpClientConnection this.connection, _Proxy this.proxy);
   final _HttpClientConnection connection;
   final _Proxy proxy;
+
+  _ConnnectionInfo(this.connection, this.proxy);
 }
 
 
 class _HttpClient implements HttpClient {
   // TODO(ajohnsen): Use eviction timeout.
   bool _closing = false;
 
   final Map<String, Set<_HttpClientConnection>> _idleConnections
       = new HashMap<String, Set<_HttpClientConnection>>();
   final Set<_HttpClientConnection> _activeConnections
@@ skipping 83 matching lines @@
       }
       assert(_activeConnections.isEmpty);
       _activeConnections.clear();
     }
   }
 
   set authenticate(Future<bool> f(Uri url, String scheme, String realm)) {
     _authenticate = f;
   }
 
-  void addCredentials(Uri url, String realm, HttpClientCredentials cr) {
-    _credentials.add(new _SiteCredentials(url, realm, cr));
-  }
+  void addCredentials(Uri url, String realm, HttpClientCredentials cr) =>
+      _credentials.add(new _SiteCredentials(url, realm, cr));
 
   set authenticateProxy(
       Future<bool> f(String host, int port, String scheme, String realm)) {
     _authenticateProxy = f;
   }
 
   void addProxyCredentials(String host,
                            int port,
                            String realm,
-                           HttpClientCredentials cr) {
-    _proxyCredentials.add(new _ProxyCredentials(host, port, realm, cr));
-  }
+                           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) {
     if (method == null) {
       throw new ArgumentError(method);
     }
     if (method != "CONNECT") {
       if (uri.host.isEmpty) {
         throw new ArgumentError("No host specified in URI $uri");
@@ skipping 39 matching lines @@
         });
   }
 
   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) {
-          // Only follow redirects if initial request did.
-          request.followRedirects = previous.followRedirects;
-          // Allow same number of redirects.
-          request.maxRedirects = previous.maxRedirects;
+
+          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]);
             }
           }
-          request.headers.chunkedTransferEncoding = false;
-          request.contentLength = 0;
-          return request;
+          return request
+              ..headers.chunkedTransferEncoding = false
+              ..contentLength = 0;
         });
   }
 
   // Return a live connection to the idle pool.
   void _returnConnection(_HttpClientConnection connection) {
     _activeConnections.remove(connection);
     if (_closing) {
       connection.close();
       return;
     }
@@ skipping 213 matching lines @@
 
   final Socket _socket;
   final _HttpServer _httpServer;
   final _HttpParser _httpParser;
   StreamSubscription _subscription;
   Timer _idleTimer;
   final Uint8List _headersBuffer = new Uint8List(_HEADERS_BUFFER_SIZE);
 
   Future _streamFuture;
 
-  _HttpConnection(Socket this._socket, _HttpServer this._httpServer)
+  _HttpConnection(this._socket, this._httpServer)
       : _httpParser = new _HttpParser.requestParser() {
     _startTimeout();
     _socket.pipe(_httpParser);
     _subscription = _httpParser.listen(
         (incoming) {
           _stopTimeout();
           // If the incoming was closed, close the connection.
           incoming.dataDone.then((closing) {
             if (closing) destroy();
           });
@@ skipping 112 matching lines @@
         .then((socket) {
           return new _HttpServer._(socket, true);
         });
   }
 
   _HttpServer._(this._serverSocket, this._closeServer) {
     _controller = new StreamController<HttpRequest>(sync: true,
                                                     onCancel: close);
   }
 
-  _HttpServer.listenOn(ServerSocket this._serverSocket)
-      : _closeServer = false {
+  _HttpServer.listenOn(this._serverSocket) : _closeServer = false {
     _controller = new StreamController<HttpRequest>(sync: true,
                                                     onCancel: close);
   }
 
   StreamSubscription<HttpRequest> listen(void onData(HttpRequest event),
                                          {Function onError,
                                          void onDone(),
                                          bool cancelOnError}) {
     _serverSocket.listen(
         (Socket socket) {
@@ skipping 54 matching lines @@
 
   InternetAddress get address {
     if (closed) throw new HttpException("HttpServer is not bound to a socket");
     return _serverSocket.address;
   }
 
   set sessionTimeout(int timeout) {
     _sessionManager.sessionTimeout = timeout;
   }
 
-  void _handleRequest(HttpRequest request) {
-    _controller.add(request);
-  }
+  void _handleRequest(HttpRequest request) => _controller.add(request);
 
   void _handleError(error) {
     if (!closed) _controller.addError(error);
   }
 
   void _connectionClosed(_HttpConnection connection) {
     _connections.remove(connection);
     _maybeCloseSessionManager();
   }
 
@@ skipping 99 matching lines @@
   }
 
   const _ProxyConfiguration.direct()
       : proxies = const [const _Proxy.direct()];
 
   final List<_Proxy> proxies;
 }
 
 
 class _Proxy {
-  const _Proxy(
-      this.host, this.port, this.username, this.password) : isDirect = false;
-  const _Proxy.direct() : host = null, port = null,
-                          username = null, password = null, isDirect = true;
-
-  bool get isAuthenticated => username != null;
-
   final String host;
   final int port;
   final String username;
   final String password;
   final bool isDirect;
+
+  const _Proxy(this.host, this.port, this.username, this.password)
+      : isDirect = false;
+  const _Proxy.direct() : host = null, port = null,
+                          username = null, password = null, isDirect = true;
+
+  bool get isAuthenticated => username != null;
 }
 
 
 class _HttpConnectionInfo implements HttpConnectionInfo {
+  InternetAddress remoteAddress;
+  int remotePort;
+  int localPort;
+
   static _HttpConnectionInfo create(Socket socket) {
     if (socket == null) return null;
     try {
       _HttpConnectionInfo info = new _HttpConnectionInfo();
-      info.remoteAddress = socket.remoteAddress;
-      info.remotePort = socket.remotePort;
-      info.localPort = socket.port;
-      return info;
+      return info
+          ..remoteAddress = socket.remoteAddress
+          ..remotePort = socket.remotePort
+          ..localPort = socket.port;
     } catch (e) { }
     return null;
   }
-
-  InternetAddress remoteAddress;
-  int remotePort;
-  int localPort;
 }
 
 
 class _DetachedSocket extends Stream<List<int>> implements Socket {
   final Stream<List<int>> _incoming;
   final Socket _socket;
 
   _DetachedSocket(this._socket, this._incoming);
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
@@ skipping 47 matching lines @@
 
   int get remotePort => _socket.remotePort;
 
   bool setOption(SocketOption option, bool enabled) {
     return _socket.setOption(option, enabled);
   }
 }
 
 
 class _AuthenticationScheme {
+  final int _scheme;
+
   static const UNKNOWN = const _AuthenticationScheme(-1);
   static const BASIC = const _AuthenticationScheme(0);
   static const DIGEST = const _AuthenticationScheme(1);
 
   const _AuthenticationScheme(this._scheme);
 
   factory _AuthenticationScheme.fromString(String scheme) {
     if (scheme.toLowerCase() == "basic") return BASIC;
     if (scheme.toLowerCase() == "digest") return DIGEST;
     return UNKNOWN;
   }
 
   String toString() {
     if (this == BASIC) return "Basic";
     if (this == DIGEST) return "Digest";
     return "Unknown";
   }
-
-  final int _scheme;
 }
 
 
 abstract class _Credentials {
   _HttpClientCredentials credentials;
   String realm;
   bool used = false;
 
   // Digest specific fields.
   String ha1;
   String nonce;
   String algorithm;
   String qop;
   int nonceCount;
 
   _Credentials(this.credentials, this.realm) {
     if (credentials.scheme == _AuthenticationScheme.DIGEST) {
       // Calculate the H(A1) value once. There is no mentioning of
       // username/password encoding in RFC 2617. However there is an
       // open draft for adding an additional accept-charset parameter to
       // the WWW-Authenticate and Proxy-Authenticate headers, see
       // http://tools.ietf.org/html/draft-reschke-basicauth-enc-06. For
       // now always use UTF-8 encoding.
       _HttpClientDigestCredentials creds = credentials;
-      var hasher = new _MD5();
-      hasher.add(UTF8.encode(creds.username));
-      hasher.add([_CharCode.COLON]);
-      hasher.add(realm.codeUnits);
-      hasher.add([_CharCode.COLON]);
-      hasher.add(UTF8.encode(creds.password));
+      var hasher = new _MD5()
+          ..add(UTF8.encode(creds.username))
+          ..add([_CharCode.COLON])
+          ..add(realm.codeUnits)
+          ..add([_CharCode.COLON])
+          ..add(UTF8.encode(creds.password));
       ha1 = _CryptoUtils.bytesToHex(hasher.close());
     }
   }
 
   _AuthenticationScheme get scheme => credentials.scheme;
 
   void authorize(HttpClientRequest request);
 }
 
 class _SiteCredentials extends _Credentials {
   Uri uri;
 
   _SiteCredentials(this.uri, realm, _HttpClientCredentials creds)
-  : super(creds, realm);
+      : super(creds, realm);
 
   bool applies(Uri uri, _AuthenticationScheme scheme) {
     if (scheme != null && credentials.scheme != scheme) return false;
     if (uri.host != this.uri.host) return false;
     int thisPort =
         this.uri.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : this.uri.port;
     int otherPort = uri.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : uri.port;
     if (otherPort != thisPort) return false;
     return uri.path.startsWith(this.uri.path);
   }
@@ skipping 12 matching lines @@
 
 
 class _ProxyCredentials extends _Credentials {
   String host;
   int port;
 
   _ProxyCredentials(this.host,
                     this.port,
                     realm,
                     _HttpClientCredentials creds)
-  : super(creds, realm);
+      : super(creds, realm);
 
   bool applies(_Proxy proxy, _AuthenticationScheme scheme) {
     if (scheme != null && credentials.scheme != scheme) return false;
     return proxy.host == host && proxy.port == port;
   }
 
   void authorize(HttpClientRequest request) {
     // Digest credentials cannot be used without a nonce from the
     // server.
     if (credentials.scheme == _AuthenticationScheme.DIGEST &&
         nonce == null) {
       return;
     }
     credentials.authorizeProxy(this, request);
   }
 }
 
 
 abstract class _HttpClientCredentials implements HttpClientCredentials {
   _AuthenticationScheme get scheme;
   void authorize(_Credentials credentials, HttpClientRequest request);
   void authorizeProxy(_ProxyCredentials credentials, HttpClientRequest request);
 }
 
 
 class _HttpClientBasicCredentials
     extends _HttpClientCredentials
     implements HttpClientBasicCredentials {
-  _HttpClientBasicCredentials(this.username,
-                              this.password);
+  String username;
+  String password;
+
+  _HttpClientBasicCredentials(this.username, this.password);
 
   _AuthenticationScheme get scheme => _AuthenticationScheme.BASIC;
 
   String authorization() {
     // There is no mentioning of username/password encoding in RFC
     // 2617. However there is an open draft for adding an additional
     // accept-charset parameter to the WWW-Authenticate and
     // Proxy-Authenticate headers, see
     // http://tools.ietf.org/html/draft-reschke-basicauth-enc-06. For
     // now always use UTF-8 encoding.
     String auth =
         _CryptoUtils.bytesToBase64(UTF8.encode("$username:$password"));
     return "Basic $auth";
   }
 
-  void authorize(_Credentials _, HttpClientRequest request) {
-    request.headers.set(HttpHeaders.AUTHORIZATION, authorization());
-  }
+  void authorize(_Credentials _, HttpClientRequest request) =>
+      request.headers.set(HttpHeaders.AUTHORIZATION, authorization());
 
-  void authorizeProxy(_ProxyCredentials _, HttpClientRequest request) {
-    request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, authorization());
-  }
-
-  String username;
-  String password;
+  void authorizeProxy(_ProxyCredentials _, HttpClientRequest request) =>
+      request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, authorization());
 }
 
 
 class _HttpClientDigestCredentials
     extends _HttpClientCredentials
     implements HttpClientDigestCredentials {
-  _HttpClientDigestCredentials(this.username,
-                               this.password);
+  String username;
+  String password;
+
+  _HttpClientDigestCredentials(this.username, this.password);
 
   _AuthenticationScheme get scheme => _AuthenticationScheme.DIGEST;
 
   String authorization(_Credentials credentials, _HttpClientRequest request) {
     String requestUri = request._requestUri();
-    _MD5 hasher = new _MD5();
-    hasher.add(request.method.codeUnits);
-    hasher.add([_CharCode.COLON]);
-    hasher.add(requestUri.codeUnits);
+    _MD5 hasher = new _MD5()
+        ..add(request.method.codeUnits)
+        ..add([_CharCode.COLON])
+        ..add(requestUri.codeUnits);
     var ha2 = _CryptoUtils.bytesToHex(hasher.close());
 
     String qop;
     String cnonce;
     String nc;
     var x;
-    hasher = new _MD5();
-    hasher.add(credentials.ha1.codeUnits);
-    hasher.add([_CharCode.COLON]);
+    hasher = new _MD5()
+        ..add(credentials.ha1.codeUnits)
+        ..add([_CharCode.COLON]);
     if (credentials.qop == "auth") {
       qop = credentials.qop;
       cnonce = _CryptoUtils.bytesToHex(_IOCrypto.getRandomBytes(4));
       ++credentials.nonceCount;
       nc = credentials.nonceCount.toRadixString(16);
       nc = "00000000".substring(0, 8 - nc.length + 1) + nc;
-      hasher.add(credentials.nonce.codeUnits);
-      hasher.add([_CharCode.COLON]);
-      hasher.add(nc.codeUnits);
-      hasher.add([_CharCode.COLON]);
-      hasher.add(cnonce.codeUnits);
-      hasher.add([_CharCode.COLON]);
-      hasher.add(credentials.qop.codeUnits);
-      hasher.add([_CharCode.COLON]);
-      hasher.add(ha2.codeUnits);
+      hasher
+          ..add(credentials.nonce.codeUnits)
+          ..add([_CharCode.COLON])
+          ..add(nc.codeUnits)
+          ..add([_CharCode.COLON])
+          ..add(cnonce.codeUnits)
+          ..add([_CharCode.COLON])
+          ..add(credentials.qop.codeUnits)
+          ..add([_CharCode.COLON])
+          ..add(ha2.codeUnits);
     } else {
-      hasher.add(credentials.nonce.codeUnits);
-      hasher.add([_CharCode.COLON]);
-      hasher.add(ha2.codeUnits);
+      hasher
+          ..add(credentials.nonce.codeUnits)
+          ..add([_CharCode.COLON])
+          ..add(ha2.codeUnits);
     }
     var response = _CryptoUtils.bytesToHex(hasher.close());
 
-    StringBuffer buffer = new StringBuffer();
-    buffer.write('Digest ');
-    buffer.write('username="$username"');
-    buffer.write(', realm="${credentials.realm}"');
-    buffer.write(', nonce="${credentials.nonce}"');
-    buffer.write(', uri="$requestUri"');
-    buffer.write(', algorithm="${credentials.algorithm}"');
+    StringBuffer buffer = new StringBuffer()
+        ..write('Digest ')
+        ..write('username="$username"')
+        ..write(', realm="${credentials.realm}"')
+        ..write(', nonce="${credentials.nonce}"')
+        ..write(', uri="$requestUri"')
+        ..write(', algorithm="${credentials.algorithm}"');
     if (qop == "auth") {
-      buffer.write(', qop="$qop"');
-      buffer.write(', cnonce="$cnonce"');
-      buffer.write(', nc="$nc"');
+      buffer
+          ..write(', qop="$qop"')
+          ..write(', cnonce="$cnonce"')
+          ..write(', nc="$nc"');
     }
     buffer.write(', response="$response"');
     return buffer.toString();
   }
 
   void authorize(_Credentials credentials, HttpClientRequest request) {
     request.headers.set(HttpHeaders.AUTHORIZATION,
                         authorization(credentials, request));
   }
 
   void authorizeProxy(_ProxyCredentials credentials,
                       HttpClientRequest request) {
     request.headers.set(HttpHeaders.PROXY_AUTHORIZATION,
                         authorization(credentials, request));
   }
-
-  String username;
-  String password;
 }
 
 
 class _RedirectInfo implements RedirectInfo {
-  const _RedirectInfo(int this.statusCode,
-                      String this.method,
-                      Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
+  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)';
 }
-
-