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

sdk/lib/io/crypto.dart

 // Copyright (c) 2012, 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;
 
 class _CryptoUtils {
   static const int PAD = 61; // '='
   static const int CR = 13;  // '\r'
   static const int LF = 10;  // '\n'
@@ skipping 216 matching lines @@
 
   // Rotate left limiting to unsigned 32-bit values.
   int _rotl32(int val, int shift) {
     var mod_shift = shift & 31;
     return ((val << mod_shift) & _MASK_32) |
         ((val & _MASK_32) >> (32 - mod_shift));
   }
 
 
   // Compute the final result as a list of bytes from the hash words.
-  List<int> _resultAsBytes() {
-    var result = <int>[];
+  _resultAsBytes() {
+    var result = [];
     for (var i = 0; i < _h.length; i++) {
       result.addAll(_wordToBytes(_h[i]));
     }
     return result;
   }
 
   // Converts a list of bytes to a chunk of 32-bit words.
   _bytesToChunk(List<int> data, int dataIndex) {
     assert((data.length - dataIndex) >= (_chunkSizeInWords * _BYTES_PER_WORD));
 
     for (var wordIndex = 0; wordIndex < _chunkSizeInWords; wordIndex++) {
       var w3 = _bigEndianWords ? data[dataIndex] : data[dataIndex + 3];
       var w2 = _bigEndianWords ? data[dataIndex + 1] : data[dataIndex + 2];
       var w1 = _bigEndianWords ? data[dataIndex + 2] : data[dataIndex + 1];
       var w0 = _bigEndianWords ? data[dataIndex + 3] : data[dataIndex];
       dataIndex += 4;
       var word = (w3 & 0xff) << 24;
       word |= (w2 & _MASK_8) << 16;
       word |= (w1 & _MASK_8) << 8;
       word |= (w0 & _MASK_8);
       _currentChunk[wordIndex] = word;
     }
   }
 
   // Convert a 32-bit word to four bytes.
-  List<int> _wordToBytes(int word) {
+  _wordToBytes(int word) {
     List<int> bytes = new List(_BYTES_PER_WORD);
     bytes[0] = (word >> (_bigEndianWords ? 24 : 0)) & _MASK_8;
     bytes[1] = (word >> (_bigEndianWords ? 16 : 8)) & _MASK_8;
     bytes[2] = (word >> (_bigEndianWords ? 8 : 16)) & _MASK_8;
     bytes[3] = (word >> (_bigEndianWords ? 0 : 24)) & _MASK_8;
     return bytes;
   }
 
   // Iterate through data updating the hash computation for each
   // chunk.
@@ skipping 164 matching lines @@
 
     _h[0] = _add32(a, _h[0]);
     _h[1] = _add32(b, _h[1]);
     _h[2] = _add32(c, _h[2]);
     _h[3] = _add32(d, _h[3]);
     _h[4] = _add32(e, _h[4]);
   }
 
   List<int> _w;
 }