Reformat comments in core/layout up until LayoutTableRow

third_party/WebKit/Source/core/layout/LayoutTableCell.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, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc.
+ *               All rights reserved.
  *
  * 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
  * Library General Public License for more details.
@@ skipping 33 matching lines @@
               "LayoutTableCell should stay small");
 static_assert(sizeof(CollapsedBorderValue) == 8,
               "CollapsedBorderValue should stay small");
 
 LayoutTableCell::LayoutTableCell(Element* element)
     : LayoutBlockFlow(element),
       m_absoluteColumnIndex(unsetColumnIndex),
       m_cellWidthChanged(false),
       m_intrinsicPaddingBefore(0),
       m_intrinsicPaddingAfter(0) {
-  // We only update the flags when notified of DOM changes in colSpanOrRowSpanChanged()
-  // so we need to set their initial values here in case something asks for colSpan()/rowSpan() before then.
+  // We only update the flags when notified of DOM changes in
+  // colSpanOrRowSpanChanged() so we need to set their initial values here in
+  // case something asks for colSpan()/rowSpan() before then.
   updateColAndRowSpanFlags();
 }
 
 void LayoutTableCell::willBeRemovedFromTree() {
   LayoutBlockFlow::willBeRemovedFromTree();
 
   section()->setNeedsCellRecalc();
 
-  // When borders collapse, removing a cell can affect the the width of neighboring cells.
+  // When borders collapse, removing a cell can affect the the width of
+  // neighboring cells.
   LayoutTable* enclosingTable = table();
   DCHECK(enclosingTable);
   if (!enclosingTable->collapseBorders())
     return;
   if (previousCell()) {
     // TODO(dgrogan): Should this be setChildNeedsLayout or setNeedsLayout?
-    // remove-cell-with-border-box.html only passes with setNeedsLayout but other places
-    // use setChildNeedsLayout.
+    // remove-cell-with-border-box.html only passes with setNeedsLayout but
+    // other places use setChildNeedsLayout.
     previousCell()->setNeedsLayout(LayoutInvalidationReason::TableChanged);
     previousCell()->setPreferredLogicalWidthsDirty();
   }
   if (nextCell()) {
     // TODO(dgrogan): Same as above re: setChildNeedsLayout vs setNeedsLayout.
     nextCell()->setNeedsLayout(LayoutInvalidationReason::TableChanged);
     nextCell()->setPreferredLogicalWidthsDirty();
   }
 }
 
@@ skipping 50 matching lines @@
     // Percentage value should be returned only for colSpan == 1.
     // Otherwise we return original width for the cell.
     if (!colWidth.isFixed()) {
       if (colSpanCount > 1)
         return widthFromStyle;
       return colWidth;
     }
 
     colWidthSum += colWidth.value();
     tableCol = tableCol->nextColumn();
-    // If no next <col> tag found for the span we just return what we have for now.
+    // If no next <col> tag found for the span we just return what we have for
+    // now.
     if (!tableCol)
       break;
   }
 
-  // Column widths specified on <col> apply to the border box of the cell, see bug 8126.
+  // Column widths specified on <col> apply to the border box of the cell, see
+  // bug 8126.
   // FIXME: Why is border/padding ignored in the negative width case?
   if (colWidthSum > 0)
     return Length(
         std::max(0, colWidthSum - borderAndPaddingLogicalWidth().ceil()),
         Fixed);
   return Length(colWidthSum, Fixed);
 }
 
 void LayoutTableCell::computePreferredLogicalWidths() {
-  // The child cells rely on the grids up in the sections to do their computePreferredLogicalWidths work.  Normally the sections are set up early, as table
-  // cells are added, but relayout can cause the cells to be freed, leaving stale pointers in the sections'
-  // grids.  We must refresh those grids before the child cells try to use them.
+  // The child cells rely on the grids up in the sections to do their
+  // computePreferredLogicalWidths work.  Normally the sections are set up
+  // early, as table cells are added, but relayout can cause the cells to be
+  // freed, leaving stale pointers in the sections' grids. We must refresh those
+  // grids before the child cells try to use them.
   table()->recalcSectionsIfNeeded();
 
   LayoutBlockFlow::computePreferredLogicalWidths();
   if (node() && style()->autoWrap()) {
     // See if nowrap was set.
     Length w = styleOrColLogicalWidth();
     const AtomicString& nowrap = toElement(node())->getAttribute(nowrapAttr);
     if (!nowrap.isNull() && w.isFixed()) {
-      // Nowrap is set, but we didn't actually use it because of the
-      // fixed width set on the cell.  Even so, it is a WinIE/Moz trait
-      // to make the minwidth of the cell into the fixed width.  They do this
-      // even in strict mode, so do not make this a quirk.  Affected the top
-      // of hiptop.com.
+      // Nowrap is set, but we didn't actually use it because of the fixed width
+      // set on the cell. Even so, it is a WinIE/Moz trait to make the minwidth
+      // of the cell into the fixed width. They do this even in strict mode, so
+      // do not make this a quirk. Affected the top of hiptop.com.
       m_minPreferredLogicalWidth =
           std::max(LayoutUnit(w.value()), m_minPreferredLogicalWidth);
     }
   }
 }
 
 void LayoutTableCell::addLayerHitTestRects(
     LayerHitTestRects& layerRects,
     const PaintLayer* currentLayer,
     const LayoutPoint& layerOffset,
     const LayoutRect& containerRect) const {
   LayoutPoint adjustedLayerOffset = layerOffset;
-  // LayoutTableCell's location includes the offset of it's containing LayoutTableRow, so
-  // we need to subtract that again here (as for LayoutTableCell::offsetFromContainer.
+  // LayoutTableCell's location includes the offset of it's containing
+  // LayoutTableRow, so we need to subtract that again here (as for
+  // LayoutTableCell::offsetFromContainer.
   if (parent())
     adjustedLayerOffset -= parentBox()->locationOffset();
   LayoutBox::addLayerHitTestRects(layerRects, currentLayer, adjustedLayerOffset,
                                   containerRect);
 }
 
 void LayoutTableCell::computeIntrinsicPadding(int rowHeight,
                                               SubtreeLayoutScope& layouter) {
   int oldIntrinsicPaddingBefore = intrinsicPaddingBefore();
   int oldIntrinsicPaddingAfter = intrinsicPaddingAfter();
@@ skipping 26 matching lines @@
       break;
     case VerticalAlignBaselineMiddle:
       break;
   }
 
   int intrinsicPaddingAfter =
       rowHeight - logicalHeightWithoutIntrinsicPadding - intrinsicPaddingBefore;
   setIntrinsicPaddingBefore(intrinsicPaddingBefore);
   setIntrinsicPaddingAfter(intrinsicPaddingAfter);
 
-  // FIXME: Changing an intrinsic padding shouldn't trigger a relayout as it only shifts the cell inside the row but
-  // doesn't change the logical height.
+  // FIXME: Changing an intrinsic padding shouldn't trigger a relayout as it
+  // only shifts the cell inside the row but doesn't change the logical height.
   if (intrinsicPaddingBefore != oldIntrinsicPaddingBefore ||
       intrinsicPaddingAfter != oldIntrinsicPaddingAfter)
     layouter.setNeedsLayout(this, LayoutInvalidationReason::PaddingChanged);
 }
 
 void LayoutTableCell::updateLogicalWidth() {}
 
 void LayoutTableCell::setCellLogicalWidth(int tableLayoutLogicalWidth,
                                           SubtreeLayoutScope& layouter) {
   if (tableLayoutLogicalWidth == logicalWidth())
     return;
 
   layouter.setNeedsLayout(this, LayoutInvalidationReason::SizeChanged);
 
   setLogicalWidth(LayoutUnit(tableLayoutLogicalWidth));
   setCellWidthChanged(true);
 }
 
 void LayoutTableCell::layout() {
   ASSERT(needsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
 
   int oldCellBaseline = cellBaselinePosition();
   layoutBlock(cellWidthChanged());
 
-  // If we have replaced content, the intrinsic height of our content may have changed since the last time we laid out. If that's the case the intrinsic padding we used
-  // for layout (the padding required to push the contents of the cell down to the row's baseline) is included in our new height and baseline and makes both
-  // of them wrong. So if our content's intrinsic height has changed push the new content up into the intrinsic padding and relayout so that the rest of
-  // table and row layout can use the correct baseline and height for this cell.
+  // If we have replaced content, the intrinsic height of our content may have
+  // changed since the last time we laid out. If that's the case the intrinsic
+  // padding we used for layout (the padding required to push the contents of
+  // the cell down to the row's baseline) is included in our new height and
+  // baseline and makes both of them wrong. So if our content's intrinsic height
+  // has changed push the new content up into the intrinsic padding and relayout
+  // so that the rest of table and row layout can use the correct baseline and
+  // height for this cell.
   if (isBaselineAligned() && section()->rowBaseline(rowIndex()) &&
       cellBaselinePosition() > section()->rowBaseline(rowIndex())) {
     int newIntrinsicPaddingBefore =
         std::max(intrinsicPaddingBefore() -
                      std::max(cellBaselinePosition() - oldCellBaseline, 0),
                  0);
     setIntrinsicPaddingBefore(newIntrinsicPaddingBefore);
     SubtreeLayoutScope layouter(*this);
     layouter.setNeedsLayout(this, LayoutInvalidationReason::TableChanged);
     layoutBlock(cellWidthChanged());
   }
 
   // FIXME: This value isn't the intrinsic content logical height, but we need
   // to update the value as its used by flexbox layout. crbug.com/367324
   setIntrinsicContentLogicalHeight(contentLogicalHeight());
 
   setCellWidthChanged(false);
 }
 
 LayoutUnit LayoutTableCell::paddingTop() const {
   LayoutUnit result = computedCSSPaddingTop();
   if (isHorizontalWritingMode())
     result += (style()->getWritingMode() == TopToBottomWritingMode
                    ? intrinsicPaddingBefore()
                    : intrinsicPaddingAfter());
-  // TODO(leviw): The floor call should be removed when Table is sub-pixel aware. crbug.com/377847
+  // TODO(leviw): The floor call should be removed when Table is sub-pixel
+  // aware. crbug.com/377847
   return LayoutUnit(result.floor());
 }
 
 LayoutUnit LayoutTableCell::paddingBottom() const {
   LayoutUnit result = computedCSSPaddingBottom();
   if (isHorizontalWritingMode())
     result += (style()->getWritingMode() == TopToBottomWritingMode
                    ? intrinsicPaddingAfter()
                    : intrinsicPaddingBefore());
-  // TODO(leviw): The floor call should be removed when Table is sub-pixel aware. crbug.com/377847
+  // TODO(leviw): The floor call should be removed when Table is sub-pixel
+  // aware. crbug.com/377847
   return LayoutUnit(result.floor());
 }
 
 LayoutUnit LayoutTableCell::paddingLeft() const {
   LayoutUnit result = computedCSSPaddingLeft();
   if (!isHorizontalWritingMode())
     result += (style()->getWritingMode() == LeftToRightWritingMode
                    ? intrinsicPaddingBefore()
                    : intrinsicPaddingAfter());
-  // TODO(leviw): The floor call should be removed when Table is sub-pixel aware. crbug.com/377847
+  // TODO(leviw): The floor call should be removed when Table is sub-pixel
+  // aware. crbug.com/377847
   return LayoutUnit(result.floor());
 }
 
 LayoutUnit LayoutTableCell::paddingRight() const {
   LayoutUnit result = computedCSSPaddingRight();
   if (!isHorizontalWritingMode())
     result += (style()->getWritingMode() == LeftToRightWritingMode
                    ? intrinsicPaddingAfter()
                    : intrinsicPaddingBefore());
-  // TODO(leviw): The floor call should be removed when Table is sub-pixel aware. crbug.com/377847
+  // TODO(leviw): The floor call should be removed when Table is sub-pixel
+  // aware. crbug.com/377847
   return LayoutUnit(result.floor());
 }
 
 LayoutUnit LayoutTableCell::paddingBefore() const {
   return LayoutUnit(computedCSSPaddingBefore().floor() +
                     intrinsicPaddingBefore());
 }
 
 LayoutUnit LayoutTableCell::paddingAfter() const {
   return LayoutUnit(computedCSSPaddingAfter().floor() +
@@ skipping 11 matching lines @@
   ASSERT(o == container());
 
   LayoutSize offset = LayoutBlockFlow::offsetFromContainer(o);
   if (parent())
     offset -= parentBox()->locationOffset();
 
   return offset;
 }
 
 LayoutRect LayoutTableCell::localOverflowRectForPaintInvalidation() const {
-  // If the table grid is dirty, we cannot get reliable information about adjoining cells,
-  // so we ignore outside borders. This should not be a problem because it means that
-  // the table is going to recalculate the grid, relayout and issue a paint invalidation of its current rect, which
-  // includes any outside borders of this cell.
+  // If the table grid is dirty, we cannot get reliable information about
+  // adjoining cells, so we ignore outside borders. This should not be a problem
+  // because it means that the table is going to recalculate the grid, relayout
+  // and issue a paint invalidation of its current rect, which includes any
+  // outside borders of this cell.
   if (!table()->collapseBorders() || table()->needsSectionRecalc())
     return LayoutBlockFlow::localOverflowRectForPaintInvalidation();
 
   bool rtl = !styleForCellFlow().isLeftToRightDirection();
   int outlineOutset = style()->outlineOutsetExtent();
   int left = std::max(borderHalfLeft(true), outlineOutset);
   int right = std::max(borderHalfRight(true), outlineOutset);
   int top = std::max(borderHalfTop(true), outlineOutset);
   int bottom = std::max(borderHalfBottom(true), outlineOutset);
   if ((left && !rtl) || (right && rtl)) {
@@ skipping 25 matching lines @@
   LayoutPoint location(std::max(LayoutUnit(left), -selfVisualOverflowRect.x()),
                        std::max(LayoutUnit(top), -selfVisualOverflowRect.y()));
   return LayoutRect(-location.x(), -location.y(),
                     location.x() + std::max(size().width() + right,
                                             selfVisualOverflowRect.maxX()),
                     location.y() + std::max(size().height() + bottom,
                                             selfVisualOverflowRect.maxY()));
 }
 
 int LayoutTableCell::cellBaselinePosition() const {
-  // <http://www.w3.org/TR/2007/CR-CSS21-20070719/tables.html#height-layout>: The baseline of a cell is the baseline of
-  // the first in-flow line box in the cell, or the first in-flow table-row in the cell, whichever comes first. If there
-  // is no such line box or table-row, the baseline is the bottom of content edge of the cell box.
+  // <http://www.w3.org/TR/2007/CR-CSS21-20070719/tables.html#height-layout>:
+  // The baseline of a cell is the baseline of the first in-flow line box in the
+  // cell, or the first in-flow table-row in the cell, whichever comes first. If
+  // there is no such line box or table-row, the baseline is the bottom of
+  // content edge of the cell box.
   int firstLineBaseline = firstLineBoxBaseline();
   if (firstLineBaseline != -1)
     return firstLineBaseline;
   return (borderBefore() + paddingBefore() + contentLogicalHeight()).toInt();
 }
 
 void LayoutTableCell::styleDidChange(StyleDifference diff,
                                      const ComputedStyle* oldStyle) {
   DCHECK_EQ(style()->display(), EDisplay::TableCell);
 
   LayoutBlockFlow::styleDidChange(diff, oldStyle);
   setHasBoxDecorationBackground(true);
 
   if (parent() && section() && oldStyle &&
       style()->height() != oldStyle->height())
     section()->rowLogicalHeightChanged(row());
 
-  // Our intrinsic padding pushes us down to align with the baseline of other cells on the row. If our vertical-align
-  // has changed then so will the padding needed to align with other cells - clear it so we can recalculate it from scratch.
+  // Our intrinsic padding pushes us down to align with the baseline of other
+  // cells on the row. If our vertical-align has changed then so will the
+  // padding needed to align with other cells - clear it so we can recalculate
+  // it from scratch.
   if (oldStyle && style()->verticalAlign() != oldStyle->verticalAlign())
     clearIntrinsicPadding();
 
   // If border was changed, notify table.
   if (!parent())
     return;
   LayoutTable* table = this->table();
   if (!table)
     return;
   if (!table->selfNeedsLayout() && !table->normalChildNeedsLayout() &&
       oldStyle && oldStyle->border() != style()->border())
     table->invalidateCollapsedBorders();
 
   if (LayoutTableBoxComponent::doCellsHaveDirtyWidth(*this, *table, diff,
                                                      *oldStyle)) {
     if (previousCell()) {
-      // TODO(dgrogan) Add a layout test showing that setChildNeedsLayout is needed instead of setNeedsLayout.
+      // TODO(dgrogan) Add a layout test showing that setChildNeedsLayout is
+      // needed instead of setNeedsLayout.
       previousCell()->setChildNeedsLayout();
       previousCell()->setPreferredLogicalWidthsDirty(MarkOnlyThis);
     }
     if (nextCell()) {
-      // TODO(dgrogan) Add a layout test showing that setChildNeedsLayout is needed instead of setNeedsLayout.
+      // TODO(dgrogan) Add a layout test showing that setChildNeedsLayout is
+      // needed instead of setNeedsLayout.
       nextCell()->setChildNeedsLayout();
       nextCell()->setPreferredLogicalWidthsDirty(MarkOnlyThis);
     }
   }
 }
 
-// The following rules apply for resolving conflicts and figuring out which border
-// to use.
-// (1) Borders with the 'border-style' of 'hidden' take precedence over all other conflicting
-// borders. Any border with this value suppresses all borders at this location.
-// (2) Borders with a style of 'none' have the lowest priority. Only if the border properties of all
-// the elements meeting at this edge are 'none' will the border be omitted (but note that 'none' is
-// the default value for the border style.)
-// (3) If none of the styles are 'hidden' and at least one of them is not 'none', then narrow borders
-// are discarded in favor of wider ones. If several have the same 'border-width' then styles are preferred
-// in this order: 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset', 'groove', and the lowest: 'inset'.
-// (4) If border styles differ only in color, then a style set on a cell wins over one on a row,
-// which wins over a row group, column, column group and, lastly, table. It is undefined which color
-// is used when two elements of the same type disagree.
+// The following rules apply for resolving conflicts and figuring out which
+// border to use.
+// (1) Borders with the 'border-style' of 'hidden' take precedence over all
+//     other conflicting borders. Any border with this value suppresses all
+//     borders at this location.
+// (2) Borders with a style of 'none' have the lowest priority. Only if the
+//     border properties of all the elements meeting at this edge are 'none'
+//     will the border be omitted (but note that 'none' is the default value for
+//     the border style.)
+// (3) If none of the styles are 'hidden' and at least one of them is not
+//     'none', then narrow borders are discarded in favor of wider ones. If
+//      several have the same 'border-width' then styles are preferred in this
+//      order: 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset',
+//     'groove', and the lowest: 'inset'.
+// (4) If border styles differ only in color, then a style set on a cell wins
+//     over one on a row, which wins over a row group, column, column group and,
+//     lastly, table. It is undefined which color is used when two elements of
+//     the same type disagree.
 static bool compareBorders(const CollapsedBorderValue& border1,
                            const CollapsedBorderValue& border2) {
   // Sanity check the values passed in. The null border have lowest priority.
   if (!border2.exists())
     return false;
   if (!border1.exists())
     return true;
 
   // Rule #1 above.
   if (border1.style() == BorderStyleHidden)
     return false;
   if (border2.style() == BorderStyleHidden)
     return true;
 
-  // Rule #2 above.  A style of 'none' has lowest priority and always loses to any other border.
+  // Rule #2 above.  A style of 'none' has lowest priority and always loses to
+  // any other border.
   if (border2.style() == BorderStyleNone)
     return false;
   if (border1.style() == BorderStyleNone)
     return true;
 
   // The first part of rule #3 above. Wider borders win.
   if (border1.width() != border2.width())
     return border1.width() < border2.width();
 
   // The borders have equal width.  Sort by border style.
   if (border1.style() != border2.style())
     return border1.style() < border2.style();
 
-  // The border have the same width and style.  Rely on precedence (cell over row over row group, etc.)
+  // The border have the same width and style.  Rely on precedence (cell over
+  // row over row group, etc.)
   return border1.precedence() < border2.precedence();
 }
 
 static CollapsedBorderValue chooseBorder(const CollapsedBorderValue& border1,
                                          const CollapsedBorderValue& border2) {
   return compareBorders(border1, border2) ? border2 : border1;
 }
 
 bool LayoutTableCell::hasStartBorderAdjoiningTable() const {
   bool isStartColumn = !absoluteColumnIndex();
   bool isEndColumn = table()->absoluteColumnToEffectiveColumn(
                          absoluteColumnIndex() + colSpan() - 1) ==
                      table()->numEffectiveColumns() - 1;
   bool hasSameDirectionAsTable = hasSameDirectionAs(table());
 
-  // The table direction determines the row direction. In mixed directionality, we cannot guarantee that
-  // we have a common border with the table (think a ltr table with rtl start cell).
+  // The table direction determines the row direction. In mixed directionality,
+  // we cannot guarantee that we have a common border with the table (think a
+  // ltr table with rtl start cell).
   return (isStartColumn && hasSameDirectionAsTable) ||
          (isEndColumn && !hasSameDirectionAsTable);
 }
 
 bool LayoutTableCell::hasEndBorderAdjoiningTable() const {
   bool isStartColumn = !absoluteColumnIndex();
   bool isEndColumn = table()->absoluteColumnToEffectiveColumn(
                          absoluteColumnIndex() + colSpan() - 1) ==
                      table()->numEffectiveColumns() - 1;
   bool hasSameDirectionAsTable = hasSameDirectionAs(table());
 
-  // The table direction determines the row direction. In mixed directionality, we cannot guarantee that
-  // we have a common border with the table (think a ltr table with ltr end cell).
+  // The table direction determines the row direction. In mixed directionality,
+  // we cannot guarantee that we have a common border with the table (think a
+  // ltr table with ltr end cell).
   return (isStartColumn && !hasSameDirectionAsTable) ||
          (isEndColumn && hasSameDirectionAsTable);
 }
 
 CollapsedBorderValue LayoutTableCell::computeCollapsedStartBorder(
     IncludeBorderColorOrNot includeColor) const {
   LayoutTable* table = this->table();
 
   // For the start border, we need to check, in order of precedence:
   // (1) Our start border.
@@ skipping 14 matching lines @@
       includeColor ? resolveColor(startColorProperty) : Color(),
       BorderPrecedenceCell);
 
   // (2) The end border of the preceding cell.
   LayoutTableCell* cellBefore = table->cellBefore(this);
   if (cellBefore) {
     CollapsedBorderValue cellBeforeAdjoiningBorder = CollapsedBorderValue(
         cellBefore->borderAdjoiningCellAfter(this),
         includeColor ? cellBefore->resolveColor(endColorProperty) : Color(),
         BorderPrecedenceCell);
-    // |result| should be the 2nd argument as |cellBefore| should win in case of equality per CSS 2.1 (Border conflict resolution, point 4).
+    // |result| should be the 2nd argument as |cellBefore| should win in case of
+    // equality per CSS 2.1 (Border conflict resolution, point 4).
     result = chooseBorder(cellBeforeAdjoiningBorder, result);
     if (!result.exists())
       return result;
   }
 
   bool startBorderAdjoinsTable = hasStartBorderAdjoiningTable();
   if (startBorderAdjoinsTable) {
     // (3) Our row's start border.
     result = chooseBorder(
         result,
@@ skipping 25 matching lines @@
         CollapsedBorderValue(
             colAndColGroup.colgroup->borderAdjoiningCellStartBorder(this),
             includeColor
                 ? colAndColGroup.colgroup->resolveColor(startColorProperty)
                 : Color(),
             BorderPrecedenceColumnGroup));
     if (!result.exists())
       return result;
   }
   if (colAndColGroup.col) {
-    // Always apply the col's border irrespective of whether this cell touches it. This is per HTML5:
-    // "For the purposes of the CSS table model, the col element is expected to be treated as if it
-    // "was present as many times as its span attribute specifies".
+    // Always apply the col's border irrespective of whether this cell touches
+    // it. This is per HTML5: "For the purposes of the CSS table model, the col
+    // element is expected to be treated as if it "was present as many times as
+    // its span attribute specifies".
     result = chooseBorder(
         result,
         CollapsedBorderValue(
             colAndColGroup.col->borderAdjoiningCellStartBorder(this),
             includeColor ? colAndColGroup.col->resolveColor(startColorProperty)
                          : Color(),
             BorderPrecedenceColumn));
     if (!result.exists())
       return result;
   }
 
   // (6) The end border of the preceding column.
   if (cellBefore) {
     LayoutTable::ColAndColGroup colAndColGroup =
         table->colElementAtAbsoluteColumn(absoluteColumnIndex() - 1);
     // Only apply the colgroup's border if this cell touches the colgroup edge.
     if (colAndColGroup.colgroup && colAndColGroup.adjoinsEndBorderOfColGroup) {
       result = chooseBorder(
           CollapsedBorderValue(
               colAndColGroup.colgroup->borderAdjoiningCellEndBorder(this),
               includeColor
                   ? colAndColGroup.colgroup->resolveColor(endColorProperty)
                   : Color(),
               BorderPrecedenceColumnGroup),
           result);
       if (!result.exists())
         return result;
     }
-    // Always apply the col's border irrespective of whether this cell touches it. This is per HTML5:
-    // "For the purposes of the CSS table model, the col element is expected to be treated as if it
-    // "was present as many times as its span attribute specifies".
+    // Always apply the col's border irrespective of whether this cell touches
+    // it. This is per HTML5: "For the purposes of the CSS table model, the col
+    // element is expected to be treated as if it "was present as many times as
+    // its span attribute specifies".
     if (colAndColGroup.col) {
       result = chooseBorder(
           CollapsedBorderValue(
               colAndColGroup.col->borderAdjoiningCellAfter(this),
               includeColor ? colAndColGroup.col->resolveColor(endColorProperty)
                            : Color(),
               BorderPrecedenceColumn),
           result);
       if (!result.exists())
         return result;
@@ skipping 11 matching lines @@
     if (!result.exists())
       return result;
   }
 
   return result;
 }
 
 CollapsedBorderValue LayoutTableCell::computeCollapsedEndBorder(
     IncludeBorderColorOrNot includeColor) const {
   LayoutTable* table = this->table();
-  // Note: We have to use the effective column information instead of whether we have a cell after as a table doesn't
-  // have to be regular (any row can have less cells than the total cell count).
+  // Note: We have to use the effective column information instead of whether we
+  // have a cell after as a table doesn't have to be regular (any row can have
+  // less cells than the total cell count).
   bool isEndColumn = table->absoluteColumnToEffectiveColumn(
                          absoluteColumnIndex() + colSpan() - 1) ==
                      table->numEffectiveColumns() - 1;
 
   // For end border, we need to check, in order of precedence:
   // (1) Our end border.
   int startColorProperty = includeColor
                                ? CSSProperty::resolveDirectionAwareProperty(
                                      CSSPropertyWebkitBorderStartColor,
                                      styleForCellFlow().direction(),
@@ skipping 56 matching lines @@
         CollapsedBorderValue(
             colAndColGroup.colgroup->borderAdjoiningCellEndBorder(this),
             includeColor
                 ? colAndColGroup.colgroup->resolveColor(endColorProperty)
                 : Color(),
             BorderPrecedenceColumnGroup));
     if (!result.exists())
       return result;
   }
   if (colAndColGroup.col) {
-    // Always apply the col's border irrespective of whether this cell touches it. This is per HTML5:
-    // "For the purposes of the CSS table model, the col element is expected to be treated as if it
-    // "was present as many times as its span attribute specifies".
+    // Always apply the col's border irrespective of whether this cell touches
+    // it. This is per HTML5: "For the purposes of the CSS table model, the col
+    // element is expected to be treated as if it "was present as many times as
+    // its span attribute specifies".
     result = chooseBorder(
         result,
         CollapsedBorderValue(
             colAndColGroup.col->borderAdjoiningCellEndBorder(this),
             includeColor ? colAndColGroup.col->resolveColor(endColorProperty)
                          : Color(),
             BorderPrecedenceColumn));
     if (!result.exists())
       return result;
   }
 
   // (6) The start border of the next column.
   if (!isEndColumn) {
     LayoutTable::ColAndColGroup colAndColGroup =
         table->colElementAtAbsoluteColumn(absoluteColumnIndex() + colSpan());
     if (colAndColGroup.colgroup &&
         colAndColGroup.adjoinsStartBorderOfColGroup) {
-      // Only apply the colgroup's border if this cell touches the colgroup edge.
+      // Only apply the colgroup's border if this cell touches the colgroup
+      // edge.
       result = chooseBorder(
           result,
           CollapsedBorderValue(
               colAndColGroup.colgroup->borderAdjoiningCellStartBorder(this),
               includeColor
                   ? colAndColGroup.colgroup->resolveColor(startColorProperty)
                   : Color(),
               BorderPrecedenceColumnGroup));
       if (!result.exists())
         return result;
     }
     if (colAndColGroup.col) {
-      // Always apply the col's border irrespective of whether this cell touches it. This is per HTML5:
-      // "For the purposes of the CSS table model, the col element is expected to be treated as if it
-      // "was present as many times as its span attribute specifies".
+      // Always apply the col's border irrespective of whether this cell touches
+      // it. This is per HTML5: "For the purposes of the CSS table model, the
+      // col element is expected to be treated as if it "was present as many
+      // times as its span attribute specifies".
       result = chooseBorder(
           result, CollapsedBorderValue(
                       colAndColGroup.col->borderAdjoiningCellBefore(this),
                       includeColor
                           ? colAndColGroup.col->resolveColor(startColorProperty)
                           : Color(),
                       BorderPrecedenceColumn));
       if (!result.exists())
         return result;
     }
@@ skipping 296 matching lines @@
 int LayoutTableCell::borderTop() const {
   return table()->collapseBorders() ? borderHalfTop(false)
                                     : LayoutBlockFlow::borderTop();
 }
 
 int LayoutTableCell::borderBottom() const {
   return table()->collapseBorders() ? borderHalfBottom(false)
                                     : LayoutBlockFlow::borderBottom();
 }
 
-// FIXME: https://bugs.webkit.org/show_bug.cgi?id=46191, make the collapsed border drawing
-// work with different block flow values instead of being hard-coded to top-to-bottom.
+// FIXME: https://bugs.webkit.org/show_bug.cgi?id=46191, make the collapsed
+// border drawing work with different block flow values instead of being
+// hard-coded to top-to-bottom.
 int LayoutTableCell::borderStart() const {
   return table()->collapseBorders() ? borderHalfStart(false)
                                     : LayoutBlockFlow::borderStart();
 }
 
 int LayoutTableCell::borderEnd() const {
   return table()->collapseBorders() ? borderHalfEnd(false)
                                     : LayoutBlockFlow::borderEnd();
 }
 
@@ skipping 114 matching lines @@
   bool changed = false;
   if (!newValues.startBorder.isVisible() && !newValues.endBorder.isVisible() &&
       !newValues.beforeBorder.isVisible() &&
       !newValues.afterBorder.isVisible()) {
     changed = !!m_collapsedBorderValues;
     m_collapsedBorderValues = nullptr;
   } else if (!m_collapsedBorderValues) {
     changed = true;
     m_collapsedBorderValues = wrapUnique(new CollapsedBorderValues(newValues));
   } else {
-    // We check visuallyEquals so that the table cell is invalidated only if a changed
-    // collapsed border is visible in the first place.
+    // We check visuallyEquals so that the table cell is invalidated only if a
+    // changed collapsed border is visible in the first place.
     changed = !m_collapsedBorderValues->startBorder.visuallyEquals(
                   newValues.startBorder) ||
               !m_collapsedBorderValues->endBorder.visuallyEquals(
                   newValues.endBorder) ||
               !m_collapsedBorderValues->beforeBorder.visuallyEquals(
                   newValues.beforeBorder) ||
               !m_collapsedBorderValues->afterBorder.visuallyEquals(
                   newValues.afterBorder);
     if (changed)
       *m_collapsedBorderValues = newValues;
   }
 
-  // If collapsed borders changed, invalidate the cell's display item client on the table's backing.
-  // TODO(crbug.com/451090#c5): Need a way to invalidate/repaint the borders only.
+  // If collapsed borders changed, invalidate the cell's display item client on
+  // the table's backing.
+  // TODO(crbug.com/451090#c5): Need a way to invalidate/repaint the borders
+  // only.
   if (changed)
     ObjectPaintInvalidator(*table())
         .slowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
             *this, PaintInvalidationStyleChange);
 
   addBorderStyle(borderValues, newValues.startBorder);
   addBorderStyle(borderValues, newValues.endBorder);
   addBorderStyle(borderValues, newValues.beforeBorder);
   addBorderStyle(borderValues, newValues.afterBorder);
 }
@@ skipping 18 matching lines @@
     BackgroundBleedAvoidance,
     const InlineFlowBox*) const {
   return false;
 }
 
 void LayoutTableCell::scrollbarsChanged(bool horizontalScrollbarChanged,
                                         bool verticalScrollbarChanged) {
   LayoutBlock::scrollbarsChanged(horizontalScrollbarChanged,
                                  verticalScrollbarChanged);
   int scrollbarHeight = scrollbarLogicalHeight();
+  // Not sure if we should be doing something when a scrollbar goes away or not.
   if (!scrollbarHeight)
-    return;  // Not sure if we should be doing something when a scrollbar goes away or not.
+    return;
 
-  // We only care if the scrollbar that affects our intrinsic padding has been added.
+  // We only care if the scrollbar that affects our intrinsic padding has been
+  // added.
   if ((isHorizontalWritingMode() && !horizontalScrollbarChanged) ||
       (!isHorizontalWritingMode() && !verticalScrollbarChanged))
     return;
 
-  // Shrink our intrinsic padding as much as possible to accommodate the scrollbar.
+  // Shrink our intrinsic padding as much as possible to accommodate the
+  // scrollbar.
   if (style()->verticalAlign() == VerticalAlignMiddle) {
     LayoutUnit totalHeight = logicalHeight();
     LayoutUnit heightWithoutIntrinsicPadding =
         totalHeight - intrinsicPaddingBefore() - intrinsicPaddingAfter();
     totalHeight -= scrollbarHeight;
     LayoutUnit newBeforePadding =
         (totalHeight - heightWithoutIntrinsicPadding) / 2;
     LayoutUnit newAfterPadding =
         totalHeight - heightWithoutIntrinsicPadding - newBeforePadding;
     setIntrinsicPaddingBefore(newBeforePadding.toInt());
@@ skipping 15 matching lines @@
       LayoutTableCell::createAnonymous(&parent->document());
   RefPtr<ComputedStyle> newStyle =
       ComputedStyle::createAnonymousStyleWithDisplay(parent->styleRef(),
                                                      EDisplay::TableCell);
   newCell->setStyle(newStyle.release());
   return newCell;
 }
 
 bool LayoutTableCell::backgroundIsKnownToBeOpaqueInRect(
     const LayoutRect& localRect) const {
-  // If this object has layer, the area of collapsed borders should be transparent
-  // to expose the collapsed borders painted on the underlying layer.
+  // If this object has layer, the area of collapsed borders should be
+  // transparent to expose the collapsed borders painted on the underlying
+  // layer.
   if (hasLayer() && table()->collapseBorders())
     return false;
   return LayoutBlockFlow::backgroundIsKnownToBeOpaqueInRect(localRect);
 }
 
 // TODO(lunalu): Deliberately dump the "inner" box of table cells, since that
 // is what current results reflect.  We'd like to clean up the results to dump
-// both the outer box and the intrinsic padding so that both bits of
-// information are captured by the results.
+// both the outer box and the intrinsic padding so that both bits of information
+// are captured by the results.
 LayoutRect LayoutTableCell::debugRect() const {
   LayoutRect rect = LayoutRect(
       location().x(), location().y() + intrinsicPaddingBefore(), size().width(),
       size().height() - intrinsicPaddingBefore() - intrinsicPaddingAfter());
 
   LayoutBlock* cb = containingBlock();
   if (cb)
     cb->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 void LayoutTableCell::adjustChildDebugRect(LayoutRect& r) const {
   r.move(0, -intrinsicPaddingBefore());
 }
 
 }  // namespace blink