Move painting code for tables into *Paint classes.

Source/core/rendering/RenderTableSection.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
  * modify it under the terms of the GNU Library General Public
@@ skipping 12 matching lines @@
  */
 
 #ifndef RenderTableSection_h
 #define RenderTableSection_h
 
 #include "core/rendering/RenderTable.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
+extern float gMaxAllowedOverflowingCellRatioForFastPaintPath;

[pdr., 2014/09/19 20:51:37]

I think this can be: const float gMaxAllowedOverflowingCellRatioForFastPaintPath
= 0.1f;

[chrishtr, 2014/09/19 20:59:43]

Done.

+
 enum CollapsedBorderSide {
     CBSBefore,
     CBSAfter,
     CBSStart,
     CBSEnd
 };
 
 // Helper class for paintObject.
 class CellSpan {
 public:
@@ skipping 174 matching lines @@
     int distributeExtraLogicalHeightToRows(int extraLogicalHeight);
 
     static RenderTableSection* createAnonymousWithParentRenderer(const RenderObject*);
     virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const OVERRIDE
     {
         return createAnonymousWithParentRenderer(parent);
     }
 
     virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
 
+    // Flip the rect so it aligns with the coordinates used by the rowPos and columnPos vectors.
+    LayoutRect logicalRectForWritingModeAndDirection(const LayoutRect&) const;
+
+    CellSpan dirtiedRows(const LayoutRect& paintInvalidationRect) const;
+    CellSpan dirtiedColumns(const LayoutRect& paintInvalidationRect) const;
+    WillBeHeapHashSet<RawPtrWillBeMember<RenderTableCell> >& overflowingCells() { return m_overflowingCells; }
+    bool hasMultipleCellLevels() { return m_hasMultipleCellLevels; }
+
 protected:
     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE;
     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
 
 private:
     virtual RenderObjectChildList* virtualChildren() OVERRIDE { return children(); }
     virtual const RenderObjectChildList* virtualChildren() const OVERRIDE { return children(); }
 
     virtual const char* renderName() const OVERRIDE { return (isAnonymous() || isPseudoElement()) ? "RenderTableSection (anonymous)" : "RenderTableSection"; }
 
     virtual bool isTableSection() const OVERRIDE { return true; }
 
     virtual void willBeRemovedFromTree() OVERRIDE;
 
     virtual void layout() OVERRIDE;
 
-    void paintCell(RenderTableCell*, PaintInfo&, const LayoutPoint&);
     virtual void paintObject(PaintInfo&, const LayoutPoint&) OVERRIDE;
 
     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0) OVERRIDE;
 
     int borderSpacingForRow(unsigned row) const { return m_grid[row].rowRenderer ? table()->vBorderSpacing() : 0; }
 
     void ensureRows(unsigned);
 
     bool rowHasOnlySpanningCells(unsigned);
     unsigned calcRowHeightHavingOnlySpanningCells(unsigned);
     void updateRowsHeightHavingOnlySpanningCells(RenderTableCell*, struct SpanningRowsHeight&);
     bool isHeightNeededForRowHavingOnlySpanningCells(unsigned);
 
     void populateSpanningRowsHeightFromCell(RenderTableCell*, struct SpanningRowsHeight&);
     void distributeExtraRowSpanHeightToPercentRows(RenderTableCell*, int, int&, Vector<int>&);
     void distributeWholeExtraRowSpanHeightToPercentRows(RenderTableCell*, int, int&, Vector<int>&);
     void distributeExtraRowSpanHeightToAutoRows(RenderTableCell*, int, int&, Vector<int>&);
     void distributeExtraRowSpanHeightToRemainingRows(RenderTableCell*, int, int&, Vector<int>&);
     void distributeRowSpanHeightToRows(SpanningRenderTableCells& rowSpanCells);
 
     void distributeExtraLogicalHeightToPercentRows(int& extraLogicalHeight, int totalPercent);
     void distributeExtraLogicalHeightToAutoRows(int& extraLogicalHeight, unsigned autoRowsCount);
     void distributeRemainingExtraLogicalHeight(int& extraLogicalHeight);
 
     void updateBaselineForCell(RenderTableCell*, unsigned row, LayoutUnit& 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 fullTableColumnSpan() const { return CellSpan(0, table()->columns().size()); }
 
-    // Flip the rect so it aligns with the coordinates used by the rowPos and columnPos vectors.
-    LayoutRect logicalRectForWritingModeAndDirection(const LayoutRect&) const;
-
-    CellSpan dirtiedRows(const LayoutRect& paintInvalidationRect) const;
-    CellSpan dirtiedColumns(const LayoutRect& paintInvalidationRect) const;
-
     // 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;
 
     void setLogicalPositionForCell(RenderTableCell*, unsigned effectiveColumn) const;
 
     RenderObjectChildList m_children;
 
     WillBeHeapVector<RowStruct> m_grid;
@@ skipping 34 matching lines @@
     static const bool needsDestruction = false;
 };
 template<> struct VectorTraits<blink::RenderTableSection::RowStruct> : VectorTraitsBase<blink::RenderTableSection::RowStruct> {
     static const bool needsDestruction = false;
 };
 #endif
 
 }
 
 #endif // RenderTableSection_h