Reuse existing paint property node is possible

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 "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/SVGRootPainter.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 void PaintPropertyTreeBuilder::buildTreeRootNodes(FrameView& rootFrame, PaintPropertyTreeBuilderContext& context)
 {
-    RefPtr<TransformPaintPropertyNode> transformRoot = TransformPaintPropertyNode::create(TransformationMatrix(), FloatPoint3D(), nullptr);
-    context.current.transform = context.absolutePosition.transform = context.fixedPosition.transform = transformRoot.get();
-    rootFrame.setRootTransform(std::move(transformRoot));
+    if (!rootFrame.rootTransform() || rootFrame.rootTransform()->parent()) {
+        rootFrame.setRootTransform(TransformPaintPropertyNode::create(nullptr, TransformationMatrix(), FloatPoint3D()));
+        rootFrame.setRootClip(ClipPaintPropertyNode::create(nullptr, rootFrame.rootTransform(), FloatRoundedRect(LayoutRect::infiniteIntRect())));
+        rootFrame.setRootEffect(EffectPaintPropertyNode::create(nullptr, 1.0));
+    } else {
+        DCHECK(rootFrame.rootClip() && !rootFrame.rootClip()->parent());
+        DCHECK(rootFrame.rootEffect() && !rootFrame.rootEffect()->parent());
+    }
 
-    RefPtr<ClipPaintPropertyNode> clipRoot = ClipPaintPropertyNode::create(transformRoot, FloatRoundedRect(LayoutRect::infiniteIntRect()), nullptr);
-    context.current.clip = context.absolutePosition.clip = context.fixedPosition.clip = clipRoot.get();
-    rootFrame.setRootClip(std::move(clipRoot));
-
-    RefPtr<EffectPaintPropertyNode> effectRoot = EffectPaintPropertyNode::create(1.0, nullptr);
-    context.currentEffect = effectRoot.get();
-    rootFrame.setRootEffect(std::move(effectRoot));
+    context.current.transform = context.absolutePosition.transform = context.fixedPosition.transform = rootFrame.rootTransform();
+    context.current.clip = context.absolutePosition.clip = context.fixedPosition.clip = rootFrame.rootClip();
+    context.currentEffect = rootFrame.rootEffect();
 }
 
 void PaintPropertyTreeBuilder::buildTreeNodes(FrameView& frameView, PaintPropertyTreeBuilderContext& context)
 {
     // TODO(pdr): Creating paint properties for FrameView here will not be
     // needed once settings()->rootLayerScrolls() is enabled.
     // TODO(pdr): Make this conditional on the rootLayerScrolls setting.
 
     TransformationMatrix frameTranslate;
     frameTranslate.translate(frameView.x() + context.current.paintOffset.x(), frameView.y() + context.current.paintOffset.y());
-    RefPtr<TransformPaintPropertyNode> newTransformNodeForPreTranslation = TransformPaintPropertyNode::create(frameTranslate, FloatPoint3D(), context.current.transform);
+    if (TransformPaintPropertyNode* existingPreTranslation = frameView.preTranslation())
+        existingPreTranslation->update(context.current.transform, frameTranslate, FloatPoint3D());
+    else
+        frameView.setPreTranslation(TransformPaintPropertyNode::create(context.current.transform, frameTranslate, FloatPoint3D()));
 
     FloatRoundedRect contentClip(IntRect(IntPoint(), frameView.visibleContentSize()));
-    RefPtr<ClipPaintPropertyNode> newClipNodeForContentClip = ClipPaintPropertyNode::create(newTransformNodeForPreTranslation.get(), contentClip, context.current.clip);
+    if (ClipPaintPropertyNode* existingContentClip = frameView.contentClip())
+        existingContentClip->update(context.current.clip, frameView.preTranslation(), contentClip);
+    else
+        frameView.setContentClip(ClipPaintPropertyNode::create(context.current.clip, frameView.preTranslation(), contentClip));
 
     DoubleSize scrollOffset = frameView.scrollOffsetDouble();
     TransformationMatrix frameScroll;
     frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
-    RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = TransformPaintPropertyNode::create(frameScroll, FloatPoint3D(), newTransformNodeForPreTranslation);
+    if (TransformPaintPropertyNode* existingScrollTranslation = frameView.scrollTranslation())
+        existingScrollTranslation->update(frameView.preTranslation(), frameScroll, FloatPoint3D());
+    else
+        frameView.setScrollTranslation(TransformPaintPropertyNode::create(frameView.preTranslation(), frameScroll, FloatPoint3D()));
 
     // 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.
-    context.current.transform = newTransformNodeForScrollTranslation.get();
+    context.current.transform = frameView.scrollTranslation();
     context.current.paintOffset = LayoutPoint();
-    context.current.clip = newClipNodeForContentClip.get();
+    context.current.clip = frameView.contentClip();
     context.absolutePosition = context.current;
     context.containerForAbsolutePosition = nullptr;
     context.fixedPosition = context.current;
-    context.fixedPosition.transform = newTransformNodeForPreTranslation.get();
+    context.fixedPosition.transform = frameView.preTranslation();
+}
 
-    frameView.setPreTranslation(newTransformNodeForPreTranslation.release());
-    frameView.setScrollTranslation(newTransformNodeForScrollTranslation.release());
-    frameView.setContentClip(newClipNodeForContentClip.release());
+template <typename PropertyNode, void (ObjectPaintProperties::*Setter)(PassRefPtr<PropertyNode>)>
+void PaintPropertyTreeBuilder::clearPaintProperty(const LayoutObject& object)
+{
+    if (ObjectPaintProperties* existingProperties = object.objectPaintProperties())
+        (existingProperties->*Setter)(nullptr);
+}
+
+template <
+    typename PropertyNode,
+    PropertyNode* (ObjectPaintProperties::*Getter)() const,
+    void (ObjectPaintProperties::*Setter)(PassRefPtr<PropertyNode>),
+    typename... Args>
+void PaintPropertyTreeBuilder::updateOrCreatePaintProperty(const LayoutObject& object, const PaintPropertyTreeBuilderContext& context, PropertyNode*& contextProperty, const Args&... args)
+{
+    ObjectPaintProperties* existingProperties = object.objectPaintProperties();
+    PropertyNode* existingPropertyNode = existingProperties ? (existingProperties->*Getter)() : nullptr;
+    if (existingPropertyNode) {

[pdr., 2016/07/22 01:29:50]

In the previous patch you checked that the properties were different which would
cause a new node to be created if the properties other than parent changed. Do
you still want that behavior? Because property nodes are compared just with
their addresses, I think it is needed, but I'm not 100%.

To make this change, you could just pass parent first, then the rest of the
args. You could then add a function to the nodes such as "bool needsNewNode(all
args except parent)" and check that here.

[Xianzhu, 2016/07/22 04:21:03]

I don't think we there is requirement to create a new node for changed values.

About comparison of them, I guess you meant PaintChunker compares properties to
create chunks. This doesn't depend on whether we create new nodes or reuse old
nodes because PaintChunker always compare nodes in the same tree.

+        existingPropertyNode->update(contextProperty, args...);
+        contextProperty = existingPropertyNode;
+    } else {
+        RefPtr<PropertyNode> newPropertyNode = PropertyNode::create(contextProperty, args...);
+        contextProperty = newPropertyNode.get();
+        (object.getMutableForPainting().ensureObjectPaintProperties().*Setter)(newPropertyNode.release());
+    }
 }
 
 void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    if (object.isBoxModelObject()) {
+    if (object.isBoxModelObject() && context.current.paintOffset != LayoutPoint()) {
         // TODO(trchen): Eliminate PaintLayer dependency.
         PaintLayer* layer = toLayoutBoxModelObject(object).layer();
-        if (!layer || !layer->paintsWithTransform(GlobalPaintNormalPhase))
+        if (layer && layer->paintsWithTransform(GlobalPaintNormalPhase)) {
+            // 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 roundedPaintOffset = roundedIntPoint(context.current.paintOffset);
+            LayoutPoint fractionalPaintOffset = LayoutPoint(context.current.paintOffset - roundedPaintOffset);
+
+            updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::paintOffsetTranslation, &ObjectPaintProperties::setPaintOffsetTranslation>(
+                object, context, context.current.transform, TransformationMatrix().translate(roundedPaintOffset.x(), roundedPaintOffset.y()), FloatPoint3D());
+            context.current.paintOffset = fractionalPaintOffset;
             return;
+        }
     }
-
-    if (context.current.paintOffset == LayoutPoint())
-        return;
-
-    // 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 roundedPaintOffset = roundedIntPoint(context.current.paintOffset);
-    LayoutPoint fractionalPaintOffset = LayoutPoint(context.current.paintOffset - roundedPaintOffset);
-
-    RefPtr<TransformPaintPropertyNode> paintOffsetTranslation = TransformPaintPropertyNode::create(
-        TransformationMatrix().translate(roundedPaintOffset.x(), roundedPaintOffset.y()),
-        FloatPoint3D(), context.current.transform);
-    context.current.transform = paintOffsetTranslation.get();
-    context.current.paintOffset = fractionalPaintOffset;
-    object.getMutableForPainting().ensureObjectPaintProperties().setPaintOffsetTranslation(paintOffsetTranslation.release());
+    clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setPaintOffsetTranslation>(object);
 }
 
 static FloatPoint3D transformOrigin(const LayoutBox& box)
 {
     const ComputedStyle& style = box.styleRef();
     FloatSize borderBoxSize(box.size());
     return FloatPoint3D(
         floatValueForLength(style.transformOriginX(), borderBoxSize.width()),
         floatValueForLength(style.transformOriginY(), borderBoxSize.height()),
         style.transformOriginZ());
 }
 
 void PaintPropertyTreeBuilder::updateTransform(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.isSVG() && !object.isSVGRoot()) {
         // SVG does not use paint offset internally.
         DCHECK(context.current.paintOffset == LayoutPoint());
 
         // FIXME(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.
         // FIXME(pdr): Refactor this so all non-root SVG objects use the same transform function.
         const AffineTransform& transform = object.isSVGForeignObject() ? object.localSVGTransform() : object.localToSVGParentTransform();
-        if (transform.isIdentity())
+        if (!transform.isIdentity()) {
+            // The origin is included in the local transform, so leave origin empty.
+            updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::transform, &ObjectPaintProperties::setTransform>(
+                object, context, context.current.transform, TransformationMatrix(transform), FloatPoint3D());
             return;
-
-        // The origin is included in the local transform, so use an empty origin.
-        RefPtr<TransformPaintPropertyNode> svgTransform = TransformPaintPropertyNode::create(
-            transform, FloatPoint3D(0, 0, 0), context.current.transform);
-        context.current.transform = svgTransform.get();
-        object.getMutableForPainting().ensureObjectPaintProperties().setTransform(svgTransform.release());
-        return;
+        }
+    } else {
+        const ComputedStyle& style = object.styleRef();
+        if (object.isBox() && style.hasTransform()) {
+            TransformationMatrix matrix;
+            style.applyTransform(matrix, toLayoutBox(object).size(), ComputedStyle::ExcludeTransformOrigin,
+                ComputedStyle::IncludeMotionPath, ComputedStyle::IncludeIndependentTransformProperties);
+            FloatPoint3D origin = transformOrigin(toLayoutBox(object));
+            updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::transform, &ObjectPaintProperties::setTransform>(
+                object, context, context.current.transform, matrix, origin);
+            return;
+        }
     }
-
-    const ComputedStyle& style = object.styleRef();
-    if (!object.isBox() || !style.hasTransform())
-        return;
-
-    TransformationMatrix matrix;
-    style.applyTransform(matrix, toLayoutBox(object).size(), ComputedStyle::ExcludeTransformOrigin,
-        ComputedStyle::IncludeMotionPath, ComputedStyle::IncludeIndependentTransformProperties);
-    RefPtr<TransformPaintPropertyNode> transformNode = TransformPaintPropertyNode::create(
-        matrix, transformOrigin(toLayoutBox(object)), context.current.transform);
-    context.current.transform = transformNode.get();
-    object.getMutableForPainting().ensureObjectPaintProperties().setTransform(transformNode.release());
+    clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setTransform>(object);
 }
 
 void PaintPropertyTreeBuilder::updateEffect(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    if (!object.styleRef().hasOpacity())
+    if (!object.styleRef().hasOpacity()) {
+        clearPaintProperty<EffectPaintPropertyNode, &ObjectPaintProperties::setEffect>(object);
         return;
-    RefPtr<EffectPaintPropertyNode> effectNode = EffectPaintPropertyNode::create(object.styleRef().opacity(), context.currentEffect);
-    context.currentEffect = effectNode.get();
-    object.getMutableForPainting().ensureObjectPaintProperties().setEffect(effectNode.release());
+    }
+
+    updateOrCreatePaintProperty<EffectPaintPropertyNode, &ObjectPaintProperties::effect, &ObjectPaintProperties::setEffect>(
+        object, context, context.currentEffect, object.styleRef().opacity());
 }
 
 void PaintPropertyTreeBuilder::updateCssClip(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    if (!object.hasClip())
+    if (object.hasClip()) {
+        // 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 clipRect = toLayoutBox(object).clipRect(context.current.paintOffset);
+        updateOrCreatePaintProperty<ClipPaintPropertyNode, &ObjectPaintProperties::cssClip, &ObjectPaintProperties::setCssClip>(
+            object, context, context.current.clip, context.current.transform, FloatRoundedRect(LayoutRect(clipRect)));
         return;
-    ASSERT(object.canContainAbsolutePositionObjects());
-
-    // 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.
-    LayoutRect clipRect = toLayoutBox(object).clipRect(context.current.paintOffset);
-    RefPtr<ClipPaintPropertyNode> clipNode = ClipPaintPropertyNode::create(
-        context.current.transform,
-        FloatRoundedRect(FloatRect(clipRect)),
-        context.current.clip);
-    context.current.clip = clipNode.get();
-    object.getMutableForPainting().ensureObjectPaintProperties().setCssClip(clipNode.release());
+    }
+    clearPaintProperty<ClipPaintPropertyNode, &ObjectPaintProperties::setCssClip>(object);
 }
 
 void PaintPropertyTreeBuilder::updateLocalBorderBoxContext(const LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
 {
     // Avoid adding an ObjectPaintProperties for non-boxes to save memory, since we don't need them at the moment.
     if (!object.isBox() && !object.hasLayer())
         return;
 
     std::unique_ptr<ObjectPaintProperties::LocalBorderBoxProperties> borderBoxContext =
         wrapUnique(new ObjectPaintProperties::LocalBorderBoxProperties);
     borderBoxContext->paintOffset = context.current.paintOffset;
     borderBoxContext->propertyTreeState = PropertyTreeState(context.current.transform, context.current.clip, context.currentEffect);
     object.getMutableForPainting().ensureObjectPaintProperties().setLocalBorderBoxProperties(std::move(borderBoxContext));
 }
 
 // TODO(trchen): Remove this once we bake the paint offset into frameRect.
 void PaintPropertyTreeBuilder::updateScrollbarPaintOffset(const LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
 {
     IntPoint roundedPaintOffset = roundedIntPoint(context.current.paintOffset);
-    if (roundedPaintOffset == IntPoint())
-        return;
-
-    if (!object.isBoxModelObject())
-        return;
-    PaintLayerScrollableArea* scrollableArea = toLayoutBoxModelObject(object).getScrollableArea();
-    if (!scrollableArea)
-        return;
-    if (!scrollableArea->horizontalScrollbar() && !scrollableArea->verticalScrollbar())
-        return;
-
-    auto paintOffset = TransformationMatrix().translate(roundedPaintOffset.x(), roundedPaintOffset.y());
-    object.getMutableForPainting().ensureObjectPaintProperties().setScrollbarPaintOffset(
-        TransformPaintPropertyNode::create(paintOffset, FloatPoint3D(), context.current.transform));
+    if (roundedPaintOffset != IntPoint() && object.isBoxModelObject()) {
+        if (PaintLayerScrollableArea* scrollableArea = toLayoutBoxModelObject(object).getScrollableArea()) {
+            if (scrollableArea->horizontalScrollbar() || scrollableArea->verticalScrollbar()) {
+                auto paintOffset = TransformationMatrix().translate(roundedPaintOffset.x(), roundedPaintOffset.y());
+                // Make a copy of context.current.transform because we don't want to set the scrollbarPaintOffset node
+                // as the current transform.
+                TransformPaintPropertyNode* parentTransform = context.current.transform;
+                updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::scrollbarPaintOffset, &ObjectPaintProperties::setScrollbarPaintOffset>(
+                    object, context, parentTransform, paintOffset, FloatPoint3D());
+                return;
+            }
+        }
+    }
+    clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setScrollbarPaintOffset>(object);
 }
 
 void PaintPropertyTreeBuilder::updateOverflowClip(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.isBox())
         return;
     const LayoutBox& box = toLayoutBox(object);
 
     // The <input> elements can't have contents thus CSS overflow property doesn't apply.
     // However for layout purposes we do generate child layout objects for them, e.g. button label.
     // We should clip the overflow from those children. This is called control clip and we
     // technically treat them like overflow clip.
     LayoutRect clipRect;
-    if (box.hasControlClip())
+    if (box.hasControlClip()) {
         clipRect = box.controlClipRect(context.current.paintOffset);
-    else if (box.hasOverflowClip())
+    } else if (box.hasOverflowClip()) {
         clipRect = box.overflowClipRect(context.current.paintOffset);
-    else
+    } else {
+        clearPaintProperty<ClipPaintPropertyNode, &ObjectPaintProperties::setOverflowClip>(object);
         return;
+    }
 
+    // This need to be in top-level block to hold the reference until we finish creating the normal clip node.
     RefPtr<ClipPaintPropertyNode> borderRadiusClip;
     if (box.styleRef().hasBorderRadius()) {
         auto innerBorder = box.styleRef().getRoundedInnerBorderFor(
             LayoutRect(context.current.paintOffset, box.size()));
-        borderRadiusClip = ClipPaintPropertyNode::create(
-            context.current.transform, innerBorder, context.current.clip);
+        borderRadiusClip = ClipPaintPropertyNode::create(context.current.clip, context.current.transform, innerBorder);
+        context.current.clip = borderRadiusClip.get();
     }
 
-    RefPtr<ClipPaintPropertyNode> overflowClip = ClipPaintPropertyNode::create(
-        context.current.transform,
-        FloatRoundedRect(FloatRect(clipRect)),
-        borderRadiusClip ? borderRadiusClip.release() : context.current.clip);
-    context.current.clip = overflowClip.get();
-    object.getMutableForPainting().ensureObjectPaintProperties().setOverflowClip(overflowClip.release());
+    updateOrCreatePaintProperty<ClipPaintPropertyNode, &ObjectPaintProperties::overflowClip, &ObjectPaintProperties::setOverflowClip>(
+        object, context, context.current.clip, context.current.transform, FloatRoundedRect(FloatRect(clipRect)));
 }
 
 static FloatPoint perspectiveOrigin(const LayoutBox& box)
 {
     const ComputedStyle& style = box.styleRef();
     FloatSize borderBoxSize(box.size());
     return FloatPoint(
         floatValueForLength(style.perspectiveOriginX(), borderBoxSize.width()),
         floatValueForLength(style.perspectiveOriginY(), borderBoxSize.height()));
 }
 
 void PaintPropertyTreeBuilder::updatePerspective(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     const ComputedStyle& style = object.styleRef();
-    if (!object.isBox() || !style.hasPerspective())
+    if (!object.isBox() || !style.hasPerspective()) {
+        clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setPerspective>(object);
         return;
+    }
 
-    RefPtr<TransformPaintPropertyNode> perspective = TransformPaintPropertyNode::create(
-        TransformationMatrix().applyPerspective(style.perspective()),
-        perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.current.paintOffset),
-        context.current.transform);
-    context.current.transform = perspective.get();
-    object.getMutableForPainting().ensureObjectPaintProperties().setPerspective(perspective.release());
+    FloatPoint3D origin = perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.current.paintOffset);
+    updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::perspective, &ObjectPaintProperties::setPerspective>(
+        object, context, context.current.transform, TransformationMatrix().applyPerspective(style.perspective()), origin);
 }
 
 void PaintPropertyTreeBuilder::updateSvgLocalToBorderBoxTransform(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.isSVGRoot())
         return;
 
     AffineTransform transformToBorderBox = SVGRootPainter(toLayoutSVGRoot(object)).transformToPixelSnappedBorderBox(context.current.paintOffset);
 
     // The paint offset is included in |transformToBorderBox| so SVG does not need to handle paint
     // offset internally.
     context.current.paintOffset = LayoutPoint();
 
-    if (transformToBorderBox.isIdentity())
+    if (transformToBorderBox.isIdentity()) {
+        clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setSvgLocalToBorderBoxTransform>(object);
         return;
+    }
 
-    RefPtr<TransformPaintPropertyNode> svgLocalToBorderBoxTransform = TransformPaintPropertyNode::create(
-        transformToBorderBox, FloatPoint3D(0, 0, 0), context.current.transform);
-    context.current.transform = svgLocalToBorderBoxTransform.get();
-    context.current.paintOffset = LayoutPoint();
-    object.getMutableForPainting().ensureObjectPaintProperties().setSvgLocalToBorderBoxTransform(svgLocalToBorderBoxTransform.release());
+    updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::svgLocalToBorderBoxTransform, &ObjectPaintProperties::setSvgLocalToBorderBoxTransform>(
+        object, context, context.current.transform, transformToBorderBox, FloatPoint3D());
 }
 
 void PaintPropertyTreeBuilder::updateScrollTranslation(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    if (!object.isBoxModelObject() || !object.hasOverflowClip())
-        return;
+    if (object.isBoxModelObject() && object.hasOverflowClip()) {
+        PaintLayer* layer = toLayoutBoxModelObject(object).layer();
+        DCHECK(layer);
+        DoubleSize scrollOffset = layer->getScrollableArea()->scrollOffset();
 
-    PaintLayer* layer = toLayoutBoxModelObject(object).layer();
-    ASSERT(layer);
-    DoubleSize scrollOffset = layer->getScrollableArea()->scrollOffset();
-    if (scrollOffset.isZero() && !layer->scrollsOverflow())
-        return;
-
-    RefPtr<TransformPaintPropertyNode> scrollTranslation = TransformPaintPropertyNode::create(
-        TransformationMatrix().translate(-scrollOffset.width(), -scrollOffset.height()),
-        FloatPoint3D(),
-        context.current.transform);
-    context.current.transform = scrollTranslation.get();
-    object.getMutableForPainting().ensureObjectPaintProperties().setScrollTranslation(scrollTranslation.release());
+        if (!scrollOffset.isZero() || layer->scrollsOverflow()) {
+            TransformationMatrix matrix = TransformationMatrix().translate(-scrollOffset.width(), -scrollOffset.height());
+            updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::scrollTranslation, &ObjectPaintProperties::setScrollTranslation>(
+                object, context, context.current.transform, matrix, FloatPoint3D());
+            return;
+        }
+    }
+    clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setScrollTranslation>(object);
 }
 
 void PaintPropertyTreeBuilder::updateOutOfFlowContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.canContainAbsolutePositionObjects()) {
         context.absolutePosition = context.current;
         context.containerForAbsolutePosition = &object;
     }
 
     // TODO(pdr): Remove the !object.isLayoutView() condition when removing FrameView
     // paint properties for rootLayerScrolls.
     if (!object.isLayoutView() && object.canContainFixedPositionObjects()) {
         context.fixedPosition = context.current;
     } else if (object.objectPaintProperties() && object.objectPaintProperties()->cssClip()) {
         // CSS clip applies to all descendants, even if this object is not a containing block
         // ancestor of the descendant. It is okay for absolute-position descendants because
         // having CSS clip implies being absolute position container. However for fixed-position
         // descendants we need to insert the clip here if we are not a containing block ancestor
         // of them.
         auto* cssClip = object.objectPaintProperties()->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.fixedPosition.clip == cssClip->parent()) {
             context.fixedPosition.clip = cssClip;
+        } else {
+            updateOrCreatePaintProperty<ClipPaintPropertyNode, &ObjectPaintProperties::cssClipFixedPosition, &ObjectPaintProperties::setCssClipFixedPosition>(
+                object, context, context.fixedPosition.clip, const_cast<TransformPaintPropertyNode*>(cssClip->localTransformSpace()), cssClip->clipRect());
             return;
         }
-
-        RefPtr<ClipPaintPropertyNode> clipFixedPosition = ClipPaintPropertyNode::create(
-            const_cast<TransformPaintPropertyNode*>(cssClip->localTransformSpace()),
-            cssClip->clipRect(),
-            context.fixedPosition.clip);
-        context.fixedPosition.clip = clipFixedPosition.get();
-        object.getMutableForPainting().ensureObjectPaintProperties().setCssClipFixedPosition(clipFixedPosition.release());
     }
+    clearPaintProperty<ClipPaintPropertyNode, &ObjectPaintProperties::setCssClipFixedPosition>(object);
 }
 
 static void deriveBorderBoxFromContainerContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.isBoxModelObject())
         return;
 
     const LayoutBoxModelObject& boxModelObject = toLayoutBoxModelObject(object);
 
     switch (object.styleRef().position()) {
@@ skipping 33 matching lines @@
         if (boxModelObject.isTableCell()) {
             LayoutObject* parentRow = boxModelObject.parent();
             ASSERT(parentRow && parentRow->isTableRow());
             context.current.paintOffset.moveBy(-toLayoutBox(parentRow)->topLeftLocation());
         }
     }
 }
 
 void PaintPropertyTreeBuilder::buildTreeNodes(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    object.getMutableForPainting().clearObjectPaintProperties();
-
     if (!object.isBoxModelObject() && !object.isSVG())
         return;
 
     deriveBorderBoxFromContainerContext(object, context);
 
     updatePaintOffsetTranslation(object, context);
     updateTransform(object, context);
     updateEffect(object, context);
     updateCssClip(object, context);
     updateLocalBorderBoxContext(object, context);
     updateScrollbarPaintOffset(object, context);
     updateOverflowClip(object, context);
     // TODO(trchen): Insert flattening transform here, as specified by
     // http://www.w3.org/TR/css3-transforms/#transform-style-property
     updatePerspective(object, context);
     updateSvgLocalToBorderBoxTransform(object, context);
     updateScrollTranslation(object, context);
     updateOutOfFlowContext(object, context);
 }
 
 } // namespace blink