Use appropriate background object visual rect for composited table cell backgrounds.

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 28 matching lines @@
 #include "platform/geometry/TransformState.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 struct SameSizeAsLayoutTableCell : public LayoutBlockFlow {
   unsigned bitfields;
   int paddings[2];
-  void* pointer;
+  void* pointer1;
+  void* pointer2;
 };
 
 static_assert(sizeof(LayoutTableCell) == sizeof(SameSizeAsLayoutTableCell),
               "LayoutTableCell should stay small");
 static_assert(sizeof(CollapsedBorderValue) == 8,
               "CollapsedBorderValue should stay small");
 
 LayoutTableCell::LayoutTableCell(Element* element)
     : LayoutBlockFlow(element),
       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_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";
+LayoutTableCell::CompositedTableCell::CompositedTableCell(
+    const LayoutTable& layoutTable)
+    : m_layoutTable(layoutTable) {}
+
+String LayoutTableCell::CompositedTableCell::debugName() const {
+  return "CompositedTableCell";
 }
 
-LayoutRect LayoutTableCell::CollapsedBorderValues::visualRect() const {
+LayoutRect LayoutTableCell::CompositedTableCell::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.
@@ skipping 351 matching lines @@
   // The baseline of a cell is the baseline of the first in-flow line box in the
   // cell, or the first in-flow table-row in the cell, whichever comes first. If
   // there is no such line box or table-row, the baseline is the bottom of
   // content edge of the cell box.
   int firstLineBaseline = firstLineBoxBaseline();
   if (firstLineBaseline != -1)
     return firstLineBaseline;
   return (borderBefore() + paddingBefore() + contentLogicalHeight()).toInt();
 }
 
+void LayoutTableCell::ensureIsReadyForPaintInvalidation() {
+  if (usesTableAsAdditionalDisplayItemClient() && !m_compositedTableCell) {
+    m_compositedTableCell =
+        wrapUnique(new LayoutTableCell::CompositedTableCell(*table()));
+  }
+  LayoutBlockFlow::ensureIsReadyForPaintInvalidation();
+}
+
 void LayoutTableCell::styleDidChange(StyleDifference diff,
                                      const ComputedStyle* oldStyle) {
   DCHECK_EQ(style()->display(), EDisplay::TableCell);
 
   LayoutBlockFlow::styleDidChange(diff, oldStyle);
   setHasBoxDecorationBackground(true);
 
   if (parent() && section() && oldStyle &&
       style()->height() != oldStyle->height())
     section()->rowLogicalHeightChanged(row());
@@ skipping 812 matching lines @@
   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(),
+      computeCollapsedStartBorder(), computeCollapsedEndBorder(),
       computeCollapsedBeforeBorder(), computeCollapsedAfterBorder());
 
   bool changed = false;
   if (!newValues.startBorder().isVisible() &&
       !newValues.endBorder().isVisible() &&
       !newValues.beforeBorder().isVisible() &&
       !newValues.afterBorder().isVisible()) {
     changed = !!m_collapsedBorderValues;
     m_collapsedBorderValues = nullptr;
   } else if (!m_collapsedBorderValues) {
     changed = true;
     m_collapsedBorderValues = wrapUnique(new CollapsedBorderValues(
-        *table(), newValues.startBorder(), newValues.endBorder(),
+        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()) ||
@@ skipping 101 matching lines @@
 }
 
 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();
 }
 
+const LayoutTableCell::CompositedTableCell*
+LayoutTableCell::compositedTableCell() const {
+  return m_compositedTableCell.get();
+}
+
 void LayoutTableCell::invalidateDisplayItemClients(
     PaintInvalidationReason reason) const {
-  if (m_collapsedBorderValues && usesTableAsAdditionalDisplayItemClient()) {
+  if (usesTableAsAdditionalDisplayItemClient()) {

[wkorman, 2016/11/01 21:14:48]

Is it worth also making sure compositedTableCell() is not nullptr here? We
should know that it is per LayoutTableCell::ensureIsReadyForPaintInvalidation().
Could add DCHECK, open to thought.

[Xianzhu, 2016/11/01 21:28:14]

DCHECK sgtm.

[wkorman, 2016/11/03 01:41:25]

Done.

     ObjectPaintInvalidator(*this).invalidateDisplayItemClient(
-        *m_collapsedBorderValues, reason);
+        *compositedTableCell(), 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