Let table row and section's self visual overflow cover whole collapsed borders

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 1220 matching lines @@
       }
     }
     if (row_layout_object)
       row_layout_object->ComputeOverflow();
   }
 
   DCHECK(!NeedsLayout());
 
   SetLogicalHeight(LayoutUnit(row_pos_[total_rows]));
 
-  ComputeOverflowFromCells(total_rows, Table()->NumEffectiveColumns());
+  ComputeOverflowFromDescendants();
 }
 
 int LayoutTableSection::PaginationStrutForRow(LayoutTableRow* row,
                                               LayoutUnit logical_offset) const {
   DCHECK(row);
   if (row->GetPaginationBreakability() == kAllowAnyBreaks)
     return 0;
   LayoutUnit page_logical_height = PageLogicalHeightForOffset(logical_offset);
   if (!page_logical_height)
     return 0;
@@ skipping 13 matching lines @@
     // Don't break if we were at the top of a page, and we failed to fit the
     // content completely. No point in leaving a page completely blank.
     return 0;
   }
   // Table layout parts only work on integers, so we have to round. Round up, to
   // make sure that no fraction ever gets left behind in the previous
   // fragmentainer.
   return pagination_strut.Ceil();
 }
 
-void LayoutTableSection::ComputeOverflowFromCells() {
-  unsigned total_rows = grid_.size();
-  unsigned n_eff_cols = Table()->NumEffectiveColumns();
-  ComputeOverflowFromCells(total_rows, n_eff_cols);
-}
-
-void LayoutTableSection::ComputeOverflowFromCells(unsigned total_rows,
-                                                  unsigned n_eff_cols) {
-  unsigned total_cells_count = n_eff_cols * total_rows;
+void LayoutTableSection::ComputeOverflowFromDescendants() {
+  unsigned total_cells_count = NumRows() * Table()->NumEffectiveColumns();
   unsigned max_allowed_overflowing_cells_count =
       total_cells_count <
               g_min_table_size_to_use_fast_paint_path_with_overflowing_cell
           ? 0
           : kGMaxAllowedOverflowingCellRatioForFastPaintPath *
                 total_cells_count;
 
   overflow_.reset();
   overflowing_cells_.clear();
   force_slow_paint_path_with_overflowing_cell_ = false;
 #if DCHECK_IS_ON()
   bool has_overflowing_cell = false;
 #endif
-  // Now that our height has been determined, add in overflow from cells.
-  for (unsigned r = 0; r < total_rows; r++) {
-    unsigned n_cols = NumCols(r);
-    for (unsigned c = 0; c < n_cols; c++) {
-      const auto* cell = OriginatingCellAt(r, c);
-      if (!cell)
+
+  for (auto* row = FirstRow(); row; row = row->NextRow()) {
+    AddOverflowFromChild(*row);
+
+    for (auto* cell = row->FirstCell(); cell; cell = cell->NextCell()) {
+      // Let the section's self visual overflow cover the cell's whole collapsed
+      // borders. This ensures correct raster invalidation on section border
+      // style change.
+      // TODO(wangxianzhu): When implementing row as DisplayItemClient of
+      // collapsed borders, the following logic should be replaced by
+      // invalidation of rows on section border style change. crbug.com/663208.
+      if (const auto* collapsed_borders = cell->GetCollapsedBorderValues()) {
+        LayoutRect rect = cell->RectForOverflowPropagation(
+            collapsed_borders->LocalVisualRect());
+        rect.MoveBy(cell->Location());
+        AddSelfVisualOverflow(rect);
+      }
+
+      if (force_slow_paint_path_with_overflowing_cell_ ||
+          !cell->HasVisualOverflow())
         continue;
-      AddOverflowFromChild(*cell);
+
 #if DCHECK_IS_ON()
-      has_overflowing_cell |= cell->HasVisualOverflow();
+      has_overflowing_cell = true;
 #endif
-      if (cell->HasVisualOverflow() &&
-          !force_slow_paint_path_with_overflowing_cell_) {
-        overflowing_cells_.insert(cell);
-        if (overflowing_cells_.size() > max_allowed_overflowing_cells_count) {
-          // We need to set m_forcesSlowPaintPath only if there is a least one
-          // overflowing cells as the hit testing code rely on this information.
-          force_slow_paint_path_with_overflowing_cell_ = true;
-          // The slow path does not make any use of the overflowing cells info,
-          // don't hold on to the memory.
-          overflowing_cells_.clear();
-        }
+      if (overflowing_cells_.size() >= max_allowed_overflowing_cells_count) {
+        // We need to set force_slow_paint_path_with_overflowing_cell_ only if
+        // there is at least one overflowing cell as the hit testing code relies
+        // on this information.
+        force_slow_paint_path_with_overflowing_cell_ = true;
+        // The slow path does not make any use of the overflowing cells info,
+        // don't hold on to the memory.
+        overflowing_cells_.clear();
+        continue;
       }
+
+      overflowing_cells_.insert(cell);
     }
   }
 
 #if DCHECK_IS_ON()
   DCHECK_EQ(has_overflowing_cell, this->HasOverflowingCell());
 #endif
 }
 
 bool LayoutTableSection::RecalcChildOverflowAfterStyleChange() {
   DCHECK(ChildNeedsOverflowRecalcAfterStyleChange());
@@ skipping 11 matching lines @@
     for (unsigned c = 0; c < n_cols; c++) {
       auto* cell = OriginatingCellAt(r, c);
       if (!cell || !cell->NeedsOverflowRecalcAfterStyleChange())
         continue;
       row_children_overflow_changed |= cell->RecalcOverflowAfterStyleChange();
     }
     if (row_children_overflow_changed)
       row_layouter->ComputeOverflow();
     children_overflow_changed |= row_children_overflow_changed;
   }
-  // TODO(crbug.com/604136): Add visual overflow from rows too.
   if (children_overflow_changed)
-    ComputeOverflowFromCells(total_rows, Table()->NumEffectiveColumns());
+    ComputeOverflowFromDescendants();
   return children_overflow_changed;
 }
 
 void LayoutTableSection::MarkAllCellsWidthsDirtyAndOrNeedsLayout(
     LayoutTable::WhatToMarkAllCells what_to_mark) {
   for (LayoutTableRow* row = FirstRow(); row; row = row->NextRow()) {
     for (LayoutTableCell* cell = row->FirstCell(); cell;
          cell = cell->NextCell()) {
       cell->SetPreferredLogicalWidthsDirty();
       if (what_to_mark == LayoutTable::kMarkDirtyAndNeedsLayout)
@@ skipping 804 matching lines @@
 bool LayoutTableSection::PaintedOutputOfObjectHasNoEffectRegardlessOfSize()
     const {
   // LayoutTableSection paints background from columns.
   if (Table()->HasColElements())
     return false;
   return LayoutTableBoxComponent::
       PaintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink