Introduce PaintPropertyTreeBuilderFragmentContext and use it throughout.

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

 // Copyright 2015 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/PaintPropertyTreeBuilder.h"
 
 #include <memory>
 #include "core/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositingReasonFinder.h"
 #include "core/layout/svg/LayoutSVGResourceMasker.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/layout/svg/SVGResources.h"
 #include "core/layout/svg/SVGResourcesCache.h"
 #include "core/paint/FindPaintOffsetAndVisualRectNeedingUpdate.h"
 #include "core/paint/FindPropertiesNeedingUpdate.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/SVGRootPainter.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
-PaintPropertyTreeBuilderContext::PaintPropertyTreeBuilderContext()
-    : container_for_absolute_position(nullptr),
-      current_effect(EffectPaintPropertyNode::Root()),
-      input_clip_of_current_effect(ClipPaintPropertyNode::Root()),
-      force_subtree_update(false) {
+PaintPropertyTreeBuilderFragmentContext::
+    PaintPropertyTreeBuilderFragmentContext()
+    : current_effect(EffectPaintPropertyNode::Root()),
+      input_clip_of_current_effect(ClipPaintPropertyNode::Root()) {
   current.clip = absolute_position.clip = fixed_position.clip =
       ClipPaintPropertyNode::Root();
   current.transform = absolute_position.transform = fixed_position.transform =
       TransformPaintPropertyNode::Root();
   current.scroll = absolute_position.scroll = fixed_position.scroll =
       ScrollPaintPropertyNode::Root();
 }
 
 // True if a new property was created, false if an existing one was updated.
 static bool UpdatePreTranslation(
@@ skipping 78 matching lines @@
   auto reasons = ancestor_reasons;
   if (!frame_view.GetFrame().GetSettings()->GetThreadedScrollingEnabled())
     reasons |= MainThreadScrollingReason::kThreadedScrollingDisabled;
   if (frame_view.HasBackgroundAttachmentFixedObjects())
     reasons |= MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
   return reasons;
 }
 
 void PaintPropertyTreeBuilder::UpdateProperties(
     FrameView& frame_view,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderContext& full_context) {
+  if (full_context.fragments.IsEmpty())
+    full_context.fragments.push_back(PaintPropertyTreeBuilderFragmentContext());
+
+  PaintPropertyTreeBuilderFragmentContext& context = full_context.fragments[0];
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // With root layer scrolling, the LayoutView (a LayoutObject) properties are
     // updated like other objects (see updatePropertiesAndContextForSelf and
     // updatePropertiesAndContextForChildren) instead of needing LayoutView-
     // specific property updates here.
     context.current.paint_offset.MoveBy(frame_view.Location());
     context.current.rendering_context_id = 0;
     context.current.should_flatten_inherited_transform = true;
     context.absolute_position = context.current;
-    context.container_for_absolute_position = nullptr;
+    full_context.container_for_absolute_position = nullptr;
     context.fixed_position = context.current;
     return;
   }
 
 #if DCHECK_IS_ON()
-  FindFrameViewPropertiesNeedingUpdateScope check_scope(&frame_view, context);
+  FindFrameViewPropertiesNeedingUpdateScope check_scope(
+      &frame_view, full_context.is_actually_needed);
 #endif
 
-  if (frame_view.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+  if (frame_view.NeedsPaintPropertyUpdate() ||
+      full_context.force_subtree_update) {
     TransformationMatrix frame_translate;
     frame_translate.Translate(
         frame_view.X() + context.current.paint_offset.X(),
         frame_view.Y() + context.current.paint_offset.Y());
-    context.force_subtree_update |= UpdatePreTranslation(
+    full_context.force_subtree_update |= UpdatePreTranslation(
         frame_view, context.current.transform, frame_translate, FloatPoint3D());
 
     FloatRoundedRect content_clip(
         IntRect(IntPoint(), frame_view.VisibleContentSize()));
-    context.force_subtree_update |=
+    full_context.force_subtree_update |=
         UpdateContentClip(frame_view, context.current.clip,
                           frame_view.PreTranslation(), content_clip);
 
     ScrollOffset scroll_offset = frame_view.GetScrollOffset();
     if (frame_view.IsScrollable() || !scroll_offset.IsZero()) {
       TransformationMatrix frame_scroll;
       frame_scroll.Translate(-scroll_offset.Width(), -scroll_offset.Height());
 
       IntSize scroll_clip = frame_view.VisibleContentSize();
       IntSize scroll_bounds = frame_view.ContentsSize();
       bool user_scrollable_horizontal =
           frame_view.UserInputScrollable(kHorizontalScrollbar);
       bool user_scrollable_vertical =
           frame_view.UserInputScrollable(kVerticalScrollbar);
 
       auto ancestor_reasons =
           context.current.scroll->GetMainThreadScrollingReasons();
       auto reasons =
           GetMainThreadScrollingReasons(frame_view, ancestor_reasons);
 
-      context.force_subtree_update |= UpdateScrollTranslation(
+      full_context.force_subtree_update |= UpdateScrollTranslation(
           frame_view, frame_view.PreTranslation(), frame_scroll, FloatPoint3D(),
           context.current.scroll, scroll_clip, scroll_bounds,
           user_scrollable_horizontal, user_scrollable_vertical, reasons,
           frame_view.GetScrollableArea());
     } else {
       if (frame_view.ScrollTranslation()) {
         // Ensure pre-existing properties are cleared if there is no scrolling.
         frame_view.SetScrollTranslation(nullptr);
         // Rebuild all descendant properties because a property was removed.
-        context.force_subtree_update = true;
+        full_context.force_subtree_update = true;
       }
     }
   }
 
   // Initialize the context for current, absolute and fixed position cases.
   // They are the same, except that scroll translation does not apply to
   // fixed position descendants.
   const auto* fixed_transform_node = frame_view.PreTranslation()
                                          ? frame_view.PreTranslation()
                                          : context.current.transform;
   auto* fixed_scroll_node = context.current.scroll;
   DCHECK(frame_view.PreTranslation());
   context.current.transform = frame_view.PreTranslation();
   DCHECK(frame_view.ContentClip());
   context.current.clip = frame_view.ContentClip();
   if (const auto* scroll_translation = frame_view.ScrollTranslation()) {
     context.current.transform = scroll_translation;
     context.current.scroll = scroll_translation->ScrollNode();
   }
   context.current.paint_offset = LayoutPoint();
   context.current.rendering_context_id = 0;
   context.current.should_flatten_inherited_transform = true;
   context.absolute_position = context.current;
-  context.container_for_absolute_position = nullptr;
+  full_context.container_for_absolute_position = nullptr;
   context.fixed_position = context.current;
   context.fixed_position.transform = fixed_transform_node;
   context.fixed_position.scroll = fixed_scroll_node;
 
   std::unique_ptr<PropertyTreeState> contents_state(new PropertyTreeState(
       context.current.transform, context.current.clip, context.current_effect));
   frame_view.SetTotalPropertyTreeStateForContents(std::move(contents_state));
 }
 
 static bool NeedsPaintOffsetTranslation(const LayoutObject& object) {
   if (!object.IsBoxModelObject())
     return false;
   const LayoutBoxModelObject& box_model = ToLayoutBoxModelObject(object);
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       box_model.IsLayoutView()) {
     // Root layer scrolling always creates a translation node for LayoutView to
     // ensure fixed and absolute contexts use the correct transform space.
     return true;
   } else if (box_model.HasLayer() &&
              box_model.Layer()->PaintsWithTransform(
                  kGlobalPaintFlattenCompositingLayers)) {
     return true;
   }
   return false;
 }
 
 void PaintPropertyTreeBuilder::UpdatePaintOffsetTranslation(
     const LayoutBoxModelObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
   if (NeedsPaintOffsetTranslation(object) &&
       // As an optimization, skip these paint offset translation nodes when
       // the offset is an identity. An exception is the layout view because root
       // layer scrolling needs a transform node to ensure fixed and absolute
       // descendants use the correct transform space.
       (object.IsLayoutView() ||
        context.current.paint_offset != LayoutPoint())) {
     auto& properties = *object.GetMutableForPainting().PaintProperties();
     // We should use the same subpixel paint offset values for snapping
     // regardless of whether a transform is present. If there is a transform
     // we round the paint offset but keep around the residual fractional
     // component for the transformed content to paint with.  In spv1 this was
     // called "subpixel accumulation". For more information, see
     // PaintLayer::subpixelAccumulation() and
     // PaintLayerPainter::paintFragmentByApplyingTransform.
     IntPoint rounded_paint_offset =
         RoundedIntPoint(context.current.paint_offset);
     LayoutPoint fractional_paint_offset =
         LayoutPoint(context.current.paint_offset - rounded_paint_offset);
 
-    context.force_subtree_update |= properties.UpdatePaintOffsetTranslation(
+    force_subtree_update |= properties.UpdatePaintOffsetTranslation(
         context.current.transform,
         TransformationMatrix().Translate(rounded_paint_offset.X(),
                                          rounded_paint_offset.Y()),
         FloatPoint3D(), context.current.should_flatten_inherited_transform,
         context.current.rendering_context_id);
 
     context.current.transform = properties.PaintOffsetTranslation();
     context.current.paint_offset = fractional_paint_offset;
     if (RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
         object.IsLayoutView()) {
       context.absolute_position.transform = properties.PaintOffsetTranslation();
       context.fixed_position.transform = properties.PaintOffsetTranslation();
       context.absolute_position.paint_offset = LayoutPoint();
       context.fixed_position.paint_offset = LayoutPoint();
     }
   } else {
     if (auto* properties = object.GetMutableForPainting().PaintProperties())
-      context.force_subtree_update |= properties->ClearPaintOffsetTranslation();
+      force_subtree_update |= properties->ClearPaintOffsetTranslation();
   }
 }
 
 static bool NeedsTransformForNonRootSVG(const LayoutObject& object) {
   // TODO(pdr): Check for the presence of a transform instead of the value.
   // Checking for an identity matrix will cause the property tree structure
   // to change during animations if the animation passes through the
   // identity matrix.
   return object.IsSVGChild() &&
          !object.LocalToSVGParentTransform().IsIdentity();
 }
 
 // SVG does not use the general transform update of |updateTransform|, instead
 // creating a transform node for SVG-specific transforms without 3D.
 void PaintPropertyTreeBuilder::UpdateTransformForNonRootSVG(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
   DCHECK(object.IsSVGChild());
   // SVG does not use paint offset internally, except for SVGForeignObject which
   // has different SVG and HTML coordinate spaces.
   DCHECK(object.IsSVGForeignObject() ||
          context.current.paint_offset == LayoutPoint());
 
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     AffineTransform transform = object.LocalToSVGParentTransform();
     if (NeedsTransformForNonRootSVG(object)) {
       // The origin is included in the local transform, so leave origin empty.
       auto& properties = *object.GetMutableForPainting().PaintProperties();
-      context.force_subtree_update |= properties.UpdateTransform(
+      force_subtree_update |= properties.UpdateTransform(
           context.current.transform, TransformationMatrix(transform),
           FloatPoint3D());
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        context.force_subtree_update |= properties->ClearTransform();
+        force_subtree_update |= properties->ClearTransform();
     }
   }
 
   if (object.PaintProperties() && object.PaintProperties()->Transform()) {
     context.current.transform = object.PaintProperties()->Transform();
     context.current.should_flatten_inherited_transform = false;
     context.current.rendering_context_id = 0;
   }
 }
 
@@ skipping 35 matching lines @@
 static bool NeedsTransform(const LayoutObject& object) {
   if (!object.IsBox())
     return false;
   return object.StyleRef().HasTransform() || object.StyleRef().Preserves3D() ||
          CompositingReasonsForTransform(ToLayoutBox(object)) !=
              kCompositingReasonNone;
 }
 
 void PaintPropertyTreeBuilder::UpdateTransform(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
   if (object.IsSVGChild()) {
-    UpdateTransformForNonRootSVG(object, context);
+    UpdateTransformForNonRootSVG(object, context, force_subtree_update);
     return;
   }
 
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     const ComputedStyle& style = object.StyleRef();
 
     // A transform node is allocated for transforms, preserves-3d and any
     // direct compositing reason. The latter is required because this is the
     // only way to represent compositing both an element and its stacking
     // descendants.
     if (NeedsTransform(object)) {
       auto& box = ToLayoutBox(object);
 
       CompositingReasons compositing_reasons =
@@ skipping 12 matching lines @@
       unsigned rendering_context_id = context.current.rendering_context_id;
       if (style.Preserves3D() && !rendering_context_id)
         rendering_context_id = PtrHash<const LayoutObject>::GetHash(&object);
 
       CompositorElementId compositor_element_id =
           style.HasCurrentTransformAnimation()
               ? CreateDomNodeBasedCompositorElementId(object)
               : CompositorElementId();
 
       auto& properties = *object.GetMutableForPainting().PaintProperties();
-      context.force_subtree_update |= properties.UpdateTransform(
+      force_subtree_update |= properties.UpdateTransform(
           context.current.transform, matrix, TransformOrigin(box),
           context.current.should_flatten_inherited_transform,
           rendering_context_id, compositing_reasons, compositor_element_id);
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        context.force_subtree_update |= properties->ClearTransform();
+        force_subtree_update |= properties->ClearTransform();
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->Transform()) {
     context.current.transform = properties->Transform();
     if (object.StyleRef().Preserves3D()) {
       context.current.rendering_context_id =
           properties->Transform()->RenderingContextId();
       context.current.should_flatten_inherited_transform = false;
@@ skipping 91 matching lines @@
   }
 
   if (object.StyleRef().HasMask())
     return true;
 
   return false;
 }
 
 void PaintPropertyTreeBuilder::UpdateEffect(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
   const ComputedStyle& style = object.StyleRef();
 
   // TODO(trchen): Can't omit effect node if we have 3D children.
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     const ClipPaintPropertyNode* output_clip =
         context.input_clip_of_current_effect;
 
     if (NeedsEffect(object)) {
       auto& properties = *object.GetMutableForPainting().PaintProperties();
 
       // We may begin to composite our subtree prior to an animation starts,
       // but a compositor element ID is only needed when an animation is
       // current.
       CompositingReasons compositing_reasons = kCompositingReasonNone;
       if (CompositingReasonFinder::RequiresCompositingForOpacityAnimation(
               style)) {
         compositing_reasons = kCompositingReasonActiveAnimation;
       }
 
       IntRect mask_clip;
       ColorFilter mask_color_filter;
       bool has_mask = ComputeMaskParameters(
           mask_clip, mask_color_filter, object, context.current.paint_offset);
       if (has_mask) {
-        context.force_subtree_update |= properties.UpdateMaskClip(
+        force_subtree_update |= properties.UpdateMaskClip(
             context.current.clip, context.current.transform,
             FloatRoundedRect(mask_clip));
         output_clip = properties.MaskClip();
 
         // TODO(crbug.com/683425): PaintArtifactCompositor does not handle
         // grouping (i.e. descendant-dependent compositing reason) properly
         // yet. This forces masked subtree always create a layer for now.
         compositing_reasons |= kCompositingReasonIsolateCompositedDescendants;
       } else {
         if (auto* properties = object.GetMutableForPainting().PaintProperties())
-          context.force_subtree_update |= properties->ClearMaskClip();
+          force_subtree_update |= properties->ClearMaskClip();
       }
 
       SkBlendMode blend_mode =
           object.IsBlendingAllowed()
               ? WebCoreCompositeToSkiaComposite(kCompositeSourceOver,
                                                 style.BlendMode())
               : SkBlendMode::kSrcOver;
 
       CompositorElementId compositor_element_id =
           style.HasCurrentOpacityAnimation()
               ? CreateDomNodeBasedCompositorElementId(object)
               : CompositorElementId();
 
       DCHECK(!style.HasCurrentOpacityAnimation() ||
              compositing_reasons != kCompositingReasonNone);
 
-      context.force_subtree_update |= properties.UpdateEffect(
+      force_subtree_update |= properties.UpdateEffect(
           context.current_effect, context.current.transform, output_clip,
           kColorFilterNone, CompositorFilterOperations(), style.Opacity(),
           blend_mode, compositing_reasons, compositor_element_id);
       if (has_mask) {
         // TODO(crbug.com/683425): PaintArtifactCompositor does not handle
         // grouping (i.e. descendant-dependent compositing reason) properly
         // yet. Adding CompositingReasonSquashingDisallowed forces mask not
         // getting squashed into a child effect. Have no compositing reason
         // otherwise.
-        context.force_subtree_update |= properties.UpdateMask(
+        force_subtree_update |= properties.UpdateMask(
             properties.Effect(), context.current.transform, output_clip,
             mask_color_filter, CompositorFilterOperations(), 1.f,
             SkBlendMode::kDstIn, kCompositingReasonSquashingDisallowed,
             CompositorElementId());
       } else {
-        context.force_subtree_update |= properties.ClearMask();
+        force_subtree_update |= properties.ClearMask();
       }
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties()) {
-        context.force_subtree_update |= properties->ClearEffect();
-        context.force_subtree_update |= properties->ClearMask();
-        context.force_subtree_update |= properties->ClearMaskClip();
+        force_subtree_update |= properties->ClearEffect();
+        force_subtree_update |= properties->ClearMask();
+        force_subtree_update |= properties->ClearMaskClip();
       }
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->Effect()) {
     context.current_effect = properties->Effect();
     if (properties->MaskClip()) {
       context.input_clip_of_current_effect = context.current.clip =
           context.absolute_position.clip = context.fixed_position.clip =
               properties->MaskClip();
     }
   }
 }
 
 static bool NeedsFilter(const LayoutObject& object) {
   // TODO(trchen): SVG caches filters in SVGResources. Implement it.
   return object.IsBoxModelObject() && ToLayoutBoxModelObject(object).Layer() &&
          (object.StyleRef().HasFilter() || object.HasReflection());
 }
 
 void PaintPropertyTreeBuilder::UpdateFilter(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
   const ComputedStyle& style = object.StyleRef();
 
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     if (NeedsFilter(object)) {
       CompositorFilterOperations filter =
           ToLayoutBoxModelObject(object)
               .Layer()
               ->CreateCompositorFilterOperationsForFilter(style);
 
       // The CSS filter spec didn't specify how filters interact with overflow
       // clips. The implementation here mimics the old Blink/WebKit behavior for
       // backward compatibility.
       // Basically the output of the filter will be affected by clips that
@@ skipping 25 matching lines @@
               ? CreateDomNodeBasedCompositorElementId(object)
               : CompositorElementId();
       CompositingReasons compositing_reasons =
           CompositingReasonFinder::RequiresCompositingForFilterAnimation(style)
               ? kCompositingReasonActiveAnimation
               : kCompositingReasonNone;
       DCHECK(!style.HasCurrentFilterAnimation() ||
              compositing_reasons != kCompositingReasonNone);
 
       auto& properties = *object.GetMutableForPainting().PaintProperties();
-      context.force_subtree_update |= properties.UpdateFilter(
+      force_subtree_update |= properties.UpdateFilter(
           context.current_effect, context.current.transform, output_clip,
           kColorFilterNone, std::move(filter), 1.f, SkBlendMode::kSrcOver,
           compositing_reasons, compositor_element_id);
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        context.force_subtree_update |= properties->ClearFilter();
+        force_subtree_update |= properties->ClearFilter();
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->Filter()) {
     context.current_effect = properties->Filter();
     // TODO(trchen): Change input clip to expansion hint once implemented.
     const ClipPaintPropertyNode* input_clip =
         properties->Filter()->OutputClip();
     context.input_clip_of_current_effect = context.current.clip =
         context.absolute_position.clip = context.fixed_position.clip =
             input_clip;
   }
 }
 
 static bool NeedsCssClip(const LayoutObject& object) {
   return object.HasClip();
 }
 
 void PaintPropertyTreeBuilder::UpdateCssClip(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     if (NeedsCssClip(object)) {
       // Create clip node for descendants that are not fixed position.
       // We don't have to setup context.absolutePosition.clip here because this
       // object must be a container for absolute position descendants, and will
       // copy from in-flow context later at updateOutOfFlowContext() step.
       DCHECK(object.CanContainAbsolutePositionObjects());
       LayoutRect clip_rect =
           ToLayoutBox(object).ClipRect(context.current.paint_offset);
       auto& properties = *object.GetMutableForPainting().PaintProperties();
-      context.force_subtree_update |= properties.UpdateCssClip(
+      force_subtree_update |= properties.UpdateCssClip(
           context.current.clip, context.current.transform,
           FloatRoundedRect(FloatRect(clip_rect)));
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        context.force_subtree_update |= properties->ClearCssClip();
+        force_subtree_update |= properties->ClearCssClip();
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->CssClip())
     context.current.clip = properties->CssClip();
 }
 
 void PaintPropertyTreeBuilder::UpdateLocalBorderBoxContext(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
-  if (!object.NeedsPaintPropertyUpdate() && !context.force_subtree_update)
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
+  if (!object.NeedsPaintPropertyUpdate() && !force_subtree_update)
     return;
 
   // We only need to cache the local border box properties for layered objects.
   if (!object.HasLayer()) {
     object.GetMutableForPainting().ClearLocalBorderBoxProperties();
   } else {
     PropertyTreeState local_border_box =
         PropertyTreeState(context.current.transform, context.current.clip,
                           context.current_effect);
     object.GetMutableForPainting().SetLocalBorderBoxProperties(
         local_border_box);
   }
 }
 
 static bool NeedsScrollbarPaintOffset(const LayoutObject& object) {
   if (object.IsBoxModelObject()) {
     if (auto* area = ToLayoutBoxModelObject(object).GetScrollableArea()) {
       if (area->HorizontalScrollbar() || area->VerticalScrollbar())
         return true;
     }
   }
   return false;
 }
 
 // TODO(trchen): Remove this once we bake the paint offset into frameRect.
 void PaintPropertyTreeBuilder::UpdateScrollbarPaintOffset(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
-  if (!object.NeedsPaintPropertyUpdate() && !context.force_subtree_update)
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
+  if (!object.NeedsPaintPropertyUpdate() && !force_subtree_update)
     return;
 
   if (NeedsScrollbarPaintOffset(object)) {
     IntPoint rounded_paint_offset =
         RoundedIntPoint(context.current.paint_offset);
     auto paint_offset = TransformationMatrix().Translate(
         rounded_paint_offset.X(), rounded_paint_offset.Y());
     auto& properties = *object.GetMutableForPainting().PaintProperties();
-    context.force_subtree_update |= properties.UpdateScrollbarPaintOffset(
+    force_subtree_update |= properties.UpdateScrollbarPaintOffset(
         context.current.transform, paint_offset, FloatPoint3D());
   } else {
     if (auto* properties = object.GetMutableForPainting().PaintProperties())
-      context.force_subtree_update |= properties->ClearScrollbarPaintOffset();
+      force_subtree_update |= properties->ClearScrollbarPaintOffset();
   }
 }
 
 static bool NeedsOverflowScroll(const LayoutObject& object) {
   return object.IsBox() && ToLayoutBox(object).ShouldClipOverflow();
 }
 
 void PaintPropertyTreeBuilder::UpdateOverflowClip(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     if (NeedsOverflowScroll(object)) {
       const LayoutBox& box = ToLayoutBox(object);
       LayoutRect clip_rect;
       clip_rect =
           LayoutRect(box.OverflowClipRect(context.current.paint_offset));
 
       auto& properties = *object.GetMutableForPainting().PaintProperties();
       const auto* current_clip = context.current.clip;
       if (box.StyleRef().HasBorderRadius()) {
         auto inner_border = box.StyleRef().GetRoundedInnerBorderFor(
             LayoutRect(context.current.paint_offset, box.Size()));
-        context.force_subtree_update |= properties.UpdateInnerBorderRadiusClip(
+        force_subtree_update |= properties.UpdateInnerBorderRadiusClip(
             context.current.clip, context.current.transform, inner_border);
         current_clip = properties.InnerBorderRadiusClip();
       } else {
-        context.force_subtree_update |= properties.ClearInnerBorderRadiusClip();
+        force_subtree_update |= properties.ClearInnerBorderRadiusClip();
       }
 
-      context.force_subtree_update |=
+      force_subtree_update |=
           properties.UpdateOverflowClip(current_clip, context.current.transform,
                                         FloatRoundedRect(FloatRect(clip_rect)));
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties()) {
-        context.force_subtree_update |=
-            properties->ClearInnerBorderRadiusClip();
-        context.force_subtree_update |= properties->ClearOverflowClip();
+        force_subtree_update |= properties->ClearInnerBorderRadiusClip();
+        force_subtree_update |= properties->ClearOverflowClip();
       }
       return;
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->OverflowClip())
     context.current.clip = properties->OverflowClip();
 }
 
 static FloatPoint PerspectiveOrigin(const LayoutBox& box) {
   const ComputedStyle& style = box.StyleRef();
   // Perspective origin has no effect without perspective.
   DCHECK(style.HasPerspective());
   FloatSize border_box_size(box.Size());
   return FloatPoint(
       FloatValueForLength(style.PerspectiveOriginX(), border_box_size.Width()),
       FloatValueForLength(style.PerspectiveOriginY(),
                           border_box_size.Height()));
 }
 
 static bool NeedsPerspective(const LayoutObject& object) {
   return object.IsBox() && object.StyleRef().HasPerspective();
 }
 
 void PaintPropertyTreeBuilder::UpdatePerspective(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     if (NeedsPerspective(object)) {
       const ComputedStyle& style = object.StyleRef();
       // The perspective node must not flatten (else nothing will get
       // perspective), but it should still extend the rendering context as
       // most transform nodes do.
       TransformationMatrix matrix =
           TransformationMatrix().ApplyPerspective(style.Perspective());
       FloatPoint3D origin = PerspectiveOrigin(ToLayoutBox(object)) +
                             ToLayoutSize(context.current.paint_offset);
       auto& properties = *object.GetMutableForPainting().PaintProperties();
-      context.force_subtree_update |= properties.UpdatePerspective(
+      force_subtree_update |= properties.UpdatePerspective(
           context.current.transform, matrix, origin,
           context.current.should_flatten_inherited_transform,
           context.current.rendering_context_id);
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        context.force_subtree_update |= properties->ClearPerspective();
+        force_subtree_update |= properties->ClearPerspective();
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->Perspective()) {
     context.current.transform = properties->Perspective();
     context.current.should_flatten_inherited_transform = false;
   }
 }
 
 static bool NeedsSVGLocalToBorderBoxTransform(const LayoutObject& object) {
   return object.IsSVGRoot();
 }
 
 void PaintPropertyTreeBuilder::UpdateSvgLocalToBorderBoxTransform(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
   if (!object.IsSVGRoot())
     return;
 
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     AffineTransform transform_to_border_box =
         SVGRootPainter(ToLayoutSVGRoot(object))
             .TransformToPixelSnappedBorderBox(context.current.paint_offset);
     if (!transform_to_border_box.IsIdentity() &&
         NeedsSVGLocalToBorderBoxTransform(object)) {
       auto& properties = *object.GetMutableForPainting().PaintProperties();
-      context.force_subtree_update |=
-          properties.UpdateSvgLocalToBorderBoxTransform(
-              context.current.transform, transform_to_border_box,
-              FloatPoint3D());
+      force_subtree_update |= properties.UpdateSvgLocalToBorderBoxTransform(
+          context.current.transform, transform_to_border_box, FloatPoint3D());
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties()) {
-        context.force_subtree_update |=
-            properties->ClearSvgLocalToBorderBoxTransform();
+        force_subtree_update |= properties->ClearSvgLocalToBorderBoxTransform();
       }
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->SvgLocalToBorderBoxTransform()) {
     context.current.transform = properties->SvgLocalToBorderBoxTransform();
     context.current.should_flatten_inherited_transform = false;
     context.current.rendering_context_id = 0;
   }
@@ skipping 21 matching lines @@
     auto* scrollable_area = box.GetScrollableArea();
     IntSize scroll_offset = box.ScrolledContentOffset();
     if (!scroll_offset.IsZero() || scrollable_area->ScrollsOverflow())
       return true;
   }
   return false;
 }
 
 void PaintPropertyTreeBuilder::UpdateScrollAndScrollTranslation(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     if (NeedsScrollTranslation(object)) {
       const LayoutBox& box = ToLayoutBox(object);
       auto* scrollable_area = box.GetScrollableArea();
       IntSize scroll_offset = box.ScrolledContentOffset();
       auto& properties = *object.GetMutableForPainting().PaintProperties();
 
       IntSize scroll_clip = scrollable_area->VisibleContentRect().Size();
       IntSize scroll_bounds = scrollable_area->ContentsSize();
       bool user_scrollable_horizontal =
           scrollable_area->UserInputScrollable(kHorizontalScrollbar);
       bool user_scrollable_vertical =
           scrollable_area->UserInputScrollable(kVerticalScrollbar);
 
       auto ancestor_reasons =
           context.current.scroll->GetMainThreadScrollingReasons();
       auto reasons = GetMainThreadScrollingReasons(object, ancestor_reasons);
 
       // Main thread scrolling reasons depend on their ancestor's reasons
       // so ensure the entire subtree is updated when reasons change.
       if (auto* existing_scroll_translation = properties.ScrollTranslation()) {
         auto* existing_scroll_node = existing_scroll_translation->ScrollNode();
         if (existing_scroll_node->GetMainThreadScrollingReasons() != reasons)
-          context.force_subtree_update = true;
+          force_subtree_update = true;
       }
 
       CompositorElementId compositor_element_id =
           CreateDomNodeBasedCompositorElementId(object);
       TransformationMatrix matrix = TransformationMatrix().Translate(
           -scroll_offset.Width(), -scroll_offset.Height());
-      context.force_subtree_update |= properties.UpdateScrollTranslation(
+      force_subtree_update |= properties.UpdateScrollTranslation(
           context.current.transform, matrix, FloatPoint3D(),
           context.current.should_flatten_inherited_transform,
           context.current.rendering_context_id, kCompositingReasonNone,
           compositor_element_id, context.current.scroll, scroll_clip,
           scroll_bounds, user_scrollable_horizontal, user_scrollable_vertical,
           reasons, scrollable_area);
     } else {
       // Ensure pre-existing properties are cleared.
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        context.force_subtree_update |= properties->ClearScrollTranslation();
+        force_subtree_update |= properties->ClearScrollTranslation();
     }
   }
 
   if (object.PaintProperties() &&
       object.PaintProperties()->ScrollTranslation()) {
     context.current.transform = object.PaintProperties()->ScrollTranslation();
     context.current.scroll = context.current.transform->ScrollNode();
     context.current.should_flatten_inherited_transform = false;
   }
 }
 
 static bool NeedsCssClipFixedPosition(const LayoutObject& object) {
   return !object.IsLayoutView() && !object.CanContainFixedPositionObjects() &&
          NeedsCssClip(object);
 }
 
 void PaintPropertyTreeBuilder::UpdateOutOfFlowContext(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
   if (object.IsLayoutBlock())
     context.paint_offset_for_float = context.current.paint_offset;
 
-  if (object.CanContainAbsolutePositionObjects()) {
+  if (object.CanContainAbsolutePositionObjects())
     context.absolute_position = context.current;
-    context.container_for_absolute_position = &object;
-  }
 
   if (object.IsLayoutView()) {
     if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       const auto* initial_fixed_transform = context.fixed_position.transform;
       const auto* initial_fixed_scroll = context.fixed_position.scroll;
 
       context.fixed_position = context.current;
 
       // Fixed position transform and scroll nodes should not be affected.
       context.fixed_position.transform = initial_fixed_transform;
@@ skipping 10 matching lines @@
     // need to insert the clip here if we are not a containing block ancestor of
     // them.
     auto& properties = *object.GetMutableForPainting().PaintProperties();
     auto* css_clip = properties.CssClip();
 
     // Before we actually create anything, check whether in-flow context and
     // fixed-position context has exactly the same clip. Reuse if possible.
     if (context.fixed_position.clip == css_clip->Parent()) {
       context.fixed_position.clip = css_clip;
     } else {
-      if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
-        context.force_subtree_update |= properties.UpdateCssClipFixedPosition(
+      if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
+        force_subtree_update |= properties.UpdateCssClipFixedPosition(
             context.fixed_position.clip,
             const_cast<TransformPaintPropertyNode*>(
                 css_clip->LocalTransformSpace()),
             css_clip->ClipRect());
       }
       if (properties.CssClipFixedPosition())
         context.fixed_position.clip = properties.CssClipFixedPosition();
       return;
     }
   }
 
-  if (object.NeedsPaintPropertyUpdate() || context.force_subtree_update) {
+  if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     if (auto* properties = object.GetMutableForPainting().PaintProperties())
-      context.force_subtree_update |= properties->ClearCssClipFixedPosition();
+      force_subtree_update |= properties->ClearCssClipFixedPosition();
   }
 }
 
 void PaintPropertyTreeBuilder::UpdatePaintOffset(
     const LayoutBoxModelObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderFragmentContext& context,
+    const LayoutObject* container_for_absolute_position) {
   if (object.IsFloating())
     context.current.paint_offset = context.paint_offset_for_float;
 
   // Multicolumn spanners are painted starting at the multicolumn container (but
   // still inherit properties in layout-tree order) so reset the paint offset.
   if (object.IsColumnSpanAll())
     context.current.paint_offset = object.Container()->PaintOffset();
 
   switch (object.StyleRef().GetPosition()) {
     case EPosition::kStatic:
       break;
     case EPosition::kRelative:
       context.current.paint_offset += object.OffsetForInFlowPosition();
       break;
     case EPosition::kAbsolute: {
-      DCHECK(context.container_for_absolute_position == object.Container());
+      DCHECK(container_for_absolute_position == object.Container());
       context.current = context.absolute_position;
 
       // Absolutely positioned content in an inline should be positioned
       // relative to the inline.
-      const LayoutObject* container = context.container_for_absolute_position;
+      const LayoutObject* container = container_for_absolute_position;
       if (container && container->IsInFlowPositioned() &&
           container->IsLayoutInline()) {
         DCHECK(object.IsBox());
         context.current.paint_offset +=
             ToLayoutInline(container)->OffsetForInFlowPositionedInline(
                 ToLayoutBox(object));
       }
       break;
     }
     case EPosition::kSticky:
       context.current.paint_offset += object.OffsetForInFlowPosition();
       break;
     case EPosition::kFixed:
       context.current = context.fixed_position;
       break;
     default:
       ASSERT_NOT_REACHED();
   }
 
   if (object.IsBox()) {
     // TODO(pdr): Several calls in this function walk back up the tree to
     // calculate containers (e.g., physicalLocation, offsetForInFlowPosition*).
     // The containing block and other containers can be stored on
-    // PaintPropertyTreeBuilderContext instead of recomputing them.
+    // PaintPropertyTreeBuilderFragmentContext instead of recomputing them.
     context.current.paint_offset.MoveBy(ToLayoutBox(object).PhysicalLocation());
     // This is a weird quirk that table cells paint as children of table rows,
     // but their location have the row's location baked-in.
     // Similar adjustment is done in LayoutTableCell::offsetFromContainer().
     if (object.IsTableCell()) {
       LayoutObject* parent_row = object.Parent();
       DCHECK(parent_row && parent_row->IsTableRow());
       context.current.paint_offset.MoveBy(
           -ToLayoutBox(parent_row)->PhysicalLocation());
     }
   }
 }
 
 void PaintPropertyTreeBuilder::UpdateForObjectLocationAndSize(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    const LayoutObject* container_for_absolute_position,
+    bool& is_actually_needed,
+    PaintPropertyTreeBuilderFragmentContext& context,
+    bool& force_subtree_update) {
 #if DCHECK_IS_ON()
-  FindPaintOffsetNeedingUpdateScope check_scope(object, context);
+  FindPaintOffsetNeedingUpdateScope check_scope(object, is_actually_needed);
 #endif
 
   if (object.IsBoxModelObject()) {
-    UpdatePaintOffset(ToLayoutBoxModelObject(object), context);
-    UpdatePaintOffsetTranslation(ToLayoutBoxModelObject(object), context);
+    UpdatePaintOffset(ToLayoutBoxModelObject(object), context,
+                      container_for_absolute_position);
+    UpdatePaintOffsetTranslation(ToLayoutBoxModelObject(object), context,
+                                 force_subtree_update);
   }
 
   if (object.PaintOffset() != context.current.paint_offset) {
     // Many paint properties depend on paint offset so we force an update of
     // the entire subtree on paint offset changes.
-    context.force_subtree_update = true;
+    force_subtree_update = true;
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       object.GetMutableForPainting().SetShouldDoFullPaintInvalidation(
           kPaintInvalidationLocationChange);
     }
     object.GetMutableForPainting().SetPaintOffset(context.current.paint_offset);
   }
 
   if (!object.IsBox())
     return;
@@ skipping 15 matching lines @@
       box.HasClip() ||
       // Relative lengths (e.g., percentage values) in transform, perspective,
       // transform-origin, and perspective-origin can depend on the size of the
       // frame rect, so force a property update if it changes. TODO(pdr): We
       // only need to update properties if there are relative lengths.
       box.StyleRef().HasTransform() || box.StyleRef().HasPerspective() ||
       box_generates_property_nodes_for_mask_and_clip_path)
     box.GetMutableForPainting().SetNeedsPaintPropertyUpdate();
 }
 
-void PaintPropertyTreeBuilder::UpdatePaintProperties(
+void PaintPropertyTreeBuilder::CollectFragments(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderContext& full_context) {
   bool needs_paint_properties =
       NeedsPaintOffsetTranslation(object) || NeedsTransform(object) ||
       NeedsEffect(object) || NeedsTransformForNonRootSVG(object) ||
       NeedsFilter(object) || NeedsCssClip(object) ||
       NeedsScrollbarPaintOffset(object) || NeedsOverflowScroll(object) ||
       NeedsPerspective(object) || NeedsSVGLocalToBorderBoxTransform(object) ||
       NeedsScrollTranslation(object) || NeedsCssClipFixedPosition(object);
 
   bool had_paint_properties = object.PaintProperties();
 
   if (needs_paint_properties) {
     object.GetMutableForPainting().EnsurePaintProperties();
   } else {
     object.GetMutableForPainting().ClearPaintProperties();
     if (had_paint_properties)
-      context.force_subtree_update = true;
+      full_context.force_subtree_update = true;
   }
 }
 
 void PaintPropertyTreeBuilder::UpdatePropertiesForSelf(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    PaintPropertyTreeBuilderContext& full_context) {
+  PaintPropertyTreeBuilderFragmentContext& context = full_context.fragments[0];
   if (object.IsSVGHiddenContainer()) {
     // SVG resources are painted within one or more other locations in the
     // SVG during paint, and hence have their own independent paint property
     // trees, paint offset, etc.
-    context = PaintPropertyTreeBuilderContext();
+    context = PaintPropertyTreeBuilderFragmentContext();
   }
 
-  UpdatePaintProperties(object, context);
+  CollectFragments(object, full_context);
+
+  bool is_actually_needed = false;
+#if DCHECK_IS_ON()
+  is_actually_needed = full_context.is_actually_needed;
+#endif
 
   // This is not in FindObjectPropertiesNeedingUpdateScope because paint offset
   // can change without needsPaintPropertyUpdate.
-  UpdateForObjectLocationAndSize(object, context);
+  UpdateForObjectLocationAndSize(
+      object, full_context.container_for_absolute_position, is_actually_needed,
+      context, full_context.force_subtree_update);
 
 #if DCHECK_IS_ON()
-  FindObjectPropertiesNeedingUpdateScope check_needs_update_scope(object,
-                                                                  context);
+  FindObjectPropertiesNeedingUpdateScope check_needs_update_scope(
+      object, full_context.force_subtree_update);
 #endif
 
   if (object.IsBoxModelObject() || object.IsSVG()) {
-    UpdateTransform(object, context);
-    UpdateCssClip(object, context);
+    UpdateTransform(object, context, full_context.force_subtree_update);
+    UpdateCssClip(object, context, full_context.force_subtree_update);
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
-      UpdateEffect(object, context);
-      UpdateFilter(object, context);
+      UpdateEffect(object, context, full_context.force_subtree_update);
+      UpdateFilter(object, context, full_context.force_subtree_update);
     }
-    UpdateLocalBorderBoxContext(object, context);
-    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
-      UpdateScrollbarPaintOffset(object, context);
+    UpdateLocalBorderBoxContext(object, context,
+                                full_context.force_subtree_update);
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+      UpdateScrollbarPaintOffset(object, context,
+                                 full_context.force_subtree_update);
+    }
   }
 }
 
 void PaintPropertyTreeBuilder::UpdatePropertiesForChildren(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
-#if DCHECK_IS_ON()
-  FindObjectPropertiesNeedingUpdateScope check_needs_update_scope(object,
-                                                                  context);
-#endif
-
   if (!object.IsBoxModelObject() && !object.IsSVG())
     return;
 
-  UpdateOverflowClip(object, context);
-  UpdatePerspective(object, context);
-  UpdateSvgLocalToBorderBoxTransform(object, context);
-  UpdateScrollAndScrollTranslation(object, context);
-  UpdateOutOfFlowContext(object, context);
+  for (auto& fragment_context : context.fragments) {
+#if DCHECK_IS_ON()
+    FindObjectPropertiesNeedingUpdateScope check_needs_update_scope(
+        object, context.force_subtree_update);
+#endif
+    UpdateOverflowClip(object, fragment_context, context.force_subtree_update);
+    UpdatePerspective(object, fragment_context, context.force_subtree_update);
+    UpdateSvgLocalToBorderBoxTransform(object, fragment_context,
+                                       context.force_subtree_update);
+    UpdateScrollAndScrollTranslation(object, fragment_context,
+                                     context.force_subtree_update);
+    UpdateOutOfFlowContext(object, fragment_context,
+                           context.force_subtree_update);
 
-  context.force_subtree_update |= object.SubtreeNeedsPaintPropertyUpdate();
+    context.force_subtree_update |= object.SubtreeNeedsPaintPropertyUpdate();
+  }
+
+  if (object.CanContainAbsolutePositionObjects())
+    context.container_for_absolute_position = &object;
 }
 
 }  // namespace blink