Replace LayoutTableCell::AbsoluteColumnIndex() with EffectiveColumnIndex()

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 174 matching lines @@
 
   // Returns the primary cell at (row, effectiveColumn) if the cell exists and
   // originates from (instead of spanning into) the grid slot, or nullptr.
   LayoutTableCell* OriginatingCellAt(unsigned row, unsigned effective_column);
   const LayoutTableCell* OriginatingCellAt(unsigned row,
                                            unsigned effective_column) const {
     return const_cast<LayoutTableSection*>(this)->OriginatingCellAt(
         row, effective_column);
   }
 
-  unsigned NumCols(unsigned row) const { return grid_[row].grid_cells.size(); }
+  unsigned NumEffectiveColumns(unsigned row) const {
+    return grid_[row].grid_cells.size();
+  }
 
   // Returns null for cells with a rowspan that exceed the last row. Possibly
   // others.
   LayoutTableRow* RowLayoutObjectAt(unsigned row) { return grid_[row].row; }
   const LayoutTableRow* RowLayoutObjectAt(unsigned row) const {
     return grid_[row].row;
   }
 
   void AppendEffectiveColumn(unsigned pos);
   void SplitEffectiveColumn(unsigned pos, unsigned first);
 
   enum BlockBorderSide { kBorderBefore, kBorderAfter };
   int CalcBlockDirectionOuterBorder(BlockBorderSide) const;
   enum InlineBorderSide { kBorderStart, kBorderEnd };
   int CalcInlineDirectionOuterBorder(InlineBorderSide) const;
   void RecalcOuterBorder();
 
   int OuterBorderBefore() const { return outer_border_before_; }
   int OuterBorderAfter() const { return outer_border_after_; }
   int OuterBorderStart() const { return outer_border_start_; }
   int OuterBorderEnd() const { return outer_border_end_; }
 
   unsigned NumRows() const {
     DCHECK(!NeedsCellRecalc());
     return grid_.size();
   }
-  unsigned NumEffectiveColumns() const;
+  // This is slow. Use Table()->NumEffectiveColumns() instead if possible.
+  unsigned MaxNumEffectiveColumnsOfRows() const;
 
   // recalcCells() is used when we are not sure about the section's structure
   // and want to do an expensive (but safe) reconstruction of m_grid from
   // scratch.
   // An example of this is inserting a new cell in the middle of an existing
   // row or removing a row.
   //
   // Accessing m_grid when m_needsCellRecalc is set is UNSAFE as pointers can
   // be left dangling. Thus care should be taken in the code to check
   // m_needsCellRecalc before accessing m_grid.
@@ skipping 88 matching lines @@
   int BorderSpacingForRow(unsigned row) const {
     return grid_[row].row ? Table()->VBorderSpacing() : 0;
   }
 
   void EnsureRows(unsigned num_rows) {
     if (num_rows > grid_.size())
       grid_.Grow(num_rows);
   }
 
   void EnsureCols(unsigned row_index, unsigned num_cols) {
-    if (num_cols > this->NumCols(row_index))
+    if (num_cols > grid_[row_index].grid_cells.size())
       grid_[row_index].grid_cells.Grow(num_cols);
   }
 
   bool RowHasOnlySpanningCells(unsigned);
   unsigned CalcRowHeightHavingOnlySpanningCells(unsigned,
                                                 int&,
                                                 unsigned,
                                                 unsigned&,
                                                 Vector<int>&);
   void UpdateRowsHeightHavingOnlySpanningCells(LayoutTableCell*,
@@ skipping 113 matching lines @@
 
   // Whether any cell spans multiple rows or cols.
   bool has_spanning_cells_;
 };
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutTableSection, IsTableSection());
 
 }  // namespace blink
 
 #endif  // LayoutTableSection_h