Fix table background painting

third_party/WebKit/Source/core/paint/TableCellPainter.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/TableCellPainter.h"
 
 #include "core/layout/LayoutTableCell.h"
+#include "core/layout/LayoutTableCol.h"
 #include "core/paint/BlockPainter.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/PaintInfo.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 
 namespace blink {
 
 inline const CollapsedBorderValue* TableCellPainter::cachedCollapsedLeftBorder(const ComputedStyle& styleForCellFlow) const
 {
@@ skipping 115 matching lines @@
     if (displayItemType & DisplayItem::TableCollapsedBorderLeft) {
         ObjectPainter::drawLineForBoxSide(graphicsContext, borderRect.x(), borderRect.y(), borderRect.x() + leftWidth, borderRect.maxY(), BSLeft,
             leftBorderValue->color().resolve(cellColor), collapsedBorderStyle(leftBorderValue->style()), 0, 0, true);
     }
     if (displayItemType & DisplayItem::TableCollapsedBorderRight) {
         ObjectPainter::drawLineForBoxSide(graphicsContext, borderRect.maxX() - rightWidth, borderRect.y(), borderRect.maxX(), borderRect.maxY(), BSRight,
             rightBorderValue->color().resolve(cellColor), collapsedBorderStyle(rightBorderValue->style()), 0, 0, true);
     }
 }
 
-void TableCellPainter::paintBackgroundsBehindCell(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const LayoutObject* backgroundObject, DisplayItem::Type type)
+void TableCellPainter::paintBackgroundsBehindCell(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const LayoutBox* backgroundObject, DisplayItem::Type type)
 {
+    if (RuntimeEnabledFeatures::newTableCellBackgroundPaintingEnabled() && backgroundObject != &m_layoutTableCell) {
+        paintParentBackgroundsBehindCell(paintInfo, paintOffset, backgroundObject, type);
+        return;
+    }
+
     if (!backgroundObject)
         return;
 
     if (m_layoutTableCell.style()->visibility() != VISIBLE)
         return;
 
     LayoutTable* tableElt = m_layoutTableCell.table();
     if (!tableElt->collapseBorders() && m_layoutTableCell.style()->emptyCells() == EmptyCellsHide && !m_layoutTableCell.firstChild())
         return;
 
@@ skipping 18 matching lines @@
         GraphicsContextStateSaver stateSaver(paintInfo.context, shouldClip);
         if (shouldClip) {
             LayoutRect clipRect(paintRect.location(), m_layoutTableCell.size());
             clipRect.expand(m_layoutTableCell.borderInsets());
             paintInfo.context.clip(pixelSnappedIntRect(clipRect));
         }
         BoxPainter(m_layoutTableCell).paintFillLayers(paintInfo, c, bgLayer, paintRect, BackgroundBleedNone, SkXfermode::kSrcOver_Mode, backgroundObject);
     }
 }
 
+void TableCellPainter::paintParentBackgroundsBehindCell(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const LayoutBox* backgroundObject, DisplayItem::Type type)
+{
+    if (!backgroundObject)
+        return;
+
+    if (m_layoutTableCell.style()->visibility() != VISIBLE)
+        return;
+
+    LayoutTable* tableElt = m_layoutTableCell.table();
+    if (!tableElt->collapseBorders() && m_layoutTableCell.style()->emptyCells() == EmptyCellsHide && !m_layoutTableCell.firstChild())
+        return;
+
+    LayoutRect backgroundRect = paintBoundsParent(paintOffset, backgroundObject, type);
+
+    LayoutRect cellRect = m_layoutTableCell.frameRect();
+    cellRect.moveBy(paintOffset);
+
+    cellRect.setLocation(LayoutPoint(cellRect.pixelSnappedLocation()));
+    cellRect.setSize(LayoutSize(cellRect.pixelSnappedSize()));
+
+    // We paint background LTR, top->bottom.
+    // This makes code much simpler, but is not spec-conformant.
+    // The spec-conformant code would have to handle all writing-mode
+    // painting directions correctly.
+
+    if (backgroundRect.x() > cellRect.x())
+        backgroundRect.setX(cellRect.x());
+    if (backgroundRect.y() > cellRect.y())
+        backgroundRect.setY(cellRect.y());
+
+    Optional<LayoutObjectDrawingRecorder> recorder;
+    if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutTableCell, type)) {
+        return;
+    }
+    recorder.emplace(paintInfo.context, m_layoutTableCell, type, cellRect);
+
+    Color c = backgroundObject->resolveColor(CSSPropertyBackgroundColor);
+    const FillLayer& bgLayer = backgroundObject->style()->backgroundLayers();
+    FillLayer bgAdjustedLayer(bgLayer);
+
+    if (bgLayer.hasImage() || c.alpha()) {
+
+        GraphicsContextStateSaver stateSaver(paintInfo.context, true);
+        LayoutRect clipRect(m_layoutTableCell.location(), m_layoutTableCell.size());
+        clipRect.moveBy(paintOffset);
+        paintInfo.context.clip(pixelSnappedIntRect(clipRect));
+
+        // If cell is larger than background, we might have to paint multiple times.
+        LayoutUnit colExtraPixels = std::max(LayoutUnit(0), cellRect.maxX() - backgroundRect.maxX());
+        unsigned colRepeat = 1 + (colExtraPixels / backgroundRect.width()) + (colExtraPixels % backgroundRect.width() != 0);
+        LayoutUnit rowExtraPixels = std::max(LayoutUnit(0), cellRect.maxY() - backgroundRect.maxY());
+        unsigned rowRepeat = 1 + (rowExtraPixels / backgroundRect.height()) + (rowExtraPixels % backgroundRect.height() != 0);
+        for (unsigned row = 0; row < rowRepeat; row++) {
+            for (unsigned col = 0; col < colRepeat; col++) {
+                LayoutRect paintRect = backgroundRect;
+                paintRect.move(col * paintRect.width(), row * paintRect.height());
+                BoxPainter(*backgroundObject).paintFillLayers(paintInfo, c, bgLayer, paintRect, BackgroundBleedNone, SkXfermode::kSrcOver_Mode, backgroundObject);
+            }
+        }
+    }
+}
+
 void TableCellPainter::paintBoxDecorationBackground(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     LayoutTable* table = m_layoutTableCell.table();
     if (!table->collapseBorders() && m_layoutTableCell.style()->emptyCells() == EmptyCellsHide && !m_layoutTableCell.firstChild())
         return;
 
     bool needsToPaintBorder = m_layoutTableCell.styleRef().hasBorderDecoration() && !table->collapseBorders();
     if (!m_layoutTableCell.hasBackground() && !m_layoutTableCell.styleRef().boxShadow() && !needsToPaintBorder)
         return;
 
@@ skipping 38 matching lines @@
 }
 
 LayoutRect TableCellPainter::paintBounds(const LayoutPoint& paintOffset, PaintBoundOffsetBehavior paintBoundOffsetBehavior)
 {
     LayoutPoint adjustedPaintOffset = paintOffset;
     if (paintBoundOffsetBehavior == AddOffsetFromParent)
         adjustedPaintOffset.moveBy(m_layoutTableCell.location());
     return LayoutRect(adjustedPaintOffset, LayoutSize(m_layoutTableCell.pixelSnappedSize()));
 }
 
+LayoutRect TableCellPainter::paintBoundsParent(const LayoutPoint& paintOffset, const LayoutBox* backgroundObject, DisplayItem::Type type)
+{
+    LayoutRect position;
+    switch (type) {
+    case DisplayItem::TableCellBackgroundFromColumnGroup:
+    case DisplayItem::TableCellBackgroundFromColumn:
+        {
+        position = static_cast<const LayoutTableCol*>(backgroundObject)->positionByCellSpan(
+            m_layoutTableCell.absoluteColumnIndex());
+        // position is relative to table, must correct for section location
+        LayoutPoint sectionLocation = m_layoutTableCell.section()->location();
+        position.moveBy(-sectionLocation);
+        position.moveBy(paintOffset);
+        }
+        break;
+    case DisplayItem::TableCellBackgroundFromSection:
+        position = static_cast<const LayoutTableSection*>(backgroundObject)->positionByCellSpan();
+        position.moveBy(paintOffset);
+        break;
+    case DisplayItem::TableCellBackgroundFromRow:
+        position = static_cast<const LayoutTableRow*>(backgroundObject)->positionByCellSpan();
+        position.moveBy(paintOffset);
+        break;
+    case DisplayItem::BoxDecorationBackground: {
+        LayoutPoint adjustedPaintOffset = paintOffset;
+        adjustedPaintOffset.moveBy(m_layoutTableCell.location());
+        position =  LayoutRect(adjustedPaintOffset, LayoutSize(m_layoutTableCell.pixelSnappedSize()));
+        }
+        break;
+    default:
+        ASSERT(false);
+        break;
+    }
+    return LayoutRect(position.pixelSnappedLocation(), position.pixelSnappedSize());
+}
+
 } // namespace blink