Skip both paint and raster invalidation for LayoutSVGHiddenContainer subtree

third_party/WebKit/Source/core/layout/PaintInvalidationState.cpp

 // Copyright 2014 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/layout/PaintInvalidationState.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 135 matching lines @@
     // We are changing paintInvalidationContainer to
     // m_paintInvalidationContainerForStackedContents. Must disable cached
     // offsets because we didn't track paint offset from
     // m_paintInvalidationContainerForStackedContents.
     // TODO(wangxianzhu): There are optimization opportunities:
     // - Like what we do for fixed-position, calculate the paint offset in slow
     //   path and enable fast path for descendants if possible; or
     // - Track offset between the two paintInvalidationContainers.
     cached_offsets_enabled_ = false;
     if (forced_subtree_invalidation_flags_ &
-        PaintInvalidatorContext::
-            kForcedSubtreeFullInvalidationForStackedContents)
+        PaintInvalidatorContext::kSubtreeFullInvalidationForStackedContents) {
       forced_subtree_invalidation_flags_ |=
-          PaintInvalidatorContext::kForcedSubtreeFullInvalidation;
+          PaintInvalidatorContext::kSubtreeFullInvalidation;
+    }
   }
 
   if (!current_object.IsBoxModelObject() && !current_object.IsSVG())
     return;
 
   if (cached_offsets_enabled_ ||
       current_object == paint_invalidation_container_)
     cached_offsets_enabled_ = SupportsCachedOffsets(current_object);
 
   if (current_object.IsSVG()) {
@@ skipping 11 matching lines @@
 
   if (current_object == 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 (current_object != paint_invalidation_container_for_stacked_contents_) {
       // However, we need to keep the FullInvalidationForStackedContents flag
       // if the current object isn't the paint invalidation container of
       // stacked contents.
-      forced_subtree_invalidation_flags_ &= PaintInvalidatorContext::
-          kForcedSubtreeFullInvalidationForStackedContents;
+      forced_subtree_invalidation_flags_ &=
+          PaintInvalidatorContext::kSubtreeFullInvalidationForStackedContents;
     } else {
       forced_subtree_invalidation_flags_ = 0;
       if (current_object != container_for_absolute_position_ &&
           cached_offsets_for_absolute_position_enabled_ &&
           cached_offsets_enabled_) {
         // The current object is the new paintInvalidationContainer for
         // absolute-position descendants but is not their container.
         // Call updateForCurrentObject() before resetting m_paintOffset to get
         // paint offset of the current object from the original
         // paintInvalidationContainerForStackingContents, then use this paint
@@ skipping 94 matching lines @@
   DCHECK(!did_update_for_children_);
   did_update_for_children_ = true;
 #endif
 
   switch (reason) {
     case PaintInvalidationReason::kDelayedFull:
       pending_delayed_paint_invalidations_.push_back(&current_object_);
       break;
     case PaintInvalidationReason::kSubtree:
       forced_subtree_invalidation_flags_ |=
-          (PaintInvalidatorContext::kForcedSubtreeFullInvalidation |
-           PaintInvalidatorContext::
-               kForcedSubtreeFullInvalidationForStackedContents);
+          (PaintInvalidatorContext::kSubtreeFullInvalidation |
+           PaintInvalidatorContext::kSubtreeFullInvalidationForStackedContents);
       break;
     case PaintInvalidationReason::kSVGResource:
       forced_subtree_invalidation_flags_ |=
-          PaintInvalidatorContext::kForcedSubtreeSVGResourceChange;
+          PaintInvalidatorContext::kSubtreeSVGResourceChange;
       break;
     default:
       break;
   }
 
   UpdateForNormalChildren();
 
   if (current_object_ == container_for_absolute_position_) {
     if (paint_invalidation_container_ ==
         paint_invalidation_container_for_stacked_contents_) {
@@ skipping 215 matching lines @@
 
 PaintLayer& PaintInvalidationState::PaintingLayer() const {
   DCHECK_EQ(&painting_layer_, current_object_.PaintingLayer());
   return painting_layer_;
 }
 
 PaintInvalidatorContextAdapter::PaintInvalidatorContextAdapter(
     const PaintInvalidationState& paint_invalidation_state)
     : PaintInvalidatorContext(),
       paint_invalidation_state_(paint_invalidation_state) {
-  forced_subtree_invalidation_flags =
-      paint_invalidation_state.forced_subtree_invalidation_flags_;
+  subtree_flags = paint_invalidation_state.forced_subtree_invalidation_flags_;
   paint_invalidation_container =
       &paint_invalidation_state.PaintInvalidationContainer();
   painting_layer = &paint_invalidation_state.PaintingLayer();
 }
 
 void PaintInvalidatorContextAdapter::MapLocalRectToVisualRectInBacking(
     const LayoutObject& object,
     LayoutRect& rect) const {
   DCHECK_EQ(&object, &paint_invalidation_state_.CurrentObject());
   paint_invalidation_state_.MapLocalRectToVisualRectInBacking(rect);
 }
 
 }  // namespace blink