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

sdk/lib/io/websocket_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 String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 class _WebSocketMessageType {
   static const int NONE = 0;
@@ skipping 33 matching lines @@
 // TODO(ajohnsen): make this transformer reusable?
 class _WebSocketProtocolTransformer implements StreamTransformer, EventSink {
   static const int START = 0;
   static const int LEN_FIRST = 1;
   static const int LEN_REST = 2;
   static const int MASK = 3;
   static const int PAYLOAD = 4;
   static const int CLOSED = 5;
   static const int FAILURE = 6;
 
+  int _state;
+  bool _fin;
+  int _opcode;
+  int _len;
+  bool _masked;
+  int _maskingKey;
+  int _remainingLenBytes;
+  int _remainingMaskingKeyBytes;
+  int _remainingPayloadBytes;
+  int _unmaskingIndex;
+
+  int _currentMessageType;
+  List<int> _controlPayload;
+  StreamController _controller;
+
+  int closeCode = WebSocketStatus.NO_STATUS_RECEIVED;
+  String closeReason = "";
+
   bool _serverSide;
   EventSink _eventSink;
 
-  _WebSocketProtocolTransformer([bool this._serverSide = false]) {
+  _WebSocketProtocolTransformer([this._serverSide = false]) {
     _prepareForNextFrame();
     _currentMessageType = _WebSocketMessageType.NONE;
   }
 
   Stream bind(Stream stream) {
     return new Stream.eventTransformed(
         stream,
         (EventSink eventSink) {
           if (_eventSink != null) {
             throw new StateError("WebSocket transformer already used.");
           }
           _eventSink = eventSink;
           return this;
         });
   }
 
-  void addError(Object error, [StackTrace stackTrace]) {
-    _eventSink.addError(error, stackTrace);
-  }
+  void addError(Object error, [StackTrace stackTrace]) =>
+      _eventSink.addError(error, stackTrace);
 
   void close() => _eventSink.close();
 
   /**
    * Process data received from the underlying communication channel.
    */
   void add(Uint8List buffer) {
     int count = buffer.length;
     int index = 0;
     int lastIndex = count;
@@ skipping 263 matching lines @@
     _opcode = null;
     _len = null;
     _masked = null;
     _maskingKey = 0;
     _remainingLenBytes = null;
     _remainingMaskingKeyBytes = null;
     _remainingPayloadBytes = null;
     _unmaskingIndex = 0;
     _controlPayload = null;
   }
-
-  int _state;
-  bool _fin;
-  int _opcode;
-  int _len;
-  bool _masked;
-  int _maskingKey;
-  int _remainingLenBytes;
-  int _remainingMaskingKeyBytes;
-  int _remainingPayloadBytes;
-  int _unmaskingIndex;
-
-  int _currentMessageType;
-  List<int> _controlPayload;
-  StreamController _controller;
-
-  int closeCode = WebSocketStatus.NO_STATUS_RECEIVED;
-  String closeReason = "";
 }
 
 
 class _WebSocketPing {
   final List<int> payload;
   _WebSocketPing([this.payload = null]);
 }
 
 
 class _WebSocketPong {
@@ skipping 16 matching lines @@
             .catchError(_controller.addError);
     });
 
     return _controller.stream;
   }
 
   static Future<WebSocket> _upgrade(HttpRequest request, _protocolSelector) {
     var response = request.response;
     if (!_isUpgradeRequest(request)) {
       // Send error response.
-      response.statusCode = HttpStatus.BAD_REQUEST;
-      response.close();
+      response
+          ..statusCode = HttpStatus.BAD_REQUEST
+          ..close();
       return new Future.error(
           new WebSocketException("Invalid WebSocket upgrade request"));
     }
 
     Future upgrade(String protocol) {
       // Send the upgrade response.
-      response.statusCode = HttpStatus.SWITCHING_PROTOCOLS;
-      response.headers.add(HttpHeaders.CONNECTION, "Upgrade");
-      response.headers.add(HttpHeaders.UPGRADE, "websocket");
+      response
+          ..statusCode = HttpStatus.SWITCHING_PROTOCOLS
+          ..headers.add(HttpHeaders.CONNECTION, "Upgrade")
+          ..headers.add(HttpHeaders.UPGRADE, "websocket");
       String key = request.headers.value("Sec-WebSocket-Key");
       _SHA1 sha1 = new _SHA1();
       sha1.add("$key$_webSocketGUID".codeUnits);
       String accept = _CryptoUtils.bytesToBase64(sha1.close());
       response.headers.add("Sec-WebSocket-Accept", accept);
       if (protocol != null && protocol.isNotEmpty) {
         response.headers.add("Sec-WebSocket-Protocol", protocol);
       }
       response.headers.contentLength = 0;
       return response.detachSocket()
           .then((socket) => new _WebSocketImpl._fromSocket(
                 socket, protocol, true));
     }
 
     var protocols = request.headers['Sec-WebSocket-Protocol'];
     if (protocols != null && _protocolSelector != null) {
       // The suggested protocols can be spread over multiple lines, each
       // consisting of multiple protocols. To unify all of them, first join
       // the lists with ', ' and then tokenize.
       protocols = _HttpParser._tokenizeFieldValue(protocols.join(', '));
       return new Future(() => _protocolSelector(protocols))
         .then((protocol) {
           if (protocols.indexOf(protocol) < 0) {
             throw new WebSocketException(
                 "Selected protocol is not in the list of available protocols");
           }
           return protocol;
         })
         .catchError((error) {
-          response.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
-          response.close();
+          response
+              ..statusCode = HttpStatus.INTERNAL_SERVER_ERROR
+              ..close();
           throw error;
         })
         .then(upgrade);
     } else {
       return upgrade(null);
     }
   }
 
   static bool _isUpgradeRequest(HttpRequest request) {
     if (request.method != "GET") {
@@ skipping 22 matching lines @@
     return true;
   }
 }
 
 
 // TODO(ajohnsen): Make this transformer reusable.
 class _WebSocketOutgoingTransformer implements StreamTransformer, EventSink {
   final _WebSocketImpl webSocket;
   EventSink _eventSink;
 
-  _WebSocketOutgoingTransformer(_WebSocketImpl this.webSocket);
+  _WebSocketOutgoingTransformer(this.webSocket);
 
   Stream bind(Stream stream) {
     return new Stream.eventTransformed(
         stream,
         (EventSink eventSink) {
           if (_eventSink != null) {
             throw new StateError("WebSocket transformer already used");
           }
           _eventSink = eventSink;
           return this;
@@ skipping 21 matching lines @@
         }
         opcode = _WebSocketOpcode.BINARY;
         data = message;
       }
     } else {
       opcode = _WebSocketOpcode.TEXT;
     }
     addFrame(opcode, data);
   }
 
-  void addError(Object error, [StackTrace stackTrace]) {
-    _eventSink.addError(error, stackTrace);
-  }
+  void addError(Object error, [StackTrace stackTrace]) =>
+      _eventSink.addError(error, stackTrace);
 
   void close() {
     int code = webSocket._outCloseCode;
     String reason = webSocket._outCloseReason;
     List<int> data;
     if (code != null) {
       data = new List<int>();
       data.add((code >> 8) & 0xFF);
       data.add(code & 0xFF);
       if (reason != null) {
         data.addAll(UTF8.encode(reason));
       }
     }
     addFrame(_WebSocketOpcode.CLOSE, data);
     _eventSink.close();
   }
 
-  void addFrame(int opcode, List<int> data) {
-    createFrame(opcode, data, webSocket._serverSide).forEach(_eventSink.add);
-  }
+  void addFrame(int opcode, List<int> data) =>
+      createFrame(opcode, data, webSocket._serverSide).forEach(_eventSink.add);
 
   static Iterable createFrame(int opcode, List<int> data, bool serverSide) {
     bool mask = !serverSide;  // Masking not implemented for server.
     int dataLength = data == null ? 0 : data.length;
     // Determine the header size.
     int headerSize = (mask) ? 6 : 2;
     if (dataLength > 65535) {
       headerSize += 8;
     } else if (dataLength > 125) {
       headerSize += 2;
@@ skipping 60 matching lines @@
 class _WebSocketConsumer implements StreamConsumer {
   final _WebSocketImpl webSocket;
   final Socket socket;
   StreamController _controller;
   StreamSubscription _subscription;
   bool _issuedPause = false;
   bool _closed = false;
   Completer _closeCompleter = new Completer();
   Completer _completer;
 
-  _WebSocketConsumer(_WebSocketImpl this.webSocket, Socket this.socket);
+  _WebSocketConsumer(this.webSocket, this.socket);
 
   void _onListen() {
     if (_subscription != null) {
       _subscription.cancel();
     }
   }
 
   void _onPause() {
     if (_subscription != null) {
       _subscription.pause();
@@ skipping 141 matching lines @@
     uri = new Uri(scheme: uri.scheme == "wss" ? "https" : "http",
                   userInfo: uri.userInfo,
                   host: uri.host,
                   port: uri.port,
                   path: uri.path,
                   query: uri.query,
                   fragment: uri.fragment);
     return _httpClient.openUrl("GET", uri)
       .then((request) {
         // Setup the initial handshake.
-        request.headers.add(HttpHeaders.CONNECTION, "upgrade");
-        request.headers.set(HttpHeaders.UPGRADE, "websocket");
-        request.headers.set("Sec-WebSocket-Key", nonce);
-        request.headers.set("Sec-WebSocket-Version", "13");
+        request.headers
+            ..add(HttpHeaders.CONNECTION, "upgrade")
+            ..set(HttpHeaders.UPGRADE, "websocket")
+            ..set("Sec-WebSocket-Key", nonce)
+            ..set("Sec-WebSocket-Version", "13");
         if (protocols.isNotEmpty) {
           request.headers.add("Sec-WebSocket-Protocol", protocols);
         }
         return request.close();
       })
       .then((response) {
         void error(String message) {
           // Flush data.
           response.detachSocket().then((socket) {
             socket.destroy();
@@ skipping 23 matching lines @@
           if (expectedAccept[i] != receivedAccept[i]) {
             error("Bad response 'Sec-WebSocket-Accept' header");
           }
         }
         var protocol = response.headers.value('Sec-WebSocket-Protocol');
         return response.detachSocket()
             .then((socket) => new _WebSocketImpl._fromSocket(socket, protocol));
       });
   }
 
-  _WebSocketImpl._fromSocket(Socket this._socket,
-                             String this.protocol,
-                             [bool this._serverSide = false]) {
+  _WebSocketImpl._fromSocket(this._socket, this.protocol,
+                             [this._serverSide = false]) {
     _consumer = new _WebSocketConsumer(this, _socket);
     _sink = new _StreamSinkImpl(_consumer);
     _readyState = WebSocket.OPEN;
 
     var transformer = new _WebSocketProtocolTransformer(_serverSide);
     _subscription = _socket.transform(transformer).listen(
         (data) {
           if (data is _WebSocketPing) {
             if (!_writeClosed) _consumer.add(new _WebSocketPong(data.payload));
           } else if (data is _WebSocketPong) {
@@ skipping 100 matching lines @@
            (code < WebSocketStatus.NORMAL_CLOSURE ||
             code == WebSocketStatus.RESERVED_1004 ||
             code == WebSocketStatus.NO_STATUS_RECEIVED ||
             code == WebSocketStatus.ABNORMAL_CLOSURE ||
             (code > WebSocketStatus.INTERNAL_SERVER_ERROR &&
              code < WebSocketStatus.RESERVED_1015) ||
             (code >= WebSocketStatus.RESERVED_1015 &&
              code < 3000));
   }
 }