Replace LayoutTableCell::AbsoluteColumnIndex() with EffectiveColumnIndex()

third_party/WebKit/Source/core/layout/LayoutTable.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, 2007, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 40 matching lines @@
 
 using namespace HTMLNames;
 
 LayoutTable::LayoutTable(Element* element)
     : LayoutBlock(element),
       head_(nullptr),
       foot_(nullptr),
       first_body_(nullptr),
       collapsed_borders_valid_(false),
       needs_invalidate_collapsed_borders_for_all_cells_(false),
-      has_col_elements_(false),
       needs_section_recalc_(false),
       column_logical_width_changed_(false),
-      column_layout_objects_valid_(false),
+      // This is initially true because we don't have column elements initially.
+      cols_at_effective_columns_valid_(true),
       no_cell_colspan_at_least_(0),
       h_spacing_(0),
       v_spacing_(0),
       border_start_(0),
       border_end_(0) {
   DCHECK(!ChildrenInline());
   effective_column_positions_.Fill(0, 1);
 }
 
 LayoutTable::~LayoutTable() {}
@@ skipping 54 matching lines @@
   // wrapped in a table section box.
   EDisplay display = object->Style()->Display();
   return display != EDisplay::kTableCaption &&
          display != EDisplay::kTableColumnGroup &&
          display != EDisplay::kTableColumn;
 }
 
 void LayoutTable::AddChild(LayoutObject* child, LayoutObject* before_child) {
   bool wrap_in_anonymous_section = !child->IsOutOfFlowPositioned();
 
-  if (child->IsTableCaption()) {
-    wrap_in_anonymous_section = false;
-  } else if (child->IsLayoutTableCol()) {
-    has_col_elements_ = true;
+  if (child->IsTableCaption() || child->IsLayoutTableCol()) {
     wrap_in_anonymous_section = false;
   } else if (child->IsTableSection()) {
     switch (child->Style()->Display()) {
       case EDisplay::kTableHeaderGroup:
         ResetSectionPointerIfNotBefore(head_, before_child);
         if (!head_) {
           head_ = ToLayoutTableSection(child);
         } else {
           ResetSectionPointerIfNotBefore(first_body_, before_child);
           if (!first_body_)
@@ skipping 76 matching lines @@
 
 void LayoutTable::RemoveCaption(const LayoutTableCaption* old_caption) {
   size_t index = captions_.Find(old_caption);
   DCHECK_NE(index, kNotFound);
   if (index == kNotFound)
     return;
 
   captions_.erase(index);
 }
 
-void LayoutTable::InvalidateCachedColumns() {
-  column_layout_objects_valid_ = false;
-  column_layout_objects_.resize(0);
+void LayoutTable::InvalidateColsAtEffectiveColumns() const {
+  cols_at_effective_columns_valid_ = false;
+  cols_at_effective_columns_ = nullptr;
 }
 
 void LayoutTable::AddColumn(const LayoutTableCol*) {
-  InvalidateCachedColumns();
+  InvalidateColsAtEffectiveColumns();
 }
 
 void LayoutTable::RemoveColumn(const LayoutTableCol*) {
-  InvalidateCachedColumns();
-  // We don't really need to recompute our sections, but we need to update our
-  // column count and whether we have a column. Currently, we only have one
-  // size-fit-all flag but we may have to consider splitting it.
-  SetNeedsSectionRecalc();
+  InvalidateColsAtEffectiveColumns();
 }
 
 bool LayoutTable::IsLogicalWidthAuto() const {
   Length style_logical_width = Style()->LogicalWidth();
   return (!style_logical_width.IsSpecified() ||
           !style_logical_width.IsPositive()) &&
          !style_logical_width.IsIntrinsic();
 }
 
 void LayoutTable::UpdateLogicalWidth() {
@@ skipping 738 matching lines @@
       continue;
 
     LayoutTableSection* section = ToLayoutTableSection(child);
     if (section->NeedsCellRecalc())
       continue;
 
     section->SplitEffectiveColumn(index, first_span);
   }
 
   effective_column_positions_.Grow(NumEffectiveColumns() + 1);
+
+  InvalidateColsAtEffectiveColumns();
 }
 
 void LayoutTable::AppendEffectiveColumn(unsigned span) {
   unsigned new_column_index = effective_columns_.size();
   effective_columns_.push_back(span);
 
   // Unless the table has cell(s) with colspan that exceed the number of columns
   // afforded by the other rows in the table we can use the fast path when
   // mapping columns to effective columns.
   if (span == 1 && no_cell_colspan_at_least_ + 1 == NumEffectiveColumns()) {
     no_cell_colspan_at_least_++;
   }
 
   // Propagate the change in our columns representation to the sections that
   // don't need cell recalc. If they do, they will be synced up directly with
   // m_columns later.
   for (LayoutObject* child = FirstChild(); child;
        child = child->NextSibling()) {
     if (!child->IsTableSection())
       continue;
 
     LayoutTableSection* section = ToLayoutTableSection(child);
     if (section->NeedsCellRecalc())
       continue;
 
     section->AppendEffectiveColumn(new_column_index);
   }
 
   effective_column_positions_.Grow(NumEffectiveColumns() + 1);
+
+  InvalidateColsAtEffectiveColumns();
 }
 
 LayoutTableCol* LayoutTable::FirstColumn() const {
   for (LayoutObject* child = FirstChild(); child;
        child = child->NextSibling()) {
     if (child->IsLayoutTableCol())
       return ToLayoutTableCol(child);
   }
 
   return nullptr;
 }
 
-void LayoutTable::UpdateColumnCache() const {
-  DCHECK(has_col_elements_);
-  DCHECK(column_layout_objects_.IsEmpty());
-  DCHECK(!column_layout_objects_valid_);
-
-  for (LayoutTableCol* column_layout_object = FirstColumn();
-       column_layout_object;
-       column_layout_object = column_layout_object->NextColumn()) {
-    if (column_layout_object->IsTableColumnGroupWithColumnChildren())
-      continue;
-    column_layout_objects_.push_back(column_layout_object);
-  }
-  column_layout_objects_valid_ = true;
+LayoutTableCol* LayoutTable::FirstInnermostColumn() const {
+  auto* col = FirstColumn();
+  return !col || col->IsInnermost() ? col : col->NextInnermostColumn();
 }
 
-LayoutTable::ColAndColGroup LayoutTable::SlowColElementAtAbsoluteColumn(
-    unsigned absolute_column_index) const {
-  DCHECK(has_col_elements_);
+void LayoutTable::UpdateColsAtEffectiveColumns() const {
+  DCHECK(!NeedsSectionRecalc());
+  DCHECK(!cols_at_effective_columns_valid_);
+  DCHECK(!cols_at_effective_columns_);
 
-  if (!column_layout_objects_valid_)
-    UpdateColumnCache();
+  cols_at_effective_columns_valid_ = true;
+  auto* col = FirstInnermostColumn();
+  if (!col)
+    return;
 
-  unsigned column_count = 0;
-  for (unsigned i = 0; i < column_layout_objects_.size(); i++) {
-    LayoutTableCol* column_layout_object = column_layout_objects_[i];
-    DCHECK(!column_layout_object->IsTableColumnGroupWithColumnChildren());
-    unsigned span = column_layout_object->Span();
-    unsigned start_col = column_count;
-    DCHECK_GE(span, 1u);
-    unsigned end_col = column_count + span - 1;
-    column_count += span;
-    if (column_count > absolute_column_index) {
-      ColAndColGroup col_and_col_group;
-      bool is_at_start_edge = start_col == absolute_column_index;
-      bool is_at_end_edge = end_col == absolute_column_index;
-      if (column_layout_object->IsTableColumnGroup()) {
-        col_and_col_group.colgroup = column_layout_object;
-        col_and_col_group.adjoins_start_border_of_col_group = is_at_start_edge;
-        col_and_col_group.adjoins_end_border_of_col_group = is_at_end_edge;
-      } else {
-        col_and_col_group.col = column_layout_object;
-        col_and_col_group.colgroup =
-            column_layout_object->EnclosingColumnGroup();
-        if (col_and_col_group.colgroup) {
-          col_and_col_group.adjoins_start_border_of_col_group =
-              is_at_start_edge && !col_and_col_group.col->PreviousSibling();
-          col_and_col_group.adjoins_end_border_of_col_group =
-              is_at_end_edge && !col_and_col_group.col->NextSibling();
-        }
+  cols_at_effective_columns_ = WTF::MakeUnique<Vector<ColAndColGroup>>();
+
+  unsigned absolute_column_index = 0;
+  unsigned col_absolute_column_index = 0;
+  unsigned next_col_absolute_column_index = col->Span();
+  for (unsigned effective_column_index = 0;
+       col && effective_column_index < effective_columns_.size();
+       effective_column_index++) {
+    unsigned next_absolute_column_index =
+        absolute_column_index + effective_columns_[effective_column_index].span;
+    bool is_at_start_edge = absolute_column_index == col_absolute_column_index;
+    bool is_at_end_edge =
+        next_absolute_column_index == next_col_absolute_column_index;
+    ColAndColGroup col_and_col_group;
+    if (col->IsTableColumnGroup()) {
+      col_and_col_group.colgroup = col;
+      col_and_col_group.adjoins_start_border_of_col_group = is_at_start_edge;
+      col_and_col_group.adjoins_end_border_of_col_group = is_at_end_edge;
+    } else {
+      col_and_col_group.col = col;
+      col_and_col_group.colgroup = col->EnclosingColumnGroup();
+      if (col_and_col_group.colgroup) {
+        col_and_col_group.adjoins_start_border_of_col_group =
+            is_at_start_edge && !col->PreviousSibling();
+        col_and_col_group.adjoins_end_border_of_col_group =
+            is_at_end_edge && !col->NextSibling();
       }
-      return col_and_col_group;
     }
+
+    // Skip useless col objects that don't generate effective columns.
+    while (next_absolute_column_index >= next_col_absolute_column_index) {
+      if (next_col_absolute_column_index == next_absolute_column_index &&
+          !col_and_col_group.adjoins_end_border_of_col_group &&
+          col_and_col_group.colgroup == col->EnclosingColumnGroup()) {
+        // Special case: the effective column adjoins the end border of
+        // col_and_col_group.colgroup though it doesn't adjoin the end border of
+        // col_and_col_group.col. All subsequent cols of col_and_col_group.col
+        // don't generate new effective columns.
+        col_and_col_group.adjoins_end_border_of_col_group = true;
+      }
+
+      col_absolute_column_index = next_col_absolute_column_index;
+      col = col->NextInnermostColumn();
+      if (!col)
+        break;
+      next_col_absolute_column_index += col->Span();
+    }
+
+    absolute_column_index = next_absolute_column_index;
+    cols_at_effective_columns_->push_back(col_and_col_group);
   }
-  return ColAndColGroup();
 }
 
 void LayoutTable::RecalcSections() const {
   DCHECK(needs_section_recalc_);
 
   head_ = nullptr;
   foot_ = nullptr;
   first_body_ = nullptr;
-  has_col_elements_ = false;
 
   // We need to get valid pointers to caption, head, foot and first body again
   LayoutObject* next_sibling;
   for (LayoutObject* child = FirstChild(); child; child = next_sibling) {
     next_sibling = child->NextSibling();
     switch (child->Style()->Display()) {
-      case EDisplay::kTableColumn:
-      case EDisplay::kTableColumnGroup:
-        has_col_elements_ = true;
-        break;
       case EDisplay::kTableHeaderGroup:
         if (child->IsTableSection()) {
           LayoutTableSection* section = ToLayoutTableSection(child);
           if (!head_)
             head_ = section;
           else if (!first_body_)
             first_body_ = section;
           section->RecalcCellsIfNeeded();
         }
         break;
@@ skipping 20 matching lines @@
     }
   }
 
   // repair column count (addChild can grow it too much, because it always adds
   // elements to the last row of a section)
   unsigned max_cols = 0;
   for (LayoutObject* child = FirstChild(); child;
        child = child->NextSibling()) {
     if (child->IsTableSection()) {
       LayoutTableSection* section = ToLayoutTableSection(child);
-      unsigned section_cols = section->NumEffectiveColumns();
+      unsigned section_cols = section->MaxNumEffectiveColumnsOfRows();
       if (section_cols > max_cols)
         max_cols = section_cols;
     }
   }
 
   effective_columns_.resize(max_cols);
   effective_column_positions_.resize(max_cols + 1);
   no_cell_colspan_at_least_ = CalcNoCellColspanAtLeast();
 
+  InvalidateColsAtEffectiveColumns();
+
   DCHECK(SelfNeedsLayout());
 
   needs_section_recalc_ = false;
 }
 
 int LayoutTable::CalcBorderStart() const {
   if (!ShouldCollapseBorders())
     return LayoutBlock::BorderStart().ToInt();
 
   // Determined by the first cell of the first row. See the CSS 2.1 spec,
   // section 17.6.2.
   if (!NumEffectiveColumns())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& table_start_border = Style()->BorderStart();
   if (table_start_border.Style() == EBorderStyle::kHidden)
     return 0;
   if (table_start_border.Style() > EBorderStyle::kHidden)
     border_width = table_start_border.Width();
 
   // TODO(dgrogan): This logic doesn't properly account for the first column in
   // the first column-group case.
   if (LayoutTableCol* column =
-          ColElementAtAbsoluteColumn(0).InnermostColOrColGroup()) {
+          ColAndColGroupAtEffectiveColumn(0).InnermostColOrColGroup()) {
     // FIXME: We don't account for direction on columns and column groups.
     const BorderValue& column_adjoining_border = column->Style()->BorderStart();
     if (column_adjoining_border.Style() == EBorderStyle::kHidden)
       return 0;
     if (column_adjoining_border.Style() > EBorderStyle::kHidden)
       border_width =
           std::max<int>(border_width, column_adjoining_border.Width());
   }
 
   if (const LayoutTableSection* top_non_empty_section =
@@ skipping 47 matching lines @@
   const BorderValue& table_end_border = Style()->BorderEnd();
   if (table_end_border.Style() == EBorderStyle::kHidden)
     return 0;
   if (table_end_border.Style() > EBorderStyle::kHidden)
     border_width = table_end_border.Width();
 
   unsigned end_column = NumEffectiveColumns() - 1;
 
   // TODO(dgrogan): This logic doesn't properly account for the last column in
   // the last column-group case.
-  if (LayoutTableCol* column =
-          ColElementAtAbsoluteColumn(end_column).InnermostColOrColGroup()) {
+  if (LayoutTableCol* column = ColAndColGroupAtEffectiveColumn(end_column)
+                                   .InnermostColOrColGroup()) {
     // FIXME: We don't account for direction on columns and column groups.
     const BorderValue& column_adjoining_border = column->Style()->BorderEnd();
     if (column_adjoining_border.Style() == EBorderStyle::kHidden)
       return 0;
     if (column_adjoining_border.Style() > EBorderStyle::kHidden)
       border_width =
           std::max<int>(border_width, column_adjoining_border.Width());
   }
 
   if (const LayoutTableSection* top_non_empty_section =
@@ skipping 223 matching lines @@
     r_above = r - 1;
   } else {
     section = SectionAbove(cell->Section(), kSkipEmptySections);
     if (section) {
       DCHECK(section->NumRows());
       r_above = section->NumRows() - 1;
     }
   }
 
   // Look up the cell in the section's grid, which requires effective col index
-  if (section) {
-    unsigned eff_col =
-        AbsoluteColumnToEffectiveColumn(cell->AbsoluteColumnIndex());
-    return section->PrimaryCellAt(r_above, eff_col);
-  }
+  if (section)
+    return section->PrimaryCellAt(r_above, cell->EffectiveColumnIndex());
   return nullptr;
 }
 
 LayoutTableCell* LayoutTable::CellBelow(const LayoutTableCell* cell) const {
   RecalcSectionsIfNeeded();
 
   // Find the section and row to look in
   unsigned r = cell->RowIndex() + cell->RowSpan() - 1;
   LayoutTableSection* section = nullptr;
   unsigned r_below = 0;
   if (r < cell->Section()->NumRows() - 1) {
     // The cell is not in the last row, so use the next row in the section.
     section = cell->Section();
     r_below = r + 1;
   } else {
     section = SectionBelow(cell->Section(), kSkipEmptySections);
     if (section)
       r_below = 0;
   }
 
   // Look up the cell in the section's grid, which requires effective col index
-  if (section) {
-    unsigned eff_col =
-        AbsoluteColumnToEffectiveColumn(cell->AbsoluteColumnIndex());
-    return section->PrimaryCellAt(r_below, eff_col);
-  }
+  if (section)
+    return section->PrimaryCellAt(r_below, cell->EffectiveColumnIndex());
   return nullptr;
 }
 
 LayoutTableCell* LayoutTable::CellBefore(const LayoutTableCell* cell) const {
   RecalcSectionsIfNeeded();
 
-  LayoutTableSection* section = cell->Section();
-  unsigned eff_col =
-      AbsoluteColumnToEffectiveColumn(cell->AbsoluteColumnIndex());
+  unsigned eff_col = cell->EffectiveColumnIndex();
   if (!eff_col)
     return nullptr;
 
   // If we hit a colspan back up to a real cell.
-  return section->PrimaryCellAt(cell->RowIndex(), eff_col - 1);
+  return cell->Section()->PrimaryCellAt(cell->RowIndex(), eff_col - 1);
 }
 
 LayoutTableCell* LayoutTable::CellAfter(const LayoutTableCell* cell) const {
   RecalcSectionsIfNeeded();
 
-  unsigned eff_col = AbsoluteColumnToEffectiveColumn(
-      cell->AbsoluteColumnIndex() + cell->ColSpan());
-  return cell->Section()->PrimaryCellAt(cell->RowIndex(), eff_col);
+  return cell->Section()->PrimaryCellAt(
+      cell->RowIndex(), cell->EffectiveColumnIndexOfCellAfter());
 }
 
 int LayoutTable::BaselinePosition(FontBaseline baseline_type,
                                   bool first_line,
                                   LineDirectionMode direction,
                                   LinePositionMode line_position_mode) const {
   DCHECK_EQ(line_position_mode, kPositionOnContainingLine);
   int baseline = FirstLineBoxBaseline();
   if (baseline != -1) {
     if (IsInline())
@@ skipping 183 matching lines @@
 }
 
 LayoutUnit LayoutTable::PaddingRight() const {
   if (ShouldCollapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::PaddingRight();
 }
 
 }  // namespace blink