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

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";
 const String _clientNoContextTakeover = "client_no_context_takeover";
 const String _serverNoContextTakeover = "server_no_context_takeover";
 const String _clientMaxWindowBits = "client_max_window_bits";
@@ skipping 32 matching lines @@
  */
 class _CompressionMaxWindowBits {
   String headerValue;
   int maxWindowBits;
   _CompressionMaxWindowBits([this.headerValue, this.maxWindowBits]);
   String toString() => headerValue;
 }
 
 /**
  * The web socket protocol transformer handles the protocol byte stream
- * which is supplied through the `handleData`. As the protocol is processed,
+ * which is supplied through the [:handleData:]. As the protocol is processed,
  * it'll output frame data as either a List<int> or String.
  *
  * Important information about usage: Be sure you use cancelOnError, so the
  * socket will be closed when the processor encounter an error. Not using it
  * will lead to undefined behaviour.
  */
 // TODO(ajohnsen): make this transformer reusable?
 class _WebSocketProtocolTransformer
-    implements EventSink<List<int>>, StreamTransformer<
-        List<int>, dynamic/*List<int>|_WebSocketPing|_WebSocketPong>*/> {
+    implements StreamTransformer<List<int>, dynamic>, EventSink<Uint8List> {
   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;
   static const int FIN = 0x80;
   static const int RSV1 = 0x40;
   static const int RSV2 = 0x20;
   static const int RSV3 = 0x10;
   static const int OPCODE = 0xF;
 
   int _state = START;
   bool _fin = false;
   bool _compressed = false;
   int _opcode = -1;
   int _len = -1;
   bool _masked = false;
   int _remainingLenBytes = -1;
   int _remainingMaskingKeyBytes = 4;
   int _remainingPayloadBytes = -1;
   int _unmaskingIndex = 0;
   int _currentMessageType = _WebSocketMessageType.NONE;
   int closeCode = WebSocketStatus.NO_STATUS_RECEIVED;
   String closeReason = "";
 
-  EventSink<dynamic/*List<int>|_WebSocketPing|_WebSocketPong>*/> _eventSink;
+  EventSink _eventSink;
 
   final bool _serverSide;
   final List _maskingBytes = new List(4);
   final BytesBuilder _payload = new BytesBuilder(copy: false);
 
   _WebSocketPerMessageDeflate _deflate;
   _WebSocketProtocolTransformer([this._serverSide = false, this._deflate]);
 
-  Stream<dynamic/*List<int>|_WebSocketPing|_WebSocketPong>*/> bind(
-      Stream<List<int>> stream) {
+  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]) {
@@ skipping 277 matching lines @@
 class _WebSocketPing {
   final List<int> payload;
   _WebSocketPing([this.payload = null]);
 }
 
 class _WebSocketPong {
   final List<int> payload;
   _WebSocketPong([this.payload = null]);
 }
 
-typedef /*String|Future<String>*/ _ProtocolSelector(List<String> protocols);
-
 class _WebSocketTransformerImpl implements WebSocketTransformer {
   final StreamController<WebSocket> _controller =
       new StreamController<WebSocket>(sync: true);
-  final _ProtocolSelector _protocolSelector;
+  final Function _protocolSelector;
   final CompressionOptions _compression;
 
   _WebSocketTransformerImpl(this._protocolSelector, this._compression);
 
   Stream<WebSocket> bind(Stream<HttpRequest> stream) {
     stream.listen((request) {
       _upgrade(request, _protocolSelector, _compression)
           .then((WebSocket webSocket) => _controller.add(webSocket))
           .catchError(_controller.addError);
     }, onDone: () {
       _controller.close();
     });
 
     return _controller.stream;
   }
 
-  static Future<WebSocket> _upgrade(HttpRequest request,
-      _ProtocolSelector _protocolSelector, CompressionOptions compression) {
+  static Future<WebSocket> _upgrade(
+      HttpRequest request, _protocolSelector, CompressionOptions compression) {
     var response = request.response;
     if (!_isUpgradeRequest(request)) {
       // Send error response.
       response
         ..statusCode = HttpStatus.BAD_REQUEST
         ..close();
       return new Future.error(
           new WebSocketException("Invalid WebSocket upgrade request"));
     }
 
-    Future<WebSocket> upgrade(String protocol) {
+    Future upgrade(String protocol) {
       // Send the upgrade response.
       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) {
         response.headers.add("Sec-WebSocket-Protocol", protocol);
       }
 
       var deflate = _negotiateCompression(request, response, compression);
 
       response.headers.contentLength = 0;
-      return response.detachSocket().then/*<WebSocket>*/((socket) =>
+      return response.detachSocket().then((socket) =>
           new _WebSocketImpl._fromSocket(
               socket, protocol, compression, true, deflate));
     }
 
     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<String>(() => _protocolSelector(protocols))
-          .then/*<String>*/((protocol) {
+      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
           ..close();
         throw error;
-      }).then/*<WebSocket>*/(upgrade);
+      }).then(upgrade);
     } else {
       return upgrade(null);
     }
   }
 
   static _WebSocketPerMessageDeflate _negotiateCompression(HttpRequest request,
       HttpResponse response, CompressionOptions compression) {
     var extensionHeader = request.headers.value("Sec-WebSocket-Extensions");
 
     extensionHeader ??= "";
@@ skipping 83 matching lines @@
           ZLibOption.DEFAULT_MEM_LEVEL,
           ZLibOption.STRATEGY_DEFAULT,
           null,
           true);
     }
   }
 
   Uint8List processIncomingMessage(List<int> msg) {
     _ensureDecoder();
 
-    var data = <int>[];
+    var data = [];
     data.addAll(msg);
     data.addAll(const [0x00, 0x00, 0xff, 0xff]);
 
     decoder.process(data, 0, data.length);
-    var result = <int>[];
-    List<int> out;
+    var result = [];
+    var out;
 
     while ((out = decoder.processed()) != null) {
       result.addAll(out);
     }
 
     if ((serverSide && clientNoContextTakeover) ||
         (!serverSide && serverNoContextTakeover)) {
       decoder = null;
     }
 
     return new Uint8List.fromList(result);
   }
 
   List<int> processOutgoingMessage(List<int> msg) {
     _ensureEncoder();
-    var result = <int>[];
+    var result = [];
     Uint8List buffer;
+    var out;
 
     if (msg is! Uint8List) {
       for (var i = 0; i < msg.length; i++) {
         if (msg[i] < 0 || 255 < msg[i]) {
           throw new ArgumentError("List element is not a byte value "
               "(value ${msg[i]} at index $i)");
         }
       }
       buffer = new Uint8List.fromList(msg);
     } else {
       buffer = msg;
     }
 
     encoder.process(buffer, 0, buffer.length);
 
-    List<int> out;
     while ((out = encoder.processed()) != null) {
       result.addAll(out);
     }
 
     if ((!serverSide && clientNoContextTakeover) ||
         (serverSide && serverNoContextTakeover)) {
       encoder = null;
     }
 
     if (result.length > 4) {
@@ skipping 10 matching lines @@
   final _WebSocketImpl webSocket;
   EventSink<List<int>> _eventSink;
 
   _WebSocketPerMessageDeflate _deflateHelper;
 
   _WebSocketOutgoingTransformer(this.webSocket) {
     _deflateHelper = webSocket._deflate;
   }
 
   Stream<List<int>> bind(Stream stream) {
-    return new Stream<List<int>>.eventTransformed(
-        stream, (EventSink<List<int>> eventSink) {
+    return new Stream.eventTransformed(stream, (eventSink) {
       if (_eventSink != null) {
         throw new StateError("WebSocket transformer already used");
       }
       _eventSink = eventSink;
       return this;
     });
   }
 
   void add(message) {
     if (message is _WebSocketPong) {
       addFrame(_WebSocketOpcode.PONG, message.payload);
       return;
     }
     if (message is _WebSocketPing) {
       addFrame(_WebSocketOpcode.PING, message.payload);
       return;
     }
     List<int> data;
     int opcode;
     if (message != null) {
       if (message is String) {
         opcode = _WebSocketOpcode.TEXT;
         data = UTF8.encode(message);
       } else {
         if (message is List<int>) {
+          data = message;
           opcode = _WebSocketOpcode.BINARY;
-          data = message;
         } else {
           throw new ArgumentError(message);
         }
       }
 
       if (_deflateHelper != null) {
         data = _deflateHelper.processOutgoingMessage(data);
       }
     } else {
       opcode = _WebSocketOpcode.TEXT;
@@ skipping 14 matching lines @@
       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,
-        _deflateHelper != null &&
-            (opcode == _WebSocketOpcode.TEXT ||
-                opcode == _WebSocketOpcode.BINARY))
-      .forEach((e) { _eventSink.add(e); });
-  }
+  void addFrame(int opcode, List<int> data) => createFrame(
+          opcode,
+          data,
+          webSocket._serverSide,
+          _deflateHelper != null &&
+              (opcode == _WebSocketOpcode.TEXT ||
+                  opcode == _WebSocketOpcode.BINARY)).forEach((e) {
+        _eventSink.add(e);
+      });
 
   static Iterable<List<int>> createFrame(
       int opcode, List<int> data, bool serverSide, bool compressed) {
     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) {
@@ skipping 525 matching lines @@
     return code != null &&
         (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));
   }
 }