Paint collapsed borders of a table as one display item

third_party/WebKit/Source/core/layout/LayoutTableCell.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 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 48 matching lines @@
       m_absoluteColumnIndex(unsetColumnIndex),
       m_cellWidthChanged(false),
       m_intrinsicPaddingBefore(0),
       m_intrinsicPaddingAfter(0) {
   // We only update the flags when notified of DOM changes in
   // colSpanOrRowSpanChanged() so we need to set their initial values here in
   // case something asks for colSpan()/rowSpan() before then.
   updateColAndRowSpanFlags();
 }
 
-LayoutTableCell::CollapsedBorderValues::CollapsedBorderValues(
-    const LayoutTable& layoutTable,
-    const CollapsedBorderValue& startBorder,
-    const CollapsedBorderValue& endBorder,
-    const CollapsedBorderValue& beforeBorder,
-    const CollapsedBorderValue& afterBorder)
-    : m_layoutTable(layoutTable),
-      m_startBorder(startBorder),
-      m_endBorder(endBorder),
-      m_beforeBorder(beforeBorder),
-      m_afterBorder(afterBorder) {}
-
-void LayoutTableCell::CollapsedBorderValues::setCollapsedBorderValues(
-    const CollapsedBorderValues& other) {
-  m_startBorder = other.startBorder();
-  m_endBorder = other.endBorder();
-  m_beforeBorder = other.beforeBorder();
-  m_afterBorder = other.afterBorder();
-}
-
-String LayoutTableCell::CollapsedBorderValues::debugName() const {
-  return "CollapsedBorderValues";
-}
-
-LayoutRect LayoutTableCell::CollapsedBorderValues::visualRect() const {
-  return m_layoutTable.visualRect();
-}
-
 void LayoutTableCell::willBeRemovedFromTree() {
   LayoutBlockFlow::willBeRemovedFromTree();
 
   section()->setNeedsCellRecalc();
 
   // When borders collapse, removing a cell can affect the the width of
   // neighboring cells.
   LayoutTable* enclosingTable = table();
   DCHECK(enclosingTable);
   if (!enclosingTable->collapseBorders())
@@ skipping 1166 matching lines @@
                                                                        : 0)) /
            2;
   return 0;
 }
 
 void LayoutTableCell::paint(const PaintInfo& paintInfo,
                             const LayoutPoint& paintOffset) const {
   TableCellPainter(*this).paint(paintInfo, paintOffset);
 }
 
-static void addBorderStyle(LayoutTable::CollapsedBorderValues& borderValues,
+static void addBorderStyle(Vector<CollapsedBorderValue>& borderValues,
                            CollapsedBorderValue borderValue) {
   if (!borderValue.isVisible())
     return;
   size_t count = borderValues.size();
   for (size_t i = 0; i < count; ++i) {
     if (borderValues[i].isSameIgnoringColor(borderValue))
       return;
   }
   borderValues.append(borderValue);
 }
 
 void LayoutTableCell::collectBorderValues(
-    LayoutTable::CollapsedBorderValues& borderValues) {
-  CollapsedBorderValues newValues(
-      *table(), computeCollapsedStartBorder(), computeCollapsedEndBorder(),
-      computeCollapsedBeforeBorder(), computeCollapsedAfterBorder());
+    Vector<CollapsedBorderValue>& borderValues) {
+  CollapsedBorderValues newValues = {
+      computeCollapsedStartBorder(), computeCollapsedEndBorder(),
+      computeCollapsedBeforeBorder(), computeCollapsedAfterBorder()};
 
-  bool changed = false;
-  if (!newValues.startBorder().isVisible() &&
-      !newValues.endBorder().isVisible() &&
-      !newValues.beforeBorder().isVisible() &&
-      !newValues.afterBorder().isVisible()) {
-    changed = !!m_collapsedBorderValues;
+  if (!newValues.startBorder.isVisible() && !newValues.endBorder.isVisible() &&
+      !newValues.beforeBorder.isVisible() && !newValues.afterBorder.isVisible())
     m_collapsedBorderValues = nullptr;
-  } else if (!m_collapsedBorderValues) {
-    changed = true;
-    m_collapsedBorderValues = wrapUnique(new CollapsedBorderValues(
-        *table(), newValues.startBorder(), newValues.endBorder(),
-        newValues.beforeBorder(), newValues.afterBorder()));
-  } else {
-    // We check visuallyEquals so that the table cell is invalidated only if a
-    // changed collapsed border is visible in the first place.
-    changed = !m_collapsedBorderValues->startBorder().visuallyEquals(
-                  newValues.startBorder()) ||
-              !m_collapsedBorderValues->endBorder().visuallyEquals(
-                  newValues.endBorder()) ||
-              !m_collapsedBorderValues->beforeBorder().visuallyEquals(
-                  newValues.beforeBorder()) ||
-              !m_collapsedBorderValues->afterBorder().visuallyEquals(
-                  newValues.afterBorder());
-    if (changed)
-      m_collapsedBorderValues->setCollapsedBorderValues(newValues);
-  }
+  else if (!m_collapsedBorderValues)
+    m_collapsedBorderValues = wrapUnique(new CollapsedBorderValues(newValues));
+  else
+    *m_collapsedBorderValues = newValues;
 
-  // If collapsed borders changed, invalidate the cell's display item client on
-  // the table's backing.
-  // TODO(crbug.com/451090#c5): Need a way to invalidate/repaint the borders
-  // only.
-  if (changed)
-    ObjectPaintInvalidator(*table())
-        .slowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
-            *this, PaintInvalidationStyleChange);
-
-  addBorderStyle(borderValues, newValues.startBorder());
-  addBorderStyle(borderValues, newValues.endBorder());
-  addBorderStyle(borderValues, newValues.beforeBorder());
-  addBorderStyle(borderValues, newValues.afterBorder());
+  addBorderStyle(borderValues, newValues.startBorder);
+  addBorderStyle(borderValues, newValues.endBorder);
+  addBorderStyle(borderValues, newValues.beforeBorder);
+  addBorderStyle(borderValues, newValues.afterBorder);
 }
 
 void LayoutTableCell::sortBorderValues(
-    LayoutTable::CollapsedBorderValues& borderValues) {
+    Vector<CollapsedBorderValue>& borderValues) {
   std::sort(borderValues.begin(), borderValues.end(), compareBorders);
 }
 
 void LayoutTableCell::paintBoxDecorationBackground(
     const PaintInfo& paintInfo,
     const LayoutPoint& paintOffset) const {
   TableCellPainter(*this).paintBoxDecorationBackground(paintInfo, paintOffset);
 }
 
 void LayoutTableCell::paintMask(const PaintInfo& paintInfo,
@@ skipping 60 matching lines @@
 bool LayoutTableCell::backgroundIsKnownToBeOpaqueInRect(
     const LayoutRect& localRect) const {
   // If this object has layer, the area of collapsed borders should be
   // transparent to expose the collapsed borders painted on the underlying
   // layer.
   if (hasLayer() && table()->collapseBorders())
     return false;
   return LayoutBlockFlow::backgroundIsKnownToBeOpaqueInRect(localRect);
 }
 
-bool LayoutTableCell::usesTableAsAdditionalDisplayItemClient() const {
-  // In certain cases such as collapsed borders for composited table cells we
-  // paint content for the cell into the table graphics layer backing and so
-  // must use the table's visual rect.
-  return (hasLayer() && layer()->compositingState() != NotComposited) ||
-         RuntimeEnabledFeatures::slimmingPaintV2Enabled();
-}
-
-void LayoutTableCell::invalidateDisplayItemClients(
-    PaintInvalidationReason reason) const {
-  if (m_collapsedBorderValues && usesTableAsAdditionalDisplayItemClient()) {
-    ObjectPaintInvalidator(*this).invalidateDisplayItemClient(
-        *m_collapsedBorderValues, reason);
-  }
-  LayoutBlockFlow::invalidateDisplayItemClients(reason);
-}
-
 // TODO(lunalu): Deliberately dump the "inner" box of table cells, since that
 // is what current results reflect.  We'd like to clean up the results to dump
 // both the outer box and the intrinsic padding so that both bits of information
 // are captured by the results.
 LayoutRect LayoutTableCell::debugRect() const {
   LayoutRect rect = LayoutRect(
       location().x(), location().y() + intrinsicPaddingBefore(), size().width(),
       size().height() - intrinsicPaddingBefore() - intrinsicPaddingAfter());
 
   LayoutBlock* cb = containingBlock();
   if (cb)
     cb->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 void LayoutTableCell::adjustChildDebugRect(LayoutRect& r) const {
   r.move(0, -intrinsicPaddingBefore());
 }
 
 }  // namespace blink