Revert "Fix strong mode 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 41 matching lines @@
  * The web socket protocol transformer handles the protocol byte stream
  * 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 StreamTransformer<List<int>, dynamic>, EventSink<Uint8List> {
+    implements StreamTransformer<List<int>, dynamic>, EventSink<List<int>> {
   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;
@@ skipping 920 matching lines @@
         request.headers.add("Sec-WebSocket-Protocol", protocols.toList());
       }
 
       if (compression.enabled) {
         request.headers
             .add("Sec-WebSocket-Extensions", compression._createHeader());
       }
 
       return request.close();
     }).then((response) {
-
       void error(String message) {
         // Flush data.
         response.detachSocket().then((socket) {
           socket.destroy();
         });
         throw new WebSocketException(message);
       }
-
       if (response.statusCode != HttpStatus.SWITCHING_PROTOCOLS ||
           response.headers[HttpHeaders.CONNECTION] == null ||
           !response.headers[HttpHeaders.CONNECTION]
               .any((value) => value.toLowerCase() == "upgrade") ||
           response.headers.value(HttpHeaders.UPGRADE).toLowerCase() !=
               "websocket") {
         error("Connection to '$uri' was not upgraded to websocket");
       }
       String accept = response.headers.value("Sec-WebSocket-Accept");
       if (accept == null) {
         error("Response did not contain a 'Sec-WebSocket-Accept' header");
       }
       _SHA1 sha1 = new _SHA1();
       sha1.add("$nonce$_webSocketGUID".codeUnits);
       List<int> expectedAccept = sha1.close();
       List<int> receivedAccept = _CryptoUtils.base64StringToBytes(accept);
       if (expectedAccept.length != receivedAccept.length) {
         error("Reasponse header 'Sec-WebSocket-Accept' is the wrong length");
       }
       for (int i = 0; i < expectedAccept.length; i++) {
         if (expectedAccept[i] != receivedAccept[i]) {
           error("Bad response 'Sec-WebSocket-Accept' header");
         }
       }
       var protocol = response.headers.value('Sec-WebSocket-Protocol');
 
       _WebSocketPerMessageDeflate deflate =
           negotiateClientCompression(response, compression);
 
-      return response.detachSocket().then/*<WebSocket>*/((socket) =>
+      return response.detachSocket().then((socket) =>
           new _WebSocketImpl._fromSocket(
               socket, protocol, compression, false, deflate));
     });
   }
 
   static _WebSocketPerMessageDeflate negotiateClientCompression(
       HttpClientResponse response, CompressionOptions compression) {
     String extensionHeader = response.headers.value('Sec-WebSocket-Extensions');
 
     if (extensionHeader == null) {
       extensionHeader = "";
     }
 
     var hv = HeaderValue.parse(extensionHeader, valueSeparator: ',');
 
     if (compression.enabled && hv.value == PER_MESSAGE_DEFLATE) {
       var serverNoContextTakeover =
           hv.parameters.containsKey(_serverNoContextTakeover);
       var clientNoContextTakeover =
           hv.parameters.containsKey(_clientNoContextTakeover);
 
       int getWindowBits(String type) {
         var o = hv.parameters[type];
         if (o == null) {
           return DEFAULT_WINDOW_BITS;
         }
 
-        return int.parse(o, onError: (s) => DEFAULT_WINDOW_BITS);
+        o = int.parse(o, onError: (s) => DEFAULT_WINDOW_BITS);
+        return o;
       }
 
       return new _WebSocketPerMessageDeflate(
           clientMaxWindowBits: getWindowBits(_clientMaxWindowBits),
           serverMaxWindowBits: getWindowBits(_serverMaxWindowBits),
           clientNoContextTakeover: clientNoContextTakeover,
           serverNoContextTakeover: serverNoContextTakeover);
     }
 
     return null;
@@ skipping 134 matching lines @@
       _outCloseReason = reason;
     }
     _writeClosed = true;
     _consumer.closeSocket();
     _webSockets.remove(_serviceId);
   }
 
   String get _serviceTypePath => 'io/websockets';
   String get _serviceTypeName => 'WebSocket';
 
-  Map<String, dynamic> _toJSON(bool ref) {
+  Map _toJSON(bool ref) {
     var name = '${_socket.address.host}:${_socket.port}';
     var r = <String, dynamic>{
       'id': _servicePath,
       'type': _serviceType(ref),
       'name': name,
       'user_name': name,
     };
     if (ref) {
       return r;
     }
@@ skipping 14 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));
   }
 }