reflow comments in modules/accessiblity

third_party/WebKit/Source/modules/accessibility/AXTable.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 97 matching lines @@
   // This employs a heuristic to determine if this table should appear.
   // Only "data" tables should be exposed as tables.
   // Unfortunately, there is no good way to determine the difference
   // between a "layout" table and a "data" table.
 
   LayoutTable* table = toLayoutTable(m_layoutObject);
   Node* tableNode = table->node();
   if (!isHTMLTableElement(tableNode))
     return false;
 
-  // Do not consider it a data table if any of its descendants have an ARIA role.
+  // Do not consider it a data table if any of its descendants have an ARIA
+  // role.
   HTMLTableElement* tableElement = toHTMLTableElement(tableNode);
   if (elementHasAriaRole(tableElement->tHead()))
     return false;
   if (elementHasAriaRole(tableElement->tFoot()))
     return false;
 
   HTMLCollection* bodies = tableElement->tBodies();
   for (unsigned bodyIndex = 0; bodyIndex < bodies->length(); ++bodyIndex) {
     Element* bodyElement = bodies->item(bodyIndex);
     if (elementHasAriaRole(bodyElement))
       return false;
   }
 
   HTMLTableRowsCollection* rows = tableElement->rows();
   unsigned rowCount = rows->length();
   for (unsigned rowIndex = 0; rowIndex < rowCount; ++rowIndex) {
     HTMLTableRowElement* rowElement = rows->item(rowIndex);
     if (elementHasAriaRole(rowElement))
       return false;
     HTMLCollection* cells = rowElement->cells();
     for (unsigned cellIndex = 0; cellIndex < cells->length(); ++cellIndex) {
       if (elementHasAriaRole(cells->item(cellIndex)))
         return false;
     }
   }
 
-  // If there is a caption element, summary, THEAD, or TFOOT section, it's most certainly a data table
+  // If there is a caption element, summary, THEAD, or TFOOT section, it's most
+  // certainly a data table
   if (!tableElement->summary().isEmpty() || tableElement->tHead() ||
       tableElement->tFoot() || tableElement->caption())
     return true;
 
   // if someone used "rules" attribute than the table should appear
   if (!tableElement->rules().isEmpty())
     return true;
 
   // if there's a colgroup or col element, it's probably a data table.
   if (Traversal<HTMLTableColElement>::firstChild(*tableElement))
@@ skipping 10 matching lines @@
   int numRows = firstBody->numRows();
 
   // If there's only one cell, it's not a good AXTable candidate.
   if (numRows == 1 && numCols == 1)
     return false;
 
   // If there are at least 20 rows, we'll call it a data table.
   if (numRows >= 20)
     return true;
 
-  // Store the background color of the table to check against cell's background colors.
+  // Store the background color of the table to check against cell's background
+  // colors.
   const ComputedStyle* tableStyle = table->style();
   if (!tableStyle)
     return false;
   Color tableBGColor =
       tableStyle->visitedDependentColor(CSSPropertyBackgroundColor);
 
   // check enough of the cells to find if the table matches our criteria
   // Criteria:
   //   1) must have at least one valid cell (and)
   //   2) at least half of cells have borders (or)
-  //   3) at least half of cells have different bg colors than the table, and there is cell spacing
+  //   3) at least half of cells have different bg colors than the table, and
+  //      there is cell spacing
   unsigned validCellCount = 0;
   unsigned borderedCellCount = 0;
   unsigned backgroundDifferenceCellCount = 0;
   unsigned cellsWithTopBorder = 0;
   unsigned cellsWithBottomBorder = 0;
   unsigned cellsWithLeftBorder = 0;
   unsigned cellsWithRightBorder = 0;
 
   Color alternatingRowColors[5];
   int alternatingRowColorCount = 0;
 
   int headersInFirstColumnCount = 0;
   for (int row = 0; row < numRows; ++row) {
     int headersInFirstRowCount = 0;
     for (int col = 0; col < numCols; ++col) {
       LayoutTableCell* cell = firstBody->primaryCellAt(row, col);
       if (!cell)
         continue;
       Node* cellNode = cell->node();
       if (!cellNode)
         continue;
 
       if (cell->size().width() < 1 || cell->size().height() < 1)
         continue;
 
       validCellCount++;
 
       bool isTHCell = cellNode->hasTagName(thTag);
-      // If the first row is comprised of all <th> tags, assume it is a data table.
+      // If the first row is comprised of all <th> tags, assume it is a data
+      // table.
       if (!row && isTHCell)
         headersInFirstRowCount++;
 
-      // If the first column is comprised of all <th> tags, assume it is a data table.
+      // If the first column is comprised of all <th> tags, assume it is a data
+      // table.
       if (!col && isTHCell)
         headersInFirstColumnCount++;
 
-      // in this case, the developer explicitly assigned a "data" table attribute
+      // In this case, the developer explicitly assigned a "data" table
+      // attribute.
       if (isHTMLTableCellElement(*cellNode)) {
         HTMLTableCellElement& cellElement = toHTMLTableCellElement(*cellNode);
         if (!cellElement.headers().isEmpty() || !cellElement.abbr().isEmpty() ||
             !cellElement.axis().isEmpty() || !cellElement.scope().isEmpty())
           return true;
       }
 
       const ComputedStyle* computedStyle = cell->style();
       if (!computedStyle)
         continue;
 
       // If the empty-cells style is set, we'll call it a data table.
       if (computedStyle->emptyCells() == EEmptyCells::Hide)
         return true;
 
       // If a cell has matching bordered sides, call it a (fully) bordered cell.
       if ((cell->borderTop() > 0 && cell->borderBottom() > 0) ||
           (cell->borderLeft() > 0 && cell->borderRight() > 0))
         borderedCellCount++;
 
-      // Also keep track of each individual border, so we can catch tables where most
-      // cells have a bottom border, for example.
+      // Also keep track of each individual border, so we can catch tables where
+      // most cells have a bottom border, for example.
       if (cell->borderTop() > 0)
         cellsWithTopBorder++;
       if (cell->borderBottom() > 0)
         cellsWithBottomBorder++;
       if (cell->borderLeft() > 0)
         cellsWithLeftBorder++;
       if (cell->borderRight() > 0)
         cellsWithRightBorder++;
 
-      // If the cell has a different color from the table and there is cell spacing,
-      // then it is probably a data table cell (spacing and colors take the place of borders).
+      // If the cell has a different color from the table and there is cell
+      // spacing, then it is probably a data table cell (spacing and colors take
+      // the place of borders).
       Color cellColor =
           computedStyle->visitedDependentColor(CSSPropertyBackgroundColor);
       if (table->hBorderSpacing() > 0 && table->vBorderSpacing() > 0 &&
           tableBGColor != cellColor && cellColor.alpha() != 1)
         backgroundDifferenceCellCount++;
 
       // If we've found 10 "good" cells, we don't need to keep searching.
       if (borderedCellCount >= 10 || backgroundDifferenceCellCount >= 10)
         return true;
 
-      // For the first 5 rows, cache the background color so we can check if this table has zebra-striped rows.
+      // For the first 5 rows, cache the background color so we can check if
+      // this table has zebra-striped rows.
       if (row < 5 && row == alternatingRowColorCount) {
         LayoutObject* layoutRow = cell->parent();
         if (!layoutRow || !layoutRow->isBoxModelObject() ||
             !toLayoutBoxModelObject(layoutRow)->isTableRow())
           continue;
         const ComputedStyle* rowComputedStyle = layoutRow->style();
         if (!rowComputedStyle)
           continue;
         Color rowColor =
             rowComputedStyle->visitedDependentColor(CSSPropertyBackgroundColor);
@@ skipping 19 matching lines @@
       cellsWithTopBorder >= neededCellCount ||
       cellsWithBottomBorder >= neededCellCount ||
       cellsWithLeftBorder >= neededCellCount ||
       cellsWithRightBorder >= neededCellCount)
     return true;
 
   // half had different background colors, it's a data table
   if (backgroundDifferenceCellCount >= neededCellCount)
     return true;
 
-  // Check if there is an alternating row background color indicating a zebra striped style pattern.
+  // Check if there is an alternating row background color indicating a zebra
+  // striped style pattern.
   if (alternatingRowColorCount > 2) {
     Color firstColor = alternatingRowColors[0];
     for (int k = 1; k < alternatingRowColorCount; k++) {
       // If an odd row was the same color as the first row, its not alternating.
       if (k % 2 == 1 && alternatingRowColors[k] == firstColor)
         return false;
       // If an even row is not the same as the first row, its not alternating.
       if (!(k % 2) && alternatingRowColors[k] != firstColor)
         return false;
     }
@@ skipping 52 matching lines @@
     return;
 
   // Add caption
   if (HTMLTableCaptionElement* caption =
           toHTMLTableElement(tableNode)->caption()) {
     AXObject* captionObject = axCache.getOrCreate(caption);
     if (captionObject && !captionObject->accessibilityIsIgnored())
       m_children.append(captionObject);
   }
 
-  // Go through all the available sections to pull out the rows and add them as children.
+  // Go through all the available sections to pull out the rows and add them as
+  // children.
   table->recalcSectionsIfNeeded();
   LayoutTableSection* tableSection = table->topSection();
   if (!tableSection)
     return;
 
   LayoutTableSection* initialTableSection = tableSection;
   while (tableSection) {
     HeapHashSet<Member<AXObject>> appendedRows;
     unsigned numRows = tableSection->numRows();
     for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) {
@@ skipping 97 matching lines @@
   updateChildrenIfNecessary();
 
   return m_rows.size();
 }
 
 AXTableCell* AXTable::cellForColumnAndRow(unsigned column, unsigned row) {
   updateChildrenIfNecessary();
   if (column >= columnCount() || row >= rowCount())
     return 0;
 
-  // Iterate backwards through the rows in case the desired cell has a rowspan and exists in a previous row.
+  // Iterate backwards through the rows in case the desired cell has a rowspan
+  // and exists in a previous row.
   for (unsigned rowIndexCounter = row + 1; rowIndexCounter > 0;
        --rowIndexCounter) {
     unsigned rowIndex = rowIndexCounter - 1;
     const auto& children = m_rows[rowIndex]->children();
-    // Since some cells may have colspans, we have to check the actual range of each
-    // cell to determine which is the right one.
+    // Since some cells may have colspans, we have to check the actual range of
+    // each cell to determine which is the right one.
     for (unsigned colIndexCounter =
              std::min(static_cast<unsigned>(children.size()), column + 1);
          colIndexCounter > 0; --colIndexCounter) {
       unsigned colIndex = colIndexCounter - 1;
       AXObject* child = children[colIndex].get();
 
       if (!child->isTableCell())
         continue;
 
       std::pair<unsigned, unsigned> columnRange;
@@ skipping 34 matching lines @@
 }
 
 DEFINE_TRACE(AXTable) {
   visitor->trace(m_rows);
   visitor->trace(m_columns);
   visitor->trace(m_headerContainer);
   AXLayoutObject::trace(visitor);
 }
 
 }  // namespace blink