Big merge from experimental to bleeding edge.

sdk/lib/crypto/hash_utils.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.crypto;
 
 // Constants.
 const _MASK_8 = 0xff;
 const _MASK_32 = 0xffffffff;
 const _BITS_PER_BYTE = 8;
 const _BYTES_PER_WORD = 4;
 
 // Helper functions used by more than one hasher.
 
 // 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));
 }
 
 // Base class encapsulating common behavior for cryptographic hash
 // functions.
 abstract class _HashBase implements Hash {
   _HashBase(int this._chunkSizeInWords,
             int this._digestSizeInWords,
             bool this._bigEndianWords)
       : _pendingData = [] {
-    _currentChunk = new List(_chunkSizeInWords);
-    _h = new List(_digestSizeInWords);
+    _currentChunk = new List.fixedLength(_chunkSizeInWords);
+    _h = new List.fixedLength(_digestSizeInWords);
   }
 
   // Update the hasher with more data.
-  _HashBase update(List<int> data) {
+  add(List<int> data) {
     if (_digestCalled) {
       throw new HashException(
           'Hash update method called after digest was retrieved');
     }
     _lengthInBytes += data.length;
     _pendingData.addAll(data);
     _iterate();
-    return this;
   }
 
   // Finish the hash computation and return the digest string.
-  List<int> digest() {
+  List<int> close() {
     if (_digestCalled) {
       return _resultAsBytes();
     }
     _digestCalled = true;
     _finalizeData();
     _iterate();
     assert(_pendingData.length == 0);
     return _resultAsBytes();
   }
 
@@ skipping 34 matching lines @@
       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.
   _wordToBytes(int word) {
-    List<int> bytes = new List(_BYTES_PER_WORD);
+    List<int> bytes = new List.fixedLength(_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.
   _iterate() {
@@ skipping 35 matching lines @@
   // Hasher state.
   final int _chunkSizeInWords;
   final int _digestSizeInWords;
   final bool _bigEndianWords;
   int _lengthInBytes = 0;
   List<int> _pendingData;
   List<int> _currentChunk;
   List<int> _h;
   bool _digestCalled = false;
 }