Fix spanning cell painting background from wrong row

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) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 88 matching lines @@
 LayoutTableSection::LayoutTableSection(Element* element)
     : LayoutTableBoxComponent(element),
       m_cCol(0),
       m_cRow(0),
       m_outerBorderStart(0),
       m_outerBorderEnd(0),
       m_outerBorderBefore(0),
       m_outerBorderAfter(0),
       m_needsCellRecalc(false),
       m_forceSlowPaintPathWithOverflowingCell(false),
-      m_hasMultipleCellLevels(false) {
+      m_hasMultipleCellLevels(false),
+      m_hasSpanningCells(false) {
   // init LayoutObject attributes
   setInline(false);  // our object is not Inline
 }
 
 LayoutTableSection::~LayoutTableSection() {}
 
 void LayoutTableSection::styleDidChange(StyleDifference diff,
                                         const ComputedStyle* oldStyle) {
   DCHECK(style()->display() == EDisplay::kTableFooterGroup ||
          style()->display() == EDisplay::kTableRowGroup ||
@@ skipping 120 matching lines @@
 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.
   if (needsCellRecalc())
     return;
 
   unsigned rSpan = cell->rowSpan();
   unsigned cSpan = cell->colSpan();
+  if (rSpan > 1 || cSpan > 1)
+    m_hasSpanningCells = true;
+
   const Vector<LayoutTable::ColumnStruct>& columns =
       table()->effectiveColumns();
   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:
   // <TABLE border>
   // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4
   // <TR><TD colspan="2">5
@@ skipping 1279 matching lines @@
   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());
+  if (!m_hasSpanningCells || !coveredRows.start() ||
+      coveredRows.start() >= m_grid.size())
+    return coveredRows;
 
-  return coveredRows;
+  // If there are any cells spanning into the first row, expand coveredRows
+  // to cover the primary cells.
+  unsigned nCols = numCols(coveredRows.start());
+  unsigned smallestRow = coveredRows.start();
+  CellSpan coveredColumns = spannedEffectiveColumns(damageRect);
+  for (unsigned c = coveredColumns.start();
+       c < std::min(coveredColumns.end(), nCols); ++c) {
+    if (const auto* cell = primaryCellAt(coveredRows.start(), c)) {
+      smallestRow = std::min(smallestRow, cell->rowIndex());
+      if (!smallestRow)
+        break;
+    }
+  }
+  return CellSpan(smallestRow, coveredRows.end());
 }
 
 CellSpan LayoutTableSection::dirtiedEffectiveColumns(
     const LayoutRect& damageRect) const {
   if (m_forceSlowPaintPathWithOverflowingCell)
     return fullTableEffectiveColumnSpan();
 
   CHECK(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.
   CHECK_LT(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());
+  if (!m_hasSpanningCells || !coveredColumns.start())
+    return coveredColumns;
 
-  return coveredColumns;
+  // If there are any cells spanning into the first column, expand
+  // coveredRows to cover the primary cells.
+  unsigned smallestColumn = coveredColumns.start();
+  CellSpan coveredRows = spannedRows(damageRect);
+  for (unsigned r = coveredRows.start(); r < coveredRows.end(); ++r) {
+    const auto& row = m_grid[r].row;
+    if (coveredColumns.start() < row.size()) {
+      unsigned c = coveredColumns.start();
+      while (c && row[c].inColSpan)
+        --c;
+      smallestColumn = std::min(c, smallestColumn);
+      if (!smallestColumn)
+        break;
+    }
+  }
+  return CellSpan(smallestColumn, coveredColumns.end());
 }
 
 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())
@@ skipping 136 matching lines @@
   return primaryCellAt(0, adjoiningStartCellColumnIndex);
 }
 
 const LayoutTableCell* LayoutTableSection::firstRowCellAdjoiningTableEnd()
     const {
   unsigned adjoiningEndCellColumnIndex =
       hasSameDirectionAs(table()) ? table()->lastEffectiveColumnIndex() : 0;
   return primaryCellAt(0, adjoiningEndCellColumnIndex);
 }
 
+const LayoutTableCell* LayoutTableSection::originatingCellAt(
+    unsigned row,
+    unsigned effectiveColumn) const {
+  const auto& rowVector = m_grid[row].row;
+  if (effectiveColumn >= rowVector.size())
+    return nullptr;
+  const auto& cellStruct = rowVector[effectiveColumn];
+  if (cellStruct.inColSpan)
+    return nullptr;
+  if (const auto* cell = cellStruct.primaryCell()) {
+    if (cell->rowIndex() == row)
+      return cell;
+  }
+  return nullptr;
+}
+
 void LayoutTableSection::appendEffectiveColumn(unsigned pos) {
   ASSERT(!m_needsCellRecalc);
 
   for (unsigned row = 0; row < m_grid.size(); ++row)
     m_grid[row].row.resize(pos + 1);
 }
 
 void LayoutTableSection::splitEffectiveColumn(unsigned pos, unsigned first) {
   ASSERT(!m_needsCellRecalc);
 
@@ skipping 335 matching lines @@
     transformState.flatten();
     FloatRect rect = transformState.lastPlanarQuad().boundingBox();
     rect.setHeight(table()->logicalHeight());
     transformState.setQuad(FloatQuad(rect));
   }
   return LayoutTableBoxComponent::mapToVisualRectInAncestorSpaceInternal(
       ancestor, transformState, flags);
 }
 
 }  // namespace blink