Replace LayoutTableCell::AbsoluteColumnIndex() with EffectiveColumnIndex()

third_party/WebKit/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 "core/paint/TableSectionPainter.h"
 
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableCol.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/paint/BoxClipper.h"
@@ skipping 134 matching lines @@
   layout_table_section_.DirtiedRowsAndEffectiveColumns(
       table_aligned_rect, dirtied_rows, dirtied_columns);
 
   if (dirtied_columns.Start() >= dirtied_columns.End())
     return;
 
   // Collapsed borders are painted from the bottom right to the top left so that
   // precedence due to cell position is respected.
   for (unsigned r = dirtied_rows.End(); r > dirtied_rows.Start(); r--) {
     unsigned row = r - 1;
-    unsigned n_cols = layout_table_section_.NumCols(row);
+    unsigned n_cols = layout_table_section_.NumEffectiveColumns(row);
     for (unsigned c = std::min(dirtied_columns.End(), n_cols);
          c > dirtied_columns.Start(); c--) {
       unsigned col = c - 1;
       if (const LayoutTableCell* cell =
               layout_table_section_.OriginatingCellAt(row, col)) {
         LayoutPoint cell_point =
             layout_table_section_.FlipForWritingModeForChild(
                 cell, adjusted_paint_offset);
         TableCellPainter(*cell).PaintCollapsedBorders(paint_info, cell_point,
                                                       current_border_value);
@@ skipping 84 matching lines @@
     HashSet<const LayoutTableCell*> spanning_cells;
     for (unsigned r = dirtied_rows.Start(); r < dirtied_rows.End(); r++) {
       const LayoutTableRow* row = layout_table_section_.RowLayoutObjectAt(r);
       // TODO(crbug.com/577282): This painting order is inconsistent with other
       // outlines.
       if (row && !row->HasSelfPaintingLayer() &&
           ShouldPaintSelfOutline(paint_info_for_descendants.phase)) {
         TableRowPainter(*row).PaintOutline(paint_info_for_descendants,
                                            paint_offset);
       }
-      unsigned n_cols = layout_table_section_.NumCols(r);
+      unsigned n_cols = layout_table_section_.NumEffectiveColumns(r);
       for (unsigned c = dirtied_columns.Start();
            c < n_cols && c < dirtied_columns.End(); c++) {
         if (const auto* cell = layout_table_section_.OriginatingCellAt(r, c)) {
           if (!overflowing_cells.Contains(cell))
             cells.push_back(cell);
         }
       }
     }
 
     // Sort the dirty cells by paint order.
     std::sort(cells.begin(), cells.end(), LayoutTableCell::CompareInDOMOrder);
     for (const auto* cell : cells)
       PaintCell(*cell, paint_info_for_descendants, paint_offset);
   }
 }
 
 void TableSectionPainter::PaintBoxDecorationBackground(
     const PaintInfo& paint_info,
     const LayoutPoint& paint_offset,
     const CellSpan& dirtied_rows,
     const CellSpan& dirtied_columns) {
-  bool may_have_background = layout_table_section_.Table()->HasColElements() ||
-                             layout_table_section_.StyleRef().HasBackground();
+  bool may_have_background =
+      layout_table_section_.Table()->HasColOrColGroups() ||
+      layout_table_section_.StyleRef().HasBackground();
   bool has_box_shadow = layout_table_section_.StyleRef().BoxShadow();
   if (!may_have_background && !has_box_shadow)
     return;
 
   PaintResult paint_result =
       dirtied_columns == layout_table_section_.FullTableEffectiveColumnSpan() &&
               dirtied_rows == layout_table_section_.FullSectionRowSpan()
           ? kFullyPainted
           : kMayBeClippedByPaintDirtyRect;
   layout_table_section_.GetMutableForPainting().UpdatePaintResult(
@@ skipping 39 matching lines @@
     const LayoutTableCell& cell,
     const PaintInfo& paint_info_for_cells,
     const LayoutPoint& paint_offset) {
   LayoutPoint cell_point =
       layout_table_section_.FlipForWritingModeForChild(&cell, paint_offset);
 
   // 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.
 
-  LayoutTable::ColAndColGroup col_and_col_group =
-      layout_table_section_.Table()->ColElementAtAbsoluteColumn(
-          cell.AbsoluteColumnIndex());
+  auto col_and_col_group = cell.GetColAndColGroup();
   LayoutTableCol* column = col_and_col_group.col;
   LayoutTableCol* column_group = col_and_col_group.colgroup;
   TableCellPainter table_cell_painter(cell);
 
   // 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.
@@ skipping 17 matching lines @@
                                     const PaintInfo& paint_info_for_cells,
                                     const LayoutPoint& paint_offset) {
   if (!cell.HasSelfPaintingLayer() && !cell.Row()->HasSelfPaintingLayer()) {
     LayoutPoint cell_point =
         layout_table_section_.FlipForWritingModeForChild(&cell, paint_offset);
     cell.Paint(paint_info_for_cells, cell_point);
   }
 }
 
 }  // namespace blink