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

chrome/browser/resources/chromeos/chromevox/common/traverse_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 Low-level DOM traversal utility functions to find the
  *     next (or previous) character, word, sentence, line, or paragraph,
  *     in a completely stateless manner without actually manipulating the
  *     selection.
  */
@@ skipping 93 matching lines @@
       return true;
   }
   return false;
 };
 
 /**
  * Moves the cursor forwards until it has crossed exactly one character.
  * @param {cvox.Cursor} cursor The cursor location where the search should
  *     start.  On exit, the cursor will be immediately to the right of the
  *     character returned.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The character found, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.forwardsChar = function(
     cursor, elementsEntered, elementsLeft) {
   while (true) {
     // Move down until we get to a leaf node.
     var childNode = null;
     if (!cvox.TraverseUtil.treatAsLeafNode(cursor.node)) {
       for (var i = cursor.index; i < cursor.node.childNodes.length; i++) {
@@ skipping 72 matching lines @@
       }
     }
   }
 };
 
 /**
  * Moves the cursor backwards until it has crossed exactly one character.
  * @param {cvox.Cursor} cursor The cursor location where the search should
  *     start.  On exit, the cursor will be immediately to the left of the
  *     character returned.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The previous character, or null if the top of the
  *     document has been reached.
  */
 cvox.TraverseUtil.backwardsChar = function(
     cursor, elementsEntered, elementsLeft) {
   while (true) {
     // Move down until we get to a leaf node.
     var childNode = null;
     if (!cvox.TraverseUtil.treatAsLeafNode(cursor.node)) {
       for (var i = cursor.index - 1; i >= 0; i--) {
@@ skipping 83 matching lines @@
 /**
  * Finds the next character, starting from endCursor.  Upon exit, startCursor
  * and endCursor will surround the next character. If skipWhitespace is
  * true, will skip until a real character is found. Otherwise, it will
  * attempt to select all of the whitespace between the initial position
  * of endCursor and the next non-whitespace character.
  * @param {!cvox.Cursor} startCursor On exit, points to the position before
  *     the char.
  * @param {!cvox.Cursor} endCursor The position to start searching for the next
  *     char.  On exit, will point to the position past the char.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
  *     initial and final cursor position will be pushed onto this array.
  * @param {boolean} skipWhitespace If true, will keep scanning until a
  *     non-whitespace character is found.
  * @return {?string} The next char, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getNextChar = function(
     startCursor, endCursor, elementsEntered, elementsLeft, skipWhitespace) {
 
   // Save the starting position and get the first character.
@@ skipping 41 matching lines @@
 /**
  * Finds the previous character, starting from startCursor.  Upon exit,
  * startCursor and endCursor will surround the previous character.
  * If skipWhitespace is true, will skip until a real character is found.
  * Otherwise, it will attempt to select all of the whitespace between
  * the initial position of endCursor and the next non-whitespace character.
  * @param {!cvox.Cursor} startCursor The position to start searching for the
  *     char. On exit, will point to the position before the char.
  * @param {!cvox.Cursor} endCursor The position to start searching for the next
  *     char. On exit, will point to the position past the char.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
  *     initial and final cursor position will be pushed onto this array.
  * @param {boolean} skipWhitespace If true, will keep scanning until a
  *     non-whitespace character is found.
  * @return {?string} The previous char, or null if the top of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getPreviousChar = function(
     startCursor, endCursor, elementsEntered, elementsLeft, skipWhitespace) {
 
   // Save the starting position and get the first character.
@@ skipping 36 matching lines @@
 };
 
 /**
  * Finds the next word, starting from endCursor.  Upon exit, startCursor
  * and endCursor will surround the next word.  A word is defined to be
  * a string of 1 or more non-whitespace characters in the same DOM node.
  * @param {cvox.Cursor} startCursor On exit, will point to the beginning of the
  *     word returned.
  * @param {cvox.Cursor} endCursor The position to start searching for the next
  *     word.  On exit, will point to the end of the word returned.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The next word, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getNextWord = function(startCursor, endCursor,
     elementsEntered, elementsLeft) {
 
   // Find the first non-whitespace or non-skipped character.
   var cursor = endCursor.clone();
   var c = cvox.TraverseUtil.forwardsChar(cursor, elementsEntered, elementsLeft);
   if (c == null)
@@ skipping 39 matching lines @@
 
 /**
  * Finds the previous word, starting from startCursor.  Upon exit, startCursor
  * and endCursor will surround the previous word.  A word is defined to be
  * a string of 1 or more non-whitespace characters in the same DOM node.
  * @param {cvox.Cursor} startCursor The position to start searching for the
  *     previous word.  On exit, will point to the beginning of the
  *     word returned.
  * @param {cvox.Cursor} endCursor On exit, will point to the end of the
  *     word returned.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The previous word, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getPreviousWord = function(startCursor, endCursor,
     elementsEntered, elementsLeft) {
   // Find the first non-whitespace or non-skipped character.
   var cursor = startCursor.clone();
   var c = cvox.TraverseUtil.backwardsChar(
       cursor, elementsEntered, elementsLeft);
   if (c == null)
@@ skipping 32 matching lines @@
       return word;
   }
 
   return word;
 };
 
 
 /**
  * Given elements entered and left, and break tags, returns true if the
  *     current word should break.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
- * @param {Object.<string, boolean>} breakTags Associative array of tags
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
+ * @param {Object<string, boolean>} breakTags Associative array of tags
  *     that should break.
  * @return {boolean} True if elementsEntered or elementsLeft include an
  *     element with one of these tags.
  */
 cvox.TraverseUtil.includesBreakTagOrSkippedNode = function(
     elementsEntered, elementsLeft, breakTags) {
   for (var i = 0; i < elementsEntered.length; i++) {
     if (cvox.TraverseUtil.isHidden(elementsEntered[i])) {
       return true;
     }
@@ skipping 15 matching lines @@
 
 
 /**
  * Finds the next sentence, starting from endCursor.  Upon exit,
  * startCursor and endCursor will surround the next sentence.
  *
  * @param {cvox.Cursor} startCursor On exit, marks the beginning of the
  *     sentence.
  * @param {cvox.Cursor} endCursor The position to start searching for the next
  *     sentence.  On exit, will point to the end of the returned string.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
- * @param {Object.<string, boolean>} breakTags Associative array of tags
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
+ * @param {Object<string, boolean>} breakTags Associative array of tags
  *     that should break the sentence.
  * @return {?string} The next sentence, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getNextSentence = function(
     startCursor, endCursor, elementsEntered, elementsLeft, breakTags) {
   return cvox.TraverseUtil.getNextString(
       startCursor, endCursor, elementsEntered, elementsLeft,
       function(str, word, elementsEntered, elementsLeft) {
         if (str.substr(-1) == '.')
           return true;
         return cvox.TraverseUtil.includesBreakTagOrSkippedNode(
             elementsEntered, elementsLeft, breakTags);
       });
 };
 
 /**
  * Finds the previous sentence, starting from startCursor.  Upon exit,
  * startCursor and endCursor will surround the previous sentence.
  *
  * @param {cvox.Cursor} startCursor The position to start searching for the next
  *     sentence.  On exit, will point to the start of the returned string.
  * @param {cvox.Cursor} endCursor On exit, the end of the returned string.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
- * @param {Object.<string, boolean>} breakTags Associative array of tags
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
+ * @param {Object<string, boolean>} breakTags Associative array of tags
  *     that should break the sentence.
  * @return {?string} The previous sentence, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getPreviousSentence = function(
     startCursor, endCursor, elementsEntered, elementsLeft, breakTags) {
   return cvox.TraverseUtil.getPreviousString(
       startCursor, endCursor, elementsEntered, elementsLeft,
       function(str, word, elementsEntered, elementsLeft) {
         if (word.substr(-1) == '.')
           return true;
         return cvox.TraverseUtil.includesBreakTagOrSkippedNode(
             elementsEntered, elementsLeft, breakTags);
       });
 };
 
 /**
  * Finds the next line, starting from endCursor.  Upon exit,
  * startCursor and endCursor will surround the next line.
  *
  * @param {cvox.Cursor} startCursor On exit, marks the beginning of the line.
  * @param {cvox.Cursor} endCursor The position to start searching for the next
  *     line.  On exit, will point to the end of the returned string.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
- * @param {Object.<string, boolean>} breakTags Associative array of tags
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
+ * @param {Object<string, boolean>} breakTags Associative array of tags
  *     that should break the line.
  * @return {?string} The next line, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getNextLine = function(
     startCursor, endCursor, elementsEntered, elementsLeft, breakTags) {
   var range = document.createRange();
   var currentRect = null;
   var rightMostRect = null;
   var prevCursor = endCursor.clone();
@@ skipping 23 matching lines @@
       });
 };
 
 /**
  * Finds the previous line, starting from startCursor.  Upon exit,
  * startCursor and endCursor will surround the previous line.
  *
  * @param {cvox.Cursor} startCursor The position to start searching for the next
  *     line.  On exit, will point to the start of the returned string.
  * @param {cvox.Cursor} endCursor On exit, the end of the returned string.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
- * @param {Object.<string, boolean>} breakTags Associative array of tags
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
+ * @param {Object<string, boolean>} breakTags Associative array of tags
  *     that should break the line.
  *  @return {?string} The previous line, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getPreviousLine = function(
     startCursor, endCursor, elementsEntered, elementsLeft, breakTags) {
   var range = document.createRange();
   var currentRect = null;
   var leftMostRect = null;
   var prevCursor = startCursor.clone();
@@ skipping 24 matching lines @@
 };
 
 /**
  * Finds the next paragraph, starting from endCursor.  Upon exit,
  * startCursor and endCursor will surround the next paragraph.
  *
  * @param {cvox.Cursor} startCursor On exit, marks the beginning of the
  *     paragraph.
  * @param {cvox.Cursor} endCursor The position to start searching for the next
  *     paragraph.  On exit, will point to the end of the returned string.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The next paragraph, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getNextParagraph = function(startCursor, endCursor,
     elementsEntered, elementsLeft) {
   return cvox.TraverseUtil.getNextString(
       startCursor, endCursor, elementsEntered, elementsLeft,
       function(str, word, elementsEntered, elementsLeft) {
         for (var i = 0; i < elementsEntered.length; i++) {
           if (cvox.TraverseUtil.isHidden(elementsEntered[i])) {
@@ skipping 14 matching lines @@
       });
 };
 
 /**
  * Finds the previous paragraph, starting from startCursor.  Upon exit,
  * startCursor and endCursor will surround the previous paragraph.
  *
  * @param {cvox.Cursor} startCursor The position to start searching for the next
  *     paragraph.  On exit, will point to the start of the returned string.
  * @param {cvox.Cursor} endCursor On exit, the end of the returned string.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The previous paragraph, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getPreviousParagraph = function(
     startCursor, endCursor, elementsEntered, elementsLeft) {
   return cvox.TraverseUtil.getPreviousString(
       startCursor, endCursor, elementsEntered, elementsLeft,
       function(str, word, elementsEntered, elementsLeft) {
         for (var i = 0; i < elementsEntered.length; i++) {
           if (cvox.TraverseUtil.isHidden(elementsEntered[i])) {
@@ skipping 28 matching lines @@
  * next word:
  *   str The string so far.
  *   word The next word to be added.
  *   elementsEntered The elements entered in reaching this next word.
  *   elementsLeft The elements left in reaching this next word.
  *
  * @param {cvox.Cursor} startCursor On exit, will point to the beginning of the
  *     next string.
  * @param {cvox.Cursor} endCursor The position to start searching for the next
  *     string.  On exit, will point to the end of the returned string.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
- * @param {function(string, string, Array.<Element>, Array.<Element>)}
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
+ * @param {function(string, string, Array<Element>, Array<Element>)}
  *     breakBefore Function that takes the string so far, next word to be
  *     added, and elements entered and left, and returns true if the string
  *     should be ended before adding this word.
  * @return {?string} The next string, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getNextString = function(
     startCursor, endCursor, elementsEntered, elementsLeft, breakBefore) {
   // Get the first word and set the start cursor to the start of the
   // first word.
@@ skipping 39 matching lines @@
  * the next. See getNextString, above, for more details.
  *
  * Finds the previous contiguous string, starting from startCursor.  Upon exit,
  * startCursor and endCursor will surround the next string.
  *
  * @param {cvox.Cursor} startCursor The position to start searching for the
  *     previous string.  On exit, will point to the beginning of the
  *     string returned.
  * @param {cvox.Cursor} endCursor On exit, will point to the end of the
  *     string returned.
- * @param {Array.<Element>} elementsEntered Any HTML elements entered.
- * @param {Array.<Element>} elementsLeft Any HTML elements left.
- * @param {function(string, string, Array.<Element>, Array.<Element>)}
+ * @param {Array<Element>} elementsEntered Any HTML elements entered.
+ * @param {Array<Element>} elementsLeft Any HTML elements left.
+ * @param {function(string, string, Array<Element>, Array<Element>)}
  *     breakBefore Function that takes the string so far, the word to be
  *     added, and nodes crossed, and returns true if the string should be
  *     ended before adding this word.
  * @return {?string} The next string, or null if the top of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getPreviousString = function(
     startCursor, endCursor, elementsEntered, elementsLeft, breakBefore) {
   // Get the first word and set the end cursor to the end of the
   // first word.
@@ skipping 25 matching lines @@
     newEntered = [];
     newLeft = [];
     word = cvox.TraverseUtil.getPreviousWord(
         wordStartCursor, wordEndCursor, newEntered, newLeft);
     if (word == null)
       return str;
   }
 
   return str;
 };