Extract LayoutTableSection::CellStruct to a standalone class TableGridCell

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 11 matching lines @@
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef LayoutTableSection_h
 #define LayoutTableSection_h
 
 #include "core/CoreExport.h"
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutTableBoxComponent.h"
+#include "core/layout/TableGridCell.h"
 #include "platform/wtf/Vector.h"
 
 namespace blink {
 
 // Helper class for paintObject.
 class CellSpan {
   STACK_ALLOCATED();
 
  public:
   CellSpan(unsigned start, unsigned end) : start_(start), end_(end) {}
@@ skipping 77 matching lines @@
   void LayoutRows();
   void ComputeOverflowFromDescendants();
   bool RecalcChildOverflowAfterStyleChange();
 
   void MarkAllCellsWidthsDirtyAndOrNeedsLayout(LayoutTable::WhatToMarkAllCells);
 
   LayoutTable* Table() const { return ToLayoutTable(Parent()); }
 
   typedef Vector<LayoutTableCell*, 2> SpanningLayoutTableCells;
 
-  // CellStruct represents the cells that occupy an (N, M) position in the
-  // table grid.
-  struct CellStruct {
-    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
-
-   public:
-    // All the cells that fills this grid "slot".
-    // Due to colspan / rowpsan, it is possible to have overlapping cells
-    // (see class comment about an example).
-    // This Vector is sorted in DOM order.
-    Vector<LayoutTableCell*, 1> cells;
-    bool in_col_span;  // true for columns after the first in a colspan
-
-    CellStruct();
-    ~CellStruct();
-
-    // This is the cell in the grid "slot" that is on top of the others
-    // (aka the last cell in DOM order for this slot).
-    //
-    // Multiple grid slots can have the same primary cell if the cell spans
-    // into the grid slots. The slot having the smallest row index and
-    // smallest effective column index is the originating slot of the cell.
-    //
-    // The concept of a primary cell is dubious at most as it doesn't
-    // correspond to a DOM or rendering concept. Also callers should be
-    // careful about assumptions about it. For example, even though the
-    // primary cell is visibly the top most, it is not guaranteed to be
-    // the only one visible for this slot due to different visual
-    // overflow rectangles.
-    LayoutTableCell* PrimaryCell() {
-      return HasCells() ? cells[cells.size() - 1] : 0;
-    }
-
-    const LayoutTableCell* PrimaryCell() const {
-      return HasCells() ? cells[cells.size() - 1] : 0;
-    }
-
-    bool HasCells() const { return cells.size() > 0; }
-  };
-
-  // The index is effective column index.
-  typedef Vector<CellStruct> Row;
-
-  struct RowStruct {
-    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
-
-   public:
-    RowStruct() : row_layout_object(nullptr), baseline(-1) {}
-
-    Row row;
-    LayoutTableRow* row_layout_object;
-    int baseline;
-    Length logical_height;
-  };
-
   struct SpanningRowsHeight {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(SpanningRowsHeight);
 
    public:
     SpanningRowsHeight()
         : total_rows_height(0),
           spanning_cell_height_ignoring_border_spacing(0),
           is_any_row_with_only_spanning_cells(false) {}
 
@@ skipping 16 matching lines @@
 
     return Style()->BorderStart();
   }
 
   BorderValue BorderAdjoiningStartCell(const LayoutTableCell*) const;
   BorderValue BorderAdjoiningEndCell(const LayoutTableCell*) const;
 
   const LayoutTableCell* FirstRowCellAdjoiningTableStart() const;
   const LayoutTableCell* FirstRowCellAdjoiningTableEnd() const;
 
-  CellStruct& CellAt(unsigned row, unsigned effective_column) {
-    return grid_[row].row[effective_column];
+  TableGridCell& GridCellAt(unsigned row, unsigned effective_column) {
+    return grid_[row].grid_cells[effective_column];
   }
-  const CellStruct& CellAt(unsigned row, unsigned effective_column) const {
-    return grid_[row].row[effective_column];
+  const TableGridCell& GridCellAt(unsigned row,
+                                  unsigned effective_column) const {
+    return grid_[row].grid_cells[effective_column];
   }
   LayoutTableCell* PrimaryCellAt(unsigned row, unsigned effective_column) {
-    Row& row_vector = grid_[row].row;
-    if (effective_column >= row_vector.size())
+    auto& grid_cells = grid_[row].grid_cells;
+    if (effective_column >= grid_cells.size())
       return nullptr;
-    return row_vector[effective_column].PrimaryCell();
+    return grid_cells[effective_column].PrimaryCell();
   }
   const LayoutTableCell* PrimaryCellAt(unsigned row,
                                        unsigned effective_column) const {
     return const_cast<LayoutTableSection*>(this)->PrimaryCellAt(
         row, effective_column);
   }
 
   // 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].row.size(); }
+  unsigned NumCols(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_layout_object;
-  }
+  LayoutTableRow* RowLayoutObjectAt(unsigned row) { return grid_[row].row; }
   const LayoutTableRow* RowLayoutObjectAt(unsigned row) const {
-    return grid_[row].row_layout_object;
+    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();
@@ skipping 99 matching lines @@
                    HitTestAction) override;
 
  private:
   bool IsOfType(LayoutObjectType type) const override {
     return type == kLayoutObjectTableSection || LayoutBox::IsOfType(type);
   }
 
   void WillBeRemovedFromTree() override;
 
   int BorderSpacingForRow(unsigned row) const {
-    return grid_[row].row_layout_object ? Table()->VBorderSpacing() : 0;
+    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))
-      grid_[row_index].row.Grow(num_cols);
+      grid_[row_index].grid_cells.Grow(num_cols);
   }
 
   bool RowHasOnlySpanningCells(unsigned);
   unsigned CalcRowHeightHavingOnlySpanningCells(unsigned,
                                                 int&,
                                                 unsigned,
                                                 unsigned&,
                                                 Vector<int>&);
   void UpdateRowsHeightHavingOnlySpanningCells(LayoutTableCell*,
                                                struct SpanningRowsHeight&,
@@ skipping 43 matching lines @@
   void RelayoutCellIfFlexed(LayoutTableCell&, int row_index, int row_height);
 
   int LogicalHeightForRow(const LayoutTableRow&) const;
 
   // Honor breaking restrictions inside the table row, and adjust position and
   // size accordingly.
   void AdjustRowForPagination(LayoutTableRow&, SubtreeLayoutScope&);
 
   bool PaintedOutputOfObjectHasNoEffectRegardlessOfSize() const override;
 
-  // The representation of the rows and their cells (CellStruct).
-  Vector<RowStruct> grid_;
+  struct GridRow {

[dgrogan, 2017/05/15 19:53:38]

TableGridRow for consistency with the new class?

[Xianzhu, 2017/05/15 20:28:38]

Done.

+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
+
+   public:
+    inline void SetRowLogicalHeightToRowStyleLogicalHeight();
+    inline void UpdateLogicalHeightForCell(const LayoutTableCell*);
+
+    // The index is effective column index.
+    Vector<TableGridCell> grid_cells;

[dgrogan, 2017/05/15 19:53:38]

This is so much clearer than the old "typedef Vector<blah> row".

+    LayoutTableRow* row = nullptr;

[dgrogan, 2017/05/15 19:53:38]

I know it's longer, but wdyt about s/row/layout_table_row/ or reverting back to
row_layout_object? This CL does a great job disambiguating layout objects from
grid objects except here, where it's not clear from the member name which it is.

Eh, after reading the whole CL, it's not that hard to remember that row means
LayoutTableRow. Up to you.

[Xianzhu, 2017/05/15 20:28:38]

I prefer the shorter name :)

+    int baseline = -1;
+    Length logical_height;
+  };
+
+  // The representation of the rows and their grid cells.
+  Vector<GridRow> grid_;
 
   // The logical offset of each row from the top of the section.
   //
   // Note that this Vector has one more entry than the number of rows so that
   // we can keep track of the final size of the section. That is,
   // m_rowPos[m_grid.size()] is a valid entry.
   //
   // To know a row's height at |rowIndex|, use the formula:
   // m_rowPos[rowIndex + 1] - m_rowPos[rowIndex]
   Vector<int> row_pos_;
@@ skipping 33 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