Always paint collapsed borders with the row DisplayItemClient.

This removes a reference to IsPaintInvalidationContainer in LayoutTable,
which in turn removes a dependency of PrePaint on compositing.

The need to paint on the table's DisplayItemClient appears to no longer
be necessary.

The code was added in:
https://chromium-review.googlesource.com/c/chromium/src/+/540178/

Change-Id: Ib1066d176511cfa4adc16579cc8aa7fc7475868f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2317848Reviewed-by: Xianzhu Wang <wangxianzhu@chromium.org>
Commit-Queue: Chris Harrelson <chrishtr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#791715}

third_party/blink/renderer/core/layout/layout_table.cc

@@ -60,7 +60,6 @@ LayoutTable::LayoutTable(Element* element)
       needs_adjust_collapsed_border_joints_(false),
       needs_invalidate_collapsed_borders_for_all_cells_(false),
       collapsed_outer_borders_valid_(false),
-      should_paint_all_collapsed_borders_(false),
       is_any_column_ever_collapsed_(false),
       has_col_elements_(false),
       needs_section_recalc_(false),
@@ -1675,13 +1674,11 @@ void LayoutTable::EnsureIsReadyForPaintInvalidation() {
   collapsed_borders_valid_ = true;
   has_collapsed_borders_ = false;
   needs_adjust_collapsed_border_joints_ = false;
-  should_paint_all_collapsed_borders_ = false;
   if (!ShouldCollapseBorders())
     return;
 
   CollapsedBorderValue first_border;
   for (auto* section = TopSection(); section; section = SectionBelow(section)) {
-    bool section_may_be_composited = section->IsPaintInvalidationContainer();
     for (auto* row = section->FirstRow(); row; row = row->NextRow()) {
       for (auto* cell = row->FirstCell(); cell; cell = cell->NextCell()) {
         DCHECK_EQ(cell->Table(), this);
@@ -1707,18 +1704,6 @@ void LayoutTable::EnsureIsReadyForPaintInvalidation() {
           }
         }
       }
-
-      // Collapsed borders should always be painted on the table's backing.
-      // If any row is not on the same composited layer as the table, the table
-      // should paint all collapsed borders.
-      if (has_collapsed_borders_ &&
-          (section_may_be_composited || row->IsPaintInvalidationContainer())) {
-        // Pass the row's paint invalidation flag to the table in case that the
-        // flag was set for collapsed borders.
-        if (row->ShouldDoFullPaintInvalidation())
-          SetShouldDoFullPaintInvalidation(PaintInvalidationReason::kStyle);
-        should_paint_all_collapsed_borders_ = true;
-      }
     }
   }
 }

third_party/blink/renderer/core/layout/layout_table.h

@@ -359,18 +359,6 @@ class CORE_EXPORT LayoutTable final : public LayoutBlock,
     return needs_adjust_collapsed_border_joints_;
   }
 
-  // Returns true if the table has collapsed borders and any row doesn't paint
-  // onto the same compositing layer as the table (which is rare), and the table
-  // will create one display item for all collapsed borders. Otherwise each row
-  // will create one display item for collapsed borders.
-  // It always returns false for CAP.
-  bool ShouldPaintAllCollapsedBorders() const {
-    DCHECK(collapsed_borders_valid_);
-    if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled())
-      DCHECK(!should_paint_all_collapsed_borders_);
-    return should_paint_all_collapsed_borders_;
-  }
-
   bool HasSections() const { return Header() || Footer() || FirstBody(); }
 
   void RecalcSectionsIfNeeded() const final {
@@ -571,8 +559,6 @@ class CORE_EXPORT LayoutTable final : public LayoutBlock,
   bool needs_invalidate_collapsed_borders_for_all_cells_ : 1;
   mutable bool collapsed_outer_borders_valid_ : 1;
 
-  bool should_paint_all_collapsed_borders_ : 1;
-
   // Whether any column in the table section is or has been collapsed.
   bool is_any_column_ever_collapsed_ : 1;
 

third_party/blink/renderer/core/paint/table_cell_paint_invalidator.cc

@@ -45,17 +45,13 @@ void TableCellPaintInvalidator::InvalidatePaint() {
     const auto& section = *row.Section();
     const auto& table = *section.Table();
     if (!DisplayItemClientIsFullyInvalidated(row) &&
-        (row.StyleRef().HasBackground() ||
-         (table.HasCollapsedBorders() &&
-          LIKELY(!table.ShouldPaintAllCollapsedBorders())))) {
+        (row.StyleRef().HasBackground() || table.HasCollapsedBorders())) {
       InvalidateContainerForCellGeometryChange(row, *context_.ParentContext());
-    }
-
-    if (UNLIKELY(table.ShouldPaintAllCollapsedBorders()) &&
-        !DisplayItemClientIsFullyInvalidated(table)) {
-      DCHECK(table.HasCollapsedBorders());
-      InvalidateContainerForCellGeometryChange(
-          table, *context_.ParentContext()->ParentContext()->ParentContext());
+      // Mark the table as needing repaint, in order to paint collapsed borders.
+      context_.ParentContext()
+          ->ParentContext()
+          ->ParentContext()
+          ->painting_layer->SetNeedsRepaint();
     }
 
     if (!DisplayItemClientIsFullyInvalidated(section)) {

third_party/blink/renderer/core/paint/table_painter.cc

@@ -90,17 +90,6 @@ void TablePainter::PaintMask(const PaintInfo& paint_info,
 
 void TablePainter::PaintCollapsedBorders(const PaintInfo& paint_info,
                                          const PhysicalOffset& paint_offset) {
-  base::Optional<BoxDrawingRecorder> recorder;
-  if (UNLIKELY(layout_table_.ShouldPaintAllCollapsedBorders())) {
-    if (DrawingRecorder::UseCachedDrawingIfPossible(
-            paint_info.context, layout_table_,
-            DisplayItem::kTableCollapsedBorders))
-      return;
-    recorder.emplace(paint_info.context, layout_table_,
-                     DisplayItem::kTableCollapsedBorders, paint_offset);
-  }
-  // Otherwise each rows will create its own recorder.
-
   for (LayoutTableSection* section = layout_table_.BottomSection(); section;
        section = layout_table_.SectionAbove(section)) {
     TableSectionPainter(*section).PaintCollapsedBorders(paint_info);

third_party/blink/renderer/core/paint/table_row_painter.cc

@@ -122,18 +122,17 @@ void TableRowPainter::PaintCollapsedBorders(const PaintInfo& paint_info,
   ScopedPaintState paint_state(layout_table_row_, paint_info);
   base::Optional<BoxDrawingRecorder> recorder;
 
-  if (LIKELY(!layout_table_row_.Table()->ShouldPaintAllCollapsedBorders())) {
-    HandleChangedPartialPaint(paint_info, dirtied_columns);
+  HandleChangedPartialPaint(paint_info, dirtied_columns);
+
+  if (DrawingRecorder::UseCachedDrawingIfPossible(
+          paint_info.context, layout_table_row_,
+          DisplayItem::kTableCollapsedBorders))
+    return;
 
-    if (DrawingRecorder::UseCachedDrawingIfPossible(
-            paint_info.context, layout_table_row_,
-            DisplayItem::kTableCollapsedBorders))
-      return;
+  recorder.emplace(paint_info.context, layout_table_row_,
+                   DisplayItem::kTableCollapsedBorders,
+                   paint_state.PaintOffset());
 
-    recorder.emplace(paint_info.context, layout_table_row_,
-                     DisplayItem::kTableCollapsedBorders,
-                     paint_state.PaintOffset());
-  }
   // Otherwise TablePainter should have created the drawing recorder.
 
   const auto* section = layout_table_row_.Section();

third_party/blink/renderer/core/paint/table_section_painter.cc

@@ -145,16 +145,9 @@ void TableSectionPainter::PaintCollapsedSectionBorders(
 
   CellSpan dirtied_rows;
   CellSpan dirtied_columns;
-  if (UNLIKELY(
-          layout_table_section_.Table()->ShouldPaintAllCollapsedBorders())) {
-    // Ignore paint cull rect to simplify paint invalidation in such rare case.
-    dirtied_rows = layout_table_section_.FullSectionRowSpan();
-    dirtied_columns = layout_table_section_.FullTableEffectiveColumnSpan();
-  } else {
-    layout_table_section_.DirtiedRowsAndEffectiveColumns(
-        TableAlignedRect(local_paint_info, paint_offset), dirtied_rows,
-        dirtied_columns);
-  }
+  layout_table_section_.DirtiedRowsAndEffectiveColumns(
+      TableAlignedRect(local_paint_info, paint_offset), dirtied_rows,
+      dirtied_columns);
 
   if (dirtied_columns.Start() >= dirtied_columns.End())
     return;