Extract LayoutTableSection::CellStruct to a standalone class TableGridCell

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 24 matching lines @@
 #include "core/layout/LayoutTableRow.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/SubtreeLayoutScope.h"
 #include "core/paint/TableSectionPainter.h"
 #include "platform/wtf/HashSet.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
-static inline void SetRowLogicalHeightToRowStyleLogicalHeight(
-    LayoutTableSection::RowStruct& row) {
-  DCHECK(row.row_layout_object);
-  row.logical_height = row.row_layout_object->Style()->LogicalHeight();
+void LayoutTableSection::TableGridRow::
+    SetRowLogicalHeightToRowStyleLogicalHeight() {
+  DCHECK(row);
+  logical_height = row->StyleRef().LogicalHeight();
 }
 
-static inline void UpdateLogicalHeightForCell(
-    LayoutTableSection::RowStruct& row,
+void LayoutTableSection::TableGridRow::UpdateLogicalHeightForCell(
     const LayoutTableCell* cell) {
   // We ignore height settings on rowspan cells.
   if (cell->RowSpan() != 1)
     return;
 
-  Length logical_height = cell->Style()->LogicalHeight();
-  if (logical_height.IsPositive()) {
-    Length c_row_logical_height = row.logical_height;
-    switch (logical_height.GetType()) {
+  Length cell_logical_height = cell->StyleRef().LogicalHeight();
+  if (cell_logical_height.IsPositive()) {
+    switch (cell_logical_height.GetType()) {
       case kPercent:
         // TODO(alancutter): Make this work correctly for calc lengths.
-        if (!(c_row_logical_height.IsPercentOrCalc()) ||
-            (c_row_logical_height.IsPercent() &&
-             c_row_logical_height.Percent() < logical_height.Percent()))
-          row.logical_height = logical_height;
+        if (!(logical_height.IsPercentOrCalc()) ||
+            (logical_height.IsPercent() &&
+             logical_height.Percent() < cell_logical_height.Percent()))
+          logical_height = cell_logical_height;
         break;
       case kFixed:
-        if (c_row_logical_height.GetType() < kPercent ||
-            (c_row_logical_height.IsFixed() &&
-             c_row_logical_height.Value() < logical_height.Value()))
-          row.logical_height = logical_height;
+        if (logical_height.GetType() < kPercent ||
+            (logical_height.IsFixed() &&
+             logical_height.Value() < cell_logical_height.Value()))
+          logical_height = cell_logical_height;
         break;
       default:
         break;
     }
   }
 }
 
 void CellSpan::EnsureConsistency(const unsigned maximum_span_size) {
   static_assert(std::is_same<decltype(start_), unsigned>::value,
                 "Asserts below assume start_ is unsigned");
   static_assert(std::is_same<decltype(end_), unsigned>::value,
                 "Asserts below assume end_ is unsigned");
   CHECK_LE(start_, maximum_span_size);
   CHECK_LE(end_, maximum_span_size);
   CHECK_LE(start_, end_);
 }
 
-LayoutTableSection::CellStruct::CellStruct() : in_col_span(false) {}
-
-LayoutTableSection::CellStruct::~CellStruct() {}
-
 LayoutTableSection::LayoutTableSection(Element* element)
     : LayoutTableBoxComponent(element),
       c_col_(0),
       c_row_(0),
       outer_border_start_(0),
       outer_border_end_(0),
       outer_border_before_(0),
       outer_border_after_(0),
       needs_cell_recalc_(false),
       force_full_paint_(false),
@@ skipping 81 matching lines @@
   if (before_child)
     SetNeedsCellRecalc();
 
   unsigned insertion_row = c_row_;
   ++c_row_;
   c_col_ = 0;
 
   EnsureRows(c_row_);
 
   LayoutTableRow* row = ToLayoutTableRow(child);
-  grid_[insertion_row].row_layout_object = row;
+  grid_[insertion_row].row = row;
   row->SetRowIndex(insertion_row);
 
   if (!before_child)
-    SetRowLogicalHeightToRowStyleLogicalHeight(grid_[insertion_row]);
+    grid_[insertion_row].SetRowLogicalHeightToRowStyleLogicalHeight();
 
   if (before_child && before_child->Parent() != this)
     before_child = SplitAnonymousBoxesAroundChild(before_child);
 
   DCHECK(!before_child || before_child->IsTableRow());
   LayoutTableBoxComponent::AddChild(child, before_child);
 }
 
 static inline void CheckThatVectorIsDOMOrdered(
     const Vector<LayoutTableCell*, 1>& cells) {
@@ skipping 23 matching lines @@
 }
 
 void LayoutTableSection::AddCell(LayoutTableCell* cell, LayoutTableRow* row) {
   // We don't insert the cell if we need cell recalc as our internal columns'
   // representation will have drifted from the table's representation. Also
   // recalcCells will call addCell at a later time after sync'ing our columns'
   // with the table's.
   if (NeedsCellRecalc())
     return;
 
+  DCHECK(cell);
   unsigned r_span = cell->RowSpan();
   unsigned c_span = cell->ColSpan();
   if (r_span > 1 || c_span > 1)
     has_spanning_cells_ = true;
 
   const Vector<LayoutTable::ColumnStruct>& columns =
       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);
-  while (c_col_ < n_cols && (CellAt(insertion_row, c_col_).HasCells() ||
-                             CellAt(insertion_row, c_col_).in_col_span))
+  while (c_col_ < n_cols && (GridCellAt(insertion_row, c_col_).HasCells() ||
+                             GridCellAt(insertion_row, c_col_).InColSpan()))
     c_col_++;
 
-  UpdateLogicalHeightForCell(grid_[insertion_row], cell);
+  grid_[insertion_row].UpdateLogicalHeightForCell(cell);
 
   EnsureRows(insertion_row + r_span);
 
-  grid_[insertion_row].row_layout_object = row;
+  grid_[insertion_row].row = row;
 
   unsigned col = c_col_;
   // tell the cell where it is
   bool in_col_span = false;
   unsigned col_size = columns.size();
   while (c_span) {
     unsigned current_span;
     if (c_col_ >= col_size) {
       Table()->AppendEffectiveColumn(c_span);
       current_span = c_span;
     } else {
       if (c_span < columns[c_col_].span)
         Table()->SplitEffectiveColumn(c_col_, c_span);
       current_span = columns[c_col_].span;
     }
     for (unsigned r = 0; r < r_span; r++) {
       EnsureCols(insertion_row + r, c_col_ + 1);
-      CellStruct& c = CellAt(insertion_row + r, c_col_);
-      DCHECK(cell);
-      c.cells.push_back(cell);
-      CheckThatVectorIsDOMOrdered(c.cells);
+      auto& grid_cell = GridCellAt(insertion_row + r, c_col_);
+      grid_cell.Cells().push_back(cell);
+      CheckThatVectorIsDOMOrdered(grid_cell.Cells());
       // If cells overlap then we take the special paint path for them.
-      if (c.cells.size() > 1)
+      if (grid_cell.Cells().size() > 1)
         has_multiple_cell_levels_ = true;
       if (in_col_span)
-        c.in_col_span = true;
+        grid_cell.SetInColSpan(true);
     }
     c_col_++;
     c_span -= current_span;
     in_col_span = true;
   }
   cell->SetAbsoluteColumnIndex(Table()->EffectiveColumnToAbsoluteColumn(col));
 }
 
 bool LayoutTableSection::RowHasOnlySpanningCells(unsigned row) {
-  unsigned total_cols = grid_[row].row.size();
-
-  if (!total_cols)
+  if (grid_[row].grid_cells.IsEmpty())
     return false;
 
-  for (unsigned col = 0; col < total_cols; col++) {
-    const CellStruct& row_span_cell = CellAt(row, col);
-
+  for (const auto& grid_cell : grid_[row].grid_cells) {
     // Empty cell is not a valid cell so it is not a rowspan cell.
-    if (row_span_cell.cells.IsEmpty())
+    if (!grid_cell.HasCells())
       return false;
 
-    if (row_span_cell.cells[0]->RowSpan() == 1)
+    if (grid_cell.Cells()[0]->RowSpan() == 1)
       return false;
   }
 
   return true;
 }
 
 void LayoutTableSection::PopulateSpanningRowsHeightFromCell(
     LayoutTableCell* cell,
     struct SpanningRowsHeight& spanning_rows_height) {
   const unsigned row_span = cell->RowSpan();
@@ skipping 208 matching lines @@
 }
 
 unsigned LayoutTableSection::CalcRowHeightHavingOnlySpanningCells(
     unsigned row,
     int& accumulated_cell_position_increase,
     unsigned row_to_apply_extra_height,
     unsigned& extra_table_height_to_propgate,
     Vector<int>& rows_count_with_only_spanning_cells) {
   DCHECK(RowHasOnlySpanningCells(row));
 
-  unsigned total_cols = grid_[row].row.size();
-
-  if (!total_cols)
-    return 0;
-
   unsigned row_height = 0;
 
-  for (unsigned col = 0; col < total_cols; col++) {
-    const CellStruct& row_span_cell = CellAt(row, col);
-
-    if (!row_span_cell.cells.size())
-      continue;
-
-    LayoutTableCell* cell = row_span_cell.cells[0];
-
-    if (cell->RowSpan() < 2)
-      continue;
+  for (const auto& row_span_cell : grid_[row].grid_cells) {
+    DCHECK(row_span_cell.HasCells());
+    LayoutTableCell* cell = row_span_cell.Cells()[0];
+    DCHECK_GE(cell->RowSpan(), 2u);
 
     const unsigned cell_row_index = cell->RowIndex();
     const unsigned cell_row_span = cell->RowSpan();
 
     // As we are going from the top of the table to the bottom to calculate the
     // row heights for rows that only contain spanning cells and all previous
     // rows are processed we only need to find the number of rows with spanning
     // cells from the current cell to the end of the current cells spanning
     // height.
     unsigned start_row_for_spanning_cell_count = std::max(cell_row_index, row);
@@ skipping 258 matching lines @@
   return Table()->VBorderSpacing();
 }
 
 int LayoutTableSection::CalcRowLogicalHeight() {
 #if DCHECK_IS_ON()
   SetLayoutNeededForbiddenScope layout_forbidden_scope(*this);
 #endif
 
   DCHECK(!NeedsLayout());
 
-  LayoutTableCell* cell;
-
   // We may have to forcefully lay out cells here, in which case we need a
   // layout state.
   LayoutState state(*this);
 
   row_pos_.resize(grid_.size() + 1);
   row_pos_[0] = VBorderSpacingBeforeFirstRow();
 
   SpanningLayoutTableCells row_span_cells;
 
   // At fragmentainer breaks we need to prevent rowspanned cells (and whatever
   // else) from distributing their extra height requirements over the rows that
   // it spans. Otherwise we'd need to refragment afterwards.
   unsigned index_of_first_stretchable_row = 0;
 
   for (unsigned r = 0; r < grid_.size(); r++) {
     grid_[r].baseline = -1;
     int baseline_descent = 0;
 
-    if (state.IsPaginated() && grid_[r].row_layout_object)
-      row_pos_[r] += grid_[r].row_layout_object->PaginationStrut().Ceil();
+    if (state.IsPaginated() && grid_[r].row)
+      row_pos_[r] += grid_[r].row->PaginationStrut().Ceil();
 
     if (grid_[r].logical_height.IsSpecified()) {
       // Our base size is the biggest logical height from our cells' styles
       // (excluding row spanning cells).
       row_pos_[r + 1] =
           std::max(row_pos_[r] + MinimumValueForLength(grid_[r].logical_height,
                                                        LayoutUnit())
                                      .Round(),
                    0);
     } else {
       // Non-specified lengths are ignored because the row already accounts for
       // the cells intrinsic logical height.
       row_pos_[r + 1] = std::max(row_pos_[r], 0);
     }
 
-    Row& row = grid_[r].row;
-    unsigned total_cols = row.size();
-
-    for (unsigned c = 0; c < total_cols; c++) {
-      CellStruct& current = CellAt(r, c);
-      if (current.in_col_span)
+    for (auto& grid_cell : grid_[r].grid_cells) {
+      if (grid_cell.InColSpan())
         continue;
-      for (unsigned i = 0; i < current.cells.size(); i++) {
-        cell = current.cells[i];
-
+      for (auto* cell : grid_cell.Cells()) {
         // For row spanning cells, we only handle them for the first row they
         // span. This ensures we take their baseline into account.
         if (cell->RowIndex() != r)
           continue;
 
         if (r < index_of_first_stretchable_row ||
             (state.IsPaginated() &&
              CrossesPageBoundary(
                  LayoutUnit(row_pos_[r]),
                  LayoutUnit(cell->LogicalHeightForRowSizing())))) {
@@ skipping 19 matching lines @@
         if (cell->RowSpan() == 1)
           row_pos_[r + 1] = std::max(
               row_pos_[r + 1], row_pos_[r] + cell->LogicalHeightForRowSizing());
 
         // Find out the baseline. The baseline is set on the first row in a
         // rowSpan.
         UpdateBaselineForCell(cell, r, baseline_descent);
       }
     }
 
-    if (r < index_of_first_stretchable_row && grid_[r].row_layout_object) {
+    if (r < index_of_first_stretchable_row && grid_[r].row) {
       // We're not allowed to resize this row. Just scratch what we've
       // calculated so far, and use the height that we got during initial
       // layout instead.
-      row_pos_[r + 1] =
-          row_pos_[r] + grid_[r].row_layout_object->LogicalHeight().ToInt();
+      row_pos_[r + 1] = row_pos_[r] + grid_[r].row->LogicalHeight().ToInt();
     }
 
     // Add the border-spacing to our final position.
     row_pos_[r + 1] += BorderSpacingForRow(r);
     row_pos_[r + 1] = std::max(row_pos_[r + 1], row_pos_[r]);
   }
 
   if (!row_span_cells.IsEmpty())
     DistributeRowSpanHeightToRows(row_span_cells);
 
@@ skipping 13 matching lines @@
   // it now ensures we have a stable-enough structure.
   grid_.ShrinkToFit();
 
   LayoutState state(*this);
 
   const Vector<int>& column_pos = Table()->EffectiveColumnPositions();
   LayoutUnit row_logical_top(VBorderSpacingBeforeFirstRow());
 
   SubtreeLayoutScope layouter(*this);
   for (unsigned r = 0; r < grid_.size(); ++r) {
-    Row& row = grid_[r].row;
-    unsigned cols = row.size();
+    auto& grid_cells = grid_[r].grid_cells;
+    unsigned cols = grid_cells.size();
     // First, propagate our table layout's information to the cells. This will
     // mark the row as needing layout if there was a column logical width
     // change.
     for (unsigned start_column = 0; start_column < cols; ++start_column) {
-      CellStruct& current = row[start_column];
-      LayoutTableCell* cell = current.PrimaryCell();
-      if (!cell || current.in_col_span)
+      auto& grid_cell = grid_cells[start_column];
+      LayoutTableCell* cell = grid_cell.PrimaryCell();
+      if (!cell || grid_cell.InColSpan())
         continue;
 
       unsigned end_col = start_column;
       unsigned cspan = cell->ColSpan();
       while (cspan && end_col < cols) {
         DCHECK_LT(end_col, Table()->EffectiveColumns().size());
         cspan -= Table()->EffectiveColumns()[end_col].span;
         end_col++;
       }
       int table_layout_logical_width = column_pos[end_col] -
                                        column_pos[start_column] -
                                        Table()->HBorderSpacing();
       cell->SetCellLogicalWidth(table_layout_logical_width, layouter);
     }
 
-    if (LayoutTableRow* row_layout_object = grid_[r].row_layout_object) {
+    if (LayoutTableRow* row = grid_[r].row) {
       if (state.IsPaginated())
-        row_layout_object->SetLogicalTop(row_logical_top);
-      if (!row_layout_object->NeedsLayout())
-        MarkChildForPaginationRelayoutIfNeeded(*row_layout_object, layouter);
-      row_layout_object->LayoutIfNeeded();
+        row->SetLogicalTop(row_logical_top);
+      if (!row->NeedsLayout())
+        MarkChildForPaginationRelayoutIfNeeded(*row, layouter);
+      row->LayoutIfNeeded();
       if (state.IsPaginated()) {
-        AdjustRowForPagination(*row_layout_object, layouter);
-        UpdateFragmentationInfoForChild(*row_layout_object);
-        row_logical_top = row_layout_object->LogicalBottom();
+        AdjustRowForPagination(*row, layouter);
+        UpdateFragmentationInfoForChild(*row);
+        row_logical_top = row->LogicalBottom();
         row_logical_top += LayoutUnit(Table()->VBorderSpacing());
       }
     }
   }
 
   ClearNeedsLayout();
 }
 
 void LayoutTableSection::DistributeExtraLogicalHeightToPercentRows(
     int& extra_logical_height,
@@ skipping 135 matching lines @@
   unsigned total_rows = grid_.size();
 
   // Set the width of our section now.  The rows will also be this width.
   SetLogicalWidth(Table()->ContentLogicalWidth());
 
   int vspacing = Table()->VBorderSpacing();
   LayoutState state(*this);
 
   // Set the rows' location and size.
   for (unsigned r = 0; r < total_rows; r++) {
-    LayoutTableRow* row_layout_object = grid_[r].row_layout_object;
-    if (row_layout_object) {
-      row_layout_object->SetLogicalLocation(LayoutPoint(0, row_pos_[r]));
-      row_layout_object->SetLogicalWidth(LogicalWidth());
+    if (LayoutTableRow* row = grid_[r].row) {
+      row->SetLogicalLocation(LayoutPoint(0, row_pos_[r]));
+      row->SetLogicalWidth(LogicalWidth());
       LayoutUnit row_logical_height(row_pos_[r + 1] - row_pos_[r] - vspacing);
       if (state.IsPaginated() && r + 1 < total_rows) {
         // If the next row has a pagination strut, we need to subtract it. It
         // should not be included in this row's height.
-        if (LayoutTableRow* next_row_object = grid_[r + 1].row_layout_object)
+        if (LayoutTableRow* next_row_object = grid_[r + 1].row)
           row_logical_height -= next_row_object->PaginationStrut();
       }
-      row_layout_object->SetLogicalHeight(row_logical_height);
-      row_layout_object->UpdateAfterLayout();
+      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_layout_object = grid_[r].row_layout_object;
+    LayoutTableRow* row = grid_[r].row;
 
     unsigned n_cols = NumCols(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_layout_object;
-      if (last_row_object && row_layout_object) {
-        row_logical_top = row_layout_object->LogicalTop().ToInt();
+      LayoutTableRow* last_row_object = grid_[end_row_index].row;
+      if (last_row_object && row) {
+        row_logical_top = row->LogicalTop().ToInt();
         r_height = last_row_object->LogicalBottom().ToInt() - row_logical_top;
       } else {
         r_height = row_pos_[end_row_index + 1] - row_pos_[r] - vspacing;
         row_logical_top = row_pos_[r];
       }
 
       RelayoutCellIfFlexed(*cell, r, r_height);
 
       SubtreeLayoutScope layouter(*cell);
       EVerticalAlign cell_vertical_align;
@@ skipping 20 matching lines @@
       LayoutSize child_offset(cell->Location() - old_cell_rect.Location());
       if (child_offset.Width() || child_offset.Height()) {
         // If the child moved, we have to issue paint invalidations to it as
         // well as any floating/positioned descendants. An exception is if we
         // need a layout. In this case, we know we're going to issue paint
         // invalidations ourselves (and the child) anyway.
         if (!Table()->SelfNeedsLayout())
           cell->SetMayNeedPaintInvalidation();
       }
     }
-    if (row_layout_object)
-      row_layout_object->ComputeOverflow();
+    if (row)
+      row->ComputeOverflow();
   }
 
   DCHECK(!NeedsLayout());
 
   SetLogicalHeight(LayoutUnit(row_pos_[total_rows]));
 
   ComputeOverflowFromDescendants();
 }
 
 int LayoutTableSection::PaginationStrutForRow(LayoutTableRow* row,
@@ skipping 153 matching lines @@
                               : LastRow()->Style()->BorderAfter();
   if (rb.Style() == kBorderStyleHidden)
     return -1;
   if (rb.Style() > kBorderStyleHidden && 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);
   for (unsigned c = 0; c < n_cols; c++) {
-    const CellStruct& current = CellAt(r, c);
-    if (current.in_col_span || !current.HasCells())
+    const auto& grid_cell = GridCellAt(r, c);
+    if (grid_cell.InColSpan() || !grid_cell.HasCells())
       continue;
-    const ComputedStyle& primary_cell_style = current.PrimaryCell()->StyleRef();
+    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();
     if (col) {
       const BorderValue& gb = side == kBorderBefore
                                   ? col->Style()->BorderBefore()
@@ skipping 45 matching lines @@
     if (gb.Style() == kBorderStyleHidden)
       return -1;
     if (gb.Style() > kBorderStyleHidden && 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))
       continue;
-    const CellStruct& current = CellAt(r, col_index);
-    if (!current.HasCells())
+    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 = current.PrimaryCell()->StyleRef();
+    const ComputedStyle& primary_cell_style =
+        grid_cell.PrimaryCell()->StyleRef();
     const ComputedStyle& primary_cell_parent_style =
-        current.PrimaryCell()->Parent()->StyleRef();
+        grid_cell.PrimaryCell()->Parent()->StyleRef();
     // FIXME: Make this work with perpendicular and flipped cells.
     const BorderValue& cb = side == kBorderStart
                                 ? primary_cell_style.BorderStart()
                                 : primary_cell_style.BorderEnd();
     const BorderValue& rb = side == kBorderStart
                                 ? primary_cell_parent_style.BorderStart()
                                 : primary_cell_parent_style.BorderEnd();
     if (cb.Style() == kBorderStyleHidden || rb.Style() == kBorderStyleHidden)
       continue;
     all_hidden = false;
@@ skipping 18 matching lines @@
 }
 
 int LayoutTableSection::FirstLineBoxBaseline() const {
   if (!grid_.size())
     return -1;
 
   int first_line_baseline = grid_[0].baseline;
   if (first_line_baseline >= 0)
     return first_line_baseline + row_pos_[0];
 
-  const Row& first_row = grid_[0].row;
-  for (size_t i = 0; i < first_row.size(); ++i) {
-    const CellStruct& cs = first_row.at(i);
-    const LayoutTableCell* cell = cs.PrimaryCell();
-    if (cell)
+  for (const auto& grid_cell : grid_[0].grid_cells) {
+    if (const auto* cell = grid_cell.PrimaryCell()) {
       first_line_baseline =
           std::max<int>(first_line_baseline,
                         (cell->LogicalTop() + cell->BorderBefore() +
                          cell->PaddingBefore() + cell->ContentLogicalHeight())
                             .ToInt());
+    }
   }
 
   return first_line_baseline;
 }
 
 void LayoutTableSection::Paint(const PaintInfo& paint_info,
                                const LayoutPoint& paint_offset) const {
   TableSectionPainter(*this).Paint(paint_info, paint_offset);
 }
 
@@ skipping 81 matching lines @@
 
   covered_columns.EnsureConsistency(Table()->NumEffectiveColumns());
   if (!has_spanning_cells_ || !covered_columns.Start())
     return covered_columns;
 
   // If there are any cells spanning into the first column, expand
   // covered_columns to cover the primary cells.
   unsigned smallest_column = covered_columns.Start();
   CellSpan covered_rows = SpannedRows(damage_rect);
   for (unsigned r = covered_rows.Start(); r < covered_rows.end(); ++r) {
-    const auto& row = grid_[r].row;
-    if (covered_columns.Start() < row.size()) {
+    const auto& grid_cells = grid_[r].grid_cells;
+    if (covered_columns.Start() < grid_cells.size()) {
       unsigned c = covered_columns.Start();
-      while (c && row[c].in_col_span)
+      while (c && grid_cells[c].InColSpan())
         --c;
       smallest_column = std::min(c, smallest_column);
       if (!smallest_column)
         break;
     }
   }
   return CellSpan(smallest_column, covered_columns.end());
 }
 
 CellSpan LayoutTableSection::SpannedRows(const LayoutRect& flipped_rect) const {
@@ skipping 67 matching lines @@
   c_col_ = 0;
   c_row_ = 0;
   grid_.clear();
 
   for (LayoutTableRow* row = FirstRow(); row; row = row->NextRow()) {
     unsigned insertion_row = c_row_;
     ++c_row_;
     c_col_ = 0;
     EnsureRows(c_row_);
 
-    grid_[insertion_row].row_layout_object = row;
+    grid_[insertion_row].row = row;
     row->SetRowIndex(insertion_row);
-    SetRowLogicalHeightToRowStyleLogicalHeight(grid_[insertion_row]);
+    grid_[insertion_row].SetRowLogicalHeightToRowStyleLogicalHeight();
 
     for (LayoutTableCell* cell = row->FirstCell(); cell;
          cell = cell->NextCell())
       AddCell(cell, row);
   }
 
   grid_.ShrinkToFit();
   SetNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::kUnknown);
 }
 
 // FIXME: This function could be made O(1) in certain cases (like for the
 // non-most-constrainive cells' case).
 void LayoutTableSection::RowLogicalHeightChanged(LayoutTableRow* row) {
   if (NeedsCellRecalc())
     return;
 
   unsigned row_index = row->RowIndex();
-  SetRowLogicalHeightToRowStyleLogicalHeight(grid_[row_index]);
+  grid_[row_index].SetRowLogicalHeightToRowStyleLogicalHeight();
 
-  for (LayoutTableCell* cell = grid_[row_index].row_layout_object->FirstCell();
-       cell; cell = cell->NextCell())
-    UpdateLogicalHeightForCell(grid_[row_index], cell);
+  for (LayoutTableCell* cell = grid_[row_index].row->FirstCell(); cell;
+       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 result = 0;
 
   for (unsigned r = 0; r < grid_.size(); ++r) {
     unsigned n_cols = NumCols(r);
     for (unsigned c = result; c < n_cols; ++c) {
-      const CellStruct& cell = CellAt(r, c);
-      if (cell.HasCells() || cell.in_col_span)
+      const auto& grid_cell = GridCellAt(r, c);
+      if (grid_cell.HasCells() || grid_cell.InColSpan())
         result = c;
     }
   }
 
   return result + 1;
 }
 
 BorderValue LayoutTableSection::BorderAdjoiningStartCell(
     const LayoutTableCell* cell) const {
 #if DCHECK_IS_ON()
@@ skipping 22 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) {
-  auto& row_vector = grid_[row].row;
-  if (effective_column >= row_vector.size())
+  if (effective_column >= NumCols(row))
     return nullptr;
-  auto& cell_struct = row_vector[effective_column];
-  if (cell_struct.in_col_span)
+  auto& grid_cell = GridCellAt(row, effective_column);
+  if (grid_cell.InColSpan())
     return nullptr;
-  if (auto* cell = cell_struct.PrimaryCell()) {
+  if (auto* cell = grid_cell.PrimaryCell()) {
     if (cell->RowIndex() == row)
       return cell;
   }
   return nullptr;
 }
 
 void LayoutTableSection::AppendEffectiveColumn(unsigned pos) {
   DCHECK(!needs_cell_recalc_);
 
-  for (unsigned row = 0; row < grid_.size(); ++row)
-    grid_[row].row.resize(pos + 1);
+  for (auto& row : grid_)
+    row.grid_cells.resize(pos + 1);
 }
 
 void LayoutTableSection::SplitEffectiveColumn(unsigned pos, unsigned first) {
   DCHECK(!needs_cell_recalc_);
 
   if (c_col_ > pos)
     c_col_++;
   for (unsigned row = 0; row < grid_.size(); ++row) {
-    Row& r = grid_[row].row;
+    auto& grid_cells = grid_[row].grid_cells;
     EnsureCols(row, pos + 2);
-    r.insert(pos + 1, CellStruct());
-    if (r[pos].HasCells()) {
-      r[pos + 1].cells.AppendVector(r[pos].cells);
-      LayoutTableCell* cell = r[pos].PrimaryCell();
+    grid_cells.insert(pos + 1, TableGridCell());
+    if (grid_cells[pos].HasCells()) {
+      grid_cells[pos + 1].Cells().AppendVector(grid_cells[pos].Cells());
+      LayoutTableCell* cell = grid_cells[pos].PrimaryCell();
       DCHECK(cell);
-      DCHECK_GE(cell->ColSpan(), (r[pos].in_col_span ? 1u : 0));
-      unsigned colleft = cell->ColSpan() - r[pos].in_col_span;
+      DCHECK_GE(cell->ColSpan(), (grid_cells[pos].InColSpan() ? 1u : 0));
+      unsigned colleft = cell->ColSpan() - grid_cells[pos].InColSpan();
       if (first > colleft)
-        r[pos + 1].in_col_span = 0;
+        grid_cells[pos + 1].SetInColSpan(false);
       else
-        r[pos + 1].in_col_span = first + r[pos].in_col_span;
+        grid_cells[pos + 1].SetInColSpan(first || grid_cells[pos].InColSpan());
     } else {
-      r[pos + 1].in_col_span = 0;
+      grid_cells[pos + 1].SetInColSpan(false);
     }
   }
 }
 
 // Hit Testing
 bool LayoutTableSection::NodeAtPoint(
     HitTestResult& result,
     const HitTestLocation& location_in_container,
     const LayoutPoint& accumulated_offset,
     HitTestAction action) {
@@ skipping 39 matching lines @@
       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);
     for (unsigned hit_column = column_span.Start();
          hit_column < n_cols && hit_column < column_span.end(); ++hit_column) {
-      CellStruct& current = CellAt(hit_row, hit_column);
+      auto& grid_cell = GridCellAt(hit_row, hit_column);
 
       // If the cell is empty, there's nothing to do
-      if (!current.HasCells())
+      if (!grid_cell.HasCells())
         continue;
 
-      for (unsigned i = current.cells.size(); i;) {
+      for (unsigned i = grid_cell.Cells().size(); i;) {
         --i;
-        LayoutTableCell* cell = current.cells[i];
+        LayoutTableCell* cell = grid_cell.Cells()[i];
         LayoutPoint cell_point =
             FlipForWritingModeForChild(cell, adjusted_location);
         if (static_cast<LayoutObject*>(cell)->NodeAtPoint(
                 result, location_in_container, cell_point, action)) {
           UpdateHitTestResult(
               result, location_in_container.Point() - ToLayoutSize(cell_point));
           return true;
         }
       }
       if (!result.GetHitTestRequest().ListBased())
@@ skipping 98 matching lines @@
     if (baseline > cell.BorderBefore() + cell.PaddingBefore())
       grid_[row_index].baseline = std::max(grid_[row_index].baseline, baseline);
   }
 }
 
 int LayoutTableSection::LogicalHeightForRow(
     const LayoutTableRow& row_object) const {
   unsigned row_index = row_object.RowIndex();
   DCHECK_LT(row_index, grid_.size());
   int logical_height = 0;
-  const Row& row = grid_[row_index].row;
-  unsigned cols = row.size();
-  for (unsigned col_index = 0; col_index < cols; col_index++) {
-    const CellStruct& cell_struct = CellAt(row_index, col_index);
-    const LayoutTableCell* cell = cell_struct.PrimaryCell();
-    if (!cell || cell_struct.in_col_span)
+  for (auto& grid_cell : grid_[row_index].grid_cells) {
+    const LayoutTableCell* cell = grid_cell.PrimaryCell();
+    if (!cell || grid_cell.InColSpan())
       continue;
     unsigned row_span = cell->RowSpan();
     if (row_span == 1) {
       logical_height =
           std::max(logical_height, cell->LogicalHeightForRowSizing());
       continue;
     }
     unsigned row_index_for_cell = cell->RowIndex();
     if (row_index == grid_.size() - 1 ||
         (row_span > 1 && row_index - row_index_for_cell == row_span - 1)) {
       // This is the last row of the rowspanned cell. Add extra height if
       // needed.
-      if (LayoutTableRow* first_row_for_cell =
-              grid_[row_index_for_cell].row_layout_object) {
+      if (LayoutTableRow* first_row_for_cell = grid_[row_index_for_cell].row) {
         int min_logical_height = cell->LogicalHeightForRowSizing();
         // Subtract space provided by previous rows.
         min_logical_height -= row_object.LogicalTop().ToInt() -
                               first_row_for_cell->LogicalTop().ToInt();
 
         logical_height = std::max(logical_height, min_logical_height);
       }
     }
   }
 
@@ skipping 116 matching lines @@
 bool LayoutTableSection::PaintedOutputOfObjectHasNoEffectRegardlessOfSize()
     const {
   // LayoutTableSection paints background from columns.
   if (Table()->HasColElements())
     return false;
   return LayoutTableBoxComponent::
       PaintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink