Shorten Closure template notation from Array.<*> to Array<*>.

chrome/browser/resources/cryptotoken/sha256.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // SHA256 in javascript.
 //
 // SHA256 {
 //  SHA256();
 //  void reset();
 //  void update(byte[] data, opt_length);
@@ skipping 33 matching lines @@
 SHA256.prototype.reset = function() {
   this._chain = [
     0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
     0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
 
   this._inbuf = 0;
   this._total = 0;
 };
 
 /** Hash the next block of 64 bytes
- * @param {Array.<number>} buf A 64 byte buffer
+ * @param {Array<number>} buf A 64 byte buffer
  */
 SHA256.prototype._compress = function(buf) {
   var W = this._W;
   var k = this._k;
 
   function _rotr(w, r) { return ((w << (32 - r)) | (w >>> r)); };
 
   // get 16 big endian words
   for (var i = 0; i < 64; i += 4) {
     var w = (buf[i] << 24) |
@@ skipping 41 matching lines @@
   this._chain[1] += B;
   this._chain[2] += C;
   this._chain[3] += D;
   this._chain[4] += E;
   this._chain[5] += F;
   this._chain[6] += G;
   this._chain[7] += H;
 };
 
 /** Update the hash with additional data
- * @param {Array.<number>|Uint8Array} bytes The data
+ * @param {Array<number>|Uint8Array} bytes The data
  * @param {number=} opt_length How many bytes to hash, if not all */
 SHA256.prototype.update = function(bytes, opt_length) {
   if (!opt_length) opt_length = bytes.length;
 
   this._total += opt_length;
   for (var n = 0; n < opt_length; ++n) {
     this._buf[this._inbuf++] = bytes[n];
     if (this._inbuf == 64) {
       this._compress(this._buf);
       this._inbuf = 0;
     }
   }
 };
 
 /** Update the hash with a specified range from a data buffer
- * @param {Array.<number>} bytes The data buffer
+ * @param {Array<number>} bytes The data buffer
  * @param {number} start Starting index of the range in bytes
  * @param {number} end End index, will not be included in range
  */
 SHA256.prototype.updateRange = function(bytes, start, end) {
   this._total += (end - start);
   for (var n = start; n < end; ++n) {
     this._buf[this._inbuf++] = bytes[n];
     if (this._inbuf == 64) {
       this._compress(this._buf);
       this._inbuf = 0;
     }
   }
 };
 
 /**
  * Optionally update the hash with additional arguments, and return the
  * resulting hash value.
  * @param {...*} var_args Data buffers to hash
- * @return {Array.<number>} the SHA256 hash value.
+ * @return {Array<number>} the SHA256 hash value.
  */
 SHA256.prototype.digest = function(var_args) {
   for (var i = 0; i < arguments.length; ++i)
     this.update(arguments[i]);
 
   var digest = new Array(32);
   var totalBits = this._total * 8;
 
   // add pad 0x80 0x00*
   if (this._inbuf < 56)
     this.update(this._pad, 56 - this._inbuf);
   else
     this.update(this._pad, 64 - (this._inbuf - 56));
 
   // add # bits, big endian
   for (var i = 63; i >= 56; --i) {
     this._buf[i] = totalBits & 255;
     totalBits >>>= 8;
   }
 
   this._compress(this._buf);
 
   var n = 0;
   for (var i = 0; i < 8; ++i)
     for (var j = 24; j >= 0; j -= 8)
       digest[n++] = (this._chain[i] >> j) & 255;
 
   return digest;
 };