Mark when we may have been invalidated to early out on repaintTreeAfterLayout.

Source/core/rendering/RenderTableSection.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 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 713 matching lines @@
 
     return m_rowPos[m_grid.size()];
 }
 
 void RenderTableSection::layout()
 {
     ASSERT(needsLayout());
     ASSERT(!needsCellRecalc());
     ASSERT(!table()->needsSectionRecalc());
 
+    setMayNeedInvalidation(true);
+
     // 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();
 
     LayoutStateMaintainer statePusher(*this, locationOffset());
 
     const Vector<int>& columnPos = table()->columnPositions();
 
     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.
         for (unsigned startColumn = 0; startColumn < cols; ++startColumn) {
             CellStruct& current = row[startColumn];
             RenderTableCell* cell = current.primaryCell();
             if (!cell || current.inColSpan)
                 continue;
 
+            cell->setMayNeedInvalidation(true);
+
             unsigned endCol = startColumn;
             unsigned cspan = cell->colSpan();
             while (cspan && endCol < cols) {
                 ASSERT(endCol < table()->columns().size());
                 cspan -= table()->columns()[endCol].span;
                 endCol++;
             }
             int tableLayoutLogicalWidth = columnPos[endCol] - columnPos[startColumn] - table()->hBorderSpacing();
             cell->setCellLogicalWidth(tableLayoutLogicalWidth, layouter);
         }
@@ skipping 143 matching lines @@
 
         int rowHeightIncreaseForPagination = 0;
 
         for (unsigned c = 0; c < nEffCols; c++) {
             CellStruct& cs = cellAt(r, c);
             RenderTableCell* cell = cs.primaryCell();
 
             if (!cell || cs.inColSpan)
                 continue;
 
+            cell->setMayNeedInvalidation(true);
+
             int rowIndex = cell->rowIndex();
             int rHeight = m_rowPos[rowIndex + cell->rowSpan()] - m_rowPos[rowIndex] - vspacing;
 
             // 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
             // strict mode, Mozilla and WinIE both regrow the table to accommodate the
             // new height of the cell (thus letting the percentages cause growth one
@@ skipping 804 matching lines @@
     else
         cellLocation.setX(table()->columnPositions()[effectiveColumn] + horizontalBorderSpacing);
 
     cell->setLogicalLocation(cellLocation);
 
     if (!RuntimeEnabledFeatures::repaintAfterLayoutEnabled())
         view()->addLayoutDelta(oldCellLocation - cell->location());
 }
 
 } // namespace WebCore