Fix painting background for composited table cells in a non-composited row.

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
  * modify it under the terms of the GNU Library General Public
@@ skipping 27 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),
@@ skipping 377 matching lines @@
 int LayoutTableCell::cellBaselinePosition() const {
   // <http://www.w3.org/TR/2007/CR-CSS21-20070719/tables.html#height-layout>: 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() {
+  LayoutBlockFlow::ensureIsReadyForPaintInvalidation();
+  if (!usesCompositedCellDisplayItemClients())
+    return;
+  if (!m_rowBackgroundDisplayItemClient) {
+    m_rowBackgroundDisplayItemClient =
+        wrapUnique(new LayoutTableCell::RowBackgroundDisplayItemClient(*row()));
+  }
+}
+
 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 21 matching lines @@
       previousCell()->setPreferredLogicalWidthsDirty(MarkOnlyThis);
     }
     if (nextCell()) {
       // TODO(dgrogan) Add a layout test showing that setChildNeedsLayout is needed instead of setNeedsLayout.
       nextCell()->setChildNeedsLayout();
       nextCell()->setPreferredLogicalWidthsDirty(MarkOnlyThis);
     }
   }
 }
 
-// The following rules apply for resolving conflicts and figuring out which border
-// to use.
-// (1) Borders with the 'border-style' of 'hidden' take precedence over all other conflicting
-// borders. Any border with this value suppresses all borders at this location.
-// (2) Borders with a style of 'none' have the lowest priority. Only if the border properties of all
-// the elements meeting at this edge are 'none' will the border be omitted (but note that 'none' is
-// the default value for the border style.)
-// (3) If none of the styles are 'hidden' and at least one of them is not 'none', then narrow borders
-// are discarded in favor of wider ones. If several have the same 'border-width' then styles are preferred
-// in this order: 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset', 'groove', and the lowest: 'inset'.
-// (4) If border styles differ only in color, then a style set on a cell wins over one on a row,
-// which wins over a row group, column, column group and, lastly, table. It is undefined which color
-// is used when two elements of the same type disagree.
+LayoutTableCell::RowBackgroundDisplayItemClient::RowBackgroundDisplayItemClient(
+    const LayoutTableRow& layoutTableRow)
+    : m_layoutTableRow(layoutTableRow) {}
+
+String LayoutTableCell::RowBackgroundDisplayItemClient::debugName() const {
+  return "RowBackground";
+}
+
+LayoutRect LayoutTableCell::RowBackgroundDisplayItemClient::visualRect() const {
+  return m_layoutTableRow.visualRect();
+}
+
+// The following rules apply for resolving conflicts and figuring out which
+// border to use.
+// (1) Borders with the 'border-style' of 'hidden' take precedence over all
+//     other conflicting borders. Any border with this value suppresses all
+//     borders at this location.
+// (2) Borders with a style of 'none' have the lowest priority. Only if the
+//     border properties of all the elements meeting at this edge are 'none'
+//     will the border be omitted (but note that 'none' is the default value for
+//     the border style.)
+// (3) If none of the styles are 'hidden' and at least one of them is not
+//     'none', then narrow borders are discarded in favor of wider ones. If
+//      several have the same 'border-width' then styles are preferred in this
+//      order: 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset',
+//     'groove', and the lowest: 'inset'.
+// (4) If border styles differ only in color, then a style set on a cell wins
+//     over one on a row, which wins over a row group, column, column group and,
+//     lastly, table. It is undefined which color is used when two elements of
+//     the same type disagree.
 static bool compareBorders(const CollapsedBorderValue& border1,
                            const CollapsedBorderValue& border2) {
   // Sanity check the values passed in. The null border have lowest priority.
   if (!border2.exists())
     return false;
   if (!border1.exists())
     return true;
 
   // Rule #1 above.
   if (border1.style() == BorderStyleHidden)
@@ skipping 858 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 {
+bool LayoutTableCell::usesCompositedCellDisplayItemClients() 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);
+
+  if (!usesCompositedCellDisplayItemClients())
+    return;
+
+  ObjectPaintInvalidator invalidator(*this);
+  if (m_collapsedBorderValues)
+    invalidator.invalidateDisplayItemClient(*m_collapsedBorderValues, reason);
+  if (m_rowBackgroundDisplayItemClient) {
+    invalidator.invalidateDisplayItemClient(*m_rowBackgroundDisplayItemClient,
+                                            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