Reformat comments in core/layout

third_party/WebKit/Source/core/layout/LayoutTableSection.cpp

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2013 Apple Inc.
+ *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ skipping 16 matching lines @@
 #include "core/layout/SubtreeLayoutScope.h"
 #include "core/paint/TableSectionPainter.h"
 #include "wtf/HashSet.h"
 #include <algorithm>
 #include <limits>
 
 namespace blink {
 
 using namespace HTMLNames;
 
-// This variable is used to balance the memory consumption vs the paint invalidation time on big tables.
+// This variable is used to balance the memory consumption vs the paint
+// invalidation time on big tables.
 static unsigned gMinTableSizeToUseFastPaintPathWithOverflowingCell = 75 * 75;
 
 static inline void setRowLogicalHeightToRowStyleLogicalHeight(
     LayoutTableSection::RowStruct& row) {
   ASSERT(row.rowLayoutObject);
   row.logicalHeight = row.rowLayoutObject->style()->logicalHeight();
 }
 
 static inline void updateLogicalHeightForCell(
     LayoutTableSection::RowStruct& row,
@@ skipping 106 matching lines @@
 
     if (beforeChild && !beforeChild->isAnonymous() &&
         beforeChild->parent() == this) {
       LayoutObject* row = beforeChild->previousSibling();
       if (row && row->isTableRow() && row->isAnonymous()) {
         row->addChild(child);
         return;
       }
     }
 
-    // If beforeChild is inside an anonymous cell/row, insert into the cell or into
-    // the anonymous row containing it, if there is one.
+    // If beforeChild is inside an anonymous cell/row, insert into the cell or
+    // into the anonymous row containing it, if there is one.
     LayoutObject* lastBox = last;
     while (lastBox && lastBox->parent()->isAnonymous() &&
            !lastBox->isTableRow())
       lastBox = lastBox->parent();
     if (lastBox && lastBox->isAnonymous() &&
         !lastBox->isBeforeOrAfterContent()) {
       lastBox->addChild(child, beforeChild);
       return;
     }
 
@@ skipping 59 matching lines @@
     for (; row && row != previousCell->row(); row = row->previousRow()) {
     }
     ASSERT(row == previousCell->row());
 
     previousCell = currentCell;
   }
 #endif  // NDEBUG
 }
 
 void LayoutTableSection::addCell(LayoutTableCell* cell, LayoutTableRow* row) {
-  // We don't insert the cell if we need cell recalc as our internal columns' representation
-  // will have drifted from the table's representation. Also recalcCells will call addCell
-  // at a later time after sync'ing our columns' with the table's.
+  // We don't insert the cell if we need cell recalc as our internal columns'
+  // representation will have drifted from the table's representation. Also
+  // recalcCells will call addCell at a later time after sync'ing our columns'
+  // with the table's.
   if (needsCellRecalc())
     return;
 
   unsigned rSpan = cell->rowSpan();
   unsigned cSpan = cell->colSpan();
   const Vector<LayoutTable::ColumnStruct>& columns =
       table()->effectiveColumns();
   unsigned nCols = columns.size();
   unsigned insertionRow = row->rowIndex();
 
   // ### mozilla still seems to do the old HTML way, even for strict DTD
-  // (see the annotation on table cell layouting in the CSS specs and the testcase below:
+  // (see the annotation on table cell layouting in the CSS specs and the
+  // testcase below:
   // <TABLE border>
   // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4
   // <TR><TD colspan="2">5
   // </TABLE>
   while (m_cCol < nCols && (cellAt(insertionRow, m_cCol).hasCells() ||
                             cellAt(insertionRow, m_cCol).inColSpan))
     m_cCol++;
 
   updateLogicalHeightForCell(m_grid[insertionRow], cell);
 
@@ skipping 70 matching lines @@
                                         m_rowPos[actualRow] -
                                         borderSpacingForRow(actualRow);
     if (!spanningRowsHeight.rowHeight[row])
       spanningRowsHeight.isAnyRowWithOnlySpanningCells |=
           rowHasOnlySpanningCells(actualRow);
 
     spanningRowsHeight.totalRowsHeight += spanningRowsHeight.rowHeight[row];
     spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing -=
         borderSpacingForRow(actualRow);
   }
-  // We don't span the following row so its border-spacing (if any) should be included.
+  // We don't span the following row so its border-spacing (if any) should be
+  // included.
   spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing +=
       borderSpacingForRow(rowIndex + rowSpan - 1);
 }
 
 void LayoutTableSection::distributeExtraRowSpanHeightToPercentRows(
     LayoutTableCell* cell,
     float totalPercent,
     int& extraRowSpanningHeight,
     Vector<int>& rowsHeight) {
   if (!extraRowSpanningHeight || !totalPercent)
     return;
 
   const unsigned rowSpan = cell->rowSpan();
   const unsigned rowIndex = cell->rowIndex();
   float percent = std::min(totalPercent, 100.0f);
   const int tableHeight = m_rowPos[m_grid.size()] + extraRowSpanningHeight;
 
-  // Our algorithm matches Firefox. Extra spanning height would be distributed Only in first percent height rows
-  // those total percent is 100. Other percent rows would be uneffected even extra spanning height is remain.
+  // Our algorithm matches Firefox. Extra spanning height would be distributed
+  // Only in first percent height rows those total percent is 100. Other percent
+  // rows would be uneffected even extra spanning height is remain.
   int accumulatedPositionIncrease = 0;
   for (unsigned row = rowIndex; row < (rowIndex + rowSpan); row++) {
     if (percent > 0 && extraRowSpanningHeight > 0) {
       // TODO(alancutter): Make this work correctly for calc lengths.
       if (m_grid[row].logicalHeight.isPercent()) {
         int toAdd =
             (tableHeight *
              std::min(m_grid[row].logicalHeight.percent(), percent) / 100) -
             rowsHeight[row - rowIndex];
 
@@ skipping 10 matching lines @@
 static void updatePositionIncreasedWithRowHeight(
     int extraHeight,
     float rowHeight,
     float totalHeight,
     int& accumulatedPositionIncrease,
     double& remainder) {
   // Without the cast we lose enough precision to cause heights to miss pixels
   // (and trigger asserts) in some layout tests.
   double proportionalPositionIncrease =
       remainder + (extraHeight * double(rowHeight)) / totalHeight;
-  // The epsilon is to push any values that are close to a whole number but aren't due to floating point imprecision.
-  // The epsilons are not accumulated, any that aren't necessary are lost in the cast to int.
+  // The epsilon is to push any values that are close to a whole number but
+  // aren't due to floating point imprecision. The epsilons are not accumulated,
+  // any that aren't necessary are lost in the cast to int.
   int positionIncreaseInt = proportionalPositionIncrease + 0.000001;
   accumulatedPositionIncrease += positionIncreaseInt;
   remainder = proportionalPositionIncrease - positionIncreaseInt;
 }
 
-// This is mainly used to distribute whole extra rowspanning height in percent rows when all spanning rows are
-// percent rows.
-// Distributing whole extra rowspanning height in percent rows based on the ratios of percent because this method works
-// same as percent distribution when only percent rows are present and percent is 100. Also works perfectly fine when
-// percent is not equal to 100.
+// This is mainly used to distribute whole extra rowspanning height in percent
+// rows when all spanning rows are percent rows.
+// Distributing whole extra rowspanning height in percent rows based on the
+// ratios of percent because this method works same as percent distribution when
+// only percent rows are present and percent is 100. Also works perfectly fine
+// when percent is not equal to 100.
 void LayoutTableSection::distributeWholeExtraRowSpanHeightToPercentRows(
     LayoutTableCell* cell,
     float totalPercent,
     int& extraRowSpanningHeight,
     Vector<int>& rowsHeight) {
   if (!extraRowSpanningHeight || !totalPercent)
     return;
 
   const unsigned rowSpan = cell->rowSpan();
   const unsigned rowIndex = cell->rowIndex();
@@ skipping 21 matching lines @@
     int& extraRowSpanningHeight,
     Vector<int>& rowsHeight) {
   if (!extraRowSpanningHeight || !totalAutoRowsHeight)
     return;
 
   const unsigned rowSpan = cell->rowSpan();
   const unsigned rowIndex = cell->rowIndex();
   int accumulatedPositionIncrease = 0;
   double remainder = 0;
 
-  // Aspect ratios of auto rows should not change otherwise table may look different than user expected.
-  // So extra height distributed in auto spanning rows based on their weight in spanning cell.
+  // Aspect ratios of auto rows should not change otherwise table may look
+  // different than user expected. So extra height distributed in auto spanning
+  // rows based on their weight in spanning cell.
   for (unsigned row = rowIndex; row < (rowIndex + rowSpan); row++) {
     if (m_grid[row].logicalHeight.isAuto()) {
       updatePositionIncreasedWithRowHeight(
           extraRowSpanningHeight, rowsHeight[row - rowIndex],
           totalAutoRowsHeight, accumulatedPositionIncrease, remainder);
     }
     m_rowPos[row + 1] += accumulatedPositionIncrease;
   }
 
   DCHECK(!round(remainder)) << "remainder was " << remainder;
 
   extraRowSpanningHeight -= accumulatedPositionIncrease;
 }
 
 void LayoutTableSection::distributeExtraRowSpanHeightToRemainingRows(
     LayoutTableCell* cell,
     int totalRemainingRowsHeight,
     int& extraRowSpanningHeight,
     Vector<int>& rowsHeight) {
   if (!extraRowSpanningHeight || !totalRemainingRowsHeight)
     return;
 
   const unsigned rowSpan = cell->rowSpan();
   const unsigned rowIndex = cell->rowIndex();
   int accumulatedPositionIncrease = 0;
   double remainder = 0;
 
-  // Aspect ratios of the rows should not change otherwise table may look different than user expected.
-  // So extra height distribution in remaining spanning rows based on their weight in spanning cell.
+  // Aspect ratios of the rows should not change otherwise table may look
+  // different than user expected. So extra height distribution in remaining
+  // spanning rows based on their weight in spanning cell.
   for (unsigned row = rowIndex; row < (rowIndex + rowSpan); row++) {
     if (!m_grid[row].logicalHeight.isPercentOrCalc()) {
       updatePositionIncreasedWithRowHeight(
           extraRowSpanningHeight, rowsHeight[row - rowIndex],
           totalRemainingRowsHeight, accumulatedPositionIncrease, remainder);
     }
     m_rowPos[row + 1] += accumulatedPositionIncrease;
   }
 
   DCHECK(!round(remainder)) << "remainder was " << remainder;
 
   extraRowSpanningHeight -= accumulatedPositionIncrease;
 }
 
 static bool cellIsFullyIncludedInOtherCell(const LayoutTableCell* cell1,
                                            const LayoutTableCell* cell2) {
   return (cell1->rowIndex() >= cell2->rowIndex() &&
           (cell1->rowIndex() + cell1->rowSpan()) <=
               (cell2->rowIndex() + cell2->rowSpan()));
 }
 
-// To avoid unneeded extra height distributions, we apply the following sorting algorithm:
+// To avoid unneeded extra height distributions, we apply the following sorting
+// algorithm:
 static bool compareRowSpanCellsInHeightDistributionOrder(
     const LayoutTableCell* cell1,
     const LayoutTableCell* cell2) {
-  // Sorting bigger height cell first if cells are at same index with same span because we will skip smaller
-  // height cell to distribute it's extra height.
+  // Sorting bigger height cell first if cells are at same index with same span
+  // because we will skip smaller height cell to distribute it's extra height.
   if (cell1->rowIndex() == cell2->rowIndex() &&
       cell1->rowSpan() == cell2->rowSpan())
     return (cell1->logicalHeightForRowSizing() >
             cell2->logicalHeightForRowSizing());
-  // Sorting inner most cell first because if inner spanning cell'e extra height is distributed then outer
-  // spanning cell's extra height will adjust accordingly. In reverse order, there is more chances that outer
-  // spanning cell's height will exceed than defined by user.
+  // Sorting inner most cell first because if inner spanning cell'e extra height
+  // is distributed then outer spanning cell's extra height will adjust
+  // accordingly. In reverse order, there is more chances that outer spanning
+  // cell's height will exceed than defined by user.
   if (cellIsFullyIncludedInOtherCell(cell1, cell2))
     return true;
-  // Sorting lower row index first because first we need to apply the extra height of spanning cell which
-  // comes first in the table so lower rows's position would increment in sequence.
+  // Sorting lower row index first because first we need to apply the extra
+  // height of spanning cell which comes first in the table so lower rows's
+  // position would increment in sequence.
   if (!cellIsFullyIncludedInOtherCell(cell2, cell1))
     return (cell1->rowIndex() < cell2->rowIndex());
 
   return false;
 }
 
 unsigned LayoutTableSection::calcRowHeightHavingOnlySpanningCells(
     unsigned row,
     int& accumulatedCellPositionIncrease,
     unsigned rowToApplyExtraHeight,
@@ skipping 15 matching lines @@
       continue;
 
     LayoutTableCell* cell = rowSpanCell.cells[0];
 
     if (cell->rowSpan() < 2)
       continue;
 
     const unsigned cellRowIndex = cell->rowIndex();
     const unsigned cellRowSpan = cell->rowSpan();
 
-    // As we are going from the top of the table to the bottom to calculate the row
-    // heights for rows that only contain spanning cells and all previous rows are
-    // processed we only need to find the number of rows with spanning cells from the
-    // current cell to the end of the current cells spanning height.
+    // As we are going from the top of the table to the bottom to calculate the
+    // row heights for rows that only contain spanning cells and all previous
+    // rows are processed we only need to find the number of rows with spanning
+    // cells from the current cell to the end of the current cells spanning
+    // height.
     unsigned startRowForSpanningCellCount = std::max(cellRowIndex, row);
     unsigned endRow = cellRowIndex + cellRowSpan;
     unsigned spanningCellsRowsCountHavingZeroHeight =
         rowsCountWithOnlySpanningCells[endRow - 1];
 
     if (startRowForSpanningCellCount)
       spanningCellsRowsCountHavingZeroHeight -=
           rowsCountWithOnlySpanningCells[startRowForSpanningCellCount - 1];
 
     int totalRowspanCellHeight = (m_rowPos[endRow] - m_rowPos[cellRowIndex]) -
@@ skipping 37 matching lines @@
           actualRow, accumulatedPositionIncrease, rowIndex + rowSpan,
           extraHeightToPropagate, rowsCountWithOnlySpanningCells);
       accumulatedPositionIncrease += spanningRowsHeight.rowHeight[row];
     }
     m_rowPos[actualRow + 1] += accumulatedPositionIncrease;
   }
 
   spanningRowsHeight.totalRowsHeight += accumulatedPositionIncrease;
 }
 
-// Distribute rowSpan cell height in rows those comes in rowSpan cell based on the ratio of row's height if
-// 1. RowSpan cell height is greater than the total height of rows in rowSpan cell
+// Distribute rowSpan cell height in rows those comes in rowSpan cell based on
+// the ratio of row's height if 1 RowSpan cell height is greater than the total
+// height of rows in rowSpan cell.
 void LayoutTableSection::distributeRowSpanHeightToRows(
     SpanningLayoutTableCells& rowSpanCells) {
   ASSERT(rowSpanCells.size());
 
-  // 'rowSpanCells' list is already sorted based on the cells rowIndex in ascending order
+  // 'rowSpanCells' list is already sorted based on the cells rowIndex in
+  // ascending order
   // Arrange row spanning cell in the order in which we need to process first.
   std::sort(rowSpanCells.begin(), rowSpanCells.end(),
             compareRowSpanCellsInHeightDistributionOrder);
 
   unsigned extraHeightToPropagate = 0;
   unsigned lastRowIndex = 0;
   unsigned lastRowSpan = 0;
 
   Vector<int> rowsCountWithOnlySpanningCells;
 
-  // At this stage, Height of the rows are zero for the one containing only spanning cells.
+  // At this stage, Height of the rows are zero for the one containing only
+  // spanning cells.
   int count = 0;
   for (unsigned row = 0; row < m_grid.size(); row++) {
     if (rowHasOnlySpanningCells(row))
       count++;
     rowsCountWithOnlySpanningCells.append(count);
   }
 
   for (unsigned i = 0; i < rowSpanCells.size(); i++) {
     LayoutTableCell* cell = rowSpanCells[i];
 
     unsigned rowIndex = cell->rowIndex();
 
     unsigned rowSpan = cell->rowSpan();
 
     unsigned spanningCellEndIndex = rowIndex + rowSpan;
     unsigned lastSpanningCellEndIndex = lastRowIndex + lastRowSpan;
 
-    // Only the highest spanning cell will distribute its extra height in a row if more than one spanning cell
-    // is present at the same level.
+    // Only the highest spanning cell will distribute its extra height in a row
+    // if more than one spanning cell is present at the same level.
     if (rowIndex == lastRowIndex && rowSpan == lastRowSpan)
       continue;
 
     int originalBeforePosition = m_rowPos[spanningCellEndIndex];
 
-    // When 2 spanning cells are ending at same row index then while extra height distribution of first spanning
-    // cell updates position of the last row so getting the original position of the last row in second spanning
+    // When 2 spanning cells are ending at same row index then while extra
+    // height distribution of first spanning cell updates position of the last
+    // row so getting the original position of the last row in second spanning
     // cell need to reduce the height changed by first spanning cell.
     if (spanningCellEndIndex == lastSpanningCellEndIndex)
       originalBeforePosition -= extraHeightToPropagate;
 
     if (extraHeightToPropagate) {
       for (unsigned row = lastSpanningCellEndIndex + 1;
            row <= spanningCellEndIndex; row++)
         m_rowPos[row] += extraHeightToPropagate;
     }
 
     lastRowIndex = rowIndex;
     lastRowSpan = rowSpan;
 
     struct SpanningRowsHeight spanningRowsHeight;
 
     populateSpanningRowsHeightFromCell(cell, spanningRowsHeight);
 
-    // Here we are handling only row(s) who have only rowspanning cells and do not have any empty cell.
+    // Here we are handling only row(s) who have only rowspanning cells and do
+    // not have any empty cell.
     if (spanningRowsHeight.isAnyRowWithOnlySpanningCells)
       updateRowsHeightHavingOnlySpanningCells(cell, spanningRowsHeight,
                                               extraHeightToPropagate,
                                               rowsCountWithOnlySpanningCells);
 
-    // This code handle row(s) that have rowspanning cell(s) and at least one empty cell.
-    // Such rows are not handled below and end up having a height of 0. That would mean
-    // content overlapping if one of their cells has any content. To avoid the problem, we
-    // add all the remaining spanning cells' height to the last spanned row.
-    // This means that we could grow a row past its 'height' or break percentage spreading
-    // however this is better than overlapping content.
+    // This code handle row(s) that have rowspanning cell(s) and at least one
+    // empty cell. Such rows are not handled below and end up having a height of
+    // 0. That would mean content overlapping if one of their cells has any
+    // content. To avoid the problem, we add all the remaining spanning cells'
+    // height to the last spanned row. This means that we could grow a row past
+    // its 'height' or break percentage spreading however this is better than
+    // overlapping content.
     // FIXME: Is there a better algorithm?
     if (!spanningRowsHeight.totalRowsHeight) {
       if (spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing)
         m_rowPos[spanningCellEndIndex] +=
             spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing +
             borderSpacingForRow(spanningCellEndIndex - 1);
 
       extraHeightToPropagate =
           m_rowPos[spanningCellEndIndex] - originalBeforePosition;
       continue;
     }
 
     if (spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing <=
         spanningRowsHeight.totalRowsHeight) {
       extraHeightToPropagate =
           m_rowPos[rowIndex + rowSpan] - originalBeforePosition;
       continue;
     }
 
-    // Below we are handling only row(s) who have at least one visible cell without rowspan value.
+    // Below we are handling only row(s) who have at least one visible cell
+    // without rowspan value.
     float totalPercent = 0;
     int totalAutoRowsHeight = 0;
     int totalRemainingRowsHeight = spanningRowsHeight.totalRowsHeight;
 
-    // FIXME: Inner spanning cell height should not change if it have fixed height when it's parent spanning cell
-    // is distributing it's extra height in rows.
+    // FIXME: Inner spanning cell height should not change if it have fixed
+    // height when it's parent spanning cell is distributing it's extra height
+    //in rows.
 
-    // Calculate total percentage, total auto rows height and total rows height except percent rows.
+    // Calculate total percentage, total auto rows height and total rows height
+    // except percent rows.
     for (unsigned row = rowIndex; row < spanningCellEndIndex; row++) {
       // TODO(alancutter): Make this work correctly for calc lengths.
       if (m_grid[row].logicalHeight.isPercent()) {
         totalPercent += m_grid[row].logicalHeight.percent();
         totalRemainingRowsHeight -=
             spanningRowsHeight.rowHeight[row - rowIndex];
       } else if (m_grid[row].logicalHeight.isAuto()) {
         totalAutoRowsHeight += spanningRowsHeight.rowHeight[row - rowIndex];
       }
     }
 
     int extraRowSpanningHeight =
         spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing -
         spanningRowsHeight.totalRowsHeight;
 
     if (totalPercent < 100 && !totalAutoRowsHeight &&
         !totalRemainingRowsHeight) {
-      // Distributing whole extra rowspanning height in percent row when only non-percent rows height is 0.
+      // Distributing whole extra rowspanning height in percent row when only
+      // non-percent rows height is 0.
       distributeWholeExtraRowSpanHeightToPercentRows(
           cell, totalPercent, extraRowSpanningHeight,
           spanningRowsHeight.rowHeight);
     } else {
       distributeExtraRowSpanHeightToPercentRows(cell, totalPercent,
                                                 extraRowSpanningHeight,
                                                 spanningRowsHeight.rowHeight);
       distributeExtraRowSpanHeightToAutoRows(cell, totalAutoRowsHeight,
                                              extraRowSpanningHeight,
                                              spanningRowsHeight.rowHeight);
       distributeExtraRowSpanHeightToRemainingRows(
           cell, totalRemainingRowsHeight, extraRowSpanningHeight,
           spanningRowsHeight.rowHeight);
     }
 
     ASSERT(!extraRowSpanningHeight);
 
     // Getting total changed height in the table
     extraHeightToPropagate =
         m_rowPos[spanningCellEndIndex] - originalBeforePosition;
   }
 
   if (extraHeightToPropagate) {
-    // Apply changed height by rowSpan cells to rows present at the end of the table
+    // Apply changed height by rowSpan cells to rows present at the end of the
+    // table
     for (unsigned row = lastRowIndex + lastRowSpan + 1; row <= m_grid.size();
          row++)
       m_rowPos[row] += extraHeightToPropagate;
   }
 }
 
 // Find out the baseline of the cell
-// If the cell's baseline is more than the row's baseline then the cell's baseline become the row's baseline
-// and if the row's baseline goes out of the row's boundaries then adjust row height accordingly.
+// If the cell's baseline is more than the row's baseline then the cell's
+// baseline become the row's baseline and if the row's baseline goes out of the
+// row's boundaries then adjust row height accordingly.
 void LayoutTableSection::updateBaselineForCell(LayoutTableCell* cell,
                                                unsigned row,
                                                int& baselineDescent) {
   if (!cell->isBaselineAligned())
     return;
 
-  // Ignoring the intrinsic padding as it depends on knowing the row's baseline, which won't be accurate
-  // until the end of this function.
+  // Ignoring the intrinsic padding as it depends on knowing the row's baseline,
+  // which won't be accurate until the end of this function.
   int baselinePosition =
       cell->cellBaselinePosition() - cell->intrinsicPaddingBefore();
   if (baselinePosition >
       cell->borderBefore() +
           (cell->paddingBefore() - cell->intrinsicPaddingBefore())) {
     m_grid[row].baseline = std::max(m_grid[row].baseline, baselinePosition);
 
     int cellStartRowBaselineDescent = 0;
     if (cell->rowSpan() == 1) {
       baselineDescent =
           std::max(baselineDescent,
                    cell->logicalHeightForRowSizing() - baselinePosition);
       cellStartRowBaselineDescent = baselineDescent;
     }
     m_rowPos[row + 1] =
         std::max<int>(m_rowPos[row + 1], m_rowPos[row] + m_grid[row].baseline +
                                              cellStartRowBaselineDescent);
   }
 }
 
 int LayoutTableSection::calcRowLogicalHeight() {
 #if ENABLE(ASSERT)
   SetLayoutNeededForbiddenScope layoutForbiddenScope(*this);
 #endif
 
   ASSERT(!needsLayout());
 
   LayoutTableCell* cell;
 
-  // We may have to forcefully lay out cells here, in which case we need a layout
-  // state. Technically, we should also push state for the row, but since rows don't push a
-  // coordinate transform, that's not necessary.
+  // We may have to forcefully lay out cells here, in which case we need a
+  // layout state. Technically, we should also push state for the row, but since
+  // rows don't push a coordinate transform, that's not necessary.
   LayoutState state(*this, locationOffset());
 
   m_rowPos.resize(m_grid.size() + 1);
 
-  // We ignore the border-spacing on any non-top section as it is already included in the previous section's last row position.
+  // We ignore the border-spacing on any non-top section as it is already
+  // included in the previous section's last row position.
   if (this == table()->topSection())
     m_rowPos[0] = table()->vBorderSpacing();
   else
     m_rowPos[0] = 0;
 
   SpanningLayoutTableCells rowSpanCells;
 #if ENABLE(ASSERT)
   HashSet<const LayoutTableCell*> uniqueCells;
 #endif
 
   for (unsigned r = 0; r < m_grid.size(); r++) {
     m_grid[r].baseline = -1;
     int baselineDescent = 0;
 
     if (m_grid[r].logicalHeight.isSpecified()) {
-      // Our base size is the biggest logical height from our cells' styles (excluding row spanning cells).
+      // Our base size is the biggest logical height from our cells' styles
+      // (excluding row spanning cells).
       m_rowPos[r + 1] = std::max(
           m_rowPos[r] +
               minimumValueForLength(m_grid[r].logicalHeight, LayoutUnit())
                   .round(),
           0);
     } else {
-      // Non-specified lengths are ignored because the row already accounts for the cells
-      // intrinsic logical height.
+      // Non-specified lengths are ignored because the row already accounts for
+      // the cells intrinsic logical height.
       m_rowPos[r + 1] = std::max(m_rowPos[r], 0);
     }
 
     Row& row = m_grid[r].row;
     unsigned totalCols = row.size();
     LayoutTableCell* lastRowSpanCell = nullptr;
 
     for (unsigned c = 0; c < totalCols; c++) {
       CellStruct& current = cellAt(r, c);
       for (unsigned i = 0; i < current.cells.size(); i++) {
         cell = current.cells[i];
         if (current.inColSpan && cell->rowSpan() == 1)
           continue;
 
         if (cell->rowSpan() > 1) {
-          // For row spanning cells, we only handle them for the first row they span. This ensures we take their baseline into account.
+          // For row spanning cells, we only handle them for the first row they
+          // span. This ensures we take their baseline into account.
           if (lastRowSpanCell != cell && cell->rowIndex() == r) {
 #if ENABLE(ASSERT)
             ASSERT(!uniqueCells.contains(cell));
             uniqueCells.add(cell);
 #endif
 
             rowSpanCells.append(cell);
             lastRowSpanCell = cell;
           }
         }
 
         if (cell->rowIndex() == r && cell->hasOverrideLogicalContentHeight()) {
           cell->clearIntrinsicPadding();
           cell->clearOverrideSize();
           cell->forceChildLayout();
         }
 
         if (cell->rowSpan() == 1)
           m_rowPos[r + 1] = std::max(
               m_rowPos[r + 1], m_rowPos[r] + cell->logicalHeightForRowSizing());
 
-        // Find out the baseline. The baseline is set on the first row in a rowSpan.
+        // Find out the baseline. The baseline is set on the first row in a
+        // rowSpan.
         if (cell->rowIndex() == r)
           updateBaselineForCell(cell, r, baselineDescent);
       }
     }
 
     // Add the border-spacing to our final position.
     m_rowPos[r + 1] += borderSpacingForRow(r);
     m_rowPos[r + 1] = std::max(m_rowPos[r + 1], m_rowPos[r]);
   }
 
   if (!rowSpanCells.isEmpty())
     distributeRowSpanHeightToRows(rowSpanCells);
 
   ASSERT(!needsLayout());
 
   return m_rowPos[m_grid.size()];
 }
 
 void LayoutTableSection::layout() {
   ASSERT(needsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
   RELEASE_ASSERT(!needsCellRecalc());
   ASSERT(!table()->needsSectionRecalc());
 
-  // addChild may over-grow m_grid but we don't want to throw away the memory too early as addChild
-  // can be called in a loop (e.g during parsing). Doing it now ensures we have a stable-enough structure.
+  // addChild may over-grow m_grid but we don't want to throw away the memory
+  // too early as addChild can be called in a loop (e.g during parsing). Doing
+  // it now ensures we have a stable-enough structure.
   m_grid.shrinkToFit();
 
   LayoutState state(*this, locationOffset());
 
   const Vector<int>& columnPos = table()->effectiveColumnPositions();
 
   SubtreeLayoutScope layouter(*this);
   for (unsigned r = 0; r < m_grid.size(); ++r) {
     Row& row = m_grid[r].row;
     unsigned cols = row.size();
-    // First, propagate our table layout's information to the cells. This will mark the row as needing layout
-    // if there was a column logical width change.
+    // First, propagate our table layout's information to the cells. This will
+    // mark the row as needing layout if there was a column logical width
+    // change.
     for (unsigned startColumn = 0; startColumn < cols; ++startColumn) {
       CellStruct& current = row[startColumn];
       LayoutTableCell* cell = current.primaryCell();
       if (!cell || current.inColSpan)
         continue;
 
       unsigned endCol = startColumn;
       unsigned cspan = cell->colSpan();
       while (cspan && endCol < cols) {
         ASSERT(endCol < table()->effectiveColumns().size());
@@ skipping 48 matching lines @@
 
 void LayoutTableSection::distributeExtraLogicalHeightToAutoRows(
     int& extraLogicalHeight,
     unsigned autoRowsCount) {
   if (!autoRowsCount)
     return;
 
   int totalLogicalHeightAdded = 0;
   for (unsigned r = 0; r < m_grid.size(); ++r) {
     if (autoRowsCount > 0 && m_grid[r].logicalHeight.isAuto()) {
-      // Recomputing |extraLogicalHeightForRow| guarantees that we properly ditribute round |extraLogicalHeight|.
+      // Recomputing |extraLogicalHeightForRow| guarantees that we properly
+      // ditribute round |extraLogicalHeight|.
       int extraLogicalHeightForRow = extraLogicalHeight / autoRowsCount;
       totalLogicalHeightAdded += extraLogicalHeightForRow;
       extraLogicalHeight -= extraLogicalHeightForRow;
       --autoRowsCount;
     }
     m_rowPos[r + 1] += totalLogicalHeightAdded;
   }
 }
 
 void LayoutTableSection::distributeRemainingExtraLogicalHeight(
@@ skipping 57 matching lines @@
 
 void LayoutTableSection::layoutRows() {
 #if ENABLE(ASSERT)
   SetLayoutNeededForbiddenScope layoutForbiddenScope(*this);
 #endif
 
   ASSERT(!needsLayout());
 
   LayoutAnalyzer::Scope analyzer(*this);
 
-  // FIXME: Changing the height without a layout can change the overflow so it seems wrong.
+  // FIXME: Changing the height without a layout can change the overflow so it
+  // seems wrong.
 
   unsigned totalRows = m_grid.size();
 
   // Set the width of our section now.  The rows will also be this width.
   setLogicalWidth(table()->contentLogicalWidth());
 
   int vspacing = table()->vBorderSpacing();
   unsigned nEffCols = table()->numEffectiveColumns();
   bool isPaginated = view()->layoutState()->isPaginated();
 
   if (isPaginated) {
     LayoutTableSection* header = table()->header();
-    // If we're a table header nested inside a table cell then we want to repeat on each
-    // page, but below the header we're nested inside. Note we don't try to match the padding
-    // on the cell on each repeated header.
+    // If we're a table header nested inside a table cell then we want to repeat
+    // on each page, but below the header we're nested inside. Note we don't try
+    // to match the padding on the cell on each repeated header.
     if (header && header == this)
       setOffsetForRepeatingHeader(
           view()->layoutState()->heightOffsetForTableHeaders());
   }
 
   LayoutState state(*this, locationOffset());
 
   for (unsigned r = 0; r < totalRows; r++) {
     // Set the row's x/y position and width/height.
     LayoutTableRow* rowLayoutObject = m_grid[r].rowLayoutObject;
     int paginationStrutOnRow = 0;
     if (rowLayoutObject) {
       rowLayoutObject->setLogicalLocation(LayoutPoint(0, m_rowPos[r]));
       rowLayoutObject->setLogicalWidth(logicalWidth());
       rowLayoutObject->setLogicalHeight(
           LayoutUnit(m_rowPos[r + 1] - m_rowPos[r] - vspacing));
       rowLayoutObject->updateLayerTransformAfterLayout();
       if (isPaginated) {
         paginationStrutOnRow =
             paginationStrutForRow(rowLayoutObject, LayoutUnit(m_rowPos[r]));
         rowLayoutObject->setPaginationStrut(LayoutUnit(paginationStrutOnRow));
         bool rowIsAtTopOfColumn =
             state.heightOffsetForTableHeaders() &&
             pageRemainingLogicalHeightForOffset(LayoutUnit(m_rowPos[r]),
                                                 AssociateWithLatterPage) ==
                 pageLogicalHeightForOffset(LayoutUnit(m_rowPos[r]));
         if (paginationStrutOnRow || rowIsAtTopOfColumn) {
-          // If there isn't room for at least one content row on a page with a header group, then
-          // we won't repeat the header on each page.
+          // If there isn't room for at least one content row on a page with a
+          // header group, then we won't repeat the header on each page.
           if (!r && table()->header() &&
               table()->sectionAbove(this) == table()->header() &&
               table()->header()->getPaginationBreakability() != AllowAnyBreaks)
             state.setHeightOffsetForTableHeaders(
                 state.heightOffsetForTableHeaders() -
                 table()->header()->logicalHeight());
-          // If we have a header group we will paint it at the top of each page, move the rows
-          // down to accomodate it.
+          // If we have a header group we will paint it at the top of each page,
+          // move the rows down to accomodate it.
           paginationStrutOnRow += state.heightOffsetForTableHeaders().toInt();
           for (unsigned rowIndex = r; rowIndex <= totalRows; rowIndex++)
             m_rowPos[rowIndex] += paginationStrutOnRow;
         }
       }
     }
 
     int rowHeightIncreaseForPagination = INT_MIN;
 
     for (unsigned c = 0; c < nEffCols; c++) {
@@ skipping 17 matching lines @@
       setLogicalPositionForCell(cell, c);
 
       if (!cell->needsLayout())
         markChildForPaginationRelayoutIfNeeded(*cell, layouter);
 
       cell->layoutIfNeeded();
 
       // FIXME: Make pagination work with vertical tables.
       if (view()->layoutState()->pageLogicalHeight() &&
           cell->logicalHeight() != rHeight) {
-        // FIXME: Pagination might have made us change size. For now just shrink or grow the cell to fit without doing a relayout.
-        // We'll also do a basic increase of the row height to accommodate the cell if it's bigger, but this isn't quite right
-        // either. It's at least stable though and won't result in an infinite # of relayouts that may never stabilize.
+        // FIXME: Pagination might have made us change size. For now just shrink
+        // or grow the cell to fit without doing a relayout.
+        // We'll also do a basic increase of the row height to accommodate the
+        // cell if it's bigger, but this isn't quite right either. It's at least
+        // stable though and won't result in an infinite # of relayouts that may
+        // never stabilize.
         LayoutUnit oldLogicalHeight = cell->logicalHeight();
         rowHeightIncreaseForPagination =
             std::max<int>(rowHeightIncreaseForPagination,
                           (oldLogicalHeight - rHeight).toInt());
         cell->setLogicalHeight(LayoutUnit(rHeight));
         cell->computeOverflow(oldLogicalHeight, false);
       }
 
       LayoutSize childOffset(cell->location() - oldCellRect.location());
       if (childOffset.width() || childOffset.height()) {
-        // If the child moved, we have to issue paint invalidations to it as well as any floating/positioned
-        // descendants. An exception is if we need a layout. In this case, we know we're going to
-        // issue paint invalidations ourselves (and the child) anyway.
+        // If the child moved, we have to issue paint invalidations to it as
+        // well as any floating/positioned descendants. An exception is if we
+        // need a layout. In this case, we know we're going to issue paint
+        // invalidations ourselves (and the child) anyway.
         if (!table()->selfNeedsLayout())
           cell->setMayNeedPaintInvalidation();
       }
     }
     if (rowHeightIncreaseForPagination > INT_MIN) {
       for (unsigned rowIndex = r + 1; rowIndex <= totalRows; rowIndex++)
         m_rowPos[rowIndex] += rowHeightIncreaseForPagination;
       for (unsigned c = 0; c < nEffCols; ++c) {
         Vector<LayoutTableCell*, 1>& cells = cellAt(r, c).cells;
         for (size_t i = 0; i < cells.size(); ++i) {
@@ skipping 11 matching lines @@
   ASSERT(!needsLayout());
 
   setLogicalHeight(LayoutUnit(m_rowPos[totalRows]));
 
   computeOverflowFromCells(totalRows, nEffCols);
 }
 
 int LayoutTableSection::paginationStrutForRow(LayoutTableRow* row,
                                               LayoutUnit logicalOffset) const {
   DCHECK(row);
-  // Even if the row allows us to break-inside, we will want to put a strut on the row if we have a header
-  // group that wants to appear at the top of each page.
+  // Even if the row allows us to break-inside, we will want to put a strut on
+  // the row if we have a header group that wants to appear at the top of each
+  // page.
   bool tableHeaderForcesStrut =
       table()->header()
           ? table()->header()->getPaginationBreakability() != AllowAnyBreaks
           : false;
   if (row->getPaginationBreakability() == AllowAnyBreaks &&
       !tableHeaderForcesStrut)
     return 0;
   LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
   if (!pageLogicalHeight)
     return 0;
@@ skipping 11 matching lines @@
   // repeating header.
   if (offsetForBorderSpacing < 0)
     return offsetForBorderSpacing.toInt();
 
   if (remainingLogicalHeight >= rowLogicalHeight)
     return 0;  // It fits fine where it is. No need to break.
   LayoutUnit paginationStrut = calculatePaginationStrutToFitContent(
       logicalOffset, remainingLogicalHeight, rowLogicalHeight);
   if (paginationStrut == remainingLogicalHeight &&
       remainingLogicalHeight == pageLogicalHeight) {
-    // Don't break if we were at the top of a page, and we failed to fit the content
-    // completely. No point in leaving a page completely blank.
+    // Don't break if we were at the top of a page, and we failed to fit the
+    // content completely. No point in leaving a page completely blank.
     return 0;
   }
   // Table layout parts only work on integers, so we have to round. Round up, to
   // make sure that no fraction ever gets left behind in the previous
   // fragmentainer.
   return paginationStrut.ceil();
 }
 
 void LayoutTableSection::computeOverflowFromCells() {
   unsigned totalRows = m_grid.size();
@@ skipping 25 matching lines @@
       if (r < totalRows - 1 && cell == primaryCellAt(r + 1, c))
         continue;
       addOverflowFromChild(cell);
 #if ENABLE(ASSERT)
       hasOverflowingCell |= cell->hasVisualOverflow();
 #endif
       if (cell->hasVisualOverflow() &&
           !m_forceSlowPaintPathWithOverflowingCell) {
         m_overflowingCells.add(cell);
         if (m_overflowingCells.size() > maxAllowedOverflowingCellsCount) {
-          // We need to set m_forcesSlowPaintPath only if there is a least one overflowing cells as the hit testing code rely on this information.
+          // We need to set m_forcesSlowPaintPath only if there is a least one
+          // overflowing cells as the hit testing code rely on this information.
           m_forceSlowPaintPathWithOverflowingCell = true;
-          // The slow path does not make any use of the overflowing cells info, don't hold on to the memory.
+          // The slow path does not make any use of the overflowing cells info,
+          // don't hold on to the memory.
           m_overflowingCells.clear();
         }
       }
     }
   }
 
   ASSERT(hasOverflowingCell == this->hasOverflowingCell());
 }
 
 bool LayoutTableSection::recalcChildOverflowAfterStyleChange() {
@@ skipping 61 matching lines @@
   if (rb.style() > BorderStyleHidden && rb.width() > borderWidth)
     borderWidth = rb.width();
 
   bool allHidden = true;
   for (unsigned c = 0; c < totalCols; c++) {
     const CellStruct& current =
         cellAt(side == BorderBefore ? 0 : m_grid.size() - 1, c);
     if (current.inColSpan || !current.hasCells())
       continue;
     const ComputedStyle& primaryCellStyle = current.primaryCell()->styleRef();
-    const BorderValue& cb =
-        side == BorderBefore
-            ? primaryCellStyle.borderBefore()
-            : primaryCellStyle
-                  .borderAfter();  // FIXME: Make this work with perpendicular and flipped cells.
+    // FIXME: Make this work with perpendicular and flipped cells.
+    const BorderValue& cb = side == BorderBefore
+                                ? primaryCellStyle.borderBefore()
+                                : primaryCellStyle.borderAfter();
     // FIXME: Don't repeat for the same col group
     LayoutTableCol* col =
         table()->colElementAtAbsoluteColumn(c).innermostColOrColGroup();
     if (col) {
       const BorderValue& gb = side == BorderBefore
                                   ? col->style()->borderBefore()
                                   : col->style()->borderAfter();
       if (gb.style() == BorderStyleHidden || cb.style() == BorderStyleHidden)
         continue;
       allHidden = false;
@@ skipping 46 matching lines @@
 
   bool allHidden = true;
   for (unsigned r = 0; r < m_grid.size(); r++) {
     const CellStruct& current = cellAt(r, colIndex);
     if (!current.hasCells())
       continue;
     // FIXME: Don't repeat for the same cell
     const ComputedStyle& primaryCellStyle = current.primaryCell()->styleRef();
     const ComputedStyle& primaryCellParentStyle =
         current.primaryCell()->parent()->styleRef();
-    const BorderValue& cb =
-        side == BorderStart
-            ? primaryCellStyle.borderStart()
-            : primaryCellStyle
-                  .borderEnd();  // FIXME: Make this work with perpendicular and flipped cells.
+    // FIXME: Make this work with perpendicular and flipped cells.
+    const BorderValue& cb = side == BorderStart ? primaryCellStyle.borderStart()
+                                                : primaryCellStyle.borderEnd();
     const BorderValue& rb = side == BorderStart
                                 ? primaryCellParentStyle.borderStart()
                                 : primaryCellParentStyle.borderEnd();
     if (cb.style() == BorderStyleHidden || rb.style() == BorderStyleHidden)
       continue;
     allHidden = false;
     if (cb.style() > BorderStyleHidden && cb.width() > borderWidth)
       borderWidth = cb.width();
     if (rb.style() > BorderStyleHidden && rb.width() > borderWidth)
       borderWidth = rb.width();
@@ skipping 44 matching lines @@
 LayoutRect LayoutTableSection::logicalRectForWritingModeAndDirection(
     const LayoutRect& rect) const {
   LayoutRect tableAlignedRect(rect);
 
   flipForWritingMode(tableAlignedRect);
 
   if (!style()->isHorizontalWritingMode())
     tableAlignedRect = tableAlignedRect.transposedRect();
 
   const Vector<int>& columnPos = table()->effectiveColumnPositions();
-  // FIXME: The table's direction should determine our row's direction, not the section's (see bug 96691).
+  // FIXME: The table's direction should determine our row's direction, not the
+  // section's (see bug 96691).
   if (!style()->isLeftToRightDirection())
     tableAlignedRect.setX(columnPos[columnPos.size() - 1] -
                           tableAlignedRect.maxX());
 
   return tableAlignedRect;
 }
 
 CellSpan LayoutTableSection::dirtiedRows(const LayoutRect& damageRect) const {
   if (m_forceSlowPaintPathWithOverflowingCell)
     return fullTableRowSpan();
 
   if (!m_grid.size())
     return CellSpan(0, 0);
 
   CellSpan coveredRows = spannedRows(damageRect);
 
-  // To issue paint invalidations for the border we might need to paint invalidate the first
-  // or last row even if they are not spanned themselves.
+  // To issue paint invalidations for the border we might need to paint
+  // invalidate the first or last row even if they are not spanned themselves.
   RELEASE_ASSERT(coveredRows.start() < m_rowPos.size());
   if (coveredRows.start() == m_rowPos.size() - 1 &&
       m_rowPos[m_rowPos.size() - 1] + table()->outerBorderAfter() >=
           damageRect.y())
     coveredRows.decreaseStart();
 
   if (!coveredRows.end() &&
       m_rowPos[0] - table()->outerBorderBefore() <= damageRect.maxY())
     coveredRows.increaseEnd();
 
   coveredRows.ensureConsistency(m_grid.size());
 
   return coveredRows;
 }
 
 CellSpan LayoutTableSection::dirtiedEffectiveColumns(
     const LayoutRect& damageRect) const {
   if (m_forceSlowPaintPathWithOverflowingCell)
     return fullTableEffectiveColumnSpan();
 
   RELEASE_ASSERT(table()->numEffectiveColumns());
   CellSpan coveredColumns = spannedEffectiveColumns(damageRect);
 
   const Vector<int>& columnPos = table()->effectiveColumnPositions();
-  // To issue paint invalidations for the border we might need to paint invalidate the first
-  // or last column even if they are not spanned themselves.
+  // To issue paint invalidations for the border we might need to paint
+  // invalidate the first or last column even if they are not spanned
+  // themselves.
   RELEASE_ASSERT(coveredColumns.start() < columnPos.size());
   if (coveredColumns.start() == columnPos.size() - 1 &&
       columnPos[columnPos.size() - 1] + table()->outerBorderEnd() >=
           damageRect.x())
     coveredColumns.decreaseStart();
 
   if (!coveredColumns.end() &&
       columnPos[0] - table()->outerBorderStart() <= damageRect.maxX())
     coveredColumns.increaseEnd();
 
   coveredColumns.ensureConsistency(table()->numEffectiveColumns());
 
   return coveredColumns;
 }
 
 CellSpan LayoutTableSection::spannedRows(const LayoutRect& flippedRect) const {
   // Find the first row that starts after rect top.
   unsigned nextRow =
       std::upper_bound(m_rowPos.begin(), m_rowPos.end(), flippedRect.y()) -
       m_rowPos.begin();
 
+  // After all rows.
   if (nextRow == m_rowPos.size())
-    return CellSpan(m_rowPos.size() - 1,
-                    m_rowPos.size() - 1);  // After all rows.
+    return CellSpan(m_rowPos.size() - 1, m_rowPos.size() - 1);
 
   unsigned startRow = nextRow > 0 ? nextRow - 1 : 0;
 
   // Find the first row that starts after rect bottom.
   unsigned endRow;
   if (m_rowPos[nextRow] >= flippedRect.maxY()) {
     endRow = nextRow;
   } else {
     endRow = std::upper_bound(m_rowPos.begin() + nextRow, m_rowPos.end(),
                               flippedRect.maxY()) -
              m_rowPos.begin();
     if (endRow == m_rowPos.size())
       endRow = m_rowPos.size() - 1;
   }
 
   return CellSpan(startRow, endRow);
 }
 
 CellSpan LayoutTableSection::spannedEffectiveColumns(
     const LayoutRect& flippedRect) const {
   const Vector<int>& columnPos = table()->effectiveColumnPositions();
 
   // Find the first column that starts after rect left.
-  // lower_bound doesn't handle the edge between two cells properly as it would wrongly return the
-  // cell on the logical top/left.
-  // upper_bound on the other hand properly returns the cell on the logical bottom/right, which also
-  // matches the behavior of other browsers.
+  // lower_bound doesn't handle the edge between two cells properly as it would
+  // wrongly return the cell on the logical top/left.
+  // upper_bound on the other hand properly returns the cell on the logical
+  // bottom/right, which also matches the behavior of other browsers.
   unsigned nextColumn =
       std::upper_bound(columnPos.begin(), columnPos.end(), flippedRect.x()) -
       columnPos.begin();
 
   if (nextColumn == columnPos.size())
     return CellSpan(columnPos.size() - 1,
                     columnPos.size() - 1);  // After all columns.
 
   unsigned startColumn = nextColumn > 0 ? nextColumn - 1 : 0;
 
   // Find the first column that starts after rect right.
   unsigned endColumn;
   if (columnPos[nextColumn] >= flippedRect.maxX()) {
     endColumn = nextColumn;
   } else {
     endColumn = std::upper_bound(columnPos.begin() + nextColumn,
                                  columnPos.end(), flippedRect.maxX()) -
                 columnPos.begin();
     if (endColumn == columnPos.size())
       endColumn = columnPos.size() - 1;
   }
 
   return CellSpan(startColumn, endColumn);
 }
 
 void LayoutTableSection::recalcCells() {
   ASSERT(m_needsCellRecalc);
-  // We reset the flag here to ensure that |addCell| works. This is safe to do as
-  // fillRowsWithDefaultStartingAtPosition makes sure we match the table's columns
-  // representation.
+  // We reset the flag here to ensure that |addCell| works. This is safe to do
+  // as fillRowsWithDefaultStartingAtPosition makes sure we match the table's
+  // columns representation.
   m_needsCellRecalc = false;
 
   m_cCol = 0;
   m_cRow = 0;
   m_grid.clear();
 
   for (LayoutTableRow* row = firstRow(); row; row = row->nextRow()) {
     unsigned insertionRow = m_cRow;
     ++m_cRow;
     m_cCol = 0;
     ensureRows(m_cRow);
 
     m_grid[insertionRow].rowLayoutObject = row;
     row->setRowIndex(insertionRow);
     setRowLogicalHeightToRowStyleLogicalHeight(m_grid[insertionRow]);
 
     for (LayoutTableCell* cell = row->firstCell(); cell;
          cell = cell->nextCell())
       addCell(cell, row);
   }
 
   m_grid.shrinkToFit();
   setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::Unknown);
 }
 
-// FIXME: This function could be made O(1) in certain cases (like for the non-most-constrainive cells' case).
+// FIXME: This function could be made O(1) in certain cases (like for the
+// non-most-constrainive cells' case).
 void LayoutTableSection::rowLogicalHeightChanged(LayoutTableRow* row) {
   if (needsCellRecalc())
     return;
 
   unsigned rowIndex = row->rowIndex();
   setRowLogicalHeightToRowStyleLogicalHeight(m_grid[rowIndex]);
 
   for (LayoutTableCell* cell = m_grid[rowIndex].rowLayoutObject->firstCell();
        cell; cell = cell->nextCell())
     updateLogicalHeightForCell(m_grid[rowIndex], cell);
@@ skipping 90 matching lines @@
   // Table sections cannot ever be hit tested.  Effectively they do not exist.
   // Just forward to our children always.
   LayoutPoint adjustedLocation = accumulatedOffset + location();
 
   if (hasOverflowClip() &&
       !locationInContainer.intersects(overflowClipRect(adjustedLocation)))
     return false;
 
   if (hasOverflowingCell()) {
     for (LayoutTableRow* row = lastRow(); row; row = row->previousRow()) {
-      // FIXME: We have to skip over inline flows, since they can show up inside table rows
-      // at the moment (a demoted inline <form> for example). If we ever implement a
-      // table-specific hit-test method (which we should do for performance reasons anyway),
-      // then we can remove this check.
+      // FIXME: We have to skip over inline flows, since they can show up inside
+      // table rows at the moment (a demoted inline <form> for example). If we
+      // ever implement a table-specific hit-test method (which we should do for
+      // performance reasons anyway), then we can remove this check.
       if (!row->hasSelfPaintingLayer()) {
         LayoutPoint childPoint =
             flipForWritingModeForChild(row, adjustedLocation);
         if (row->nodeAtPoint(result, locationInContainer, childPoint, action)) {
           updateHitTestResult(
               result, toLayoutPoint(locationInContainer.point() - childPoint));
           return true;
         }
       }
     }
@@ skipping 52 matching lines @@
   newSection->setStyle(newStyle.release());
   return newSection;
 }
 
 void LayoutTableSection::setLogicalPositionForCell(
     LayoutTableCell* cell,
     unsigned effectiveColumn) const {
   LayoutPoint cellLocation(0, m_rowPos[cell->rowIndex()]);
   int horizontalBorderSpacing = table()->hBorderSpacing();
 
-  // FIXME: The table's direction should determine our row's direction, not the section's (see bug 96691).
+  // FIXME: The table's direction should determine our row's direction, not the
+  // section's (see bug 96691).
   if (!style()->isLeftToRightDirection())
     cellLocation.setX(LayoutUnit(
         table()->effectiveColumnPositions()[table()->numEffectiveColumns()] -
         table()->effectiveColumnPositions()
             [table()->absoluteColumnToEffectiveColumn(
                 cell->absoluteColumnIndex() + cell->colSpan())] +
         horizontalBorderSpacing));
   else
     cellLocation.setX(
         LayoutUnit(table()->effectiveColumnPositions()[effectiveColumn] +
                    horizontalBorderSpacing));
 
   cell->setLogicalLocation(cellLocation);
 }
 
 void LayoutTableSection::relayoutCellIfFlexed(LayoutTableCell& cell,
                                               int rowIndex,
                                               int rowHeight) {
   // Force percent height children to lay themselves out again.
   // This will cause these children to grow to fill the cell.
   // FIXME: There is still more work to do here to fully match WinIE (should
   // it become necessary to do so).  In quirks mode, WinIE behaves like we
-  // do, but it will clip the cells that spill out of the table section.  In
+  // do, but it will clip the cells that spill out of the table section.
   // strict mode, Mozilla and WinIE both regrow the table to accommodate the
   // new height of the cell (thus letting the percentages cause growth one
-  // time only).  We may also not be handling row-spanning cells correctly.
+  // time only). We may also not be handling row-spanning cells correctly.
   //
-  // Note also the oddity where replaced elements always flex, and yet
-  // blocks/tables do not necessarily flex. WinIE is crazy and inconsistent,
-  // and we can't hope to match the behavior perfectly, but we'll continue to
-  // refine it as we discover new bugs. :)
+  // Note also the oddity where replaced elements always flex, and yet blocks/
+  // tables do not necessarily flex. WinIE is crazy and inconsistent, and we
+  // can't hope to match the behavior perfectly, but we'll continue to refine it
+  // as we discover new bugs. :)
   bool cellChildrenFlex = false;
   bool flexAllChildren = cell.style()->logicalHeight().isFixed() ||
                          (!table()->style()->logicalHeight().isAuto() &&
                           rowHeight != cell.logicalHeight());
 
   for (LayoutObject* child = cell.firstChild(); child;
        child = child->nextSibling()) {
     if (!child->isText() && child->style()->logicalHeight().isPercentOrCalc() &&
         (flexAllChildren || shouldFlexCellChild(child)) &&
         (!child->isTable() || toLayoutTable(child)->hasSections())) {
@@ skipping 37 matching lines @@
   // TODO(rhogan): Should we paint a header repeatedly if it's self-painting?
   if (hasSelfPaintingLayer())
     return false;
   LayoutUnit pageHeight = table()->pageLogicalHeightForOffset(LayoutUnit());
   if (!pageHeight)
     return false;
 
   if (logicalHeight() > pageHeight)
     return false;
 
-  // If the first row of the section after the header group doesn't fit on the page, then
-  // don't repeat the header on each page. See https://drafts.csswg.org/css-tables-3/#repeated-headers
+  // If the first row of the section after the header group doesn't fit on the
+  // page, then don't repeat the header on each page.
+  // See https://drafts.csswg.org/css-tables-3/#repeated-headers
   LayoutTableSection* sectionBelow = table()->sectionBelow(this);
   if (sectionBelow && sectionBelow->firstRow() &&
       sectionBelow->firstRow()->paginationStrut())
     return false;
 
   return true;
 }
 
 bool LayoutTableSection::mapToVisualRectInAncestorSpace(
     const LayoutBoxModelObject* ancestor,
     LayoutRect& rect,
     VisualRectFlags flags) const {
   if (ancestor == this)
     return true;
-  // Repeating table headers are painted once per fragmentation page/column. This does not go through the regular fragmentation machinery,
-  // so we need special code to expand the invalidation rect to contain all positions of the header in all columns.
-  // Note that this is in flow thread coordinates, not visual coordinates. The enclosing LayoutFlowThread will convert to visual coordinates.
+  // Repeating table headers are painted once per fragmentation page/column.
+  // This does not go through the regular fragmentation machinery, so we need
+  // special code to expand the invalidation rect to contain all positions of
+  // the header in all columns.
+  // Note that this is in flow thread coordinates, not visual coordinates. The
+  // enclosing LayoutFlowThread will convert to visual coordinates.
   if (table()->header() == this && isRepeatingHeaderGroup())
     rect.setHeight(table()->logicalHeight());
   return LayoutTableBoxComponent::mapToVisualRectInAncestorSpace(ancestor, rect,
                                                                  flags);
 }
 
 }  // namespace blink