Move painting code from RenderTableCell to TableCellPainter.

Source/core/paint/TableSectionPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/TableSectionPainter.h"
 
 #include "core/paint/ObjectPainter.h"
+#include "core/paint/TableCellPainter.h"
 #include "core/paint/TableRowPainter.h"
 #include "core/rendering/GraphicsContextAnnotator.h"
 #include "core/rendering/PaintInfo.h"
 #include "core/rendering/RenderBoxClipper.h"
 #include "core/rendering/RenderTable.h"
 #include "core/rendering/RenderTableCell.h"
 #include "core/rendering/RenderTableCol.h"
 #include "core/rendering/RenderTableRow.h"
 
 namespace blink {
@@ skipping 57 matching lines @@
                 // due to cell position is respected.
                 for (unsigned r = dirtiedRows.end(); r > dirtiedRows.start(); r--) {
                     unsigned row = r - 1;
                     for (unsigned c = dirtiedColumns.end(); c > dirtiedColumns.start(); c--) {
                         unsigned col = c - 1;
                         RenderTableSection::CellStruct& current = m_renderTableSection.cellAt(row, col);
                         RenderTableCell* cell = current.primaryCell();
                         if (!cell || (row > dirtiedRows.start() && m_renderTableSection.primaryCellAt(row - 1, col) == cell) || (col > dirtiedColumns.start() && m_renderTableSection.primaryCellAt(row, col - 1) == cell))
                             continue;
                         LayoutPoint cellPoint = m_renderTableSection.flipForWritingModeForChild(cell, paintOffset);
-                        cell->paintCollapsedBorders(paintInfo, cellPoint);
+                        TableCellPainter(*cell).paintCollapsedBorders(paintInfo, cellPoint);
                     }
                 }
             } else {
                 // Draw the dirty cells in the order that they appear.
                 for (unsigned r = dirtiedRows.start(); r < dirtiedRows.end(); r++) {
                     RenderTableRow* row = m_renderTableSection.rowRendererAt(r);
                     if (row && !row->hasSelfPaintingLayer())
                         TableRowPainter(*row).paintOutlineForRowIfNeeded(paintInfo, paintOffset);
                     for (unsigned c = dirtiedColumns.start(); c < dirtiedColumns.end(); c++) {
                         RenderTableSection::CellStruct& current = m_renderTableSection.cellAt(r, c);
@@ skipping 42 matching lines @@
 
             // Sort the dirty cells by paint order.
             if (!overflowingCells.size())
                 std::stable_sort(cells.begin(), cells.end(), compareCellPositions);
             else
                 std::sort(cells.begin(), cells.end(), compareCellPositionsWithOverflowingCells);
 
             if (paintInfo.phase == PaintPhaseCollapsedTableBorders) {
                 for (unsigned i = cells.size(); i > 0; --i) {
                     LayoutPoint cellPoint = m_renderTableSection.flipForWritingModeForChild(cells[i - 1], paintOffset);
-                    cells[i - 1]->paintCollapsedBorders(paintInfo, cellPoint);
+                    TableCellPainter(*cells[i - 1]).paintCollapsedBorders(paintInfo, cellPoint);
                 }
             } else {
                 for (unsigned i = 0; i < cells.size(); ++i)
                     paintCell(cells[i], paintInfo, paintOffset);
             }
         }
     }
 }
 
 void TableSectionPainter::paintCell(RenderTableCell* cell, PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     LayoutPoint cellPoint = m_renderTableSection.flipForWritingModeForChild(cell, paintOffset);
     PaintPhase paintPhase = paintInfo.phase;
     RenderTableRow* row = toRenderTableRow(cell->parent());
 
     if (paintPhase == PaintPhaseBlockBackground || paintPhase == PaintPhaseChildBlockBackground) {
         // We need to handle painting a stack of backgrounds. This stack (from bottom to top) consists of
         // the column group, column, row group, row, and then the cell.
         RenderTableCol* column = m_renderTableSection.table()->colElement(cell->col());
         RenderTableCol* columnGroup = column ? column->enclosingColumnGroup() : 0;
 
         // Column groups and columns first.
         // FIXME: Columns and column groups do not currently support opacity, and they are being painted "too late" in
         // the stack, since we have already opened a transparency layer (potentially) for the table row group.
         // Note that we deliberately ignore whether or not the cell has a layer, since these backgrounds paint "behind" the
         // cell.
-        cell->paintBackgroundsBehindCell(paintInfo, cellPoint, columnGroup);
-        cell->paintBackgroundsBehindCell(paintInfo, cellPoint, column);
+        TableCellPainter(*cell).paintBackgroundsBehindCell(paintInfo, cellPoint, columnGroup);
+        TableCellPainter(*cell).paintBackgroundsBehindCell(paintInfo, cellPoint, column);
 
         // Paint the row group next.
-        cell->paintBackgroundsBehindCell(paintInfo, cellPoint, &m_renderTableSection);
+        TableCellPainter(*cell).paintBackgroundsBehindCell(paintInfo, cellPoint, &m_renderTableSection);
 
         // Paint the row next, but only if it doesn't have a layer. If a row has a layer, it will be responsible for
         // painting the row background for the cell.
         if (!row->hasSelfPaintingLayer())
-            cell->paintBackgroundsBehindCell(paintInfo, cellPoint, row);
+            TableCellPainter(*cell).paintBackgroundsBehindCell(paintInfo, cellPoint, row);
     }
     if ((!cell->hasSelfPaintingLayer() && !row->hasSelfPaintingLayer()))
         cell->paint(paintInfo, cellPoint);
 }
 
 } // namespace blink