Replace LayoutTableCell::AbsoluteColumnIndex() with EffectiveColumnIndex()

third_party/WebKit/Source/core/layout/LayoutTable.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, 2010 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 109 matching lines @@
 //
 // The following example would have 2 entries [ 3, 2 ] in effectiveColumns():
 // <table>
 //   <tr>
 //     <td colspan="3"></td>
 //     <td colspan="2"></td>
 //   </tr>
 // </table>
 //
 // Columns can be split if we add a row with a different colspan structure.
-// See splitEffectiveColumn() and appendEffectiveColumn() for operations
-// over effectiveColumns() and effectiveColumnPositions().
+// See SplitEffectiveColumn() and AppendEffectiveColumn() for operations
+// over EffectiveColumns() and EffectiveColumnPositions().
 //
 // See absoluteColumnToEffectiveColumn() for converting an absolute column
 // index into an index into effectiveColumns() and effectiveColumnPositions().
 
 class CORE_EXPORT LayoutTable final : public LayoutBlock {
  public:
   explicit LayoutTable(Element*);
   ~LayoutTable() override;
 
   // Per CSS 3 writing-mode: "The first and second values of the
@@ skipping 207 matching lines @@
     // 'border-spacing' only applies to separate borders (see 17.6.1 The
     // separated borders model).
     return BorderStart() + BorderEnd() +
            (ShouldCollapseBorders() ? LayoutUnit()
                                     : (PaddingStart() + PaddingEnd() +
                                        BorderSpacingInRowDirection()));
   }
 
   // Return the first column or column-group.
   LayoutTableCol* FirstColumn() const;
+  LayoutTableCol* FirstInnermostColumn() const;
 
   struct ColAndColGroup {
     ColAndColGroup()
         : col(nullptr),
           colgroup(nullptr),
           adjoins_start_border_of_col_group(false),
           adjoins_end_border_of_col_group(false) {}
     LayoutTableCol* col;
     LayoutTableCol* colgroup;
     bool adjoins_start_border_of_col_group;
     bool adjoins_end_border_of_col_group;
     LayoutTableCol* InnermostColOrColGroup() { return col ? col : colgroup; }
   };
-  ColAndColGroup ColElementAtAbsoluteColumn(
-      unsigned absolute_column_index) const {
-    // The common case is to not have col/colgroup elements, make that case
-    // fast.
-    if (!has_col_elements_)
+  ColAndColGroup ColAndColGroupAtEffectiveColumn(
+      unsigned effective_column) const {
+    if (!cols_at_effective_columns_valid_)
+      UpdateColsAtEffectiveColumns();
+    if (!cols_at_effective_columns_ ||
+        effective_column >= cols_at_effective_columns_->size())
       return ColAndColGroup();
-    return SlowColElementAtAbsoluteColumn(absolute_column_index);
+    return cols_at_effective_columns_->at(effective_column);
   }
-  bool HasColElements() const { return has_col_elements_; }
+  bool HasColOrColGroups() const {
+    if (!cols_at_effective_columns_valid_)
+      UpdateColsAtEffectiveColumns();
+    return !!cols_at_effective_columns_;
+  }
 
   bool NeedsSectionRecalc() const { return needs_section_recalc_; }
   void SetNeedsSectionRecalc() {
     if (DocumentBeingDestroyed())
       return;
     // For all we know, sections may have been deleted at this point. Don't
     // keep pointers dangling around.
     head_ = nullptr;
     foot_ = nullptr;
     first_body_ = nullptr;
@@ skipping 103 matching lines @@
                    HitTestAction) override;
 
   int BaselinePosition(
       FontBaseline,
       bool first_line,
       LineDirectionMode,
       LinePositionMode = kPositionOnContainingLine) const override;
   int FirstLineBoxBaseline() const override;
   int InlineBlockBaseline(LineDirectionMode) const override;
 
-  ColAndColGroup SlowColElementAtAbsoluteColumn(unsigned col) const;
-
-  void UpdateColumnCache() const;
-  void InvalidateCachedColumns();
+  void UpdateColsAtEffectiveColumns() const;
+  void InvalidateColsAtEffectiveColumns() const;
 
   void UpdateLogicalWidth() override;
 
   LayoutUnit ConvertStyleLogicalWidthToComputedWidth(
       const Length& style_logical_width,
       LayoutUnit available_width) const;
   LayoutUnit ConvertStyleLogicalHeightToComputedHeight(
       const Length& style_logical_height) const;
 
   LayoutRect OverflowClipRect(
@@ skipping 32 matching lines @@
   // Holds the logical layout positions of effective columns, and the last item
   // (whose index is numEffectiveColumns()) holds the position of the imaginary
   // column after the last column.
   // Because of the last item, m_effectiveColumnPositions.size() is always
   // numEffectiveColumns() + 1.
   mutable Vector<int> effective_column_positions_;
 
   // The captions associated with this object.
   mutable Vector<LayoutTableCaption*> captions_;
 
-  // Holds pointers to LayoutTableCol objects for <col>s and <colgroup>s under
-  // this table.
-  // There is no direct relationship between the size of and index into this
-  // vector and those of m_effectiveColumns because they hold different things.
-  mutable Vector<LayoutTableCol*> column_layout_objects_;
+  // Stores cached ColAndColGroup structures at effective columns.
+  mutable std::unique_ptr<Vector<ColAndColGroup>> cols_at_effective_columns_;
 
   mutable LayoutTableSection* head_;
   mutable LayoutTableSection* foot_;
   mutable LayoutTableSection* first_body_;
 
   // The layout algorithm used by this table.
   //
   // CSS 2.1 defines 2 types of table layouts toggled with 'table-layout':
   // fixed (TableLayoutAlgorithmFixed) and auto (TableLayoutAlgorithmAuto).
   // See http://www.w3.org/TR/CSS21/tables.html#width-layout.
   //
   // The layout algorithm is delegated to TableLayoutAlgorithm. This enables
   // changing 'table-layout' without having to reattach the <table>.
   //
   // As the algorithm is dependent on the style, this field is nullptr before
   // the first style is applied in styleDidChange().
   std::unique_ptr<TableLayoutAlgorithm> table_layout_;
 
   // A sorted list of all unique border values that we want to paint.
   //
   // Collapsed borders are SUPER EXPENSIVE to compute. The reason is that we
   // need to compare a cells border against all the adjoining cells, rows,
   // row groups, column, column groups and table. Thus we cache them in this
   // field.
   CollapsedBorderValues collapsed_borders_;
   bool collapsed_borders_valid_ : 1;
   bool needs_invalidate_collapsed_borders_for_all_cells_ : 1;
 
-  mutable bool has_col_elements_ : 1;
   mutable bool needs_section_recalc_ : 1;
 
   bool column_logical_width_changed_ : 1;
-  mutable bool column_layout_objects_valid_ : 1;
+  mutable bool cols_at_effective_columns_valid_ : 1;
   mutable unsigned no_cell_colspan_at_least_;
   unsigned CalcNoCellColspanAtLeast() const {
     for (unsigned c = 0; c < NumEffectiveColumns(); c++) {
       if (effective_columns_[c].span > 1)
         return c;
     }
     return NumEffectiveColumns();
   }
 
   short h_spacing_;
@@ skipping 13 matching lines @@
   if (first_body_)
     return first_body_;
   return foot_;
 }
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutTable, IsTable());
 
 }  // namespace blink
 
 #endif  // LayoutTable_h