Remove non-compositing descendant DisplayItemClient invalidation

This is currently only used for scrollbar parts, which do not have
descendant layers. Instead just set needs paint on the painting layer
and invalidate the DisplayItemClient (the same LayoutObject the
ObjectPaintInvalidator is initialized with) via
SlowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient.

There was not any unit test coverage for
InvalidatePaintIncludingNonCompositingDescendants which uses the same
traversal algorithm, so convert tests of the deleted method to use this
one instead, and validate only the paint invalidation side-effects.

Bug: 1007989

Change-Id: Ic9849f889958300941bc9a48d97cf7f04a91c786
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2247157Reviewed-by: Philip Rogers <pdr@chromium.org>
Commit-Queue: Daniel Libby <dlibby@microsoft.com>
Cr-Commit-Position: refs/heads/master@{#779554}

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

@@ -407,8 +407,8 @@ void CustomScrollbar::PositionScrollbarParts() {
 void CustomScrollbar::InvalidateDisplayItemClientsOfScrollbarParts() {
   for (auto& part : parts_) {
     ObjectPaintInvalidator(*part.value)
-        .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-            PaintInvalidationReason::kScrollControl);
+        .SlowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
+            *part.value, PaintInvalidationReason::kScrollControl);
   }
 }
 

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

@@ -134,21 +134,6 @@ static void SetPaintingLayerNeedsRepaintDuringTraverse(
   }
 }
 
-void ObjectPaintInvalidator::
-    InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-        PaintInvalidationReason reason) {
-  // This is valid because we want to invalidate the client in the display item
-  // list of the current backing.
-  DisableCompositingQueryAsserts disabler;
-
-  SlowSetPaintingLayerNeedsRepaint();
-  TraverseNonCompositingDescendantsInPaintOrder(
-      object_, [reason](const LayoutObject& object) {
-        SetPaintingLayerNeedsRepaintDuringTraverse(object);
-        object.InvalidateDisplayItemClients(reason);
-      });
-}
-
 void ObjectPaintInvalidator::
     InvalidatePaintIncludingNonCompositingDescendants() {
   DCHECK(!RuntimeEnabledFeatures::CompositeAfterPaintEnabled());

third_party/blink/renderer/core/paint/object_paint_invalidator.h

@@ -36,9 +36,6 @@ class CORE_EXPORT ObjectPaintInvalidator {
     InvalidateDisplayItemClient(client, reason);
   }
 
-  void InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-      PaintInvalidationReason);
-
   // The caller should ensure the painting layer has been SetNeedsRepaint
   // before calling this function.
   void InvalidateDisplayItemClient(const DisplayItemClient& client,

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

@@ -34,8 +34,7 @@ class ObjectPaintInvalidatorTest : public RenderingTest {
 
 using ::testing::ElementsAre;
 
-TEST_F(ObjectPaintInvalidatorTest,
-       TraverseNonCompositingDescendantsInPaintOrder) {
+TEST_F(ObjectPaintInvalidatorTest, TraverseNonCompositingDescendants) {
   if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled())
     return;
 
@@ -65,58 +64,51 @@ TEST_F(ObjectPaintInvalidatorTest,
   )HTML");
 
   auto* container = GetLayoutObjectByElementId("container");
-  auto* normal_child = GetLayoutObjectByElementId("normal-child");
+  auto* container_layer = ToLayoutBoxModelObject(container)->Layer();
   auto* stacked_child = GetLayoutObjectByElementId("stacked-child");
+  auto* stacked_child_layer = ToLayoutBoxModelObject(stacked_child)->Layer();
   auto* composited_stacking_context =
       GetLayoutObjectByElementId("composited-stacking-context");
-  auto* normal_child_of_composited_stacking_context =
-      GetLayoutObjectByElementId("normal-child-of-composited-stacking-context");
+  auto* composited_stacking_context_layer =
+      ToLayoutBoxModelObject(composited_stacking_context)->Layer();
   auto* stacked_child_of_composited_stacking_context =
       GetLayoutObjectByElementId(
           "stacked-child-of-composited-stacking-context");
+  auto* stacked_child_of_composited_stacking_context_layer =
+      ToLayoutBoxModelObject(stacked_child_of_composited_stacking_context)
+          ->Layer();
   auto* composited_non_stacking_context =
       GetLayoutObjectByElementId("composited-non-stacking-context");
-  auto* normal_child_of_composited_non_stacking_context =
-      GetLayoutObjectByElementId(
-          "normal-child-of-composited-non-stacking-context");
+  auto* composited_non_stacking_context_layer =
+      ToLayoutBoxModelObject(composited_non_stacking_context)->Layer();
   auto* stacked_child_of_composited_non_stacking_context =
       GetLayoutObjectByElementId(
           "stacked-child-of-composited-non-stacking-context");
+  auto* stacked_child_of_composited_non_stacking_context_layer =
+      ToLayoutBoxModelObject(stacked_child_of_composited_non_stacking_context)
+          ->Layer();
   auto* non_stacked_layered_child_of_composited_non_stacking_context =
       GetLayoutObjectByElementId(
           "non-stacked-layered-child-of-composited-non-stacking-context");
-
-  ValidateDisplayItemClient(container);
-  ValidateDisplayItemClient(normal_child);
-  ValidateDisplayItemClient(stacked_child);
-  ValidateDisplayItemClient(composited_stacking_context);
-  ValidateDisplayItemClient(normal_child_of_composited_stacking_context);
-  ValidateDisplayItemClient(stacked_child_of_composited_stacking_context);
-  ValidateDisplayItemClient(composited_non_stacking_context);
-  ValidateDisplayItemClient(normal_child_of_composited_non_stacking_context);
-  ValidateDisplayItemClient(stacked_child_of_composited_non_stacking_context);
-  ValidateDisplayItemClient(
-      non_stacked_layered_child_of_composited_non_stacking_context);
+  auto* non_stacked_layered_child_of_composited_non_stacking_context_layer =
+      ToLayoutBoxModelObject(
+          non_stacked_layered_child_of_composited_non_stacking_context)
+          ->Layer();
 
   ObjectPaintInvalidator(*container)
-      .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-          PaintInvalidationReason::kSubtree);
-
-  EXPECT_FALSE(IsValidDisplayItemClient(container));
-  EXPECT_FALSE(IsValidDisplayItemClient(normal_child));
-  EXPECT_FALSE(IsValidDisplayItemClient(stacked_child));
-  EXPECT_TRUE(IsValidDisplayItemClient(composited_stacking_context));
-  EXPECT_TRUE(
-      IsValidDisplayItemClient(normal_child_of_composited_stacking_context));
-  EXPECT_TRUE(
-      IsValidDisplayItemClient(stacked_child_of_composited_stacking_context));
-  EXPECT_TRUE(IsValidDisplayItemClient(composited_non_stacking_context));
-  EXPECT_TRUE(IsValidDisplayItemClient(
-      normal_child_of_composited_non_stacking_context));
-  EXPECT_FALSE(IsValidDisplayItemClient(
-      stacked_child_of_composited_non_stacking_context));
-  EXPECT_TRUE(IsValidDisplayItemClient(
-      non_stacked_layered_child_of_composited_non_stacking_context));
+      .InvalidatePaintIncludingNonCompositingDescendants();
+
+  EXPECT_TRUE(container_layer->SelfNeedsRepaint());
+  EXPECT_TRUE(stacked_child_layer->SelfNeedsRepaint());
+  EXPECT_FALSE(composited_stacking_context_layer->SelfNeedsRepaint());
+  EXPECT_FALSE(
+      stacked_child_of_composited_stacking_context_layer->SelfNeedsRepaint());
+  EXPECT_FALSE(composited_non_stacking_context_layer->SelfNeedsRepaint());
+  EXPECT_TRUE(stacked_child_of_composited_non_stacking_context_layer
+                  ->SelfNeedsRepaint());
+  EXPECT_FALSE(
+      non_stacked_layered_child_of_composited_non_stacking_context_layer
+          ->SelfNeedsRepaint());
 }
 
 TEST_F(ObjectPaintInvalidatorTest, TraverseFloatUnderCompositedInline) {
@@ -146,7 +138,6 @@ TEST_F(ObjectPaintInvalidatorTest, TraverseFloatUnderCompositedInline) {
       ToLayoutBoxModelObject(composited_container)->Layer();
   auto* span = GetLayoutObjectByElementId("span");
   auto* span_layer = ToLayoutBoxModelObject(span)->Layer();
-  auto* text = span->SlowFirstChild();
 
   EXPECT_TRUE(span->IsPaintInvalidationContainer());
   EXPECT_TRUE(span->IsStackingContext());
@@ -158,25 +149,11 @@ TEST_F(ObjectPaintInvalidatorTest, TraverseFloatUnderCompositedInline) {
     EXPECT_EQ(containing_block_layer, target->PaintingLayer());
   }
 
-  ValidateDisplayItemClient(target);
-  ValidateDisplayItemClient(containing_block);
-  ValidateDisplayItemClient(composited_container);
-  if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
-    NGInlineCursor fragments;
-    for (fragments.MoveTo(*span); fragments;
-         fragments.MoveToNextForSameLayoutObject())
-      ValidateDisplayItemClient(fragments.Current().GetDisplayItemClient());
-  } else {
-    ValidateDisplayItemClient(span);
-    ValidateDisplayItemClient(text);
-  }
-
   // Traversing from target should mark needsRepaint on correct layers.
   EXPECT_FALSE(containing_block_layer->SelfNeedsRepaint());
   EXPECT_FALSE(composited_container_layer->DescendantNeedsRepaint());
   ObjectPaintInvalidator(*target)
-      .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-          PaintInvalidationReason::kSubtree);
+      .InvalidatePaintIncludingNonCompositingDescendants();
   if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
     EXPECT_FALSE(containing_block_layer->SelfOrDescendantNeedsRepaint());
     EXPECT_FALSE(composited_container_layer->SelfOrDescendantNeedsRepaint());
@@ -188,32 +165,15 @@ TEST_F(ObjectPaintInvalidatorTest, TraverseFloatUnderCompositedInline) {
     EXPECT_TRUE(composited_container_layer->DescendantNeedsRepaint());
     EXPECT_FALSE(span_layer->SelfNeedsRepaint());
   }
-  EXPECT_FALSE(IsValidDisplayItemClient(target));
-  ValidateDisplayItemClient(target);
-  EXPECT_TRUE(IsValidDisplayItemClient(containing_block));
-  EXPECT_TRUE(IsValidDisplayItemClient(composited_container));
-  if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
-    NGInlineCursor fragments;
-    for (fragments.MoveTo(*span); fragments;
-         fragments.MoveToNextForSameLayoutObject()) {
-      EXPECT_TRUE(
-          IsValidDisplayItemClient(fragments.Current().GetDisplayItemClient()));
-    }
-  } else {
-    EXPECT_TRUE(IsValidDisplayItemClient(span));
-    EXPECT_TRUE(IsValidDisplayItemClient(text));
-  }
 
   composited_container_layer->ClearNeedsRepaintRecursively();
 
   // Traversing from span should mark needsRepaint on correct layers for target.
-  ValidateDisplayItemClient(target);
   EXPECT_FALSE(containing_block_layer->SelfOrDescendantNeedsRepaint());
   EXPECT_FALSE(composited_container_layer->SelfOrDescendantNeedsRepaint());
   EXPECT_FALSE(span_layer->SelfOrDescendantNeedsRepaint());
   ObjectPaintInvalidator(*span)
-      .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-          PaintInvalidationReason::kSubtree);
+      .InvalidatePaintIncludingNonCompositingDescendants();
   if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
     EXPECT_FALSE(containing_block_layer->SelfOrDescendantNeedsRepaint());
     EXPECT_FALSE(composited_container_layer->SelfOrDescendantNeedsRepaint());
@@ -225,25 +185,6 @@ TEST_F(ObjectPaintInvalidatorTest, TraverseFloatUnderCompositedInline) {
   }
   EXPECT_TRUE(span_layer->SelfNeedsRepaint());
 
-  EXPECT_FALSE(IsValidDisplayItemClient(target));
-  ValidateDisplayItemClient(target);
-  EXPECT_TRUE(IsValidDisplayItemClient(containing_block));
-  EXPECT_TRUE(IsValidDisplayItemClient(composited_container));
-  if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
-    NGInlineCursor fragments;
-    for (fragments.MoveTo(*span); fragments;
-         fragments.MoveToNextForSameLayoutObject()) {
-      EXPECT_FALSE(
-          IsValidDisplayItemClient(fragments.Current().GetDisplayItemClient()));
-      ValidateDisplayItemClient(fragments.Current().GetDisplayItemClient());
-    }
-  } else {
-    EXPECT_FALSE(IsValidDisplayItemClient(span));
-    ValidateDisplayItemClient(span);
-    EXPECT_FALSE(IsValidDisplayItemClient(text));
-    ValidateDisplayItemClient(text);
-  }
-
   composited_container_layer->ClearNeedsRepaintRecursively();
 
   // Traversing from compositedContainer should not reach target.
@@ -251,29 +192,10 @@ TEST_F(ObjectPaintInvalidatorTest, TraverseFloatUnderCompositedInline) {
   EXPECT_FALSE(composited_container_layer->SelfOrDescendantNeedsRepaint());
   EXPECT_FALSE(span_layer->SelfOrDescendantNeedsRepaint());
   ObjectPaintInvalidator(*composited_container)
-      .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-          PaintInvalidationReason::kSubtree);
+      .InvalidatePaintIncludingNonCompositingDescendants();
   EXPECT_TRUE(containing_block_layer->SelfNeedsRepaint());
   EXPECT_TRUE(composited_container_layer->DescendantNeedsRepaint());
   EXPECT_FALSE(span_layer->SelfNeedsRepaint());
-
-  if (RuntimeEnabledFeatures::LayoutNGEnabled())
-    EXPECT_TRUE(IsValidDisplayItemClient(target));
-  else
-    EXPECT_FALSE(IsValidDisplayItemClient(target));
-  EXPECT_FALSE(IsValidDisplayItemClient(containing_block));
-  EXPECT_FALSE(IsValidDisplayItemClient(composited_container));
-  if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
-    NGInlineCursor fragments;
-    for (fragments.MoveTo(*span); fragments;
-         fragments.MoveToNextForSameLayoutObject()) {
-      EXPECT_TRUE(
-          IsValidDisplayItemClient(fragments.Current().GetDisplayItemClient()));
-    }
-  } else {
-    EXPECT_TRUE(IsValidDisplayItemClient(span));
-    EXPECT_TRUE(IsValidDisplayItemClient(text));
-  }
 }
 
 TEST_F(ObjectPaintInvalidatorTest, TraverseStackedFloatUnderCompositedInline) {
@@ -311,22 +233,8 @@ TEST_F(ObjectPaintInvalidatorTest, TraverseStackedFloatUnderCompositedInline) {
   // Traversing from span should reach target.
   EXPECT_FALSE(span_layer->SelfNeedsRepaint());
   ObjectPaintInvalidator(*span)
-      .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-          PaintInvalidationReason::kSubtree);
+      .InvalidatePaintIncludingNonCompositingDescendants();
   EXPECT_TRUE(span_layer->SelfNeedsRepaint());
-
-  EXPECT_FALSE(IsValidDisplayItemClient(target));
-  if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
-    NGInlineCursor fragments;
-    for (fragments.MoveTo(*span); fragments;
-         fragments.MoveToNextForSameLayoutObject()) {
-      EXPECT_FALSE(
-          IsValidDisplayItemClient(fragments.Current().GetDisplayItemClient()));
-    }
-  } else {
-    EXPECT_FALSE(IsValidDisplayItemClient(span));
-    EXPECT_FALSE(IsValidDisplayItemClient(text));
-  }
 }
 
 TEST_F(ObjectPaintInvalidatorTest, InvalidatePaintRectangle) {

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

@@ -3024,13 +3024,13 @@ void PaintLayerScrollableArea::InvalidatePaintOfScrollControlsIfNeeded(
     SetScrollCornerAndResizerVisualRect(scroll_corner_and_resizer_visual_rect);
     if (LayoutCustomScrollbarPart* scroll_corner = ScrollCorner()) {
       ObjectPaintInvalidator(*scroll_corner)
-          .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-              PaintInvalidationReason::kScrollControl);
+          .SlowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
+              *scroll_corner, PaintInvalidationReason::kScrollControl);
     }
     if (LayoutCustomScrollbarPart* resizer = Resizer()) {
       ObjectPaintInvalidator(*resizer)
-          .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-              PaintInvalidationReason::kScrollControl);
+          .SlowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
+              *resizer, PaintInvalidationReason::kScrollControl);
     }
     if (!GraphicsLayerForScrollCorner()) {
       context.painting_layer->SetNeedsRepaint();