1 files changed, 184 insertions, 159 deletions

diff --git a/Source/WebCore/rendering/RenderTableSection.h b/Source/WebCore/rendering/RenderTableSection.h
index 5ad118742..af9ab44d3 100644
--- a/Source/WebCore/rendering/RenderTableSection.h
+++ b/Source/WebCore/rendering/RenderTableSection.h
@@ -22,14 +22,14 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef RenderTableSection_h
-#define RenderTableSection_h
+#pragma once
 
 #include "RenderTable.h"
 #include <wtf/Vector.h>
 
 namespace WebCore {
 
+class RenderTableCell;
 class RenderTableRow;
 
 enum CollapsedBorderSide {
@@ -40,230 +40,158 @@ enum CollapsedBorderSide {
 };
 
 // Helper class for paintObject.
-class CellSpan {
+struct CellSpan {
 public:
     CellSpan(unsigned start, unsigned end)
-        : m_start(start)
-        , m_end(end)
+        : start(start)
+        , end(end)
     {
     }
 
-    unsigned start() const { return m_start; }
-    unsigned end() const { return m_end; }
-
-    unsigned& start() { return m_start; }
-    unsigned& end() { return m_end; }
-
-private:
-    unsigned m_start;
-    unsigned m_end;
+    unsigned start;
+    unsigned end;
 };
 
-class RenderTableCell;
-class RenderTableRow;
-
 class RenderTableSection final : public RenderBox {
 public:
-    RenderTableSection(Element&, PassRef<RenderStyle>);
-    RenderTableSection(Document&, PassRef<RenderStyle>);
+    RenderTableSection(Element&, RenderStyle&&);
+    RenderTableSection(Document&, RenderStyle&&);
     virtual ~RenderTableSection();
 
     RenderTableRow* firstRow() const;
     RenderTableRow* lastRow() const;
 
-    virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0) override;
+    void addChild(RenderObject* child, RenderObject* beforeChild = 0) override;
 
-    virtual int firstLineBaseline() const override;
+    std::optional<int> firstLineBaseline() const override;
 
     void addCell(RenderTableCell*, RenderTableRow* row);
 
-    int calcRowLogicalHeight();
+    LayoutUnit calcRowLogicalHeight();
     void layoutRows();
     void computeOverflowFromCells();
 
-    RenderTable* table() const { return toRenderTable(parent()); }
+    RenderTable* table() const { return downcast<RenderTable>(parent()); }
 
     struct CellStruct {
         Vector<RenderTableCell*, 1> cells; 
-        bool inColSpan; // true for columns after the first in a colspan
-
-        CellStruct()
-            : inColSpan(false)
-        {
-        }
-
-        RenderTableCell* primaryCell()
-        {
-            return hasCells() ? cells[cells.size() - 1] : 0;
-        }
-
-        const RenderTableCell* primaryCell() const
-        {
-            return hasCells() ? cells[cells.size() - 1] : 0;
-        }
+        bool inColSpan { false }; // true for columns after the first in a colspan
 
+        RenderTableCell* primaryCell() { return hasCells() ? cells[cells.size() - 1] : 0; }
+        const RenderTableCell* primaryCell() const { return hasCells() ? cells[cells.size() - 1] : 0; }
         bool hasCells() const { return cells.size() > 0; }
     };
 
     typedef Vector<CellStruct> Row;
-
     struct RowStruct {
-        RowStruct()
-            : rowRenderer(0)
-            , baseline()
-        {
-        }
-
         Row row;
-        RenderTableRow* rowRenderer;
+        RenderTableRow* rowRenderer { nullptr };
         LayoutUnit baseline;
         Length logicalHeight;
     };
 
-    const BorderValue& borderAdjoiningTableStart() const
-    {
-        if (hasSameDirectionAs(table()))
-            return style().borderStart();
-
-        return style().borderEnd();
-    }
-
-    const BorderValue& borderAdjoiningTableEnd() const
-    {
-        if (hasSameDirectionAs(table()))
-            return style().borderEnd();
-
-        return style().borderStart();
-    }
-
-    const BorderValue& borderAdjoiningStartCell(const RenderTableCell*) const;
-    const BorderValue& borderAdjoiningEndCell(const RenderTableCell*) const;
+    const BorderValue& borderAdjoiningTableStart() const;
+    const BorderValue& borderAdjoiningTableEnd() const;
+    const BorderValue& borderAdjoiningStartCell(const RenderTableCell&) const;
+    const BorderValue& borderAdjoiningEndCell(const RenderTableCell&) const;
 
     const RenderTableCell* firstRowCellAdjoiningTableStart() const;
     const RenderTableCell* firstRowCellAdjoiningTableEnd() const;
 
-    CellStruct& cellAt(unsigned row,  unsigned col) { return m_grid[row].row[col]; }
-    const CellStruct& cellAt(unsigned row, unsigned col) const { return m_grid[row].row[col]; }
-    RenderTableCell* primaryCellAt(unsigned row, unsigned col)
-    {
-        CellStruct& c = m_grid[row].row[col];
-        return c.primaryCell();
-    }
-
-    RenderTableRow* rowRendererAt(unsigned row) const { return m_grid[row].rowRenderer; }
+    CellStruct& cellAt(unsigned row,  unsigned col);
+    const CellStruct& cellAt(unsigned row, unsigned col) const;
+    RenderTableCell* primaryCellAt(unsigned row, unsigned col);
+    RenderTableRow* rowRendererAt(unsigned row) const;
 
     void appendColumn(unsigned pos);
     void splitColumn(unsigned pos, unsigned first);
 
-    int calcOuterBorderBefore() const;
-    int calcOuterBorderAfter() const;
-    int calcOuterBorderStart() const;
-    int calcOuterBorderEnd() const;
+    LayoutUnit calcOuterBorderBefore() const;
+    LayoutUnit calcOuterBorderAfter() const;
+    LayoutUnit calcOuterBorderStart() const;
+    LayoutUnit calcOuterBorderEnd() const;
     void recalcOuterBorder();
 
-    int outerBorderBefore() const { return m_outerBorderBefore; }
-    int outerBorderAfter() const { return m_outerBorderAfter; }
-    int outerBorderStart() const { return m_outerBorderStart; }
-    int outerBorderEnd() const { return m_outerBorderEnd; }
-
-    int outerBorderLeft(const RenderStyle* styleForCellFlow) const
-    {
-    if (styleForCellFlow->isHorizontalWritingMode())
-        return styleForCellFlow->isLeftToRightDirection() ? outerBorderStart() : outerBorderEnd();
-    return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderAfter() : outerBorderBefore();
-    }
-
-    int outerBorderRight(const RenderStyle* styleForCellFlow) const
-    {
-    if (styleForCellFlow->isHorizontalWritingMode())
-        return styleForCellFlow->isLeftToRightDirection() ? outerBorderEnd() : outerBorderStart();
-    return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderBefore() : outerBorderAfter();
-    }
-
-    int outerBorderTop(const RenderStyle* styleForCellFlow) const
-    {
-    if (styleForCellFlow->isHorizontalWritingMode())
-        return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderAfter() : outerBorderBefore();
-    return styleForCellFlow->isLeftToRightDirection() ? outerBorderStart() : outerBorderEnd();
-    }
+    LayoutUnit outerBorderBefore() const { return m_outerBorderBefore; }
+    LayoutUnit outerBorderAfter() const { return m_outerBorderAfter; }
+    LayoutUnit outerBorderStart() const { return m_outerBorderStart; }
+    LayoutUnit outerBorderEnd() const { return m_outerBorderEnd; }
 
-    int outerBorderBottom(const RenderStyle* styleForCellFlow) const
-    {
-    if (styleForCellFlow->isHorizontalWritingMode())
-        return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderBefore() : outerBorderAfter();
-    return styleForCellFlow->isLeftToRightDirection() ? outerBorderEnd() : outerBorderStart();
-    }
+    LayoutUnit outerBorderLeft(const RenderStyle* styleForCellFlow) const;
+    LayoutUnit outerBorderRight(const RenderStyle* styleForCellFlow) const;
+    LayoutUnit outerBorderTop(const RenderStyle* styleForCellFlow) const;
+    LayoutUnit outerBorderBottom(const RenderStyle* styleForCellFlow) const;
 
-    unsigned numRows() const { return m_grid.size(); }
+    unsigned numRows() const;
     unsigned numColumns() const;
     void recalcCells();
-    void recalcCellsIfNeeded()
-    {
-        if (m_needsCellRecalc)
-            recalcCells();
-    }
+    void recalcCellsIfNeeded();
 
     bool needsCellRecalc() const { return m_needsCellRecalc; }
     void setNeedsCellRecalc();
 
-    LayoutUnit rowBaseline(unsigned row) { return m_grid[row].baseline; }
-
+    LayoutUnit rowBaseline(unsigned row);
     void rowLogicalHeightChanged(unsigned rowIndex);
 
-    void removeCachedCollapsedBorders(const RenderTableCell*);
-    void setCachedCollapsedBorder(const RenderTableCell*, CollapsedBorderSide, CollapsedBorderValue);
-    CollapsedBorderValue& cachedCollapsedBorder(const RenderTableCell*, CollapsedBorderSide);
+    void clearCachedCollapsedBorders();
+    void removeCachedCollapsedBorders(const RenderTableCell&);
+    void setCachedCollapsedBorder(const RenderTableCell&, CollapsedBorderSide, CollapsedBorderValue);
+    CollapsedBorderValue cachedCollapsedBorder(const RenderTableCell&, CollapsedBorderSide);
 
     // distributeExtraLogicalHeightToRows methods return the *consumed* extra logical height.
     // FIXME: We may want to introduce a structure holding the in-flux layout information.
-    int distributeExtraLogicalHeightToRows(int extraLogicalHeight);
+    LayoutUnit distributeExtraLogicalHeightToRows(LayoutUnit extraLogicalHeight);
 
-    static RenderTableSection* createAnonymousWithParentRenderer(const RenderObject*);
-    virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const override
-    {
-        return createAnonymousWithParentRenderer(parent);
-    }
+    static std::unique_ptr<RenderTableSection> createAnonymousWithParentRenderer(const RenderTable&);
+    std::unique_ptr<RenderBox> createAnonymousBoxWithSameTypeAs(const RenderBox&) const override;
     
-    virtual void paint(PaintInfo&, const LayoutPoint&) override;
+    void paint(PaintInfo&, const LayoutPoint&) override;
 
 protected:
-    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
+    void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
 
 private:
-    virtual const char* renderName() const override { return (isAnonymous() || isPseudoElement()) ? "RenderTableSection (anonymous)" : "RenderTableSection"; }
+    static std::unique_ptr<RenderTableSection> createTableSectionWithStyle(Document&, const RenderStyle&);
+
+    enum ShouldIncludeAllIntersectingCells {
+        IncludeAllIntersectingCells,
+        DoNotIncludeAllIntersectingCells
+    };
+
+    const char* renderName() const override { return (isAnonymous() || isPseudoElement()) ? "RenderTableSection (anonymous)" : "RenderTableSection"; }
 
-    virtual bool canHaveChildren() const override { return true; }
+    bool canHaveChildren() const override { return true; }
 
-    virtual bool isTableSection() const override { return true; }
+    bool isTableSection() const override { return true; }
 
-    virtual void willBeRemovedFromTree() override;
+    void willBeRemovedFromTree() override;
 
-    virtual void layout() override;
+    void layout() override;
 
     void paintCell(RenderTableCell*, PaintInfo&, const LayoutPoint&);
-    virtual void paintObject(PaintInfo&, const LayoutPoint&) override;
+    void paintObject(PaintInfo&, const LayoutPoint&) override;
     void paintRowGroupBorder(const PaintInfo&, bool antialias, LayoutRect, BoxSide, CSSPropertyID borderColor, EBorderStyle, EBorderStyle tableBorderStyle);
     void paintRowGroupBorderIfRequired(const PaintInfo&, const LayoutPoint& paintOffset, unsigned row, unsigned col, BoxSide, RenderTableCell* = 0);
-    int offsetLeftForRowGroupBorder(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row);
+    LayoutUnit offsetLeftForRowGroupBorder(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row);
 
-    int offsetTopForRowGroupBorder(RenderTableCell*, BoxSide borderSide, unsigned row);
-    int verticalRowGroupBorderHeight(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row);
-    int horizontalRowGroupBorderWidth(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row, unsigned column);
+    LayoutUnit offsetTopForRowGroupBorder(RenderTableCell*, BoxSide borderSide, unsigned row);
+    LayoutUnit verticalRowGroupBorderHeight(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row);
+    LayoutUnit horizontalRowGroupBorderWidth(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row, unsigned column);
 
-    virtual void imageChanged(WrappedImagePtr, const IntRect* = 0) override;
+    void imageChanged(WrappedImagePtr, const IntRect* = 0) override;
 
-    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
+    bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
 
     void ensureRows(unsigned);
 
-    void distributeExtraLogicalHeightToPercentRows(int& extraLogicalHeight, int totalPercent);
-    void distributeExtraLogicalHeightToAutoRows(int& extraLogicalHeight, unsigned autoRowsCount);
-    void distributeRemainingExtraLogicalHeight(int& extraLogicalHeight);
+    void distributeExtraLogicalHeightToPercentRows(LayoutUnit& extraLogicalHeight, int totalPercent);
+    void distributeExtraLogicalHeightToAutoRows(LayoutUnit& extraLogicalHeight, unsigned autoRowsCount);
+    void distributeRemainingExtraLogicalHeight(LayoutUnit& extraLogicalHeight);
 
     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 fullTableRowSpan() const;
     CellSpan fullTableColumnSpan() const { return CellSpan(0, table()->columns().size()); }
 
     // Flip the rect so it aligns with the coordinates used by the rowPos and columnPos vectors.
@@ -274,8 +202,12 @@ private:
 
     // 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 spannedColumns(const LayoutRect& flippedRect) const;
+    // The IncludeAllIntersectingCells argument is used to determine which cells to include when
+    // an edge of the flippedRect lies exactly on a cell boundary. Using IncludeAllIntersectingCells
+    // will return both cells, and using DoNotIncludeAllIntersectingCells will return only the cell
+    // that hittesting should return.
+    CellSpan spannedRows(const LayoutRect& flippedRect, ShouldIncludeAllIntersectingCells) const;
+    CellSpan spannedColumns(const LayoutRect& flippedRect, ShouldIncludeAllIntersectingCells) const;
 
     void setLogicalPositionForCell(RenderTableCell*, unsigned effectiveColumn) const;
 
@@ -283,35 +215,128 @@ private:
     void lastChild() const = delete;
 
     Vector<RowStruct> m_grid;
-    Vector<int> m_rowPos;
+    Vector<LayoutUnit> m_rowPos;
 
     // the current insertion position
-    unsigned m_cCol;
-    unsigned m_cRow;
+    unsigned m_cCol { 0 };
+    unsigned m_cRow  { 0 };
 
-    int m_outerBorderStart;
-    int m_outerBorderEnd;
-    int m_outerBorderBefore;
-    int m_outerBorderAfter;
+    LayoutUnit m_outerBorderStart;
+    LayoutUnit m_outerBorderEnd;
+    LayoutUnit m_outerBorderBefore;
+    LayoutUnit m_outerBorderAfter;
 
-    bool m_needsCellRecalc;
+    bool m_needsCellRecalc  { false };
 
     // 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<RenderTableCell*> m_overflowingCells;
-    bool m_forceSlowPaintPathWithOverflowingCell;
+    bool m_forceSlowPaintPathWithOverflowingCell { false };
 
-    bool m_hasMultipleCellLevels;
+    bool m_hasMultipleCellLevels { false };
 
     // This map holds the collapsed border values for cells with collapsed borders.
     // It is held at RenderTableSection level to spare memory consumption by table cells.
     HashMap<std::pair<const RenderTableCell*, int>, CollapsedBorderValue > m_cellsCollapsedBorders;
 };
 
-template<> inline bool isRendererOfType<const RenderTableSection>(const RenderObject& renderer) { return renderer.isTableSection(); }
-RENDER_OBJECT_TYPE_CASTS(RenderTableSection, isTableSection())
+inline const BorderValue& RenderTableSection::borderAdjoiningTableStart() const
+{
+    if (isDirectionSame(this, table()))
+        return style().borderStart();
+    return style().borderEnd();
+}
+
+inline const BorderValue& RenderTableSection::borderAdjoiningTableEnd() const
+{
+    if (isDirectionSame(this, table()))
+        return style().borderEnd();
+    return style().borderStart();
+}
+
+inline RenderTableSection::CellStruct& RenderTableSection::cellAt(unsigned row,  unsigned col)
+{
+    recalcCellsIfNeeded();
+    return m_grid[row].row[col];
+}
+
+inline const RenderTableSection::CellStruct& RenderTableSection::cellAt(unsigned row, unsigned col) const
+{
+    ASSERT(!m_needsCellRecalc);
+    return m_grid[row].row[col];
+}
+
+inline RenderTableCell* RenderTableSection::primaryCellAt(unsigned row, unsigned col)
+{
+    recalcCellsIfNeeded();
+    CellStruct& c = m_grid[row].row[col];
+    return c.primaryCell();
+}
+
+inline RenderTableRow* RenderTableSection::rowRendererAt(unsigned row) const
+{
+    ASSERT(!m_needsCellRecalc);
+    return m_grid[row].rowRenderer;
+}
+
+inline LayoutUnit RenderTableSection::outerBorderLeft(const RenderStyle* styleForCellFlow) const
+{
+    if (styleForCellFlow->isHorizontalWritingMode())
+        return styleForCellFlow->isLeftToRightDirection() ? outerBorderStart() : outerBorderEnd();
+    return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderAfter() : outerBorderBefore();
+}
+
+inline LayoutUnit RenderTableSection::outerBorderRight(const RenderStyle* styleForCellFlow) const
+{
+    if (styleForCellFlow->isHorizontalWritingMode())
+        return styleForCellFlow->isLeftToRightDirection() ? outerBorderEnd() : outerBorderStart();
+    return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderBefore() : outerBorderAfter();
+}
+
+inline LayoutUnit RenderTableSection::outerBorderTop(const RenderStyle* styleForCellFlow) const
+{
+    if (styleForCellFlow->isHorizontalWritingMode())
+        return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderAfter() : outerBorderBefore();
+    return styleForCellFlow->isLeftToRightDirection() ? outerBorderStart() : outerBorderEnd();
+}
+
+inline LayoutUnit RenderTableSection::outerBorderBottom(const RenderStyle* styleForCellFlow) const
+{
+    if (styleForCellFlow->isHorizontalWritingMode())
+        return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderBefore() : outerBorderAfter();
+    return styleForCellFlow->isLeftToRightDirection() ? outerBorderEnd() : outerBorderStart();
+}
+
+inline unsigned RenderTableSection::numRows() const
+{
+    ASSERT(!m_needsCellRecalc);
+    return m_grid.size();
+}
+
+inline void RenderTableSection::recalcCellsIfNeeded()
+{
+    if (m_needsCellRecalc)
+        recalcCells();
+}
+
+inline LayoutUnit RenderTableSection::rowBaseline(unsigned row)
+{
+    recalcCellsIfNeeded();
+    return m_grid[row].baseline;
+}
+
+inline CellSpan RenderTableSection::fullTableRowSpan() const
+{
+    ASSERT(!m_needsCellRecalc);
+    return CellSpan(0, m_grid.size());
+}
+
+inline std::unique_ptr<RenderBox> RenderTableSection::createAnonymousBoxWithSameTypeAs(const RenderBox& renderer) const
+{
+    return RenderTableSection::createTableSectionWithStyle(renderer.document(), renderer.style());
+}
 
 } // namespace WebCore
 
-#endif // RenderTableSection_h
+SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderTableSection, isTableSection())