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 81 matching lines @@
     // explicit width is specified on the table. Auto width implies auto table
     // layout.
     if (style()->isFixedTableLayout())
       m_tableLayout = makeUnique<TableLayoutAlgorithmFixed>(this);
     else
       m_tableLayout = makeUnique<TableLayoutAlgorithmAuto>(this);
   }
 
   // If border was changed, invalidate collapsed borders cache.
   if (!needsLayout() && oldStyle && oldStyle->border() != style()->border())
-    invalidateCollapsedBorders();
+    invalidateCollapsedBorders(PaintInvalidationStyleChange);
+
   if (LayoutTableBoxComponent::doCellsHaveDirtyWidth(*this, *this, diff,
                                                      *oldStyle))
     markAllCellsWidthsDirtyAndOrNeedsLayout(MarkDirtyAndNeedsLayout);
 }
 
 static inline void resetSectionPointerIfNotBefore(LayoutTableSection*& ptr,
                                                   LayoutObject* before) {
   if (!before || !ptr)
     return;
   LayoutObject* o = before->previousSibling();
@@ skipping 612 matching lines @@
     updateLogicalHeight();
 
     // table can be containing block of positioned elements.
     bool dimensionChanged = oldLogicalWidth != logicalWidth() ||
                             oldLogicalHeight != logicalHeight();
     layoutPositionedObjects(dimensionChanged);
 
     updateLayerTransformAfterLayout();
 
     // Layout was changed, so probably borders too.
-    invalidateCollapsedBorders();
+    invalidateCollapsedBorders(PaintInvalidationForcedByLayout);

[wkorman, 2016/12/05 05:49:21]

I assume this, and the check for it in line 764, are the new bits?

[Xianzhu, 2016/12/05 17:28:54]

Yes. This ensures invalidation of collapsed borders on layout change.

 
     computeOverflow(clientLogicalBottom());
     updateAfterLayout();
 
     if (state.isPaginated() && isPageLogicalHeightKnown()) {
       m_blockOffsetToFirstRepeatableHeader = state.pageLogicalOffset(
           *this, topSection ? topSection->logicalTop() : LayoutUnit());
     }
   }
 
   // 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();
+void LayoutTable::invalidateCollapsedBorders(PaintInvalidationReason reason) {
+  DCHECK(reason == PaintInvalidationStyleChange ||
+         reason == PaintInvalidationForcedByLayout);
+
+  m_collapsedBordersInfo = nullptr;
   if (!collapseBorders())
     return;
 
   m_collapsedBordersValid = false;
-  setMayNeedPaintInvalidation();
+  if (reason == PaintInvalidationForcedByLayout)
+    setShouldDoFullPaintInvalidation(reason);
+  else
+    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;
+
+  LayoutRect boundsOfChangedCells;
+  Vector<CollapsedBorderValue> values;
   for (LayoutObject* section = firstChild(); section;
        section = section->nextSibling()) {
     if (!section->isTableSection())
       continue;
     for (LayoutTableRow* row = toLayoutTableSection(section)->firstRow(); row;
          row = row->nextRow()) {
       for (LayoutTableCell* cell = row->firstCell(); cell;
            cell = cell->nextCell()) {
-        ASSERT(cell->table() == this);
-        cell->collectBorderValues(m_collapsedBorders);
+        DCHECK(cell->table() == this);
+        if (cell->collectBorderValues(values) &&
+            !shouldDoFullPaintInvalidation()) {

[wkorman, 2016/12/05 05:49:21]

Do we potentially reduce a bit of work if we put shouldDoFullPaintInvalidation()
first? collectBorderValues does a bunch of stuff whereas
shouldDoFullPaintInvalidation just checks a bit.

[Xianzhu, 2016/12/05 17:28:54]

No. We should always do collectBorderValues().

Changed to
  bool cellCollapsedBorderChanged = cell->collectBorderValues(values);
  if (cellCollapsedBorderChanged && !shouldDoFullPaintInvalidation())...

+          LayoutRect cellRect = cell->localVisualRect();
+          cell->mapToVisualRectInAncestorSpace(this, cellRect);
+          boundsOfChangedCells.unite(cellRect);
+        }
       }
     }
   }
-  LayoutTableCell::sortBorderValues(m_collapsedBorders);
+  if (!values.isEmpty()) {
+    LayoutTableCell::sortBorderValues(values);
+    m_collapsedBordersInfo =
+        wrapUnique(new CollapsedBordersInfo(std::move(values)));
+  }
+
+  invalidatePaintRectangle(boundsOfChangedCells);
 }
 
 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