Remove LayoutTable::m_currentBorder

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 "config.h"
 #include "core/paint/TableSectionPainter.h"
 
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableCol.h"
@@ skipping 39 matching lines @@
 // 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->col() < elem2->col();
 }
 
+void TableSectionPainter::paintCollapsedBorders(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const CollapsedBorderValue& currentBorderValue)
+{

[Xianzhu, 2015/10/02 18:22:25]

Note: this is extracted from TableSectionPainter::paintObject.

+    if (!m_layoutTableSection.numRows() || !m_layoutTableSection.table()->columns().size())
+        return;
+
+    LayoutPoint adjustedPaintOffset = paintOffset + m_layoutTableSection.location();
+    BoxClipper boxClipper(m_layoutTableSection, paintInfo, adjustedPaintOffset, ForceContentsClip);
+
+    LayoutRect localPaintInvalidationRect = LayoutRect(paintInfo.rect);
+    localPaintInvalidationRect.moveBy(-adjustedPaintOffset);
+
+    LayoutRect tableAlignedRect = m_layoutTableSection.logicalRectForWritingModeAndDirection(localPaintInvalidationRect);
+
+    CellSpan dirtiedRows = m_layoutTableSection.dirtiedRows(tableAlignedRect);
+    CellSpan dirtiedColumns = m_layoutTableSection.dirtiedColumns(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.
+    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() && m_layoutTableSection.primaryCellAt(row, col - 1) == cell))
+                continue;
+            LayoutPoint cellPoint = m_layoutTableSection.flipForWritingModeForChild(cell, adjustedPaintOffset);
+            TableCellPainter(*cell).paintCollapsedBorders(paintInfo, cellPoint, currentBorderValue);
+        }
+    }
+}
+
 void TableSectionPainter::paintObject(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     LayoutRect localPaintInvalidationRect = LayoutRect(paintInfo.rect);
     localPaintInvalidationRect.moveBy(-paintOffset);
 
     LayoutRect tableAlignedRect = m_layoutTableSection.logicalRectForWritingModeAndDirection(localPaintInvalidationRect);
 
     CellSpan dirtiedRows = m_layoutTableSection.dirtiedRows(tableAlignedRect);
     CellSpan dirtiedColumns = m_layoutTableSection.dirtiedColumns(tableAlignedRect);
 
+    if (dirtiedColumns.start() >= dirtiedColumns.end())
+        return;
+
     const HashSet<LayoutTableCell*>& overflowingCells = m_layoutTableSection.overflowingCells();
-    if (dirtiedColumns.start() < dirtiedColumns.end()) {
-        if (!m_layoutTableSection.hasMultipleCellLevels() && !overflowingCells.size()) {
-            if (paintInfo.phase == PaintPhaseCollapsedTableBorders) {
-                // 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() && m_layoutTableSection.primaryCellAt(row, col - 1) == cell))
+    if (!m_layoutTableSection.hasMultipleCellLevels() && !overflowingCells.size()) {

[Xianzhu, 2015/10/02 18:22:25]

Note: Actually the amount of change here is much smaller than it looks.
Only changes are:
- Changed the original line 71 'if' to an early return;
- Removed collapsed border code (which is extracted to the new
TableSectionPainter::paintCollapsedBorders()).

The following green lines are just because of change of indent.

+        // Draw the dirty cells in the order that they appear.
+        for (unsigned r = dirtiedRows.start(); r < dirtiedRows.end(); r++) {
+            const LayoutTableRow* row = m_layoutTableSection.rowLayoutObjectAt(r);
+            if (row && !row->hasSelfPaintingLayer())
+                TableRowPainter(*row).paintOutlineForRowIfNeeded(paintInfo, paintOffset);
+            for (unsigned c = dirtiedColumns.start(); c < dirtiedColumns.end(); c++) {
+                const LayoutTableSection::CellStruct& current = m_layoutTableSection.cellAt(r, c);
+                const LayoutTableCell* cell = current.primaryCell();
+                if (!cell || (r > dirtiedRows.start() && m_layoutTableSection.primaryCellAt(r - 1, c) == cell) || (c > dirtiedColumns.start() && m_layoutTableSection.primaryCellAt(r, c - 1) == cell))
+                    continue;
+                paintCell(*cell, paintInfo, paintOffset);
+            }
+        }
+    } else {
+        // The overflowing cells should be scarce to avoid adding a lot of cells to the HashSet.
+#if ENABLE(ASSERT)
+        unsigned totalRows = m_layoutTableSection.numRows();
+        unsigned totalCols = m_layoutTableSection.table()->columns().size();
+        ASSERT(overflowingCells.size() < totalRows * totalCols * gMaxAllowedOverflowingCellRatioForFastPaintPath);
+#endif
+
+        // To make sure we properly paint invalidate the section, we paint invalidated 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);
+            if (row && !row->hasSelfPaintingLayer())
+                TableRowPainter(*row).paintOutlineForRowIfNeeded(paintInfo, paintOffset);
+            for (unsigned c = dirtiedColumns.start(); c < dirtiedColumns.end(); c++) {
+                const LayoutTableSection::CellStruct& current = m_layoutTableSection.cellAt(r, c);
+                if (!current.hasCells())
+                    continue;
+                for (unsigned i = 0; i < current.cells.size(); ++i) {
+                    if (overflowingCells.contains(current.cells[i]))
+                        continue;
+
+                    if (current.cells[i]->rowSpan() > 1 || current.cells[i]->colSpan() > 1) {
+                        if (!spanningCells.add(current.cells[i]).isNewEntry)
                             continue;
-                        LayoutPoint cellPoint = m_layoutTableSection.flipForWritingModeForChild(cell, paintOffset);
-                        TableCellPainter(*cell).paintCollapsedBorders(paintInfo, cellPoint);
                     }
-                }
-            } else {
-                // Draw the dirty cells in the order that they appear.
-                for (unsigned r = dirtiedRows.start(); r < dirtiedRows.end(); r++) {
-                    const LayoutTableRow* row = m_layoutTableSection.rowLayoutObjectAt(r);
-                    if (row && !row->hasSelfPaintingLayer())
-                        TableRowPainter(*row).paintOutlineForRowIfNeeded(paintInfo, paintOffset);
-                    for (unsigned c = dirtiedColumns.start(); c < dirtiedColumns.end(); c++) {
-                        const LayoutTableSection::CellStruct& current = m_layoutTableSection.cellAt(r, c);
-                        const LayoutTableCell* cell = current.primaryCell();
-                        if (!cell || (r > dirtiedRows.start() && m_layoutTableSection.primaryCellAt(r - 1, c) == cell) || (c > dirtiedColumns.start() && m_layoutTableSection.primaryCellAt(r, c - 1) == cell))
-                            continue;
-                        paintCell(*cell, paintInfo, paintOffset);
-                    }
+
+                    cells.append(current.cells[i]);
                 }
             }
-        } else {
-            // The overflowing cells should be scarce to avoid adding a lot of cells to the HashSet.
-#if ENABLE(ASSERT)
-            unsigned totalRows = m_layoutTableSection.numRows();
-            unsigned totalCols = m_layoutTableSection.table()->columns().size();
-            ASSERT(overflowingCells.size() < totalRows * totalCols * gMaxAllowedOverflowingCellRatioForFastPaintPath);
-#endif
+        }
 
-            // To make sure we properly paint invalidate the section, we paint invalidated all the overflowing cells that we collected.
-            Vector<LayoutTableCell*> cells;
-            copyToVector(overflowingCells, cells);
+        // Sort the dirty cells by paint order.
+        if (!overflowingCells.size())
+            std::stable_sort(cells.begin(), cells.end(), compareCellPositions);
+        else
+            std::sort(cells.begin(), cells.end(), compareCellPositionsWithOverflowingCells);
 
-            HashSet<LayoutTableCell*> spanningCells;
-
-            for (unsigned r = dirtiedRows.start(); r < dirtiedRows.end(); r++) {
-                const LayoutTableRow* row = m_layoutTableSection.rowLayoutObjectAt(r);
-                if (row && !row->hasSelfPaintingLayer())
-                    TableRowPainter(*row).paintOutlineForRowIfNeeded(paintInfo, paintOffset);
-                for (unsigned c = dirtiedColumns.start(); c < dirtiedColumns.end(); c++) {
-                    const LayoutTableSection::CellStruct& current = m_layoutTableSection.cellAt(r, c);
-                    if (!current.hasCells())
-                        continue;
-                    for (unsigned i = 0; i < current.cells.size(); ++i) {
-                        if (overflowingCells.contains(current.cells[i]))
-                            continue;
-
-                        if (current.cells[i]->rowSpan() > 1 || current.cells[i]->colSpan() > 1) {
-                            if (!spanningCells.add(current.cells[i]).isNewEntry)
-                                continue;
-                        }
-
-                        cells.append(current.cells[i]);
-                    }
-                }
-            }
-
-            // Sort the dirty cells by paint order.
-            if (!overflowingCells.size())
-                std::stable_sort(cells.begin(), cells.end(), compareCellPositions);
-            else
-                std::sort(cells.begin(), cells.end(), compareCellPositionsWithOverflowingCells);
-
-            if (paintInfo.phase == PaintPhaseCollapsedTableBorders) {
-                for (unsigned i = cells.size(); i > 0; --i) {
-                    LayoutPoint cellPoint = m_layoutTableSection.flipForWritingModeForChild(cells[i - 1], paintOffset);
-                    TableCellPainter(*cells[i - 1]).paintCollapsedBorders(paintInfo, cellPoint);
-                }
-            } else {
-                for (unsigned i = 0; i < cells.size(); ++i)
-                    paintCell(*cells[i], paintInfo, paintOffset);
-            }
-        }
+        for (unsigned i = 0; i < cells.size(); ++i)
+            paintCell(*cells[i], paintInfo, paintOffset);
     }
 }
 
 void TableSectionPainter::paintCell(const LayoutTableCell& cell, const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     LayoutPoint cellPoint = m_layoutTableSection.flipForWritingModeForChild(&cell, paintOffset);
     PaintPhase paintPhase = paintInfo.phase;
     const LayoutTableRow* row = toLayoutTableRow(cell.parent());
 
     if ((paintPhase == PaintPhaseBlockBackground || paintPhase == PaintPhaseChildBlockBackground)
@@ skipping 31 matching lines @@
                 if (rowHasBackground && !row->hasSelfPaintingLayer())
                     tableCellPainter.paintBackgroundsBehindCell(paintInfo, cellPoint, row);
             }
         }
     }
     if ((!cell.hasSelfPaintingLayer() && !row->hasSelfPaintingLayer()))
         cell.paint(paintInfo, cellPoint);
 }
 
 } // namespace blink