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

extensions/renderer/resources/data_receiver.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.
 
 define('data_receiver', [
     'device/serial/data_stream.mojom',
     'device/serial/data_stream_serialization.mojom',
     'mojo/public/js/core',
     'mojo/public/js/router',
 ], function(dataStream, serialization, core, router) {
   /**
    * @module data_receiver
    */
 
   /**
    * A pending receive operation.
    * @constructor
    * @alias module:data_receiver~PendingReceive
    * @private
    */
   function PendingReceive() {
     /**
      * The promise that will be resolved or rejected when this receive completes
      * or fails, respectively.
-     * @type {!Promise.<ArrayBuffer>}
+     * @type {!Promise<ArrayBuffer>}
      * @private
      */
     this.promise_ = new Promise(function(resolve, reject) {
       /**
        * The callback to call with the data received on success.
        * @type {Function}
        * @private
        */
       this.dataCallback_ = resolve;
       /**
        * The callback to call with the error on failure.
        * @type {Function}
        * @private
        */
       this.errorCallback_ = reject;
     }.bind(this));
   }
 
   /**
    * Returns the promise that will be resolved when this operation completes or
    * rejected if an error occurs.
-   * @return {Promise.<ArrayBuffer>} A promise to the data received.
+   * @return {Promise<ArrayBuffer>} A promise to the data received.
    */
   PendingReceive.prototype.getPromise = function() {
     return this.promise_;
   };
 
   /**
    * Dispatches received data to the promise returned by
    * [getPromise]{@link module:data_receiver.PendingReceive#getPromise}.
    * @param {!ArrayBuffer} data The data to dispatch.
    */
@@ skipping 61 matching lines @@
 
   /**
    * Initialize this DataReceiver.
    * @param {!MojoHandle} source A handle to the DataSource.
    * @param {!MojoHandle} client A handle to the DataSourceClient.
    * @param {number} fatalErrorValue The error to dispatch in the event of a
    *     fatal error.
    * @param {number} bytesReceived The number of bytes already received.
    * @param {PendingReceiveError} pendingError The pending error if there is
    *     one.
-   * @param {!Array.<!ArrayBuffer>} pendingData Data received from the
+   * @param {!Array<!ArrayBuffer>} pendingData Data received from the
    *     DataSource not yet requested by the client.
    * @param {boolean} paused Whether the DataSource is paused.
    * @private
    */
   DataReceiver.prototype.init_ = function(source, client, fatalErrorValue,
                                           bytesReceived, pendingError,
                                           pendingData, paused) {
     /**
      * The [Router]{@link module:mojo/public/js/router.Router} for the
      * connection to the DataSource.
@@ skipping 48 matching lines @@
      * Whether this DataReceiver has shut down.
      * @type {boolean}
      * @private
      */
     this.shutDown_ = false;
   };
 
   /**
    * Serializes this DataReceiver.
    * This will cancel a receive if one is in progress.
-   * @return {!Promise.<SerializedDataReceiver>} A promise that will resolve to
+   * @return {!Promise<SerializedDataReceiver>} A promise that will resolve to
    *     the serialization of this DataReceiver. If this DataReceiver has shut
    *     down, the promise will resolve to null.
    */
   DataReceiver.prototype.serialize = function() {
     if (this.shutDown_)
       return Promise.resolve(null);
 
     if (this.receive_) {
       this.receive_.dispatchFatalError(this.fatalErrorValue_);
       this.receive_ = null;
@@ skipping 43 matching lines @@
       buffer.set(data);
       pendingData.push(buffer.buffer);
     });
     this.init_(serialized.source, serialized.client,
                serialized.fatal_error_value, serialized.bytes_received,
                serialized.pending_error, pendingData, serialized.paused);
   };
 
   /**
    * Receive data from the DataSource.
-   * @return {Promise.<ArrayBuffer>} A promise to the received data. If an error
+   * @return {Promise<ArrayBuffer>} A promise to the received data. If an error
    *     occurs, the promise will reject with an Error object with a property
    *     error containing the error code.
    * @throws Will throw if this has encountered a fatal error or another receive
    *     is in progress.
    */
   DataReceiver.prototype.receive = function() {
     if (this.shutDown_)
       throw new Error('DataReceiver has been closed');
     if (this.receive_)
       throw new Error('Receive already in progress.');
@@ skipping 54 matching lines @@
     var buffer = new ArrayBuffer(data.length);
     var uintView = new Uint8Array(buffer);
     uintView.set(data);
     this.pendingDataBuffers_.push(buffer);
     if (this.receive_)
       this.dispatchData_();
   };
 
   return {DataReceiver: DataReceiver};
 });