Skip both paint and raster invalidation for LayoutSVGHiddenContainer subtree

third_party/WebKit/Source/core/paint/PaintInvalidator.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 50 matching lines @@
 
   // TODO(wkorman): The flip below is required because visual rects are
   // currently in "physical coordinates with flipped block-flow direction"
   // (see LayoutBoxModelObject.h) but we need them to be in physical
   // coordinates.
   Rect rect = local_rect;
   // Writing-mode flipping doesn't apply to non-root SVG.
   if (!is_svg_child) {
     if (object.IsBox()) {
       ToLayoutBox(object).FlipForWritingMode(rect);
-    } else if (!(context.forced_subtree_invalidation_flags &
-                 PaintInvalidatorContext::kForcedSubtreeSlowPathRect)) {
+    } else if (!(context.subtree_flags &
+                 PaintInvalidatorContext::kSubtreeSlowPathRect)) {
       // For SPv2 and the GeometryMapper path, we also need to convert the rect
       // for non-boxes into physical coordinates before applying paint offset.
       // (Otherwise we'll call mapToVisualrectInAncestorSpace() which requires
       // physical coordinates for boxes, but "physical coordinates with flipped
       // block-flow direction" for non-boxes for which we don't need to flip.)
       // TODO(wangxianzhu): Avoid containingBlock().
       object.ContainingBlock()->FlipForWritingMode(rect);
     }
   }
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     // In SPv2, visual rects are in the space of their local transform node.
     // For SVG, the input rect is in local SVG coordinates in which paint
     // offset doesn't apply.
     if (!is_svg_child)
       rect.MoveBy(Point(object.PaintOffset()));
     // Use enclosingIntRect to ensure the final visual rect will cover the
     // rect in source coordinates no matter if the painting will use pixel
     // snapping.
     return LayoutRect(EnclosingIntRect(rect));
   }
 
-  // If kForcedSubtreeNoRasterInvalidation is set, we map the rect to the
-  // temporary root paint property state instead of the paint invalidation
-  // backing.
-  bool map_to_backing =
-      !(context.forced_subtree_invalidation_flags &
-        PaintInvalidatorContext::kForcedSubtreeNoRasterInvalidation);
-
   LayoutRect result;
-  if (context.forced_subtree_invalidation_flags &
-      PaintInvalidatorContext::kForcedSubtreeSlowPathRect) {
+  if (context.subtree_flags & PaintInvalidatorContext::kSubtreeSlowPathRect) {
     result = SlowMapToVisualRectInAncestorSpace(
         object, *context.paint_invalidation_container, rect);
   } else if (object == context.paint_invalidation_container) {
-    DCHECK(map_to_backing);
     result = LayoutRect(rect);
   } else {
     // For non-root SVG, the input rect is in local SVG coordinates in which
     // paint offset doesn't apply.
     if (!is_svg_child)
       rect.MoveBy(Point(object.PaintOffset()));
 
     auto container_contents_properties =
-        map_to_backing
-            ? context.paint_invalidation_container->ContentsProperties()
-            : PropertyTreeState::Root();
+        context.paint_invalidation_container->ContentsProperties();
     if (context.tree_builder_context_->current.transform ==
             container_contents_properties.Transform() &&
         context.tree_builder_context_->current.clip ==
             container_contents_properties.Clip()) {
       result = LayoutRect(rect);
     } else {
       // Use enclosingIntRect to ensure the final visual rect will cover the
       // rect in source coordinates no matter if the painting will use pixel
       // snapping, when transforms are applied. If there is no transform,
       // enclosingIntRect is applied in the last step of paint invalidation
       // (see CompositedLayerMapping::setContentsNeedDisplayInRect()).
       if (!is_svg_child && context.tree_builder_context_->current.transform !=
                                container_contents_properties.Transform())
         rect = Rect(EnclosingIntRect(rect));
 
       PropertyTreeState current_tree_state(
           context.tree_builder_context_->current.transform,
           context.tree_builder_context_->current.clip, nullptr);
 
       FloatClipRect float_rect((FloatRect(rect)));
       GeometryMapper::SourceToDestinationVisualRect(
           current_tree_state, container_contents_properties, float_rect);
       result = LayoutRect(float_rect.Rect());
     }
 
     // Convert the result to the container's contents space.
-    if (map_to_backing)
-      result.MoveBy(-context.paint_invalidation_container->PaintOffset());
+    result.MoveBy(-context.paint_invalidation_container->PaintOffset());
   }
 
   object.AdjustVisualRectForRasterEffects(result);
-  if (!map_to_backing)
-    return result;
 
   PaintLayer::MapRectInPaintInvalidationContainerToBacking(
       *context.paint_invalidation_container, result);
 
   result.Move(object.ScrollAdjustmentForPaintInvalidation(
       *context.paint_invalidation_container));
 
   return result;
 }
 
@@ skipping 171 matching lines @@
              // This is to exclude some objects (e.g. LayoutText) inheriting
              // stacked style from parent but aren't actually stacked.
              object.HasLayer() &&
              context.paint_invalidation_container !=
                  context.paint_invalidation_container_for_stacked_contents) {
     // The current object is stacked, so we should use
     // m_paintInvalidationContainerForStackedContents as its paint invalidation
     // container on which the current object is painted.
     context.paint_invalidation_container =
         context.paint_invalidation_container_for_stacked_contents;
-    if (context.forced_subtree_invalidation_flags &
-        PaintInvalidatorContext::
-            kForcedSubtreeFullInvalidationForStackedContents)
-      context.forced_subtree_invalidation_flags |=
-          PaintInvalidatorContext::kForcedSubtreeFullInvalidation;
+    if (context.subtree_flags &
+        PaintInvalidatorContext::kSubtreeFullInvalidationForStackedContents) {
+      context.subtree_flags |=
+          PaintInvalidatorContext::kSubtreeFullInvalidation;
+    }
   }
 
   if (object == context.paint_invalidation_container) {
     // When we hit a new paint invalidation container, we don't need to
     // continue forcing a check for paint invalidation, since we're
     // descending into a different invalidation container. (For instance if
     // our parents were moved, the entire container will just move.)
     if (object != context.paint_invalidation_container_for_stacked_contents) {
-      // However, we need to keep kForcedSubtreeVisualRectUpdate and
-      // kForcedSubtreeFullInvalidationForStackedContents flags if the current
+      // However, we need to keep kSubtreeVisualRectUpdate and
+      // kSubtreeFullInvalidationForStackedContents flags if the current
       // object isn't the paint invalidation container of stacked contents.
-      context.forced_subtree_invalidation_flags &=
-          (PaintInvalidatorContext::kForcedSubtreeVisualRectUpdate |
-           PaintInvalidatorContext::
-               kForcedSubtreeFullInvalidationForStackedContents);
+      context.subtree_flags &=
+          (PaintInvalidatorContext::kSubtreeVisualRectUpdate |
+           PaintInvalidatorContext::kSubtreeFullInvalidationForStackedContents);
     } else {
-      context.forced_subtree_invalidation_flags = 0;
+      context.subtree_flags = 0;
     }
   }
 
   DCHECK(context.paint_invalidation_container ==
          object.ContainerForPaintInvalidation());
   DCHECK(context.painting_layer == object.PaintingLayer());
 }
 
 void PaintInvalidator::UpdateVisualRectIfNeeded(
     const LayoutObject& object,
@@ skipping 86 matching lines @@
 }
 
 void PaintInvalidator::InvalidatePaint(
     const LayoutObject& object,
     const PaintPropertyTreeBuilderContext* tree_builder_context,
     PaintInvalidatorContext& context) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"),
                "PaintInvalidator::invalidatePaintIfNeeded()", "object",
                object.DebugName().Ascii());
 
+  if (object.IsSVGHiddenContainer()) {
+    context.subtree_flags |= PaintInvalidatorContext::kSubtreeNoInvalidation;
+  }
+  if (context.subtree_flags & PaintInvalidatorContext::kSubtreeNoInvalidation)
+    return;
+
   object.GetMutableForPainting().EnsureIsReadyForPaintInvalidation();
 
   UpdatePaintingLayer(object, context);
 
   if (object.GetDocument().Printing() &&
       !RuntimeEnabledFeatures::printBrowserEnabled())
     return;  // Don't invalidate paints if we're printing.
 
   // TODO(crbug.com/637313): Use GeometryMapper which now supports filter
   // geometry effects, after skia optimizes filter's mapRect operation.
   // TODO(crbug.com/648274): This is a workaround for multi-column contents.
   if (object.HasFilterInducingProperty() || object.IsLayoutFlowThread()) {
-    context.forced_subtree_invalidation_flags |=
-        PaintInvalidatorContext::kForcedSubtreeSlowPathRect;
+    context.subtree_flags |= PaintInvalidatorContext::kSubtreeSlowPathRect;
   }
 
   UpdatePaintInvalidationContainer(object, context);
   UpdateVisualRectIfNeeded(object, tree_builder_context, context);
 
   if (!object.ShouldCheckForPaintInvalidation() &&
-      !(context.forced_subtree_invalidation_flags &
-        ~PaintInvalidatorContext::kForcedSubtreeVisualRectUpdate)) {
+      !(context.subtree_flags &
+        ~PaintInvalidatorContext::kSubtreeVisualRectUpdate)) {
     // We are done updating anything needed. No other paint invalidation work to
     // do for this object.
     return;
   }
 
-  if (object.IsSVGHiddenContainer()) {
-    context.forced_subtree_invalidation_flags |=
-        PaintInvalidatorContext::kForcedSubtreeNoRasterInvalidation;
-  }
-
   PaintInvalidationReason reason = object.InvalidatePaint(context);
   switch (reason) {
     case PaintInvalidationReason::kDelayedFull:
       pending_delayed_paint_invalidations_.push_back(&object);
       break;
     case PaintInvalidationReason::kSubtree:
-      context.forced_subtree_invalidation_flags |=
-          (PaintInvalidatorContext::kForcedSubtreeFullInvalidation |
-           PaintInvalidatorContext::
-               kForcedSubtreeFullInvalidationForStackedContents);
+      context.subtree_flags |=
+          (PaintInvalidatorContext::kSubtreeFullInvalidation |
+           PaintInvalidatorContext::kSubtreeFullInvalidationForStackedContents);
       break;
     case PaintInvalidationReason::kSVGResource:
-      context.forced_subtree_invalidation_flags |=
-          PaintInvalidatorContext::kForcedSubtreeSVGResourceChange;
+      context.subtree_flags |=
+          PaintInvalidatorContext::kSubtreeSVGResourceChange;
       break;
     default:
       break;
   }
 
   if (object.MayNeedPaintInvalidationSubtree()) {
-    context.forced_subtree_invalidation_flags |=
-        PaintInvalidatorContext::kForcedSubtreeInvalidationChecking;
+    context.subtree_flags |=
+        PaintInvalidatorContext::kSubtreeInvalidationChecking;
   }
 
   if (context.old_location != context.new_location &&
       !context.painting_layer->SubtreeIsInvisible()) {
-    context.forced_subtree_invalidation_flags |=
-        PaintInvalidatorContext::kForcedSubtreeInvalidationChecking;
+    context.subtree_flags |=
+        PaintInvalidatorContext::kSubtreeInvalidationChecking;
   }
 
-  if (context.forced_subtree_invalidation_flags &&
-      context.NeedsVisualRectUpdate(object)) {
+  if (context.subtree_flags && context.NeedsVisualRectUpdate(object)) {
     // If any subtree flag is set, we also need to pass needsVisualRectUpdate
     // requirement to the subtree.
-    context.forced_subtree_invalidation_flags |=
-        PaintInvalidatorContext::kForcedSubtreeVisualRectUpdate;
+    context.subtree_flags |= PaintInvalidatorContext::kSubtreeVisualRectUpdate;
   }
 }
 
 void PaintInvalidator::ProcessPendingDelayedPaintInvalidations() {
   for (auto target : pending_delayed_paint_invalidations_) {
     target->GetMutableForPainting()
         .SetShouldDoFullPaintInvalidationWithoutGeometryChange(
             PaintInvalidationReason::kDelayedFull);
   }
 }
 
 }  // namespace blink