Replace LayoutTableCell::AbsoluteColumnIndex() with EffectiveColumnIndex()

third_party/WebKit/Source/core/layout/LayoutTableCell.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 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 147 matching lines @@
       LayoutInvalidationReason::kAttributeChanged);
   if (Parent() && Section())
     Section()->SetNeedsCellRecalc();
 }
 
 Length LayoutTableCell::LogicalWidthFromColumns(
     LayoutTableCol* first_col_for_this_cell,
     Length width_from_style) const {
   DCHECK(first_col_for_this_cell);
   DCHECK_EQ(first_col_for_this_cell,
-            Table()
-                ->ColElementAtAbsoluteColumn(AbsoluteColumnIndex())
-                .InnermostColOrColGroup());
+            GetColAndColGroup().InnermostColOrColGroup());
   LayoutTableCol* table_col = first_col_for_this_cell;
 
   unsigned col_span_count = ColSpan();
   int col_width_sum = 0;
   for (unsigned i = 1; i <= col_span_count; i++) {
     Length col_width = table_col->Style()->LogicalWidth();
 
     // Percentage value should be returned only for colSpan == 1.
     // Otherwise we return original width for the cell.
     if (!col_width.IsFixed()) {
@@ skipping 406 matching lines @@
   // row over row group, etc.)
   return border1.Precedence() < border2.Precedence();
 }
 
 static CollapsedBorderValue ChooseBorder(const CollapsedBorderValue& border1,
                                          const CollapsedBorderValue& border2) {
   return CompareBorders(border1, border2) ? border2 : border1;
 }
 
 bool LayoutTableCell::IsInStartColumn() const {
-  return !AbsoluteColumnIndex();
+  return !EffectiveColumnIndex();
 }
 
 bool LayoutTableCell::IsInEndColumn() const {
-  return Table()->AbsoluteColumnToEffectiveColumn(AbsoluteColumnIndex() +
-                                                  ColSpan() - 1) ==
-         Table()->NumEffectiveColumns() - 1;
+  return EffectiveColumnIndexOfCellAfter() >= Table()->NumEffectiveColumns();
 }
 
 bool LayoutTableCell::HasStartBorderAdjoiningTable() const {
   // The table direction determines the row direction. In mixed directionality,
   // we cannot guarantee that we have a common border with the table (think a
   // ltr table with rtl start cell).
   return HasSameDirectionAs(Table()) ? IsInStartColumn() : IsInEndColumn();
 }
 
 bool LayoutTableCell::HasEndBorderAdjoiningTable() const {
@@ skipping 58 matching lines @@
     result = ChooseBorder(
         result,
         CollapsedBorderValue(Section()->BorderAdjoiningStartCell(this),
                              Section()->ResolveColor(start_color_property),
                              kBorderPrecedenceRowGroup));
     if (!result.Exists())
       return result;
   }
 
   // (5) Our column and column group's start borders.
-  LayoutTable::ColAndColGroup col_and_col_group =
-      table->ColElementAtAbsoluteColumn(AbsoluteColumnIndex());
-  if (col_and_col_group.colgroup &&
-      col_and_col_group.adjoins_start_border_of_col_group) {
+  auto start_col = GetColAndColGroup();
+  if (start_col.colgroup && start_col.adjoins_start_border_of_col_group) {
     // Only apply the colgroup's border if this cell touches the colgroup edge.
     result = ChooseBorder(
-        result,
-        CollapsedBorderValue(
-            col_and_col_group.colgroup->BorderAdjoiningCellStartBorder(this),
-            col_and_col_group.colgroup->ResolveColor(start_color_property),
-            kBorderPrecedenceColumnGroup));
+        result, CollapsedBorderValue(
+                    start_col.colgroup->BorderAdjoiningCellStartBorder(this),
+                    start_col.colgroup->ResolveColor(start_color_property),
+                    kBorderPrecedenceColumnGroup));
     if (!result.Exists())
       return result;
   }
-  if (col_and_col_group.col) {
+  if (start_col.col) {
     // Always apply the col's border irrespective of whether this cell touches
     // it. This is per HTML5: "For the purposes of the CSS table model, the col
     // element is expected to be treated as if it "was present as many times as
     // its span attribute specifies".
     result = ChooseBorder(
         result, CollapsedBorderValue(
-                    col_and_col_group.col->BorderAdjoiningCellStartBorder(this),
-                    col_and_col_group.col->ResolveColor(start_color_property),
+                    start_col.col->BorderAdjoiningCellStartBorder(this),
+                    start_col.col->ResolveColor(start_color_property),
                     kBorderPrecedenceColumn));
     if (!result.Exists())
       return result;
   }
 
   // (6) The end border of the preceding column.
   if (cell_before) {
-    LayoutTable::ColAndColGroup col_and_col_group =
-        table->ColElementAtAbsoluteColumn(AbsoluteColumnIndex() - 1);
+    auto col_before =
+        table->ColAndColGroupAtEffectiveColumn(EffectiveColumnIndex() - 1);
     // Only apply the colgroup's border if this cell touches the colgroup edge.
-    if (col_and_col_group.colgroup &&
-        col_and_col_group.adjoins_end_border_of_col_group) {
+    if (col_before.colgroup && col_before.adjoins_end_border_of_col_group) {
       result = ChooseBorder(
           CollapsedBorderValue(
-              col_and_col_group.colgroup->BorderAdjoiningCellEndBorder(this),
-              col_and_col_group.colgroup->ResolveColor(end_color_property),
+              col_before.colgroup->BorderAdjoiningCellEndBorder(this),
+              col_before.colgroup->ResolveColor(end_color_property),
               kBorderPrecedenceColumnGroup),
           result);
       if (!result.Exists())
         return result;
     }
     // Always apply the col's border irrespective of whether this cell touches
     // it. This is per HTML5: "For the purposes of the CSS table model, the col
     // element is expected to be treated as if it "was present as many times as
     // its span attribute specifies".
-    if (col_and_col_group.col) {
+    if (col_before.col) {
       result = ChooseBorder(
-          CollapsedBorderValue(
-              col_and_col_group.col->BorderAdjoiningCellAfter(this),
-              col_and_col_group.col->ResolveColor(end_color_property),
-              kBorderPrecedenceColumn),
+          CollapsedBorderValue(col_before.col->BorderAdjoiningCellAfter(this),
+                               col_before.col->ResolveColor(end_color_property),
+                               kBorderPrecedenceColumn),
           result);
       if (!result.Exists())
         return result;
     }
   }
 
   if (start_border_adjoins_table) {
     // (7) The table's start border.
     result = ChooseBorder(
         result, CollapsedBorderValue(table->TableStartBorderAdjoiningCell(this),
@@ skipping 56 matching lines @@
     result = ChooseBorder(
         result,
         CollapsedBorderValue(Section()->BorderAdjoiningEndCell(this),
                              Section()->ResolveColor(end_color_property),
                              kBorderPrecedenceRowGroup));
     if (!result.Exists())
       return result;
   }
 
   // (5) Our column and column group's end borders.
-  LayoutTable::ColAndColGroup col_and_col_group =
-      table->ColElementAtAbsoluteColumn(AbsoluteColumnIndex() + ColSpan() - 1);
-  if (col_and_col_group.colgroup &&
-      col_and_col_group.adjoins_end_border_of_col_group) {
+  auto end_col = table->ColAndColGroupAtEffectiveColumn(
+      EffectiveColumnIndexOfCellAfter() - 1);
+  if (end_col.colgroup && end_col.adjoins_end_border_of_col_group) {
     // Only apply the colgroup's border if this cell touches the colgroup edge.
     result = ChooseBorder(
-        result,
-        CollapsedBorderValue(
-            col_and_col_group.colgroup->BorderAdjoiningCellEndBorder(this),
-            col_and_col_group.colgroup->ResolveColor(end_color_property),
-            kBorderPrecedenceColumnGroup));
+        result, CollapsedBorderValue(
+                    end_col.colgroup->BorderAdjoiningCellEndBorder(this),
+                    end_col.colgroup->ResolveColor(end_color_property),
+                    kBorderPrecedenceColumnGroup));
     if (!result.Exists())
       return result;
   }
-  if (col_and_col_group.col) {
+  if (end_col.col) {
     // Always apply the col's border irrespective of whether this cell touches
     // it. This is per HTML5: "For the purposes of the CSS table model, the col
     // element is expected to be treated as if it "was present as many times as
     // its span attribute specifies".
     result = ChooseBorder(
-        result, CollapsedBorderValue(
-                    col_and_col_group.col->BorderAdjoiningCellEndBorder(this),
-                    col_and_col_group.col->ResolveColor(end_color_property),
-                    kBorderPrecedenceColumn));
+        result,
+        CollapsedBorderValue(end_col.col->BorderAdjoiningCellEndBorder(this),
+                             end_col.col->ResolveColor(end_color_property),
+                             kBorderPrecedenceColumn));
     if (!result.Exists())
       return result;
   }
 
   // (6) The start border of the next column.
   if (!is_end_column) {
-    LayoutTable::ColAndColGroup col_and_col_group =
-        table->ColElementAtAbsoluteColumn(AbsoluteColumnIndex() + ColSpan());
-    if (col_and_col_group.colgroup &&
-        col_and_col_group.adjoins_start_border_of_col_group) {
+    auto col_after = table->ColAndColGroupAtEffectiveColumn(
+        EffectiveColumnIndexOfCellAfter());
+    if (col_after.colgroup && col_after.adjoins_start_border_of_col_group) {
       // Only apply the colgroup's border if this cell touches the colgroup
       // edge.
       result = ChooseBorder(
-          result,
-          CollapsedBorderValue(
-              col_and_col_group.colgroup->BorderAdjoiningCellStartBorder(this),
-              col_and_col_group.colgroup->ResolveColor(start_color_property),
-              kBorderPrecedenceColumnGroup));
+          result, CollapsedBorderValue(
+                      col_after.colgroup->BorderAdjoiningCellStartBorder(this),
+                      col_after.colgroup->ResolveColor(start_color_property),
+                      kBorderPrecedenceColumnGroup));
       if (!result.Exists())
         return result;
     }
-    if (col_and_col_group.col) {
+    if (col_after.col) {
       // Always apply the col's border irrespective of whether this cell touches
       // it. This is per HTML5: "For the purposes of the CSS table model, the
       // col element is expected to be treated as if it "was present as many
       // times as its span attribute specifies".
       result = ChooseBorder(
           result, CollapsedBorderValue(
-                      col_and_col_group.col->BorderAdjoiningCellBefore(this),
-                      col_and_col_group.col->ResolveColor(start_color_property),
+                      col_after.col->BorderAdjoiningCellBefore(this),
+                      col_after.col->ResolveColor(start_color_property),
                       kBorderPrecedenceColumn));
       if (!result.Exists())
         return result;
     }
   }
 
   if (end_border_adjoins_table) {
     // (7) The table's end border.
     result = ChooseBorder(
         result, CollapsedBorderValue(table->TableEndBorderAdjoiningCell(this),
                                      table->ResolveColor(end_color_property),
                                      kBorderPrecedenceTable));
     if (!result.Exists())
       return result;
   }
 
   return result;
 }
 
 CollapsedBorderValue LayoutTableCell::ComputeCollapsedBeforeBorder() const {
   LayoutTable* table = this->Table();
   LayoutTableCell* prev_cell = table->CellAbove(this);
   // We can use the border shared with |prev_cell| if it is valid.
   if (prev_cell && prev_cell->collapsed_border_values_valid_ &&
-      prev_cell->AbsoluteColumnIndex() == AbsoluteColumnIndex()) {
+      prev_cell->EffectiveColumnIndex() == EffectiveColumnIndex()) {
     return prev_cell->GetCollapsedBorderValues()
                ? prev_cell->GetCollapsedBorderValues()->AfterBorder()
                : CollapsedBorderValue();
   }
 
   // For before border, we need to check, in order of precedence:
   // (1) Our before border.
   int before_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderBeforeColor);
   int after_color_property =
@@ skipping 61 matching lines @@
                                curr_section->ResolveColor(after_color_property),
                                kBorderPrecedenceRowGroup),
           result);
       if (!result.Exists())
         return result;
     }
   }
 
   if (!curr_section) {
     // (8) Our column and column group's before borders.
-    LayoutTableCol* col_elt =
-        table->ColElementAtAbsoluteColumn(AbsoluteColumnIndex())
-            .InnermostColOrColGroup();
+    LayoutTableCol* col_elt = GetColAndColGroup().InnermostColOrColGroup();
     if (col_elt) {
       result = ChooseBorder(
           result,
           CollapsedBorderValue(col_elt->Style()->BorderBefore(),
                                col_elt->ResolveColor(before_color_property),
                                kBorderPrecedenceColumn));
       if (!result.Exists())
         return result;
       if (LayoutTableCol* enclosing_column_group =
               col_elt->EnclosingColumnGroup()) {
@@ skipping 18 matching lines @@
   }
 
   return result;
 }
 
 CollapsedBorderValue LayoutTableCell::ComputeCollapsedAfterBorder() const {
   LayoutTable* table = this->Table();
   LayoutTableCell* next_cell = table->CellBelow(this);
   // We can use the border shared with |next_cell| if it is valid.
   if (next_cell && next_cell->collapsed_border_values_valid_ &&
-      next_cell->AbsoluteColumnIndex() == AbsoluteColumnIndex()) {
+      next_cell->EffectiveColumnIndex() == EffectiveColumnIndex()) {
     return next_cell->GetCollapsedBorderValues()
                ? next_cell->GetCollapsedBorderValues()->BeforeBorder()
                : CollapsedBorderValue();
   }
 
   // For after border, we need to check, in order of precedence:
   // (1) Our after border.
   int before_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderBeforeColor);
   int after_color_property =
@@ skipping 52 matching lines @@
                       curr_section->Style()->BorderBefore(),
                       curr_section->ResolveColor(before_color_property),
                       kBorderPrecedenceRowGroup));
       if (!result.Exists())
         return result;
     }
   }
 
   if (!curr_section) {
     // (8) Our column and column group's after borders.
-    LayoutTableCol* col_elt =
-        table->ColElementAtAbsoluteColumn(AbsoluteColumnIndex())
-            .InnermostColOrColGroup();
+    LayoutTableCol* col_elt = GetColAndColGroup().InnermostColOrColGroup();
     if (col_elt) {
       result = ChooseBorder(
           result,
           CollapsedBorderValue(col_elt->Style()->BorderAfter(),
                                col_elt->ResolveColor(after_color_property),
                                kBorderPrecedenceColumn));
       if (!result.Exists())
         return result;
       if (LayoutTableCol* enclosing_column_group =
               col_elt->EnclosingColumnGroup()) {
@@ skipping 396 matching lines @@
 
   return LayoutBlock::HasLineIfEmpty();
 }
 
 PaintInvalidationReason LayoutTableCell::InvalidatePaint(
     const PaintInvalidatorContext& context) const {
   return TableCellPaintInvalidator(*this, context).InvalidatePaint();
 }
 
 }  // namespace blink