Skip both paint and raster invalidation for LayoutSVGHiddenContainer subtree

third_party/WebKit/Source/core/paint/ObjectPaintInvalidator.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/ObjectPaintInvalidator.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutPartItem.h"
@@ skipping 481 matching lines @@
   // container vs scrolling contents).
   return !context_.paint_invalidation_container->UsesCompositedScrolling();
 }
 
 void ObjectPaintInvalidatorWithContext::InvalidatePaintRectangleWithContext(
     const LayoutRect& rect,
     PaintInvalidationReason reason) {
   if (rect.IsEmpty())
     return;
 
-  if (context_.forced_subtree_invalidation_flags &
-      PaintInvalidatorContext::kForcedSubtreeNoRasterInvalidation)
-    return;
-
   // If the parent has fully invalidated and its visual rect covers this object
   // on the same backing, skip the invalidation.
   if (ParentFullyInvalidatedOnSameBacking() &&
       (context_.parent_context->old_visual_rect.Contains(rect) ||
        object_.Parent()->VisualRect().Contains(rect)))
     return;
 
   InvalidatePaintUsingContainer(*context_.paint_invalidation_container, rect,
                                 reason);
 }
 
 DISABLE_CFI_PERF
 PaintInvalidationReason
 ObjectPaintInvalidatorWithContext::ComputePaintInvalidationReason() {
   // This is before any early return to ensure the background obscuration status
   // is saved.
   bool background_obscuration_changed = false;
   bool background_obscured = object_.BackgroundIsKnownToBeObscured();
   if (background_obscured != object_.PreviousBackgroundObscured()) {
     object_.GetMutableForPainting().SetPreviousBackgroundObscured(
         background_obscured);
     background_obscuration_changed = true;
   }
 
-  if (context_.forced_subtree_invalidation_flags &
-      PaintInvalidatorContext::kForcedSubtreeFullInvalidation)
+  if (context_.subtree_flags &
+      PaintInvalidatorContext::kSubtreeFullInvalidation)
     return PaintInvalidationReason::kSubtree;
 
   if (object_.ShouldDoFullPaintInvalidation())
     return object_.FullPaintInvalidationReason();
 
   if (context_.old_visual_rect.IsEmpty() && object_.VisualRect().IsEmpty())
     return PaintInvalidationReason::kNone;
 
   if (background_obscuration_changed)
     return PaintInvalidationReason::kBackground;
@@ skipping 77 matching lines @@
                          old_selection_rect, new_selection_rect);
     context_.painting_layer->SetNeedsRepaint();
     object_.InvalidateDisplayItemClients(PaintInvalidationReason::kSelection);
   }
 }
 
 DISABLE_CFI_PERF
 PaintInvalidationReason
 ObjectPaintInvalidatorWithContext::InvalidatePaintWithComputedReason(
     PaintInvalidationReason reason) {
+  DCHECK(!(context_.subtree_flags &
+           PaintInvalidatorContext::kSubtreeNoInvalidation));
+
   // We need to invalidate the selection before checking for whether we are
   // doing a full invalidation.  This is because we need to update the previous
   // selection rect regardless.
   InvalidateSelectionIfNeeded(reason);
 
   switch (reason) {
     case PaintInvalidationReason::kNone:
       // There are corner cases that the display items need to be invalidated
       // for paint offset mutation, but incurs no pixel difference (i.e. bounds
       // stay the same) so no rect-based invalidation is issued. See
       // crbug.com/508383 and crbug.com/515977.
       if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
-          (context_.forced_subtree_invalidation_flags &
-           PaintInvalidatorContext::kForcedSubtreeInvalidationChecking) &&
+          (context_.subtree_flags &
+           PaintInvalidatorContext::kSubtreeInvalidationChecking) &&
           !object_.IsSVGChild()) {
         // For SPv1, we conservatively assume the object changed paint offset
         // except for non-root SVG whose paint offset is always zero.
         reason = PaintInvalidationReason::kGeometry;
         break;
       }
 
       if (object_.IsSVG() &&
-          (context_.forced_subtree_invalidation_flags &
-           PaintInvalidatorContext::kForcedSubtreeSVGResourceChange)) {
+          (context_.subtree_flags &
+           PaintInvalidatorContext::kSubtreeSVGResourceChange)) {
         reason = PaintInvalidationReason::kSVGResource;
         break;
       }
       return PaintInvalidationReason::kNone;
     case PaintInvalidationReason::kDelayedFull:
       return PaintInvalidationReason::kDelayedFull;
     default:
       DCHECK(IsImmediateFullPaintInvalidationReason(reason));
       // This allows descendants to know the computed reason if it's different
       // from the original reason before paint invalidation.
       object_.GetMutableForPainting()
           .SetShouldDoFullPaintInvalidationWithoutGeometryChange(reason);
       FullyInvalidatePaint(reason, context_.old_visual_rect,
                            object_.VisualRect());
   }
 
   context_.painting_layer->SetNeedsRepaint();
   object_.InvalidateDisplayItemClients(reason);
   return reason;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : disabler_(&g_disable_paint_invalidation_state_asserts, true) {}
 
 }  // namespace blink