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

chrome/browser/resources/chromeos/chromevox/common/dom_util.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 A collection of JavaScript utilities used to simplify working
  * with the DOM.
  */
 
 
@@ skipping 90 matching lines @@
   'AUDIO' : 'tag_audio',
   'BUTTON' : 'tag_button',
   'SELECT' : 'tag_select',
   'TABLE' : 'tag_table',
   'TEXTAREA' : 'tag_textarea',
   'VIDEO' : 'tag_video'
 };
 
 /**
  * These tags are treated as text formatters.
- * @type {Array.<string>}
+ * @type {Array<string>}
  */
 cvox.DomUtil.FORMATTING_TAGS =
     ['B', 'BIG', 'CITE', 'CODE', 'DFN', 'EM', 'I', 'KBD', 'SAMP', 'SMALL',
      'SPAN', 'STRIKE', 'STRONG', 'SUB', 'SUP', 'U', 'VAR'];
 
 /**
  * Determine if the given node is visible on the page. This does not check if
  * it is inside the document view-port as some sites try to communicate with
  * screen readers with such elements.
  * @param {Node} node The node to determine as visible or not.
@@ skipping 817 matching lines @@
   }
   return text;
 };
 
 
 /**
  * Search the whole page for any aria-labelledby attributes and collect
  * the complete set of ids they map to, so that we can skip elements that
  * just label other elements and not double-speak them. We cache this
  * result and then throw it away at the next event loop.
- * @return {Object.<string, boolean>} Set of all ids that are mapped
+ * @return {Object<string, boolean>} Set of all ids that are mapped
  *     by aria-labelledby.
  */
 cvox.DomUtil.getLabelledByTargets = function() {
   if (cvox.labelledByTargets) {
     return cvox.labelledByTargets;
   }
 
   // Start by getting all elements with
   // aria-labelledby on the page since that's probably a short list,
   // then see if any of those ids overlap with an id in this element's
@@ skipping 212 matching lines @@
 
   return true;
 };
 
 
 /**
  * Returns a list of all the ancestors of a given node. The last element
  * is the current node.
  *
  * @param {Node} targetNode The node to get ancestors for.
- * @return {Array.<Node>} An array of ancestors for the targetNode.
+ * @return {Array<Node>} An array of ancestors for the targetNode.
  */
 cvox.DomUtil.getAncestors = function(targetNode) {
   var ancestors = new Array();
   while (targetNode) {
     ancestors.push(targetNode);
     targetNode = targetNode.parentNode;
   }
   ancestors.reverse();
   while (ancestors.length && !ancestors[0].tagName && !ancestors[0].nodeValue) {
     ancestors.shift();
@@ skipping 31 matching lines @@
 /**
  * Returns an array of ancestors that are unique for the currentNode when
  * compared to the previousNode. Having such an array is useful in generating
  * the node information (identifying when interesting node boundaries have been
  * crossed, etc.).
  *
  * @param {Node} previousNode The previous node.
  * @param {Node} currentNode The current node.
  * @param {boolean=} opt_fallback True returns node's ancestors in the case
  * where node's ancestors is a subset of previousNode's ancestors.
- * @return {Array.<Node>} An array of unique ancestors for the current node
+ * @return {Array<Node>} An array of unique ancestors for the current node
  * (inclusive).
  */
 cvox.DomUtil.getUniqueAncestors = function(
     previousNode, currentNode, opt_fallback) {
   var prevAncestors = cvox.DomUtil.getAncestors(previousNode);
   var currentAncestors = cvox.DomUtil.getAncestors(currentNode);
   var divergence = cvox.DomUtil.compareAncestors(prevAncestors,
       currentAncestors);
   var diff = currentAncestors.slice(divergence);
   return (diff.length == 0 && opt_fallback) ? currentAncestors : diff;
@@ skipping 716 matching lines @@
  * is not.
  */
 cvox.DomUtil.getContainingTable = function(node, kwargs) {
   var ancestors = cvox.DomUtil.getAncestors(node);
   return cvox.DomUtil.findTableNodeInList(ancestors, kwargs);
 };
 
 
 /**
  * Extracts a table node from a list of nodes.
- * @param {Array.<Node>} nodes The list of nodes.
+ * @param {Array<Node>} nodes The list of nodes.
  * @param {{allowCaptions: (undefined|boolean)}=} kwargs Optional named args.
  *  allowCaptions: If true, will return true even if inside a caption. False
  *    by default.
  * @return {Node} The table node if the list of nodes contains a table node.
  * Null if it does not.
  */
 cvox.DomUtil.findTableNodeInList = function(nodes, kwargs) {
   kwargs = kwargs || {allowCaptions: false};
   // Don't include the caption node because it is actually rendered outside
   // of the table.
@@ skipping 222 matching lines @@
   cvox.DomUtil.findNodes_(root, p, rv, false, 10000);
   return rv.length;
 };
 
 
 /**
  * Finds the first or all the descendant nodes that match the filter function,
  * using a depth first search.
  * @param {Node} root The root of the tree to search.
  * @param {function(Node) : boolean} p The filter function.
- * @param {Array.<Node>} rv The found nodes are added to this array.
+ * @param {Array<Node>} rv The found nodes are added to this array.
  * @param {boolean} findOne If true we exit after the first found node.
  * @param {number} maxChildCount The max child count. This is used as a kill
  * switch - if there are more nodes than this, terminate the search.
  * @return {boolean} Whether the search is complete or not. True in case
  * findOne is true and the node is found. False otherwise. This is the
  * findNodes_ function from goog.dom:
  * http://code.google.com/p/closure-library/source/browse/trunk/closure/goog/dom/dom.js.
  * @private
  */
 cvox.DomUtil.findNodes_ = function(root, p, rv, findOne, maxChildCount) {
@@ skipping 27 matching lines @@
   for (var i = 0; i < nodeList.length; i++) {
     nodeArray.push(nodeList[i]);
   }
   return nodeArray;
 };
 
 
 /**
  * Creates a new element with the same attributes and no children.
  * @param {Node|Text} node A node to clone.
- * @param {Object.<string, boolean>} skipattrs Set the attribute to true to
+ * @param {Object<string, boolean>} skipattrs Set the attribute to true to
  * skip it during cloning.
  * @return {Node|Text} The cloned node.
  */
 cvox.DomUtil.shallowChildlessClone = function(node, skipattrs) {
   if (node.nodeName == '#text') {
     return document.createTextNode(node.nodeValue);
   }
 
   if (node.nodeName == '#comment') {
     return document.createComment(node.nodeValue);
   }
 
   var ret = document.createElement(node.nodeName);
   for (var i = 0; i < node.attributes.length; ++i) {
     var attr = node.attributes[i];
     if (skipattrs && skipattrs[attr.nodeName]) {
       continue;
     }
     ret.setAttribute(attr.nodeName, attr.nodeValue);
   }
   return ret;
 };
 
 
 /**
  * Creates a new element with the same attributes and clones of children.
  * @param {Node|Text} node A node to clone.
- * @param {Object.<string, boolean>} skipattrs Set the attribute to true to
+ * @param {Object<string, boolean>} skipattrs Set the attribute to true to
  * skip it during cloning.
  * @return {Node|Text} The cloned node.
  */
 cvox.DomUtil.deepClone = function(node, skipattrs) {
   var ret = cvox.DomUtil.shallowChildlessClone(node, skipattrs);
   for (var i = 0; i < node.childNodes.length; ++i) {
     ret.appendChild(cvox.DomUtil.deepClone(node.childNodes[i], skipattrs));
   }
   return ret;
 };
@@ skipping 68 matching lines @@
  * Null if it is not.
  */
 cvox.DomUtil.getContainingMath = function(node) {
   var ancestors = cvox.DomUtil.getAncestors(node);
   return cvox.DomUtil.findMathNodeInList(ancestors);
 };
 
 
 /**
  * Extracts a math node from a list of nodes.
- * @param {Array.<Node>} nodes The list of nodes.
+ * @param {Array<Node>} nodes The list of nodes.
  * @return {Node} The math node if the list of nodes contains a math node.
  * Null if it does not.
  */
 cvox.DomUtil.findMathNodeInList = function(nodes) {
   for (var i = 0, node; node = nodes[i]; i++) {
     if (cvox.DomUtil.isMath(node)) {
       return node;
     }
   }
   return null;
 };
 
 
 /**
  * Checks to see wether a node is a math node.
  * @param {Node} node The node to be tested.
  * @return {boolean} Whether or not a node is a math node.
  */
 cvox.DomUtil.isMath = function(node) {
   return cvox.DomUtil.isMathml(node) ||
       cvox.DomUtil.isMathJax(node) ||
           cvox.DomUtil.isMathImg(node) ||
               cvox.AriaUtil.isMath(node);
 };
 
 
 /**
  * Specifies node classes in which we expect maths expressions a alt text.
- * @type {{tex: Array.<string>,
- *         asciimath: Array.<string>}}
+ * @type {{tex: Array<string>,
+ *         asciimath: Array<string>}}
  */
 // These are the classes for which we assume they contain Maths in the ALT or
 // TITLE attribute.
 // tex: Wikipedia;
 // latex: Wordpress;
 // numberedequation, inlineformula, displayformula: MathWorld;
 cvox.DomUtil.ALT_MATH_CLASSES = {
   tex: ['tex', 'latex'],
   asciimath: ['numberedequation', 'inlineformula', 'displayformula']
 };
@@ skipping 113 matching lines @@
   if (node.nodeType == Node.ELEMENT_NODE) {
     return node.tagName;
   }
   return '';
 };
 
 
 /**
  * Cleaning up a list of nodes to remove empty text nodes.
  * @param {NodeList} nodes The nodes list.
- * @return {!Array.<Node|string|null>} The cleaned up list of nodes.
+ * @return {!Array<Node|string|null>} The cleaned up list of nodes.
  */
 cvox.DomUtil.purgeNodes = function(nodes) {
   return cvox.DomUtil.toArray(nodes).
       filter(function(node) {
                return node.nodeType != Node.TEXT_NODE ||
                    !node.textContent.match(/^\s+$/);});
 };
 
 
 /**
@@ skipping 43 matching lines @@
         var describedNode = document.getElementById(describedById);
         if (describedNode) {
           desc += ' ' + cvox.DomUtil.getName(
               describedNode, true, true, true);
         }
       }
     }
   }
   return desc;
 };