Combine and simplify LayoutTableSection::DirtiedRows() and DirtiedEffectiveColumns()

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 1511 matching lines @@
   const Vector<int>& column_pos = Table()->EffectiveColumnPositions();
   // FIXME: The table's direction should determine our row's direction, not the
   // section's (see bug 96691).
   if (!Style()->IsLeftToRightDirection())
     table_aligned_rect.SetX(column_pos[column_pos.size() - 1] -
                             table_aligned_rect.MaxX());
 
   return table_aligned_rect;
 }
 
-CellSpan LayoutTableSection::DirtiedRows(const LayoutRect& damage_rect) const {
-  if (force_full_paint_)
-    return FullSectionRowSpan();
+void LayoutTableSection::DirtiedRowsAndEffectiveColumns(
+    const LayoutRect& damage_rect,
+    CellSpan& rows,
+    CellSpan& columns) const {
+  if (!grid_.size()) {
+    rows = CellSpan();
+    columns = CellSpan();
+  }
 
-  if (!grid_.size())
-    return CellSpan(0, 0);
+  if (force_full_paint_) {
+    rows = FullSectionRowSpan();
+    columns = FullTableEffectiveColumnSpan();
+    return;
+  }
 
-  CellSpan covered_rows = SpannedRows(damage_rect);
+  rows = SpannedRows(damage_rect);
+  columns = SpannedEffectiveColumns(damage_rect);
 
-  // To paint the border we might need to paint the first or last row even if
-  // they are not spanned themselves.
-  CHECK_LT(covered_rows.Start(), row_pos_.size());
-  if (covered_rows.Start() == row_pos_.size() - 1 &&
-      row_pos_[row_pos_.size() - 1] + Table()->OuterBorderAfter() >=
-          damage_rect.Y())
-    covered_rows.DecreaseStart();
+  // Expand by one cell in each direction to cover any collapsed borders.
+  if (Table()->ShouldCollapseBorders()) {
+    if (rows.Start() > 0)
+      rows.DecreaseStart();
+    if (rows.End() < grid_.size())
+      rows.IncreaseEnd();
+    if (columns.Start() > 0)
+      columns.DecreaseStart();
+    if (columns.End() < Table()->NumEffectiveColumns())
+      columns.IncreaseEnd();
+  }
 
-  if (!covered_rows.end() &&
-      row_pos_[0] - Table()->OuterBorderBefore() <= damage_rect.MaxY())
-    covered_rows.IncreaseEnd();
+  rows.EnsureConsistency(grid_.size());
+  columns.EnsureConsistency(Table()->NumEffectiveColumns());
 
-  covered_rows.EnsureConsistency(grid_.size());
-  if (!has_spanning_cells_ || !covered_rows.Start() ||
-      covered_rows.Start() >= grid_.size())
-    return covered_rows;
+  if (!has_spanning_cells_)
+    return;
 
-  // If there are any cells spanning into the first row, expand covered_rows
-  // to cover the primary cells.
-  unsigned n_cols = NumEffectiveColumns(covered_rows.Start());
-  unsigned smallest_row = covered_rows.Start();
-  CellSpan covered_columns = SpannedEffectiveColumns(damage_rect);
-  for (unsigned c = covered_columns.Start();
-       c < std::min(covered_columns.end(), n_cols); ++c) {
-    if (const auto* cell = PrimaryCellAt(covered_rows.Start(), c)) {
-      smallest_row = std::min(smallest_row, cell->RowIndex());
-      if (!smallest_row)
-        break;
+  if (rows.Start() > 0 && rows.Start() < grid_.size()) {
+    // If there are any cells spanning into the first row, expand |rows| to
+    // cover the cells.
+    unsigned n_cols = NumEffectiveColumns(rows.Start());
+    unsigned smallest_row = rows.Start();
+    for (unsigned c = columns.Start(); c < std::min(columns.End(), n_cols);
+         ++c) {
+      for (const auto* cell : GridCellAt(rows.Start(), c).Cells()) {
+        smallest_row = std::min(smallest_row, cell->RowIndex());
+        if (!smallest_row)
+          break;
+      }
     }
+    rows = CellSpan(smallest_row, rows.End());
   }
-  return CellSpan(smallest_row, covered_rows.end());
-}
 
-CellSpan LayoutTableSection::DirtiedEffectiveColumns(
-    const LayoutRect& damage_rect) const {
-  if (force_full_paint_)
-    return FullTableEffectiveColumnSpan();
-
-  CHECK(Table()->NumEffectiveColumns());
-  CellSpan covered_columns = SpannedEffectiveColumns(damage_rect);
-
-  const Vector<int>& column_pos = Table()->EffectiveColumnPositions();
-  // To paint the border we might need to paint the first or last column even if
-  // they are not spanned themselves.
-  CHECK_LT(covered_columns.Start(), column_pos.size());
-  if (covered_columns.Start() == column_pos.size() - 1 &&
-      column_pos[column_pos.size() - 1] + Table()->OuterBorderEnd() >=
-          damage_rect.X())
-    covered_columns.DecreaseStart();
-
-  if (!covered_columns.end() &&
-      column_pos[0] - Table()->OuterBorderStart() <= damage_rect.MaxX())
-    covered_columns.IncreaseEnd();
-
-  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& grid_cells = grid_[r].grid_cells;
-    if (covered_columns.Start() < grid_cells.size()) {
-      unsigned c = covered_columns.Start();
-      while (c && grid_cells[c].InColSpan())
-        --c;
-      smallest_column = std::min(c, smallest_column);
-      if (!smallest_column)
-        break;
+  if (columns.Start() > 0 && columns.Start() < Table()->NumEffectiveColumns()) {
+    // If there are any cells spanning into the first column, expand |columns|
+    // to cover the cells.
+    unsigned smallest_column = columns.Start();
+    for (unsigned r = rows.Start(); r < rows.End(); ++r) {
+      const auto& grid_cells = grid_[r].grid_cells;
+      if (columns.Start() < grid_cells.size()) {
+        unsigned c = columns.Start();
+        while (c && grid_cells[c].InColSpan())
+          --c;
+        smallest_column = std::min(c, smallest_column);
+        if (!smallest_column)
+          break;
+      }
     }
+    columns = CellSpan(smallest_column, columns.End());
   }
-  return CellSpan(smallest_column, covered_columns.end());
 }
 
 CellSpan LayoutTableSection::SpannedRows(const LayoutRect& flipped_rect) const {
   // Find the first row that starts after rect top.
   unsigned next_row =
       std::upper_bound(row_pos_.begin(), row_pos_.end(), flipped_rect.Y()) -
       row_pos_.begin();
 
   // After all rows.
   if (next_row == row_pos_.size())
@@ skipping 237 matching lines @@
 
   LayoutRect hit_test_rect = LayoutRect(location_in_container.BoundingBox());
   hit_test_rect.MoveBy(-adjusted_location);
 
   LayoutRect table_aligned_rect =
       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();
+  for (unsigned hit_row = row_span.Start(); hit_row < row_span.End();
        ++hit_row) {
     unsigned n_cols = NumEffectiveColumns(hit_row);
     for (unsigned hit_column = column_span.Start();
-         hit_column < n_cols && hit_column < column_span.end(); ++hit_column) {
+         hit_column < n_cols && hit_column < column_span.End(); ++hit_column) {
       auto& grid_cell = GridCellAt(hit_row, hit_column);
 
       // If the cell is empty, there's nothing to do
       if (!grid_cell.HasCells())
         continue;
 
       for (unsigned i = grid_cell.Cells().size(); i;) {
         --i;
         LayoutTableCell* cell = grid_cell.Cells()[i];
         LayoutPoint cell_point =
@@ skipping 258 matching lines @@
 bool LayoutTableSection::PaintedOutputOfObjectHasNoEffectRegardlessOfSize()
     const {
   // LayoutTableSection paints background from columns.
   if (Table()->HasColElements())
     return false;
   return LayoutTableBoxComponent::
       PaintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink