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::GridRow::SetRowLogicalHeightToRowStyleLogicalHeight() {
+  DCHECK(row);
+  logical_height = row->StyleRef().LogicalHeight();
 }
 
-static inline void UpdateLogicalHeightForCell(
-    LayoutTableSection::RowStruct& row,
+void LayoutTableSection::GridRow::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 40 matching lines @@
   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_);
+      auto& grid_cell = GridCellAt(insertion_row + r, c_col_);
       DCHECK(cell);

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

Optional cleanup while you're here? I think this DCHECK can/should be moved to
line 236? If I'm wrong would you mind pointing out what I missed?

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

Done.

-      c.cells.push_back(cell);
-      CheckThatVectorIsDOMOrdered(c.cells);
+      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())

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

Thanks for changing these continue to DCHECK, I wouldn't have known they weren't
possible.

Actually, how sure are you that they are not possible? Obviously they don't
trigger in our tests because the try bots are green, but we may be missing test
coverage for some weird case. Worth it to change them to CHECK so that we get a
clear signal if pages in the wild trigger them?

If you've carefully traced the code and are convinced that it can't happen then
ignore the CHECK suggestion; I'm just channeling atotic@, who likes to say that
some of this code is "unknowable".

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

The new DCHECKs are ensured by the DCHECK at the beginning of the function:
  DCHECK(RowHasOnlySpanningCells(row));

If any of the early continue conditions are true, RowHasOnlySpanningCells() is
false.

-      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