Only call paint property-requiring subroutines if there are actually properties.

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"
@@ skipping 299 matching lines @@
   // 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,
+    ObjectPaintProperties& properties,
     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() || 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();
       force_subtree_update |= properties.UpdateTransform(
           context.current.transform, TransformationMatrix(transform),
           FloatPoint3D());
     } else {
-      if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        force_subtree_update |= properties->ClearTransform();
+      force_subtree_update |= properties.ClearTransform();
     }
   }
 
-  if (object.PaintProperties() && object.PaintProperties()->Transform()) {
-    context.current.transform = object.PaintProperties()->Transform();
+  if (properties.Transform()) {
+    context.current.transform = properties.Transform();
     context.current.should_flatten_inherited_transform = false;
     context.current.rendering_context_id = 0;
   }
 }
 
 static CompositingReasons CompositingReasonsForTransform(const LayoutBox& box) {
   const ComputedStyle& style = box.StyleRef();
   CompositingReasons compositing_reasons = kCompositingReasonNone;
   if (CompositingReasonFinder::RequiresCompositingForTransform(box))
     compositing_reasons |= kCompositingReason3DTransform;
@@ skipping 30 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,
+    ObjectPaintProperties& properties,
     PaintPropertyTreeBuilderFragmentContext& context,
     bool& force_subtree_update) {
   if (object.IsSVGChild()) {
-    UpdateTransformForNonRootSVG(object, context, force_subtree_update);
+    UpdateTransformForNonRootSVG(object, properties, context,
+                                 force_subtree_update);
     return;
   }
 
   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 =
           CompositingReasonsForTransform(box);
 
@@ skipping 11 matching lines @@
       if (style.Preserves3D() && !rendering_context_id)
         rendering_context_id = PtrHash<const LayoutObject>::GetHash(&object);
 
       auto& properties = *object.GetMutableForPainting().PaintProperties();
       force_subtree_update |= properties.UpdateTransform(
           context.current.transform, matrix, TransformOrigin(box),
           context.current.should_flatten_inherited_transform,
           rendering_context_id, compositing_reasons,
           properties.GetCompositorElementId());
     } else {
-      if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        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 (properties.Transform()) {
+    context.current.transform = properties.Transform();
     if (object.StyleRef().Preserves3D()) {
       context.current.rendering_context_id =
-          properties->Transform()->RenderingContextId();
+          properties.Transform()->RenderingContextId();
       context.current.should_flatten_inherited_transform = false;
     } else {
       context.current.rendering_context_id = 0;
       context.current.should_flatten_inherited_transform = true;
     }
   }
 }
 
 static bool ComputeMaskParameters(IntRect& mask_clip,
                                   ColorFilter& mask_color_filter,
@@ skipping 82 matching lines @@
   }
 
   if (object.StyleRef().HasMask())
     return true;
 
   return false;
 }
 
 void PaintPropertyTreeBuilder::UpdateEffect(
     const LayoutObject& object,
+    ObjectPaintProperties& properties,
     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() || 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) {
         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())
-          force_subtree_update |= properties->ClearMaskClip();
+        force_subtree_update |= properties.ClearMaskClip();
       }
 
       SkBlendMode blend_mode =
           object.IsBlendingAllowed()
               ? WebCoreCompositeToSkiaComposite(kCompositeSourceOver,
                                                 style.BlendMode())
               : SkBlendMode::kSrcOver;
 
       DCHECK(!style.HasCurrentOpacityAnimation() ||
              compositing_reasons != kCompositingReasonNone);
@@ skipping 10 matching lines @@
         // otherwise.
         force_subtree_update |= properties.UpdateMask(
             properties.Effect(), context.current.transform, output_clip,
             mask_color_filter, CompositorFilterOperations(), 1.f,
             SkBlendMode::kDstIn, kCompositingReasonSquashingDisallowed,
             CompositorElementId());
       } else {
         force_subtree_update |= properties.ClearMask();
       }
     } else {
-      if (auto* properties = object.GetMutableForPainting().PaintProperties()) {
-        force_subtree_update |= properties->ClearEffect();
-        force_subtree_update |= properties->ClearMask();
-        force_subtree_update |= properties->ClearMaskClip();
-      }
+      auto* properties = object.GetMutableForPainting().PaintProperties();
+      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()) {
+  if (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();
+              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,
+    ObjectPaintProperties& properties,
     PaintPropertyTreeBuilderFragmentContext& context,
     bool& force_subtree_update) {
   const ComputedStyle& style = object.StyleRef();
 
   if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     if (NeedsFilter(object)) {
       CompositorFilterOperations filter =
           ToLayoutBoxModelObject(object)
               .Layer()
               ->CreateCompositorFilterOperationsForFilter(style);
@@ skipping 25 matching lines @@
       // 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 =
           CompositingReasonFinder::RequiresCompositingForFilterAnimation(style)
               ? kCompositingReasonActiveAnimation
               : kCompositingReasonNone;
       DCHECK(!style.HasCurrentFilterAnimation() ||
              compositing_reasons != kCompositingReasonNone);
 
-      auto& properties = *object.GetMutableForPainting().PaintProperties();
       force_subtree_update |= properties.UpdateFilter(
           context.current_effect, context.current.transform, output_clip,
           kColorFilterNone, std::move(filter), 1.f, SkBlendMode::kSrcOver,
           compositing_reasons, properties.GetCompositorElementId());
     } else {
-      if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        force_subtree_update |= properties->ClearFilter();
+      force_subtree_update |= properties.ClearFilter();
     }
   }
 
-  const auto* properties = object.PaintProperties();
-  if (properties && properties->Filter()) {
-    context.current_effect = properties->Filter();
+  if (properties.Filter()) {
+    context.current_effect = properties.Filter();
     // TODO(trchen): Change input clip to expansion hint once implemented.
-    const ClipPaintPropertyNode* input_clip =
-        properties->Filter()->OutputClip();
+    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,
+    ObjectPaintProperties& properties,
     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();
       force_subtree_update |= properties.UpdateCssClip(
           context.current.clip, context.current.transform,
           FloatRoundedRect(FloatRect(clip_rect)));
     } else {
-      if (auto* properties = object.GetMutableForPainting().PaintProperties())
-        force_subtree_update |= properties->ClearCssClip();
+      force_subtree_update |= properties.ClearCssClip();
     }
   }
 
-  const auto* properties = object.PaintProperties();
-  if (properties && properties->CssClip())
-    context.current.clip = properties->CssClip();
+  if (properties.CssClip())
+    context.current.clip = properties.CssClip();
 }
 
 void PaintPropertyTreeBuilder::UpdateLocalBorderBoxContext(
     const LayoutObject& object,
     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.
@@ skipping 14 matching lines @@
       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,
+    ObjectPaintProperties& properties,
     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();
     force_subtree_update |= properties.UpdateScrollbarPaintOffset(
         context.current.transform, paint_offset, FloatPoint3D());
   } else {
-    if (auto* properties = object.GetMutableForPainting().PaintProperties())
-      force_subtree_update |= properties->ClearScrollbarPaintOffset();
+    force_subtree_update |= properties.ClearScrollbarPaintOffset();
   }
 }
 
 static bool NeedsOverflowClip(const LayoutObject& object) {
   return object.IsBox() && ToLayoutBox(object).ShouldClipOverflow();
 }
 
 void PaintPropertyTreeBuilder::UpdateOverflowClip(
     const LayoutObject& object,
+    ObjectPaintProperties& properties,
     PaintPropertyTreeBuilderFragmentContext& context,
     bool& force_subtree_update) {
   if (object.NeedsPaintPropertyUpdate() || force_subtree_update) {
     if (NeedsOverflowClip(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()));
         force_subtree_update |= properties.UpdateInnerBorderRadiusClip(
             context.current.clip, context.current.transform, inner_border);
         current_clip = properties.InnerBorderRadiusClip();
       } else {
         force_subtree_update |= properties.ClearInnerBorderRadiusClip();
       }
 
       force_subtree_update |=
           properties.UpdateOverflowClip(current_clip, context.current.transform,
                                         FloatRoundedRect(FloatRect(clip_rect)));
     } else {
-      if (auto* properties = object.GetMutableForPainting().PaintProperties()) {
-        force_subtree_update |= properties->ClearInnerBorderRadiusClip();
-        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();
+  if (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,
+    ObjectPaintProperties& properties,
     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();
       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())
-        force_subtree_update |= properties->ClearPerspective();
+      force_subtree_update |= properties.ClearPerspective();
     }
   }
 
-  const auto* properties = object.PaintProperties();
-  if (properties && properties->Perspective()) {
-    context.current.transform = properties->Perspective();
+  if (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,
+    ObjectPaintProperties& properties,
     PaintPropertyTreeBuilderFragmentContext& context,
     bool& force_subtree_update) {
   if (!object.IsSVGRoot())
     return;
 
   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();
       force_subtree_update |= properties.UpdateSvgLocalToBorderBoxTransform(
           context.current.transform, transform_to_border_box, FloatPoint3D());
     } else {
-      if (auto* properties = object.GetMutableForPainting().PaintProperties()) {
-        force_subtree_update |= properties->ClearSvgLocalToBorderBoxTransform();
-      }
+      force_subtree_update |= properties.ClearSvgLocalToBorderBoxTransform();
     }
   }
 
-  const auto* properties = object.PaintProperties();
-  if (properties && properties->SvgLocalToBorderBoxTransform()) {
-    context.current.transform = properties->SvgLocalToBorderBoxTransform();
+  if (properties.SvgLocalToBorderBoxTransform()) {
+    context.current.transform = properties.SvgLocalToBorderBoxTransform();
     context.current.should_flatten_inherited_transform = false;
     context.current.rendering_context_id = 0;
   }
   // The paint offset is included in |transformToBorderBox| so SVG does not need
   // to handle paint offset internally.
   context.current.paint_offset = LayoutPoint();
 }
 
 static MainThreadScrollingReasons GetMainThreadScrollingReasons(
     const LayoutObject& object,
@@ skipping 14 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,
+    ObjectPaintProperties& properties,
     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();
@@ skipping 11 matching lines @@
           -scroll_offset.Width(), -scroll_offset.Height());
       force_subtree_update |= properties.UpdateScrollTranslation(
           context.current.transform, matrix, FloatPoint3D(),
           context.current.should_flatten_inherited_transform,
           context.current.rendering_context_id, kCompositingReasonNone,
           properties.GetCompositorElementId(), 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())
-        force_subtree_update |= properties->ClearScrollTranslation();
+      force_subtree_update |= properties.ClearScrollTranslation();
     }
   }
 
-  if (object.PaintProperties() &&
-      object.PaintProperties()->ScrollTranslation()) {
-    context.current.transform = object.PaintProperties()->ScrollTranslation();
+  if (properties.ScrollTranslation()) {
+    context.current.transform = properties.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,
     PaintPropertyTreeBuilderFragmentContext& context,
     bool& force_subtree_update) {
+  if (!object.IsBoxModelObject() && !object.PaintProperties())
+    return;
+
   if (object.IsLayoutBlock())
     context.paint_offset_for_float = context.current.paint_offset;
 
   if (object.CanContainAbsolutePositionObjects())
     context.absolute_position = context.current;
 
   if (object.IsLayoutView()) {
     if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       const auto* initial_fixed_transform = context.fixed_position.transform;
       const auto* initial_fixed_scroll = context.fixed_position.scroll;
@@ skipping 162 matching lines @@
 void PaintPropertyTreeBuilder::UpdatePaintProperties(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& full_context) {
   bool needs_paint_properties =
       NeedsPaintOffsetTranslation(object) || NeedsTransform(object) ||
       NeedsEffect(object) || NeedsTransformForNonRootSVG(object) ||
       NeedsFilter(object) || NeedsCssClip(object) ||
       NeedsScrollbarPaintOffset(object) || NeedsOverflowClip(object) ||
       NeedsPerspective(object) || NeedsSVGLocalToBorderBoxTransform(object) ||
       NeedsScrollTranslation(object) || NeedsCssClipFixedPosition(object);
-
   bool had_paint_properties = object.PaintProperties();
 
   if (needs_paint_properties && !had_paint_properties) {
     ObjectPaintProperties& paint_properties =
         object.GetMutableForPainting().EnsurePaintProperties();
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       paint_properties.SetCompositorElementId(
           CreateDomNodeBasedCompositorElementId(object));
     }
   } else if (!needs_paint_properties && had_paint_properties) {
@@ skipping 11 matching lines @@
     const LayoutObject& object,
     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 = PaintPropertyTreeBuilderFragmentContext();
   }
 
-  bool object_type_might_need_paint_properties =
-      ObjectTypeMightNeedPaintProperties(object);
-
-  if (object_type_might_need_paint_properties)
+  if (ObjectTypeMightNeedPaintProperties(object))
     UpdatePaintProperties(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, 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, full_context.force_subtree_update);
 #endif
 
-  if (object_type_might_need_paint_properties) {
-    UpdateTransform(object, context, full_context.force_subtree_update);
-    UpdateCssClip(object, context, full_context.force_subtree_update);
+  if (object.PaintProperties()) {
+    ObjectPaintProperties* properties =
+        object.GetMutableForPainting().PaintProperties();
+    UpdateTransform(object, *properties, context,
+                    full_context.force_subtree_update);
+    UpdateCssClip(object, *properties, context,
+                  full_context.force_subtree_update);
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
-      UpdateEffect(object, context, full_context.force_subtree_update);
-      UpdateFilter(object, context, full_context.force_subtree_update);
+      UpdateEffect(object, *properties, context,
+                   full_context.force_subtree_update);
+      UpdateFilter(object, *properties, context,
+                   full_context.force_subtree_update);
     }
-    UpdateLocalBorderBoxContext(object, context,
-                                full_context.force_subtree_update);
+  }
+  UpdateLocalBorderBoxContext(object, context,
+                              full_context.force_subtree_update);
+  if (object.PaintProperties()) {
+    ObjectPaintProperties* properties =
+        object.GetMutableForPainting().PaintProperties();
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
-      UpdateScrollbarPaintOffset(object, context,
+      UpdateScrollbarPaintOffset(object, *properties, context,
                                  full_context.force_subtree_update);
     }
   }
 }
 
 void PaintPropertyTreeBuilder::UpdatePropertiesForChildren(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!ObjectTypeMightNeedPaintProperties(object))
     return;
 
   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,
+
+    if (object.PaintProperties()) {
+      ObjectPaintProperties* properties =
+          object.GetMutableForPainting().PaintProperties();
+      UpdateOverflowClip(object, *properties, fragment_context,
+                         context.force_subtree_update);
+      UpdatePerspective(object, *properties, fragment_context,
+                        context.force_subtree_update);
+      UpdateSvgLocalToBorderBoxTransform(object, *properties, fragment_context,
+                                         context.force_subtree_update);
+      UpdateScrollAndScrollTranslation(object, *properties, 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();
   }
 
   if (object.CanContainAbsolutePositionObjects())
     context.container_for_absolute_position = &object;
 }
 
 }  // namespace blink