DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

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.
  */
 
@@ skipping 219 matching lines @@
   this.colCount = this.shadowColCount_();
   this.rowCount = this.countRows_();
 
   this.findHeaderCells_();
 
   // Listen for changes to the active table. If the active table changes,
   // rebuild the shadow table.
   // TODO (stoarca): Is this safe? When this object goes away, doesn't the
   // eventListener stay on the node? Someone with better knowledge of js
   // please confirm. If so, this is a leak.
-  this.activeTable_.addEventListener('DOMSubtreeModified',
-      goog.bind(function() {
+  this.activeTable_.addEventListener(
+      'DOMSubtreeModified', goog.bind(function() {
         this.buildShadowTable_();
         this.colCount = this.shadowColCount_();
         this.rowCount = this.countRows_();
 
         this.tableRowHeaders = [];
         this.tableColHeaders = [];
         this.findHeaderCells_();
 
         if (this.colCount == 0 && this.rowCount == 0) {
           return;
@@ skipping 36 matching lines @@
     // DomUtil.findTableNodeInList excluding captions from tables because
     // it makes them non-contiguous.
     if (!cvox.DomUtil.getContainingTable(n, {allowCaptions: true})) {
       return null;
     }
   }
   for (var i = 0; i < this.rowCount; ++i) {
     for (var j = 0; j < this.colCount; ++j) {
       if (this.shadowTable_[i][j]) {
         if (cvox.DomUtil.isDescendantOfNode(
-            n, this.shadowTable_[i][j].activeCell)) {
+                n, this.shadowTable_[i][j].activeCell)) {
           return [i, j];
         }
       }
     }
   }
   return null;
 };
 
 /**
  * Finds the valid cell nearest to the current cell cursor and moves the cell
@@ skipping 18 matching lines @@
     this.currentCellCursor = [currentCursor[0], (currentRow.length - 1)];
   } else {
     // Current row does not exist anymore. Does current column still exist?
     // Try last cell of current column
     var numRows = this.shadowTable_.length;
     if (numRows == 0) {
       // Table has been deleted!
       this.currentCellCursor = null;
       return;
     }
-    var aboveCell =
-        this.shadowTable_[numRows - 1][currentCursor[1]];
+    var aboveCell = this.shadowTable_[numRows - 1][currentCursor[1]];
     if (aboveCell) {
       this.currentCellCursor = [(numRows - 1), currentCursor[1]];
     } else {
       // Current column does not exist anymore either.
       // Move cursor to last cell in table.
       this.goToLastCell();
     }
   }
 };
 
@@ skipping 23 matching lines @@
   // Iterate through active table by row
   for (var i = 0; i < allRows.length; i++) {
     var childCells = cvox.TableUtil.getChildCells(allRows[i]);
 
     // Keep track of position in active table
     var activeTableCol = 0;
     // Keep track of position in shadow table
     var shadowTableCol = 0;
 
     while (activeTableCol < childCells.length) {
-
       // Check to make sure we haven't already filled this cell.
       if (this.shadowTable_[i][shadowTableCol] == null) {
-
         var activeTableCell = childCells[activeTableCol];
 
         // Default value for colspan and rowspan is 1
         var colsSpanned = 1;
         var rowsSpanned = 1;
 
         if (activeTableCell.hasAttribute('colspan')) {
-
-          colsSpanned =
-              parseInt(activeTableCell.getAttribute('colspan'), 10);
+          colsSpanned = parseInt(activeTableCell.getAttribute('colspan'), 10);
 
           if ((isNaN(colsSpanned)) || (colsSpanned <= 0)) {
             // The HTML5 spec defines colspan MUST be greater than 0:
             // http://dev.w3.org/html5/spec/Overview.html#attr-tdth-colspan
             //
             // This is a change from the HTML4 spec:
             // http://www.w3.org/TR/html401/struct/tables.html#adef-colspan
             //
             // We will degrade gracefully by treating a colspan=0 as
             // equivalent to a colspan=1.
             // Tested in method testColSpan0 in rowColSpanTable_test.js
             colsSpanned = 1;
           }
         }
         if (activeTableCell.hasAttribute('rowspan')) {
-          rowsSpanned =
-              parseInt(activeTableCell.getAttribute('rowspan'), 10);
+          rowsSpanned = parseInt(activeTableCell.getAttribute('rowspan'), 10);
 
           if ((isNaN(rowsSpanned)) || (rowsSpanned <= 0)) {
             // The HTML5 spec defines that rowspan can be any non-negative
             // integer, including 0:
             // http://dev.w3.org/html5/spec/Overview.html#attr-tdth-rowspan
             //
             // However, Chromium treats rowspan=0 as rowspan=1. This appears
             // to be a bug from WebKit:
             // https://bugs.webkit.org/show_bug.cgi?id=10300
             // Inherited from a bug (since fixed) in KDE:
@@ skipping 58 matching lines @@
             }
             shadowNode.rowGroup = currentRowGroup;
 
             // Check and update col group status
             if (colToColGroup.length > 0) {
               shadowNode.colGroup = colToColGroup[shadowTableCol];
             } else {
               shadowNode.colGroup = 0;
             }
 
-            if (! shadowNode.spanned) {
+            if (!shadowNode.spanned) {
               if (activeTableCell.id != null) {
                 this.idToShadowNode_[activeTableCell.id] = shadowNode;
               }
             }
 
             this.shadowTable_[i + r][shadowTableCol + c] = shadowNode;
           }
         }
         shadowTableCol += colsSpanned;
         activeTableCol++;
@@ skipping 17 matching lines @@
  * rowHeaderCells or colHeaderCells arrays.
  *
  * @private
  */
 cvox.TraverseTable.prototype.findHeaderCells_ = function() {
   // Forming relationships between data cells and header cells:
   // http://dev.w3.org/html5/spec/tabular-data.html
   // #header-and-data-cell-semantics
 
   for (var i = 0; i < this.candidateHeaders_.length; i++) {
-
     var currentShadowNode = this.candidateHeaders_[i];
     var currentCell = currentShadowNode.activeCell;
 
     var assumedScope = null;
     var specifiedScope = null;
 
     if (currentShadowNode.spanned) {
       continue;
     }
 
-    if ((currentCell.tagName == 'TH') &&
-        !(currentCell.hasAttribute('scope'))) {
+    if ((currentCell.tagName == 'TH') && !(currentCell.hasAttribute('scope'))) {
       // No scope specified - compute scope ourselves.
       // Go left/right - if there's a header node, then this is a column
       // header
       if (currentShadowNode.j > 0) {
-        if (this.shadowTable_[currentShadowNode.i][currentShadowNode.j - 1].
-            activeCell.tagName == 'TH') {
+        if (this.shadowTable_[currentShadowNode.i][currentShadowNode.j - 1]
+                .activeCell.tagName == 'TH') {
           assumedScope = 'col';
         }
-      } else if (currentShadowNode.j < this.shadowTable_[currentShadowNode.i].
-          length - 1) {
-        if (this.shadowTable_[currentShadowNode.i][currentShadowNode.j + 1].
-            activeCell.tagName == 'TH') {
+      } else if (
+          currentShadowNode.j <
+          this.shadowTable_[currentShadowNode.i].length - 1) {
+        if (this.shadowTable_[currentShadowNode.i][currentShadowNode.j + 1]
+                .activeCell.tagName == 'TH') {
           assumedScope = 'col';
         }
       } else {
         // This row has a width of 1 cell, just assume this is a colum header
         assumedScope = 'col';
       }
 
       if (assumedScope == null) {
         // Go up/down - if there's a header node, then this is a row header
         if (currentShadowNode.i > 0) {
-          if (this.shadowTable_[currentShadowNode.i - 1][currentShadowNode.j].
-              activeCell.tagName == 'TH') {
+          if (this.shadowTable_[currentShadowNode.i - 1][currentShadowNode.j]
+                  .activeCell.tagName == 'TH') {
             assumedScope = 'row';
           }
         } else if (currentShadowNode.i < this.shadowTable_.length - 1) {
-          if (this.shadowTable_[currentShadowNode.i + 1][currentShadowNode.j].
-              activeCell.tagName == 'TH') {
+          if (this.shadowTable_[currentShadowNode.i + 1][currentShadowNode.j]
+                  .activeCell.tagName == 'TH') {
             assumedScope = 'row';
           }
         } else {
           // This column has a height of 1 cell, just assume that this is
           // a row header
           assumedScope = 'row';
         }
       }
     } else if (currentCell.hasAttribute('scope')) {
       specifiedScope = currentCell.getAttribute('scope');
-    } else if (currentCell.hasAttribute('role') &&
+    } else if (
+        currentCell.hasAttribute('role') &&
         (currentCell.getAttribute('role') == 'rowheader')) {
       specifiedScope = 'row';
-    } else if (currentCell.hasAttribute('role') &&
+    } else if (
+        currentCell.hasAttribute('role') &&
         (currentCell.getAttribute('role') == 'columnheader')) {
-     specifiedScope = 'col';
+      specifiedScope = 'col';
     }
 
     if ((specifiedScope == 'row') || (assumedScope == 'row')) {
       currentShadowNode.isRowHeader = true;
 
       // Go right until you hit the edge of the table or a data
       // cell after another header cell.
       // Add this cell to each shadowNode.rowHeaderCells attribute as you go.
       for (var rightCtr = currentShadowNode.j;
            rightCtr < this.shadowTable_[currentShadowNode.i].length;
            rightCtr++) {
-
         var rightShadowNode = this.shadowTable_[currentShadowNode.i][rightCtr];
         var rightCell = rightShadowNode.activeCell;
 
-        if ((rightCell.tagName == 'TH') ||
-            (rightCell.hasAttribute('scope'))) {
-
+        if ((rightCell.tagName == 'TH') || (rightCell.hasAttribute('scope'))) {
           if (rightCtr < this.shadowTable_[currentShadowNode.i].length - 1) {
             var checkDataCell =
                 this.shadowTable_[currentShadowNode.i][rightCtr + 1];
           }
         }
         rightShadowNode.rowHeaderCells.push(currentCell);
       }
       this.tableRowHeaders.push(currentCell);
     } else if ((specifiedScope == 'col') || (assumedScope == 'col')) {
       currentShadowNode.isColHeader = true;
 
       // Go down until you hit the edge of the table or a data cell
       // after another header cell.
       // Add this cell to each shadowNode.colHeaders attribute as you go.
 
       for (var downCtr = currentShadowNode.i;
-           downCtr < this.shadowTable_.length;
-           downCtr++) {
-
+           downCtr < this.shadowTable_.length; downCtr++) {
         var downShadowNode = this.shadowTable_[downCtr][currentShadowNode.j];
         if (downShadowNode == null) {
           break;
         }
         var downCell = downShadowNode.activeCell;
 
-        if ((downCell.tagName == 'TH') ||
-            (downCell.hasAttribute('scope'))) {
-
+        if ((downCell.tagName == 'TH') || (downCell.hasAttribute('scope'))) {
           if (downCtr < this.shadowTable_.length - 1) {
             var checkDataCell =
                 this.shadowTable_[downCtr + 1][currentShadowNode.j];
           }
         }
         downShadowNode.colHeaderCells.push(currentCell);
       }
       this.tableColHeaders.push(currentCell);
     } else if (specifiedScope == 'rowgroup') {
-       currentShadowNode.isRowHeader = true;
+      currentShadowNode.isRowHeader = true;
 
       // This cell is a row header for the rest of the cells in this row group.
       var currentRowGroup = currentShadowNode.rowGroup;
 
       // Get the rest of the cells in this row first
       for (var cellsInRow = currentShadowNode.j + 1;
            cellsInRow < this.shadowTable_[currentShadowNode.i].length;
            cellsInRow++) {
-        this.shadowTable_[currentShadowNode.i][cellsInRow].
-            rowHeaderCells.push(currentCell);
+        this.shadowTable_[currentShadowNode.i][cellsInRow].rowHeaderCells.push(
+            currentCell);
       }
 
       // Now propagate to rest of row group
       for (var downCtr = currentShadowNode.i + 1;
-           downCtr < this.shadowTable_.length;
-           downCtr++) {
-
+           downCtr < this.shadowTable_.length; downCtr++) {
         if (this.shadowTable_[downCtr][0].rowGroup != currentRowGroup) {
           break;
         }
 
-        for (var rightCtr = 0;
-             rightCtr < this.shadowTable_[downCtr].length;
+        for (var rightCtr = 0; rightCtr < this.shadowTable_[downCtr].length;
              rightCtr++) {
-
-          this.shadowTable_[downCtr][rightCtr].
-              rowHeaderCells.push(currentCell);
+          this.shadowTable_[downCtr][rightCtr].rowHeaderCells.push(currentCell);
         }
       }
       this.tableRowHeaders.push(currentCell);
 
     } else if (specifiedScope == 'colgroup') {
       currentShadowNode.isColHeader = true;
 
       // This cell is a col header for the rest of the cells in this col group.
       var currentColGroup = currentShadowNode.colGroup;
 
       // Get the rest of the cells in this colgroup first
       for (var cellsInCol = currentShadowNode.j + 1;
            cellsInCol < this.shadowTable_[currentShadowNode.i].length;
            cellsInCol++) {
         if (this.shadowTable_[currentShadowNode.i][cellsInCol].colGroup ==
             currentColGroup) {
-          this.shadowTable_[currentShadowNode.i][cellsInCol].
-              colHeaderCells.push(currentCell);
+          this.shadowTable_[currentShadowNode.i][cellsInCol]
+              .colHeaderCells.push(currentCell);
         }
       }
 
       // Now propagate to rest of col group
       for (var downCtr = currentShadowNode.i + 1;
-           downCtr < this.shadowTable_.length;
-           downCtr++) {
-
-        for (var rightCtr = 0;
-             rightCtr < this.shadowTable_[downCtr].length;
+           downCtr < this.shadowTable_.length; downCtr++) {
+        for (var rightCtr = 0; rightCtr < this.shadowTable_[downCtr].length;
              rightCtr++) {
-
           if (this.shadowTable_[downCtr][rightCtr].colGroup ==
               currentColGroup) {
-            this.shadowTable_[downCtr][rightCtr].
-                colHeaderCells.push(currentCell);
+            this.shadowTable_[downCtr][rightCtr].colHeaderCells.push(
+                currentCell);
           }
         }
       }
       this.tableColHeaders.push(currentCell);
     }
     if (currentCell.hasAttribute('headers')) {
       this.findAttrbHeaders_(currentShadowNode);
     }
     if (currentCell.hasAttribute('aria-describedby')) {
       this.findAttrbDescribedBy_(currentShadowNode);
@@ skipping 18 matching lines @@
  * that has a 'headers' attribute.
  *
  * @private
  */
 cvox.TraverseTable.prototype.findAttrbHeaders_ = function(currentShadowNode) {
   var activeTableCell = currentShadowNode.activeCell;
 
   var idList = activeTableCell.getAttribute('headers').split(' ');
   for (var idToken = 0; idToken < idList.length; idToken++) {
     // Find cell(s) with this ID, add to header list
-    var idCellArray = cvox.TableUtil.getCellWithID(this.activeTable_,
-                                                   idList[idToken]);
+    var idCellArray =
+        cvox.TableUtil.getCellWithID(this.activeTable_, idList[idToken]);
 
     for (var idCtr = 0; idCtr < idCellArray.length; idCtr++) {
       if (idCellArray[idCtr].id == activeTableCell.id) {
         // Skip if the ID is the same as the current cell's ID
         break;
       }
       // Check if this list of candidate headers contains a
       // shadowNode with an active cell with this ID already
-      var possibleHeaderNode =
-          this.idToShadowNode_[idCellArray[idCtr].id];
-      if (! cvox.TableUtil.checkIfHeader(possibleHeaderNode.activeCell)) {
+      var possibleHeaderNode = this.idToShadowNode_[idCellArray[idCtr].id];
+      if (!cvox.TableUtil.checkIfHeader(possibleHeaderNode.activeCell)) {
         // This listed header cell will not be handled later.
         // Determine whether this is a row or col header for
         // the active table cell
 
         var iDiff = Math.abs(possibleHeaderNode.i - currentShadowNode.i);
         var jDiff = Math.abs(possibleHeaderNode.j - currentShadowNode.j);
         if ((iDiff == 0) || (iDiff < jDiff)) {
-          cvox.TableUtil.pushIfNotContained(currentShadowNode.rowHeaderCells,
-                                            possibleHeaderNode.activeCell);
-          cvox.TableUtil.pushIfNotContained(this.tableRowHeaders,
-                                            possibleHeaderNode.activeCell);
+          cvox.TableUtil.pushIfNotContained(
+              currentShadowNode.rowHeaderCells, possibleHeaderNode.activeCell);
+          cvox.TableUtil.pushIfNotContained(
+              this.tableRowHeaders, possibleHeaderNode.activeCell);
         } else {
           // This is a column header
-          cvox.TableUtil.pushIfNotContained(currentShadowNode.colHeaderCells,
-                                            possibleHeaderNode.activeCell);
-          cvox.TableUtil.pushIfNotContained(this.tableColHeaders,
-                                            possibleHeaderNode.activeCell);
+          cvox.TableUtil.pushIfNotContained(
+              currentShadowNode.colHeaderCells, possibleHeaderNode.activeCell);
+          cvox.TableUtil.pushIfNotContained(
+              this.tableColHeaders, possibleHeaderNode.activeCell);
         }
       }
     }
   }
 };
 
 
 /**
  * Finds header cells from the 'aria-describedby' attribute of a given shadow
  * node's active cell and classifies them in two ways:
  * -- Identifies them for the entire table by adding them to
  * this.tableRowHeaders and this.tableColHeaders.
  * -- Identifies them for the shadow table node by adding them to the node's
  * rowHeaderCells or colHeaderCells arrays.
  *
  * Please note that header cells found through the 'aria-describedby' attribute
  * must have the role='rowheader' or role='columnheader' attributes in order to
  * be considered header cells.
  *
  * @param {ShadowTableNode} currentShadowNode A shadow node with an active cell
  * that has an 'aria-describedby' attribute.
  *
  * @private
  */
-cvox.TraverseTable.prototype.findAttrbDescribedBy_ =
-    function(currentShadowNode) {
+cvox.TraverseTable.prototype.findAttrbDescribedBy_ = function(
+    currentShadowNode) {
   var activeTableCell = currentShadowNode.activeCell;
 
   var idList = activeTableCell.getAttribute('aria-describedby').split(' ');
   for (var idToken = 0; idToken < idList.length; idToken++) {
     // Find cell(s) with this ID, add to header list
-    var idCellArray = cvox.TableUtil.getCellWithID(this.activeTable_,
-                                                   idList[idToken]);
+    var idCellArray =
+        cvox.TableUtil.getCellWithID(this.activeTable_, idList[idToken]);
 
     for (var idCtr = 0; idCtr < idCellArray.length; idCtr++) {
       if (idCellArray[idCtr].id == activeTableCell.id) {
         // Skip if the ID is the same as the current cell's ID
         break;
       }
       // Check if this list of candidate headers contains a
       // shadowNode with an active cell with this ID already
-      var possibleHeaderNode =
-          this.idToShadowNode_[idCellArray[idCtr].id];
-      if (! cvox.TableUtil.checkIfHeader(possibleHeaderNode.activeCell)) {
+      var possibleHeaderNode = this.idToShadowNode_[idCellArray[idCtr].id];
+      if (!cvox.TableUtil.checkIfHeader(possibleHeaderNode.activeCell)) {
         // This listed header cell will not be handled later.
         // Determine whether this is a row or col header for
         // the active table cell
 
         if (possibleHeaderNode.activeCell.hasAttribute('role') &&
             (possibleHeaderNode.activeCell.getAttribute('role') ==
-                'rowheader')) {
-          cvox.TableUtil.pushIfNotContained(currentShadowNode.rowHeaderCells,
-                                            possibleHeaderNode.activeCell);
-          cvox.TableUtil.pushIfNotContained(this.tableRowHeaders,
-                                            possibleHeaderNode.activeCell);
-        } else if (possibleHeaderNode.activeCell.hasAttribute('role') &&
+             'rowheader')) {
+          cvox.TableUtil.pushIfNotContained(
+              currentShadowNode.rowHeaderCells, possibleHeaderNode.activeCell);
+          cvox.TableUtil.pushIfNotContained(
+              this.tableRowHeaders, possibleHeaderNode.activeCell);
+        } else if (
+            possibleHeaderNode.activeCell.hasAttribute('role') &&
             (possibleHeaderNode.activeCell.getAttribute('role') ==
-                'columnheader')) {
-          cvox.TableUtil.pushIfNotContained(currentShadowNode.colHeaderCells,
-                                            possibleHeaderNode.activeCell);
-          cvox.TableUtil.pushIfNotContained(this.tableColHeaders,
-                                            possibleHeaderNode.activeCell);
+             'columnheader')) {
+          cvox.TableUtil.pushIfNotContained(
+              currentShadowNode.colHeaderCells, possibleHeaderNode.activeCell);
+          cvox.TableUtil.pushIfNotContained(
+              this.tableColHeaders, possibleHeaderNode.activeCell);
         }
       }
     }
   }
 };
 
 
 /**
  * Gets the current cell or null if there is no current cell.
  * @return {?Node} The cell <TD> or <TH> or role='gridcell' node.
@@ skipping 92 matching lines @@
 
 /**
  * Gets the active column, represented as an array of <TH> or <TD> nodes that
  * make up a column. In this context, "active" means that this is the column
  * that contains the cell the user is currently looking at.
  * @return {Array} An array of <TH> or <TD> or role='gridcell' nodes.
  */
 cvox.TraverseTable.prototype.getCol = function() {
   var colArray = [];
   for (var i = 0; i < this.shadowTable_.length; i++) {
-
     if (this.shadowTable_[i][this.currentCellCursor[1]]) {
       var shadowEntry = this.shadowTable_[i][this.currentCellCursor[1]];
 
       if (shadowEntry.colSpan && shadowEntry.rowSpan) {
         // Look at the last element in the column cell aray.
         var prev = colArray[colArray.length - 1];
-        if (prev !=
-            shadowEntry.activeCell) {
+        if (prev != shadowEntry.activeCell) {
           // Watch out for positions spanned by a cell with rowspan and
           // colspan. We don't want the same cell showing up multiple times
           // in per-column cell lists.
-          colArray.push(
-              shadowEntry.activeCell);
+          colArray.push(shadowEntry.activeCell);
         }
       } else if ((shadowEntry.colSpan) || (!shadowEntry.rowSpan)) {
-        colArray.push(
-            shadowEntry.activeCell);
+        colArray.push(shadowEntry.activeCell);
       }
     }
   }
   return colArray;
 };
 
 
 /**
  * Gets the active row <TR> node. In this context, "active" means that this is
  * the row that contains the cell the user is currently looking at.
@@ skipping 24 matching lines @@
 
 /**
  * Gets the table caption text.
  *
  * @return {?string} Either:
  *     1) The table caption text
  *     2) Null if the table does not include a caption tag.
  */
 cvox.TraverseTable.prototype.captionText = function() {
   // If there's more than one outer <caption> element, choose the first one.
-  var captionNodes = cvox.XpathUtil.evalXPath('caption\[1]',
-      this.activeTable_);
+  var captionNodes = cvox.XpathUtil.evalXPath('caption\[1]', this.activeTable_);
   if (captionNodes.length > 0) {
     return captionNodes[0].innerHTML;
   } else {
     return null;
   }
 };
 
 
 /**
  * Calculates the number of columns in the shadow table.
@@ skipping 31 matching lines @@
  * This uses the W3C recommended algorithm for calculating number of
  * columns, but it does not take rowspans or colspans into account. This means
  * that the number of columns calculated here might be lower than the actual
  * number of columns in the table if columns are indicated by colspans.
  * @return {number} The number of columns in the table.
  * @private
  */
 cvox.TraverseTable.prototype.getW3CColCount_ = function() {
   // See http://www.w3.org/TR/html401/struct/tables.html#h-11.2.4.3
 
-  var colgroupNodes = cvox.XpathUtil.evalXPath('child::colgroup',
-      this.activeTable_);
+  var colgroupNodes =
+      cvox.XpathUtil.evalXPath('child::colgroup', this.activeTable_);
   var colNodes = cvox.XpathUtil.evalXPath('child::col', this.activeTable_);
 
   if ((colgroupNodes.length == 0) && (colNodes.length == 0)) {
     var maxcols = 0;
     var outerChildren = cvox.TableUtil.getChildRows(this.activeTable_);
     for (var i = 0; i < outerChildren.length; i++) {
       var childrenCount = cvox.TableUtil.getChildCells(outerChildren[i]);
       if (childrenCount.length > maxcols) {
         maxcols = childrenCount.length;
       }
     }
     return maxcols;
   } else {
     var sum = 0;
     for (var i = 0; i < colNodes.length; i++) {
       if (colNodes[i].hasAttribute('span')) {
         sum += colNodes[i].getAttribute('span');
       } else {
         sum += 1;
       }
     }
     for (i = 0; i < colgroupNodes.length; i++) {
-      var colChildren = cvox.XpathUtil.evalXPath('child::col',
-          colgroupNodes[i]);
+      var colChildren =
+          cvox.XpathUtil.evalXPath('child::col', colgroupNodes[i]);
       if (colChildren.length == 0) {
         if (colgroupNodes[i].hasAttribute('span')) {
           sum += colgroupNodes[i].getAttribute('span');
         } else {
           sum += 1;
         }
       }
     }
   }
   return sum;
 };
 
 
 /**
  * Moves to the next row in the table. Updates the cell cursor.
  *
  * @return {boolean} Either:
  *    1) True if the update has been made.
  *    2) False if the end of the table has been reached and the update has not
  *       happened.
-  */
+ */
 cvox.TraverseTable.prototype.nextRow = function() {
   if (!this.currentCellCursor) {
     // We have not started moving through the table yet
     return this.goToRow(0);
   } else {
     return this.goToRow(this.currentCellCursor[0] + 1);
   }
 
 };
 
@@ skipping 128 matching lines @@
  *    1) True if the index is valid and the update has been made.
  *    2) False if the index is not valid (there is no cell at that location).
  */
 cvox.TraverseTable.prototype.goToLastCell = function() {
   var numRows = this.shadowTable_.length;
   if (numRows == 0) {
     return false;
   }
   var lastRow = this.shadowTable_[numRows - 1];
   var lastIndex = [(numRows - 1), (lastRow.length - 1)];
-  var cell =
-      this.shadowTable_[lastIndex[0]][lastIndex[1]];
+  var cell = this.shadowTable_[lastIndex[0]][lastIndex[1]];
   if (cell != null) {
     this.currentCellCursor = lastIndex;
     return true;
   }
   return false;
 };
 
 
 /**
  * Moves to the cell at the last index in the current row  of the table. Update
  * the cell cursor.
  * @return {boolean} Either:
  *    1) True if the index is valid and the update has been made.
  *    2) False if the index is not valid (there is no cell at that location).
  */
 cvox.TraverseTable.prototype.goToRowLastCell = function() {
   var currentRow = this.currentCellCursor[0];
   var lastIndex = [currentRow, (this.shadowTable_[currentRow].length - 1)];
-  var cell =
-      this.shadowTable_[lastIndex[0]][lastIndex[1]];
+  var cell = this.shadowTable_[lastIndex[0]][lastIndex[1]];
   if (cell != null) {
     this.currentCellCursor = lastIndex;
     return true;
   }
   return false;
 };
 
 
 /**
  * Moves to the cell at the last index in the current column  of the table.
  * Update the cell cursor.
  * @return {boolean} Either:
  *    1) True if the index is valid and the update has been made.
  *    2) False if the index is not valid (there is no cell at that location).
  */
 cvox.TraverseTable.prototype.goToColLastCell = function() {
   var currentCol = this.getCol();
   var lastIndex = [(currentCol.length - 1), this.currentCellCursor[1]];
-  var cell =
-      this.shadowTable_[lastIndex[0]][lastIndex[1]];
+  var cell = this.shadowTable_[lastIndex[0]][lastIndex[1]];
   if (cell != null) {
     this.currentCellCursor = lastIndex;
     return true;
   }
   return false;
 };
 
 
 /**
  * Resets the table cursors.
  *
  */
 cvox.TraverseTable.prototype.resetCursor = function() {
   this.currentCellCursor = null;
 };