Paint backgrounds of a table section/row in one display item

third_party/WebKit/Source/core/layout/LayoutTableSection.h

 /*
  * 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, 2009, 2013 Apple Inc. All rights
  * reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 39 matching lines @@
   void decreaseStart() { --m_start; }
   void increaseEnd() { ++m_end; }
 
   void ensureConsistency(const unsigned);
 
  private:
   unsigned m_start;
   unsigned m_end;
 };
 
+inline bool operator==(const CellSpan& s1, const CellSpan& s2) {
+  return s1.start() == s2.start() && s1.end() == s2.end();
+}
+inline bool operator!=(const CellSpan& s1, const CellSpan& s2) {
+  return !(s1 == s2);
+}
+
 class LayoutTableCell;
 class LayoutTableRow;
 
 // LayoutTableSection is used to represent table row group (display:
 // table-row-group), header group (display: table-header-group) and footer group
 // (display: table-footer-group).
 //
 // The object holds the internal representation of the rows (m_grid). See
 // recalcCells() below for some extra explanation.
 //
@@ skipping 235 matching lines @@
 
   // Flip the rect so it aligns with the coordinates used by the rowPos and
   // columnPos vectors.
   LayoutRect logicalRectForWritingModeAndDirection(const LayoutRect&) const;
 
   // Returns a row or column span covering all grid slots from each of which
   // a primary cell intersecting |visualRect| originates.
   CellSpan dirtiedRows(const LayoutRect& visualRect) const;
   CellSpan dirtiedEffectiveColumns(const LayoutRect& visualRect) const;
 
-  const HashSet<LayoutTableCell*>& overflowingCells() const {
+  const HashSet<const LayoutTableCell*>& overflowingCells() const {
     return m_overflowingCells;
   }
   bool hasMultipleCellLevels() const { return m_hasMultipleCellLevels; }
 
   const char* name() const override { return "LayoutTableSection"; }
 
   // Whether a section has opaque background depends on many factors, e.g.
   // border spacing, border collapsing, missing cells, etc. For simplicity,
   // just conservatively assume all table sections are not opaque.
   bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect&,
                                          unsigned) const override {
     return false;
   }
   bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const override {
     return false;
   }
 
   int paginationStrutForRow(LayoutTableRow*, LayoutUnit logicalOffset) const;
 
   bool mapToVisualRectInAncestorSpaceInternal(
       const LayoutBoxModelObject* ancestor,
       TransformState&,
       VisualRectFlags = DefaultVisualRectFlags) const override;
 
   bool isRepeatingHeaderGroup() const;
 
   void layout() override;
 
+  CellSpan fullSectionRowSpan() const { return CellSpan(0, m_grid.size()); }
+  CellSpan fullTableEffectiveColumnSpan() const {
+    return CellSpan(0, table()->numEffectiveColumns());
+  }
+
  protected:
   void styleDidChange(StyleDifference, const ComputedStyle* oldStyle) override;
   bool nodeAtPoint(HitTestResult&,
                    const HitTestLocation& locationInContainer,
                    const LayoutPoint& accumulatedOffset,
                    HitTestAction) override;
 
  private:
   bool isOfType(LayoutObjectType type) const override {
     return type == LayoutObjectTableSection || LayoutBox::isOfType(type);
@@ skipping 55 matching lines @@
   void updateBaselineForCell(LayoutTableCell*,
                              unsigned row,
                              int& baselineDescent);
 
   bool hasOverflowingCell() const {
     return m_overflowingCells.size() || m_forceSlowPaintPathWithOverflowingCell;
   }
 
   void computeOverflowFromCells(unsigned totalRows, unsigned nEffCols);
 
-  CellSpan fullTableRowSpan() const { return CellSpan(0, m_grid.size()); }
-  CellSpan fullTableEffectiveColumnSpan() const {
-    return CellSpan(0, table()->numEffectiveColumns());
-  }
-
   // These two functions take a rectangle as input that has been flipped by
   // logicalRectForWritingModeAndDirection.
   // The returned span of rows or columns is end-exclusive, and empty if
   // start==end.
   CellSpan spannedRows(const LayoutRect& flippedRect) const;
   CellSpan spannedEffectiveColumns(const LayoutRect& flippedRect) const;
 
   void setLogicalPositionForCell(LayoutTableCell*,
                                  unsigned effectiveColumn) const;
 
   void relayoutCellIfFlexed(LayoutTableCell&, int rowIndex, int rowHeight);
 
   int logicalHeightForRow(const LayoutTableRow&) const;
 
   // Honor breaking restrictions inside the table row, and adjust position and
   // size accordingly.
   void adjustRowForPagination(LayoutTableRow&, SubtreeLayoutScope&);
 
+  bool paintedOutputOfObjectHasNoEffectRegardlessOfSize() const override;
+
   // The representation of the rows and their cells (CellStruct).
   Vector<RowStruct> m_grid;
 
   // The logical offset of each row from the top of the section.
   //
   // Note that this Vector has one more entry than the number of rows so that
   // we can keep track of the final size of the section. That is,
   // m_rowPos[m_grid.size()] is a valid entry.
   //
   // To know a row's height at |rowIndex|, use the formula:
@@ skipping 17 matching lines @@
   int m_outerBorderEnd;
   int m_outerBorderBefore;
   int m_outerBorderAfter;
 
   bool m_needsCellRecalc;
 
   // This HashSet holds the overflowing cells for faster painting.
   // If we have more than gMaxAllowedOverflowingCellRatio * total cells, it will
   // be empty and m_forceSlowPaintPathWithOverflowingCell will be set to save
   // memory.
-  HashSet<LayoutTableCell*> m_overflowingCells;
+  HashSet<const LayoutTableCell*> m_overflowingCells;
   bool m_forceSlowPaintPathWithOverflowingCell;
 
   // This boolean tracks if we have cells overlapping due to rowspan / colspan
   // (see class comment above about when it could appear).
   //
   // The use is to disable a painting optimization where we just paint the
   // invalidated cells.
   bool m_hasMultipleCellLevels;
 
   // Whether any cell spans multiple rows or cols.
   bool m_hasSpanningCells;
 };
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutTableSection, isTableSection());
 
 }  // namespace blink
 
 #endif  // LayoutTableSection_h