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

chrome/browser/resources/chromeos/chromevox/common/traverse_table.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.
 
 /**
  * TODO(stoarca): This class has become obsolete except for the shadow table.
  * Chop most of it away.
  * @fileoverview A DOM traversal interface for navigating data in tables.
  */
 
 goog.provide('cvox.TraverseTable');
 
 goog.require('cvox.DomPredicates');
 goog.require('cvox.DomUtil');
 goog.require('cvox.SelectionUtil');
 goog.require('cvox.TableUtil');
 goog.require('cvox.TraverseUtil');
 
 
 
 /**
  * An object that represents an active table cell inside the shadow table.
  * @constructor
  */
-function ShadowTableNode() {}
+function ShadowTableNode() {
+  /**
+   * The cells that are row headers of the corresponding active table cell
+   * @type {!Array}
+   */
+  this.rowHeaderCells = [];
+
+  /**
+   * The cells that are column headers of the corresponding active table cell
+   * @type {!Array}
+   */
+  this.colHeaderCells = [];
+}
 
 
 /**
  * Whether or not the active cell is spanned by a preceding cell.
  * @type {boolean}
  */
 ShadowTableNode.prototype.spanned;
 
 
 /**
@@ skipping 25 matching lines @@
 
 
 /**
  * The corresponding <TD> or <TH> node in the active table.
  * @type {?Node}
  */
 ShadowTableNode.prototype.activeCell;
 
 
 /**
- * The cells that are row headers of the corresponding active table cell
- * @type {!Array}
- */
-ShadowTableNode.prototype.rowHeaderCells = [];
-
-
-/**
- * The cells that are column headers of the corresponding active table cell
- * @type {!Array}
- */
-ShadowTableNode.prototype.colHeaderCells = [];
-
-
-
-/**
  * Initializes the traversal with the provided table node.
  *
  * @constructor
  * @param {Node} tableNode The table to be traversed.
  */
 cvox.TraverseTable = function(tableNode) {
 
   /**
    * The active table <TABLE> node. In this context, "active" means that this is
    * the table the TraverseTable object is navigating.
@@ skipping 11 matching lines @@
    * The shadow table will allow us efficient navigation of tables with
    * rowspans and colspans without needing to repeatedly scan the table. For
    * example, if someone requests a cell at (1,3), predecessor cells with
    * rowspans/colspans mean the cell you eventually return could actually be
    * one located at (0,2) that spans out to (1,3).
    *
    * This shadow table will contain a ShadowTableNode with the (0, 2) index at
    * the (1,3) position, eliminating the need to check for predecessor cells
    * with rowspan/colspan every time we traverse the table.
    *
-   * @type {!Array.<Array.<ShadowTableNode>>}
+   * @type {!Array<Array<ShadowTableNode>>}
    * @private
    */
   this.shadowTable_ = [];
 
   /**
    * An array of shadow table nodes that have been determined to contain header
    * cells or information about header cells. This array is collected at
    * initialization and then only recalculated if the table changes.
    * This array is used by findHeaderCells() to determine table row headers
    * and column headers.
-   * @type {Array.<ShadowTableNode>}
+   * @type {Array<ShadowTableNode>}
    * @private
    */
   this.candidateHeaders_ = [];
 
   /**
    * An array that associates cell IDs with their corresponding shadow nodes.
    * If there are two shadow nodes for the same cell (i.e. when a cell spans
    * other cells) then the first one will be associated with the ID. This means
    * that shadow nodes that have spanned set to true will not be included in
    * this array.
-   * @type {Array.<ShadowTableNode>}
+   * @type {Array<ShadowTableNode>}
    * @private
    */
   this.idToShadowNode_ = [];
 
   this.initialize(tableNode);
 };
 
 
 /**
  * The cell cursor, represented by an array that stores the row and
@@ skipping 108 matching lines @@
           this.attachCursorToNearestCell_();
         }
       }, this), false);
 };
 
 
 /**
  * Finds the cell cursor containing the specified node within the table.
  * Returns null if there is no close cell.
  * @param {!Node} node The node for which to find the cursor.
- * @return {Array.<number>} The table index for the node.
+ * @return {Array<number>} The table index for the node.
  */
 cvox.TraverseTable.prototype.findNearestCursor = function(node) {
   // TODO (stoarca): The current structure for representing the
   // shadow table is not optimal for this query, but it's not urgent
   // since this only gets executed at most once per user action.
 
   // In case node is in a table but above any individual cell, we go down as
   // deep as we can, being careful to avoid going into nested tables.
   var n = node;
 
@@ skipping 570 matching lines @@
 
   var shadowEntry =
       this.shadowTable_[this.currentCellCursor[0]][this.currentCellCursor[1]];
 
   return shadowEntry && shadowEntry.activeCell;
 };
 
 
 /**
  * Gets the cell at the specified location.
- * @param {Array.<number>} index The index <i, j> of the required cell.
+ * @param {Array<number>} index The index <i, j> of the required cell.
  * @return {?Node} The cell <TD> or <TH> or role='gridcell' node at the
  * specified location. Null if that cell does not exist.
  */
 cvox.TraverseTable.prototype.getCellAt = function(index) {
   if (((index[0] < this.rowCount) && (index[0] >= 0)) &&
       ((index[1] < this.colCount) && (index[1] >= 0))) {
     var shadowEntry = this.shadowTable_[index[0]][index[1]];
     if (shadowEntry != null) {
       return shadowEntry.activeCell;
     }
@@ skipping 343 matching lines @@
   } else {
     this.currentCellCursor = [this.currentCellCursor[0], index];
   }
   return true;
 };
 
 
 /**
  * Moves to the cell at the specified index <i, j> in the table. Updates the
  * cell cursor.
- * @param {Array.<number>} index The index <i, j> of the required cell.
+ * @param {Array<number>} index The index <i, j> of the required cell.
  * @return {boolean} Either:
  *    1) True if the index is valid and the update has been made.
  *    2) False if the index is not valid (either less than 0, greater than
  *       the number of rows or columns in the table, or there is no cell
  *       at that location).
  */
 cvox.TraverseTable.prototype.goToCell = function(index) {
   if (((index[0] < this.rowCount) && (index[0] >= 0)) &&
       ((index[1] < this.colCount) && (index[1] >= 0))) {
     var cell = this.shadowTable_[index[0]][index[1]];
@@ skipping 69 matching lines @@
 };
 
 
 /**
  * Resets the table cursors.
  *
  */
 cvox.TraverseTable.prototype.resetCursor = function() {
   this.currentCellCursor = null;
 };