Fix table background painting

third_party/WebKit/Source/core/layout/LayoutTableCol.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, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 112 matching lines @@
     ASSERT(this->location() == LayoutPoint());
 
     LayoutRect r = table->visualOverflowRect();
     mapToVisibleRectInAncestorSpace(paintInvalidationContainer, r, paintInvalidationState);
     return r;
 }
 
 void LayoutTableCol::imageChanged(WrappedImagePtr, const IntRect*)
 {
     // FIXME: Issue paint invalidation of only the rect the image paints in.
+
     setShouldDoFullPaintInvalidation();
+    // This is atotic fix, but I have been unable to find test
+    // case that confirms it. Put it back in once test case is found
+    // Vector<LayoutTableCell*> cells = getColumnCells();
+    // for (auto c = cells.begin(); c != cells.end(); c++)
+    //     (*c)->setShouldDoFullPaintInvalidation();
 }
 
 void LayoutTableCol::clearPreferredLogicalWidthsDirtyBits()
 {
     clearPreferredLogicalWidthsDirty();
 
     for (LayoutObject* child = firstChild(); child; child = child->nextSibling())
         child->clearPreferredLogicalWidthsDirty();
 }
 
 LayoutTable* LayoutTableCol::table() const
 {
     LayoutObject* table = parent();
     if (table && !table->isTable())
         table = table->parent();
     return table && table->isTable() ? toLayoutTable(table) : nullptr;
 }
 
 LayoutTableCol* LayoutTableCol::enclosingColumnGroup() const
 {
     if (!parent()->isLayoutTableCol())
         return nullptr;
 
     LayoutTableCol* parentColumnGroup = toLayoutTableCol(parent());
     ASSERT(parentColumnGroup->isTableColumnGroup());
     ASSERT(isTableColumn());
     return parentColumnGroup;
 }
 
+
+LayoutTableCol* LayoutTableCol::lastColumnInGroup() const
+{
+    ASSERT(this->isTableColumnGroupWithColumnChildren());
+
+    LayoutTableCol* endCol = nullptr;
+    LayoutTableCol* currentCol = this->nextColumn();
+    // If column has children, traverse the children to find last.
+    if (this->firstChild()) {
+        while (currentCol && currentCol->enclosingColumnGroup() == this) {
+            endCol = currentCol;
+            currentCol = currentCol->nextColumn();
+        }
+    }
+    return endCol;
+}
+
 LayoutTableCol* LayoutTableCol::nextColumn() const
 {
     // If |this| is a column-group, the next column is the colgroup's first child column.
     if (LayoutObject* firstChild = this->firstChild())
         return toLayoutTableCol(firstChild);
 
     // Otherwise it's the next column along.
     LayoutObject* next = nextSibling();
 
     // Failing that, the child is the last column in a column-group, so the next column is the next column/column-group after its column-group.
-    if (!next && parent()->isLayoutTableCol())
-        next = parent()->nextSibling();
+
+    auto p = parent();
+    if (!next && p && p->isLayoutTableCol())
+        next = p->nextSibling();
 
     for (; next && !next->isLayoutTableCol(); next = next->nextSibling()) { }
 
     return toLayoutTableCol(next);
 }
 
 const BorderValue& LayoutTableCol::borderAdjoiningCellStartBorder(const LayoutTableCell*) const
 {
     return style()->borderStart();
 }
 
 const BorderValue& LayoutTableCol::borderAdjoiningCellEndBorder(const LayoutTableCell*) const
 {
     return style()->borderEnd();
 }
 
 const BorderValue& LayoutTableCol::borderAdjoiningCellBefore(const LayoutTableCell* cell) const
 {
     ASSERT_UNUSED(cell, table()->colElementAtAbsoluteColumn(cell->absoluteColumnIndex() + cell->colSpan()).innermostColOrColGroup() == this);
     return style()->borderStart();
 }
 
 const BorderValue& LayoutTableCol::borderAdjoiningCellAfter(const LayoutTableCell* cell) const
 {
     ASSERT_UNUSED(cell, table()->colElementAtAbsoluteColumn(cell->absoluteColumnIndex() - 1).innermostColOrColGroup() == this);
     return style()->borderEnd();
 }
 
+LayoutRect LayoutTableCol::positionByCellSpan(unsigned absoluteColumnIndex) const
+{
+    LayoutTable * table = this->table();
+    LayoutRect position;
+
+    if (!table)
+        return position;
+
+    LayoutTableSection* topSection = table->topNonEmptySection();
+    LayoutTableSection* bottomSection = table->bottomNonEmptySection();
+    if (!topSection || !bottomSection)
+        return position;
+
+    Vector<unsigned> colIndexes = getEffectiveColumnIndexes();
+
+    if (colIndexes.size() == 0)
+        return position;
+
+    unsigned startColumnIndex = colIndexes[0];
+    unsigned endColumnIndex = colIndexes.last();
+
+    // Tricky: if <col> has a span, we need to pick a <col> of width 1
+    // that starts at absoluteColumnIndex
+    if (isTableColumn() && colIndexes.size() > 1) {
+        unsigned wantedEffectiveColumn = table->absoluteColumnToEffectiveColumn(absoluteColumnIndex);
+        size_t wantedIt = colIndexes.find(wantedEffectiveColumn);
+        ASSERT(wantedIt != kNotFound);
+        startColumnIndex = colIndexes[wantedIt];
+        endColumnIndex = startColumnIndex;
+    }
+    position = topSection->getCellPhysicalPosition(0, startColumnIndex);
+    position.moveBy(topSection->location());
+    LayoutRect bottomPosition = bottomSection->getCellPhysicalPosition(bottomSection->numRows() - 1, endColumnIndex);
+    bottomPosition.moveBy(bottomSection->location());
+    position.uniteEvenIfEmpty(bottomPosition);
+    return position;
+}
+
+
+Vector<unsigned> LayoutTableCol::getEffectiveColumnIndexes() const
+{
+    LayoutTable * table = this->table();
+    Vector<unsigned> indexes;
+
+    if (!table)
+        return indexes;
+
+    unsigned lastEffectiveColumn = table->lastEffectiveColumnIndex();
+
+    if (isTableColumn()) {
+        unsigned idx = table->colElementToAbsoluteColumn(this);
+        auto span = this->span();
+        unsigned lastSeenColumn = 0xFFFFFFFF;
+        while (span--) {
+            unsigned effectiveColumn = table->absoluteColumnToEffectiveColumn(idx++);
+            if (effectiveColumn != lastSeenColumn && effectiveColumn <= lastEffectiveColumn) {
+                indexes.append(effectiveColumn);
+                lastSeenColumn = effectiveColumn;
+            }
+        }
+    } else { // isTableColumnGroup
+        if (isTableColumnGroupWithColumnChildren()) {
+            LayoutTableCol* currentCol = nullptr;
+            auto lastCol = lastColumnInGroup();
+            do {
+                currentCol = currentCol ? currentCol->nextColumn() : nextColumn();
+                if (currentCol) {
+                    auto colIndexes = currentCol->getEffectiveColumnIndexes();
+                    for (auto c = colIndexes.begin(); c != colIndexes.end(); c++)
+                        indexes.append(*c);
+                }
+            } while (currentCol && currentCol != lastCol);
+        } else { // tableColumnGroup with no children
+            // its covers span columns
+            unsigned idx = table->colElementToAbsoluteColumn(this);
+            auto span = this->span();
+            unsigned lastSeenColumn = 0xFFFFFFFF;
+            while (span--) {
+                unsigned effectiveColumn = table->absoluteColumnToEffectiveColumn(idx++);
+                if (effectiveColumn != lastSeenColumn && effectiveColumn <= lastEffectiveColumn) {
+                    indexes.append(effectiveColumn);
+                    lastSeenColumn = effectiveColumn;
+                }
+            }
+        }
+    }
+    return indexes;
+}
+
+// returns all cells inside a column
+Vector<LayoutTableCell*> LayoutTableCol::getColumnCells() const
+{
+    // enumerate all the columns we need
+    LayoutTable * myTable = table();
+    Vector<LayoutTableCell*> cells;
+
+    if (!myTable) // can't do this before table is laid out
+        return cells;
+
+    auto colIndexes = getEffectiveColumnIndexes();
+    auto section = myTable->topSection();
+    // Get all cells from all columns
+    while (section) {
+        for (auto c = colIndexes.begin(); c != colIndexes.end(); c++) {
+            for (unsigned r = 0; r < section->numRows(); r++)  {
+                LayoutTableCell * cell = section->primaryCellAt(r, *c);
+                if (cell && cell->hasSetAbsoluteColumnIndex() && cell->absoluteColumnIndex() == *c)
+                    cells.append(cell);
+            }
+        }
+        section = myTable->sectionBelow(section, SkipEmptySections);
+    }
+    return cells;
+}
+
 } // namespace blink