reflow comments in core/paint

third_party/WebKit/Source/core/paint/TableSectionPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/TableSectionPainter.h"
 
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableCol.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/paint/BoxClipper.h"
@@ skipping 35 matching lines @@
     const CollapsedBorderValue& currentBorderValue,
     ItemToPaint itemToPaint) {
   if (!m_layoutTableSection.isRepeatingHeaderGroup())
     return;
 
   LayoutTable* table = m_layoutTableSection.table();
   LayoutPoint paginationOffset = paintOffset;
   LayoutUnit pageHeight = table->pageLogicalHeightForOffset(LayoutUnit());
 
   // Move paginationOffset to the top of the next page.
-  // The header may have a pagination strut before it so we need to account for that when establishing its position.
+  // The header may have a pagination strut before it so we need to account for
+  // that when establishing its position.
   LayoutUnit headerGroupOffset = table->pageLogicalOffset();
   if (LayoutTableRow* row = m_layoutTableSection.firstRow())
     headerGroupOffset += row->paginationStrut();
   LayoutUnit offsetToNextPage =
       pageHeight - intMod(headerGroupOffset, pageHeight);
   paginationOffset.move(0, offsetToNextPage.toInt());
   // Now move paginationOffset to the top of the page the cull rect starts on.
   if (paintInfo.cullRect().m_rect.y() > paginationOffset.y())
     paginationOffset.move(
         0, pageHeight.toInt() *
@@ skipping 51 matching lines @@
   if (shouldPaintSelfOutline(paintInfo.phase))
     ObjectPainter(m_layoutTableSection)
         .paintOutline(paintInfo, adjustedPaintOffset);
 }
 
 static inline bool compareCellPositions(LayoutTableCell* elem1,
                                         LayoutTableCell* elem2) {
   return elem1->rowIndex() < elem2->rowIndex();
 }
 
-// This comparison is used only when we have overflowing cells as we have an unsorted array to sort. We thus need
-// to sort both on rows and columns to properly issue paint invalidations.
+// This comparison is used only when we have overflowing cells as we have an
+// unsorted array to sort. We thus need to sort both on rows and columns to
+// properly issue paint invalidations.
 static inline bool compareCellPositionsWithOverflowingCells(
     LayoutTableCell* elem1,
     LayoutTableCell* elem2) {
   if (elem1->rowIndex() != elem2->rowIndex())
     return elem1->rowIndex() < elem2->rowIndex();
 
   return elem1->absoluteColumnIndex() < elem2->absoluteColumnIndex();
 }
 
 void TableSectionPainter::paintCollapsedBorders(
@@ skipping 28 matching lines @@
       m_layoutTableSection.logicalRectForWritingModeAndDirection(
           localPaintInvalidationRect);
 
   CellSpan dirtiedRows = m_layoutTableSection.dirtiedRows(tableAlignedRect);
   CellSpan dirtiedColumns =
       m_layoutTableSection.dirtiedEffectiveColumns(tableAlignedRect);
 
   if (dirtiedColumns.start() >= dirtiedColumns.end())
     return;
 
-  // Collapsed borders are painted from the bottom right to the top left so that precedence
-  // due to cell position is respected.
+  // Collapsed borders are painted from the bottom right to the top left so that
+  // precedence due to cell position is respected.
   for (unsigned r = dirtiedRows.end(); r > dirtiedRows.start(); r--) {
     unsigned row = r - 1;
     for (unsigned c = dirtiedColumns.end(); c > dirtiedColumns.start(); c--) {
       unsigned col = c - 1;
       const LayoutTableSection::CellStruct& current =
           m_layoutTableSection.cellAt(row, col);
       const LayoutTableCell* cell = current.primaryCell();
       if (!cell || (row > dirtiedRows.start() &&
                     m_layoutTableSection.primaryCellAt(row - 1, col) == cell) ||
           (col > dirtiedColumns.start() &&
@@ skipping 63 matching lines @@
       rowPainter.paintBoxShadow(paintInfoForDescendants, paintOffset, Inset);
     }
   }
 
   const HashSet<LayoutTableCell*>& overflowingCells =
       m_layoutTableSection.overflowingCells();
   if (!m_layoutTableSection.hasMultipleCellLevels() &&
       overflowingCells.isEmpty()) {
     for (unsigned r = dirtiedRows.start(); r < dirtiedRows.end(); r++) {
       const LayoutTableRow* row = m_layoutTableSection.rowLayoutObjectAt(r);
-      // TODO(crbug.com/577282): This painting order is inconsistent with other outlines.
+      // TODO(crbug.com/577282): This painting order is inconsistent with other
+      // outlines.
       if (row && !row->hasSelfPaintingLayer() &&
           shouldPaintSelfOutline(paintInfoForDescendants.phase))
         TableRowPainter(*row).paintOutline(paintInfoForDescendants,
                                            paintOffset);
       for (unsigned c = dirtiedColumns.start(); c < dirtiedColumns.end(); c++) {
         if (const LayoutTableCell* cell =
                 primaryCellToPaint(r, c, dirtiedRows, dirtiedColumns))
           paintCell(*cell, paintInfoForDescendants, paintOffset);
       }
     }
   } else {
-    // The overflowing cells should be scarce to avoid adding a lot of cells to the HashSet.
+    // The overflowing cells should be scarce to avoid adding a lot of cells to
+    // the HashSet.
     DCHECK(overflowingCells.size() <
            m_layoutTableSection.numRows() *
                m_layoutTableSection.table()->effectiveColumns().size() *
                gMaxAllowedOverflowingCellRatioForFastPaintPath);
 
-    // To make sure we properly paint the section, we paint all the overflowing cells that we collected.
+    // To make sure we properly paint the section, we paint all the overflowing
+    // cells that we collected.
     Vector<LayoutTableCell*> cells;
     copyToVector(overflowingCells, cells);
 
     HashSet<LayoutTableCell*> spanningCells;
     for (unsigned r = dirtiedRows.start(); r < dirtiedRows.end(); r++) {
       const LayoutTableRow* row = m_layoutTableSection.rowLayoutObjectAt(r);
-      // TODO(crbug.com/577282): This painting order is inconsistent with other outlines.
+      // TODO(crbug.com/577282): This painting order is inconsistent with other
+      // outlines.
       if (row && !row->hasSelfPaintingLayer() &&
           shouldPaintSelfOutline(paintInfoForDescendants.phase))
         TableRowPainter(*row).paintOutline(paintInfoForDescendants,
                                            paintOffset);
       for (unsigned c = dirtiedColumns.start(); c < dirtiedColumns.end(); c++) {
         const LayoutTableSection::CellStruct& current =
             m_layoutTableSection.cellAt(r, c);
         for (LayoutTableCell* cell : current.cells) {
           if (overflowingCells.contains(cell))
             continue;
@@ skipping 18 matching lines @@
   }
 }
 
 void TableSectionPainter::paintBackgroundsBehindCell(
     const LayoutTableCell& cell,
     const PaintInfo& paintInfoForCells,
     const LayoutPoint& paintOffset) {
   LayoutPoint cellPoint =
       m_layoutTableSection.flipForWritingModeForChild(&cell, paintOffset);
 
-  // We need to handle painting a stack of backgrounds. This stack (from bottom to top) consists of
-  // the column group, column, row group, row, and then the cell.
+  // We need to handle painting a stack of backgrounds. This stack (from bottom
+  // to top) consists of the column group, column, row group, row, and then the
+  // cell.
 
   LayoutTable::ColAndColGroup colAndColGroup =
       m_layoutTableSection.table()->colElementAtAbsoluteColumn(
           cell.absoluteColumnIndex());
   LayoutTableCol* column = colAndColGroup.col;
   LayoutTableCol* columnGroup = colAndColGroup.colgroup;
   TableCellPainter tableCellPainter(cell);
 
   // Column groups and columns first.
-  // FIXME: Columns and column groups do not currently support opacity, and they are being painted "too late" in
-  // the stack, since we have already opened a transparency layer (potentially) for the table row group.
-  // Note that we deliberately ignore whether or not the cell has a layer, since these backgrounds paint "behind" the
-  // cell.
+  // FIXME: Columns and column groups do not currently support opacity, and they
+  // are being painted "too late" in the stack, since we have already opened a
+  // transparency layer (potentially) for the table row group.  Note that we
+  // deliberately ignore whether or not the cell has a layer, since these
+  // backgrounds paint "behind" the cell.
   if (columnGroup && columnGroup->styleRef().hasBackground())
     tableCellPainter.paintContainerBackgroundBehindCell(
         paintInfoForCells, cellPoint, *columnGroup,
         DisplayItem::kTableCellBackgroundFromColumnGroup);
   if (column && column->styleRef().hasBackground())
     tableCellPainter.paintContainerBackgroundBehindCell(
         paintInfoForCells, cellPoint, *column,
         DisplayItem::kTableCellBackgroundFromColumn);
 
   // Paint the row group next.
@@ skipping 30 matching lines @@
   LayoutRect bounds = BoxPainter(m_layoutTableSection)
                           .boundsForDrawingRecorder(paintInfo, paintOffset);
   LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutTableSection,
                                        type, bounds);
   BoxPainter::paintBoxShadow(
       paintInfo, LayoutRect(paintOffset, m_layoutTableSection.size()),
       m_layoutTableSection.styleRef(), shadowStyle);
 }
 
 }  // namespace blink