Paint collapsed borders of a table as one display item

third_party/WebKit/Source/core/layout/LayoutTable.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, 2007, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 734 matching lines @@
 
   // FIXME: This value isn't the intrinsic content logical height, but we need
   // to update the value as its used by flexbox layout. crbug.com/367324
   setIntrinsicContentLogicalHeight(contentLogicalHeight());
 
   m_columnLogicalWidthChanged = false;
   clearNeedsLayout();
 }
 
 void LayoutTable::invalidateCollapsedBorders() {
-  m_collapsedBorders.clear();
+  m_collapsedBordersInfo = nullptr;
   if (!collapseBorders())
     return;
 
   m_collapsedBordersValid = false;
   setMayNeedPaintInvalidation();
 }
 
 // Collect all the unique border values that we want to paint in a sorted list.
 // During the collection, each cell saves its recalculated borders into the
 // cache of its containing section, and invalidates itself if any border
 // changes. This method doesn't affect layout.
 void LayoutTable::recalcCollapsedBordersIfNeeded() {
-  if (m_collapsedBordersValid || !collapseBorders())
+  if (m_collapsedBordersValid)
     return;
   m_collapsedBordersValid = true;
-  m_collapsedBorders.clear();
+  m_collapsedBordersInfo = nullptr;
+  if (!collapseBorders())
+    return;
+
+  // This records if any cell changed collapsed border and the cell is on a
+  // composited layer of the cell itself, the row or the section.
+  bool changedWithChildCompositedLayers = false;
+
+  Vector<CollapsedBorderValue> values;
   for (LayoutObject* section = firstChild(); section;
        section = section->nextSibling()) {
     if (!section->isTableSection())
       continue;
+    bool sectionChanged = false;
     for (LayoutTableRow* row = toLayoutTableSection(section)->firstRow(); row;
          row = row->nextRow()) {
+      bool rowChanged = false;
       for (LayoutTableCell* cell = row->firstCell(); cell;
            cell = cell->nextCell()) {
         ASSERT(cell->table() == this);
-        cell->collectBorderValues(m_collapsedBorders);
+        bool cellChanged = cell->collectBorderValues(values);
+        rowChanged |= cellChanged;
+        sectionChanged |= cellChanged;
+        changedWithChildCompositedLayers |=
+            cellChanged && cell->isPaintInvalidationContainer();
       }
+      changedWithChildCompositedLayers |=
+          rowChanged && row->isPaintInvalidationContainer();
     }
+    changedWithChildCompositedLayers |=
+        sectionChanged && section->isPaintInvalidationContainer();
   }
-  LayoutTableCell::sortBorderValues(m_collapsedBorders);
+  if (!values.isEmpty()) {
+    LayoutTableCell::sortBorderValues(values);
+    m_collapsedBordersInfo =
+        wrapUnique(new CollapsedBordersInfo(std::move(values)));
+  }
+
+  if (shouldDoFullPaintInvalidation())
+    return;
+
+  // All collapsed borders are painted on the table's composited layer.
+  // If there is no changed collapsed borders on child composited layer, the
+  // changed cells should have already set paint invalidation flags because of
+  // layout or style change that affected collapsed borders, and their paint
+  // invalidation will invalidate the rects of the cells on the table's layer.
+  // Otherwise we conservatively mark the whole table as needing paint
+  // invalidation to cover any changed cells on the table's composited layer.
+  if (changedWithChildCompositedLayers) {

[chrishtr, 2016/11/11 19:18:01]

How about using invalidatePaintRectangle of the union of the affected cells? We
will
need to make paint rectangle invalidation work for SPv2, for at least the use
case of
HTMLCanvas.

[Xianzhu, 2016/11/11 20:09:30]

Done.

The new patch issues redundant rectangle paint invalidations for the table and
cells (existing, caused by style change) when there is no composited layers
within the table. The extra cost should be trivial, and this seems the best for
code clarity and SPv2.

+    setShouldDoFullPaintInvalidation();
+  } else if (!shouldDoFullPaintInvalidation()) {
+    ObjectPaintInvalidator(*this)
+        .slowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
+            *this, PaintInvalidationStyleChange);
+  }
 }
 
 void LayoutTable::addOverflowFromChildren() {
   // Add overflow from borders.
   // Technically it's odd that we are incorporating the borders into layout
   // overflow, which is only supposed to be about overflow from our
   // descendant objects, but since tables don't support overflow:auto, this
   // works out fine.
   if (collapseBorders()) {
     int rightBorderOverflow =
@@ skipping 859 matching lines @@
   return style()->borderStart();
 }
 
 void LayoutTable::ensureIsReadyForPaintInvalidation() {
   LayoutBlock::ensureIsReadyForPaintInvalidation();
   recalcCollapsedBordersIfNeeded();
 }
 
 PaintInvalidationReason LayoutTable::invalidatePaintIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
-  if (collapseBorders() && !m_collapsedBorders.isEmpty())
+  if (hasCollapsedBorders()) {
     paintInvalidationState.paintingLayer()
         .setNeedsPaintPhaseDescendantBlockBackgrounds();
-
+  }
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 PaintInvalidationReason LayoutTable::invalidatePaintIfNeeded(
     const PaintInvalidatorContext& context) const {
   return TablePaintInvalidator(*this, context).invalidatePaintIfNeeded();
 }
 
 LayoutUnit LayoutTable::paddingTop() const {
   if (collapseBorders())
@@ skipping 17 matching lines @@
 }
 
 LayoutUnit LayoutTable::paddingRight() const {
   if (collapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::paddingRight();
 }
 
 }  // namespace blink