Map visual rects of descendants under LayoutSVGHiddenContainer to the temporary root

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 74 matching lines @@
     // 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 =

[chrishtr, 2017/05/17 00:42:41]

Is this mapping necessary for testing, or for repaint-after-layout checks?
If so, in what scenario?

[Xianzhu, 2017/05/17 00:49:45]

It's for repaint-after-layout checks to invalidate changed DisplayItemClients
under the hidden container, so that they will be updated when the resource is
recorded.

+      !(context.forced_subtree_invalidation_flags &
+        PaintInvalidatorContext::kForcedSubtreeNoRasterInvalidation);
+
   LayoutRect result;
   if (context.forced_subtree_invalidation_flags &
       PaintInvalidatorContext::kForcedSubtreeSlowPathRect) {
+    DCHECK(map_to_backing);
     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 =
-        context.paint_invalidation_container->ContentsProperties();
+        map_to_backing
+            ? context.paint_invalidation_container->ContentsProperties()
+            : PropertyTreeState::Root();
     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.
-    result.MoveBy(-context.paint_invalidation_container->PaintOffset());
+    if (map_to_backing)
+      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 184 matching lines @@
       context.forced_subtree_invalidation_flags |=
           PaintInvalidatorContext::kForcedSubtreeFullInvalidation;
   }
 
   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 ForcedSubtreeVisualRectUpdate and
-      // ForcedSubtreeFullInvalidationForStackedContents flags if the current
+      // However, we need to keep kForcedSubtreeVisualRectUpdate and
+      // kForcedSubtreeFullInvalidationForStackedContents flags if the current
       // object isn't the paint invalidation container of stacked contents.
       context.forced_subtree_invalidation_flags &=
           (PaintInvalidatorContext::kForcedSubtreeVisualRectUpdate |
            PaintInvalidatorContext::
                kForcedSubtreeFullInvalidationForStackedContents);
     } else {
       context.forced_subtree_invalidation_flags = 0;
     }
   }
 
@@ skipping 173 matching lines @@
 
 void PaintInvalidator::ProcessPendingDelayedPaintInvalidations() {
   for (auto target : pending_delayed_paint_invalidations_) {
     target->GetMutableForPainting()
         .SetShouldDoFullPaintInvalidationWithoutGeometryChange(
             PaintInvalidationReason::kDelayedFull);
   }
 }
 
 }  // namespace blink