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

chrome/browser/resources/chromeos/chromevox/speech_rules/base_rule_store.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.
 
 /**
  * @fileoverview Base class for all speech rule stores.
  *
  * The base rule store implements some basic functionality that is common to
  * most speech rule stores.
  */
@@ skipping 26 matching lines @@
   this.customStrings = new cvox.SpeechRuleFunctions.CustomStrings();
 
   /**
    * Set of context functions for the store.
    * @type {cvox.SpeechRuleFunctions.ContextFunctions}
    */
   this.contextFunctions = new cvox.SpeechRuleFunctions.ContextFunctions();
 
   /**
    * Set of speech rules in the store.
-   * @type {!Array.<cvox.SpeechRule>}
+   * @type {!Array<cvox.SpeechRule>}
    * @private
    */
   this.speechRules_ = [];
 
   /**
    * A priority list of dynamic constraint attributes.
-   * @type {!Array.<cvox.SpeechRule.DynamicCstrAttrib>}
+   * @type {!Array<cvox.SpeechRule.DynamicCstrAttrib>}
    */
   this.dynamicCstrAttribs = [cvox.SpeechRule.DynamicCstrAttrib.STYLE];
 
   /**
    * List of TTS properties overridden by the store when it is active.
-   * @type {!Array.<string>}
+   * @type {!Array<string>}
    */
   this.defaultTtsProps = [];
 };
 
 
 /**
  * @override
  */
 cvox.BaseRuleStore.prototype.lookupRule = function(node, dynamic) {
   if (!node ||
@@ skipping 119 matching lines @@
          }
        }
 };
 
 
 // TODO (sorge) These should move into the speech rule functions.
 /**
  * Checks if we have a custom query and applies it. Otherwise returns null.
  * @param {!Node} node The initial node.
  * @param {string} funcName A function name.
- * @return {Array.<Node>} The list of resulting nodes.
+ * @return {Array<Node>} The list of resulting nodes.
  */
 cvox.BaseRuleStore.prototype.applyCustomQuery = function(
     node, funcName) {
   var func = this.customQueries.lookup(funcName);
   return func ? func(node) : null;
 };
 
 
 /**
  * Applies either an Xpath selector or a custom query to the node
  * and returns the resulting node list.
  * @param {!Node} node The initial node.
  * @param {string} expr An Xpath expression string or a name of a custom
  *     query.
- * @return {Array.<Node>} The list of resulting nodes.
+ * @return {Array<Node>} The list of resulting nodes.
  */
 cvox.BaseRuleStore.prototype.applySelector = function(node, expr) {
   var result = this.applyCustomQuery(node, expr);
   return result || cvox.XpathUtil.evalXPath(expr, node);
 };
 
 
 /**
  * Applies either an Xpath selector or a custom query to the node
  * and returns the first result.
@@ skipping 31 matching lines @@
  * @param {cvox.SpeechRule} rule The rule.
  * @return {boolean} True if the preconditions apply to the node.
  * @protected
  */
 cvox.BaseRuleStore.prototype.testDynamicConstraints = function(
     dynamic, rule) {
   // We allow a default value for each dynamic constraints attribute.
   // The idea is that when we can not find a speech rule matching the value for
   // a particular attribute in the dynamic constraintwe choose the one that has
   // the value 'default'.
-  var allKeys = /** @type {Array.<cvox.SpeechRule.DynamicCstrAttrib>} */ (
+  var allKeys = /** @type {Array<cvox.SpeechRule.DynamicCstrAttrib>} */ (
       Object.keys(dynamic));
   return allKeys.every(
       function(key) {
         return dynamic[key] == rule.dynamicCstr[key] ||
             rule.dynamicCstr[key] == 'default';
       });
 };
 
 
 /**
  * Get a set of all dynamic constraint values.
- * @return {!Object.<cvox.SpeechRule.DynamicCstrAttrib, Array.<string>>} The
+ * @return {!Object<cvox.SpeechRule.DynamicCstrAttrib, Array<string>>} The
  *     object with all annotations.
  */
 cvox.BaseRuleStore.prototype.getDynamicConstraintValues = function() {
   var result = {};
   for (var i = 0, rule; rule = this.speechRules_[i]; i++) {
     for (var key in rule.dynamicCstr) {
       var newKey = [rule.dynamicCstr[key]];
       if (result[key]) {
         result[key] = cvox.MathUtil.union(result[key], newKey);
       } else {
@@ skipping 23 matching lines @@
   }
   return result;
 };
 
 
 /**
  * Picks the result of the most constraint rule by prefering those:
  * 1) that best match the dynamic constraints.
  * 2) with the most additional constraints.
  * @param {cvox.SpeechRule.DynamicCstr} dynamic Dynamic constraints.
- * @param {!Array.<cvox.SpeechRule>} rules An array of rules.
+ * @param {!Array<cvox.SpeechRule>} rules An array of rules.
  * @return {cvox.SpeechRule} The most constraint rule.
  * @private
  */
 cvox.BaseRuleStore.prototype.pickMostConstraint_ = function(dynamic, rules) {
   rules.sort(goog.bind(
       function(r1, r2) {
         var count1 = this.countMatchingDynamicConstraintValues_(dynamic, r1);
         var count2 = this.countMatchingDynamicConstraintValues_(dynamic, r2);
         // Rule one is a better match, don't swap.
         if (count1 > count2) {
@@ skipping 48 matching lines @@
       return false;
     }
   }
   return true;
 };
 
 
 /**
  * Compares two static constraints (i.e., lists of precondition constraints) and
  * returns true if they are equal.
- * @param {Array.<string>} cstr1 First static constraints.
- * @param {Array.<string>} cstr2 Second static constraints.
+ * @param {Array<string>} cstr1 First static constraints.
+ * @param {Array<string>} cstr2 Second static constraints.
  * @return {boolean} True if the static constraints are equal.
  * @private
  */
 cvox.BaseRuleStore.compareStaticConstraints_ = function(
     cstr1, cstr2) {
   if (cstr1.length != cstr2.length) {
     return false;
   }
   for (var i = 0, cstr; cstr = cstr1[i]; i++) {
     if (cstr2.indexOf(cstr) == -1) {
@@ skipping 13 matching lines @@
  */
 cvox.BaseRuleStore.comparePreconditions_ = function(rule1, rule2) {
   var prec1 = rule1.precondition;
   var prec2 = rule2.precondition;
   if (prec1.query != prec2.query) {
     return false;
     }
   return cvox.BaseRuleStore.compareStaticConstraints_(
       prec1.constraints, prec2.constraints);
 };