Replace LayoutTableCell::AbsoluteColumnIndex() with EffectiveColumnIndex()

third_party/WebKit/Source/core/layout/LayoutTableSection.cpp

 /*
  * 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, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 234 matching lines @@
       Table()->EffectiveColumns();
   unsigned insertion_row = row->RowIndex();
 
   // ### mozilla still seems to do the old HTML way, even for strict DTD
   // (see the annotation on table cell layouting in the CSS specs and the
   // testcase below:
   // <TABLE border>
   // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4
   // <TR><TD colspan="2">5
   // </TABLE>
-  unsigned n_cols = NumCols(insertion_row);
+  unsigned n_cols = NumEffectiveColumns(insertion_row);
   while (c_col_ < n_cols && (GridCellAt(insertion_row, c_col_).HasCells() ||
                              GridCellAt(insertion_row, c_col_).InColSpan()))
     c_col_++;
 
   grid_[insertion_row].UpdateLogicalHeightForCell(cell);
 
   EnsureRows(insertion_row + r_span);
 
   grid_[insertion_row].row = row;
 
@@ skipping 868 matching lines @@
       }
       row->SetLogicalHeight(row_logical_height);
       row->UpdateAfterLayout();
     }
   }
 
   // Vertically align and flex the cells in each row.
   for (unsigned r = 0; r < total_rows; r++) {
     LayoutTableRow* row = grid_[r].row;
 
-    unsigned n_cols = NumCols(r);
+    unsigned n_cols = NumEffectiveColumns(r);
     for (unsigned c = 0; c < n_cols; c++) {
       LayoutTableCell* cell = OriginatingCellAt(r, c);
       if (!cell)
         continue;
 
       int r_height;
       int row_logical_top;
       unsigned row_span = std::max(1U, cell->RowSpan());
       unsigned end_row_index = std::min(r + row_span, total_rows) - 1;
       LayoutTableRow* last_row_object = grid_[end_row_index].row;
@@ skipping 153 matching lines @@
   ClearChildNeedsOverflowRecalcAfterStyleChange();
   unsigned total_rows = grid_.size();
   bool children_overflow_changed = false;
   for (unsigned r = 0; r < total_rows; r++) {
     LayoutTableRow* row_layouter = RowLayoutObjectAt(r);
     if (!row_layouter ||
         !row_layouter->ChildNeedsOverflowRecalcAfterStyleChange())
       continue;
     row_layouter->ClearChildNeedsOverflowRecalcAfterStyleChange();
     bool row_children_overflow_changed = false;
-    unsigned n_cols = NumCols(r);
+    unsigned n_cols = NumEffectiveColumns(r);
     for (unsigned c = 0; c < n_cols; c++) {
       auto* cell = OriginatingCellAt(r, c);
       if (!cell || !cell->NeedsOverflowRecalcAfterStyleChange())
         continue;
       row_children_overflow_changed |= cell->RecalcOverflowAfterStyleChange();
     }
     if (row_children_overflow_changed)
       row_layouter->ComputeOverflow();
     children_overflow_changed |= row_children_overflow_changed;
   }
   if (children_overflow_changed)
     ComputeOverflowFromDescendants();
   return children_overflow_changed;
 }
 
 void LayoutTableSection::MarkAllCellsWidthsDirtyAndOrNeedsLayout(
     LayoutTable::WhatToMarkAllCells what_to_mark) {
   for (LayoutTableRow* row = FirstRow(); row; row = row->NextRow()) {
     for (LayoutTableCell* cell = row->FirstCell(); cell;
          cell = cell->NextCell()) {
       cell->SetPreferredLogicalWidthsDirty();
       if (what_to_mark == LayoutTable::kMarkDirtyAndNeedsLayout)
         cell->SetChildNeedsLayout();
     }
   }
 }
 
 int LayoutTableSection::CalcBlockDirectionOuterBorder(
     BlockBorderSide side) const {
+  // TODO(wangxianzhu): There are several issues in this function:
+  // 1. Row borders are not respected;
+  // 2. Column borders should be ignored if this section is not at the top or
+  //    the bottom.
+  // 3. It's unnecessarily complex.
+  // I think we should just use cell's calculated collapsed border values to
+  // avoid all of the problems.
   if (!grid_.size() || !Table()->NumEffectiveColumns())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& sb =
       side == kBorderBefore ? Style()->BorderBefore() : Style()->BorderAfter();
   if (sb.Style() == EBorderStyle::kHidden)
     return -1;
   if (sb.Style() > EBorderStyle::kHidden)
     border_width = sb.Width();
 
   const BorderValue& rb = side == kBorderBefore
                               ? FirstRow()->Style()->BorderBefore()
                               : LastRow()->Style()->BorderAfter();
   if (rb.Style() == EBorderStyle::kHidden)
     return -1;
   if (rb.Style() > EBorderStyle::kHidden && rb.Width() > border_width)
     border_width = rb.Width();
 
   bool all_hidden = true;
   unsigned r = side == kBorderBefore ? 0 : grid_.size() - 1;
-  unsigned n_cols = NumCols(r);
+  unsigned n_cols = NumEffectiveColumns(r);
   for (unsigned c = 0; c < n_cols; c++) {
     const auto& grid_cell = GridCellAt(r, c);
     if (grid_cell.InColSpan() || !grid_cell.HasCells())
       continue;
     const ComputedStyle& primary_cell_style =
         grid_cell.PrimaryCell()->StyleRef();
     // FIXME: Make this work with perpendicular and flipped cells.
     const BorderValue& cb = side == kBorderBefore
                                 ? primary_cell_style.BorderBefore()
                                 : primary_cell_style.BorderAfter();
     // FIXME: Don't repeat for the same col group
     LayoutTableCol* col =
-        Table()->ColElementAtAbsoluteColumn(c).InnermostColOrColGroup();
+        Table()->ColAndColGroupAtEffectiveColumn(c).InnermostColOrColGroup();
     if (col) {
       const BorderValue& gb = side == kBorderBefore
                                   ? col->Style()->BorderBefore()
                                   : col->Style()->BorderAfter();
       if (gb.Style() == EBorderStyle::kHidden ||
           cb.Style() == EBorderStyle::kHidden)
         continue;
       all_hidden = false;
       if (gb.Style() > EBorderStyle::kHidden && gb.Width() > border_width)
         border_width = gb.Width();
@@ skipping 25 matching lines @@
   int border_width = 0;
 
   const BorderValue& sb =
       side == kBorderStart ? Style()->BorderStart() : Style()->BorderEnd();
   if (sb.Style() == EBorderStyle::kHidden)
     return -1;
   if (sb.Style() > EBorderStyle::kHidden)
     border_width = sb.Width();
 
   if (LayoutTableCol* col = Table()
-                                ->ColElementAtAbsoluteColumn(col_index)
+                                ->ColAndColGroupAtEffectiveColumn(col_index)
                                 .InnermostColOrColGroup()) {
     const BorderValue& gb = side == kBorderStart ? col->Style()->BorderStart()
                                                  : col->Style()->BorderEnd();
     if (gb.Style() == EBorderStyle::kHidden)
       return -1;
     if (gb.Style() > EBorderStyle::kHidden && gb.Width() > border_width)
       border_width = gb.Width();
   }
 
   bool all_hidden = true;
   for (unsigned r = 0; r < grid_.size(); r++) {
-    if (col_index >= NumCols(r))
+    if (col_index >= NumEffectiveColumns(r))
       continue;
     const auto& grid_cell = GridCellAt(r, col_index);
     if (!grid_cell.HasCells())
       continue;
     // FIXME: Don't repeat for the same cell
     const ComputedStyle& primary_cell_style =
         grid_cell.PrimaryCell()->StyleRef();
     const ComputedStyle& primary_cell_parent_style =
         grid_cell.PrimaryCell()->Parent()->StyleRef();
     // FIXME: Make this work with perpendicular and flipped cells.
@@ skipping 104 matching lines @@
 
   rows.EnsureConsistency(grid_.size());
   columns.EnsureConsistency(Table()->NumEffectiveColumns());
 
   if (!has_spanning_cells_)
     return;
 
   if (rows.Start() > 0 && rows.Start() < grid_.size()) {
     // If there are any cells spanning into the first row, expand |rows| to
     // cover the cells.
-    unsigned n_cols = NumCols(rows.Start());
+    unsigned n_cols = NumEffectiveColumns(rows.Start());
     unsigned smallest_row = rows.Start();
     for (unsigned c = columns.Start(); c < std::min(columns.End(), n_cols);
          ++c) {
       for (const auto* cell : GridCellAt(rows.Start(), c).Cells()) {
         smallest_row = std::min(smallest_row, cell->RowIndex());
         if (!smallest_row)
           break;
       }
     }
     rows = CellSpan(smallest_row, rows.End());
@@ skipping 122 matching lines @@
        cell = cell->NextCell())
     grid_[row_index].UpdateLogicalHeightForCell(cell);
 }
 
 void LayoutTableSection::SetNeedsCellRecalc() {
   needs_cell_recalc_ = true;
   if (LayoutTable* t = Table())
     t->SetNeedsSectionRecalc();
 }
 
-unsigned LayoutTableSection::NumEffectiveColumns() const {
+unsigned LayoutTableSection::MaxNumEffectiveColumnsOfRows() const {
   unsigned result = 0;
 
   for (unsigned r = 0; r < grid_.size(); ++r) {
-    unsigned n_cols = NumCols(r);
+    unsigned n_cols = NumEffectiveColumns(r);
     for (unsigned c = result; c < n_cols; ++c) {
       const auto& grid_cell = GridCellAt(r, c);
       if (grid_cell.HasCells() || grid_cell.InColSpan())
         result = c;
     }
   }
 
   return result + 1;
 }
 
@@ skipping 25 matching lines @@
 const LayoutTableCell* LayoutTableSection::FirstRowCellAdjoiningTableEnd()
     const {
   unsigned adjoining_end_cell_column_index =
       HasSameDirectionAs(Table()) ? Table()->LastEffectiveColumnIndex() : 0;
   return PrimaryCellAt(0, adjoining_end_cell_column_index);
 }
 
 LayoutTableCell* LayoutTableSection::OriginatingCellAt(
     unsigned row,
     unsigned effective_column) {
-  if (effective_column >= NumCols(row))
+  if (effective_column >= NumEffectiveColumns(row))
     return nullptr;
   auto& grid_cell = GridCellAt(row, effective_column);
   if (grid_cell.InColSpan())
     return nullptr;
   if (auto* cell = grid_cell.PrimaryCell()) {
     if (cell->RowIndex() == row)
       return cell;
   }
   return nullptr;
 }
@@ skipping 75 matching lines @@
   hit_test_rect.MoveBy(-adjusted_location);
 
   LayoutRect table_aligned_rect =
       LogicalRectForWritingModeAndDirection(hit_test_rect);
   CellSpan row_span = SpannedRows(table_aligned_rect);
   CellSpan column_span = SpannedEffectiveColumns(table_aligned_rect);
 
   // Now iterate over the spanned rows and columns.
   for (unsigned hit_row = row_span.Start(); hit_row < row_span.End();
        ++hit_row) {
-    unsigned n_cols = NumCols(hit_row);
+    unsigned n_cols = NumEffectiveColumns(hit_row);
     for (unsigned hit_column = column_span.Start();
          hit_column < n_cols && hit_column < column_span.End(); ++hit_column) {
       auto& grid_cell = GridCellAt(hit_row, hit_column);
 
       // If the cell is empty, there's nothing to do
       if (!grid_cell.HasCells())
         continue;
 
       for (unsigned i = grid_cell.Cells().size(); i;) {
         --i;
@@ skipping 33 matching lines @@
     unsigned effective_column) const {
   LayoutPoint cell_location(0, row_pos_[cell->RowIndex()]);
   int horizontal_border_spacing = Table()->HBorderSpacing();
 
   // FIXME: The table's direction should determine our row's direction, not the
   // section's (see bug 96691).
   if (!Style()->IsLeftToRightDirection())
     cell_location.SetX(LayoutUnit(
         Table()->EffectiveColumnPositions()[Table()->NumEffectiveColumns()] -
         Table()->EffectiveColumnPositions()
-            [Table()->AbsoluteColumnToEffectiveColumn(
-                cell->AbsoluteColumnIndex() + cell->ColSpan())] +
+            [cell->EffectiveColumnIndexOfCellAfter()] +
         horizontal_border_spacing));
   else
     cell_location.SetX(
         LayoutUnit(Table()->EffectiveColumnPositions()[effective_column] +
                    horizontal_border_spacing));
 
   cell->SetLogicalLocation(cell_location);
 }
 
 void LayoutTableSection::RelayoutCellIfFlexed(LayoutTableCell& cell,
@@ skipping 199 matching lines @@
     rect.SetHeight(Table()->LogicalHeight());
     transform_state.SetQuad(FloatQuad(rect));
   }
   return LayoutTableBoxComponent::MapToVisualRectInAncestorSpaceInternal(
       ancestor, transform_state, flags);
 }
 
 bool LayoutTableSection::PaintedOutputOfObjectHasNoEffectRegardlessOfSize()
     const {
   // LayoutTableSection paints background from columns.
-  if (Table()->HasColElements())
+  if (Table()->HasColOrColGroups())
     return false;
   return LayoutTableBoxComponent::
       PaintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink