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

extensions/renderer/resources/utils.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.
 
 var createClassWrapper = requireNative('utils').createClassWrapper;
 var nativeDeepCopy = requireNative('utils').deepCopy;
 var schemaRegistry = requireNative('schema_registry');
 var CHECK = requireNative('logging').CHECK;
 var DCHECK = requireNative('logging').DCHECK;
 var WARNING = requireNative('logging').WARNING;
 
 /**
  * An object forEach. Calls |f| with each (key, value) pair of |obj|, using
  * |self| as the target.
  * @param {Object} obj The object to iterate over.
  * @param {function} f The function to call in each iteration.
  * @param {Object} self The object to use as |this| in each function call.
  */
 function forEach(obj, f, self) {
   for (var key in obj) {
     if ($Object.hasOwnProperty(obj, key))
       $Function.call(f, self, key, obj[key]);
   }
 }
 
 /**
  * Assuming |array_of_dictionaries| is structured like this:
  * [{id: 1, ... }, {id: 2, ...}, ...], you can use
  * lookup(array_of_dictionaries, 'id', 2) to get the dictionary with id == 2.
- * @param {Array.<Object.<string, ?>>} array_of_dictionaries
+ * @param {Array<Object<string, ?>>} array_of_dictionaries
  * @param {string} field
  * @param {?} value
  */
 function lookup(array_of_dictionaries, field, value) {
   var filter = function (dict) {return dict[field] == value;};
   var matches = array_of_dictionaries.filter(filter);
   if (matches.length == 0) {
     return undefined;
   } else if (matches.length == 1) {
     return matches[0]
@@ skipping 27 matching lines @@
  * Takes a private class implementation |cls| and exposes a subset of its
  * methods |functions| and properties |properties| and |readonly| in a public
  * wrapper class that it returns. Within bindings code, you can access the
  * implementation from an instance of the wrapper class using
  * privates(instance).impl, and from the implementation class you can access
  * the wrapper using this.wrapper (or implInstance.wrapper if you have another
  * instance of the implementation class).
  * @param {string} name The name of the exposed wrapper class.
  * @param {Object} cls The class implementation.
  * @param {{superclass: ?Function,
- *          functions: ?Array.<string>,
- *          properties: ?Array.<string>,
- *          readonly: ?Array.<string>}} exposed The names of properties on the
+ *          functions: ?Array<string>,
+ *          properties: ?Array<string>,
+ *          readonly: ?Array<string>}} exposed The names of properties on the
  *     implementation class to be exposed. |superclass| represents the
  *     constructor of the class to be used as the superclass of the exposed
  *     class; |functions| represents the names of functions which should be
  *     delegated to the implementation; |properties| are gettable/settable
  *     properties and |readonly| are read-only properties.
  */
 function expose(name, cls, exposed) {
   var publicClass = createClassWrapper(name, cls, exposed.superclass);
 
   if ('functions' in exposed) {
@@ skipping 74 matching lines @@
     $Function.apply(func, null, args);
   });
 }
 
 exports.forEach = forEach;
 exports.loadTypeSchema = loadTypeSchema;
 exports.lookup = lookup;
 exports.expose = expose;
 exports.deepCopy = deepCopy;
 exports.promise = promise;