Add static root property tree nodes [spv2]

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/LayoutView.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)
-{
-    if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
-        return;
-
-    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));
-        rootFrame.setRootScroll(ScrollPaintPropertyNode::create(nullptr, rootFrame.rootTransform(), IntSize(), IntSize(), false, false));
-    } else {
-        DCHECK(rootFrame.rootClip() && !rootFrame.rootClip()->parent());
-        DCHECK(rootFrame.rootEffect() && !rootFrame.rootEffect()->parent());
-        DCHECK(rootFrame.rootScroll() && !rootFrame.rootScroll()->parent());
-        // Ensure main thread scroll reasons are reset.
-        rootFrame.rootScroll()->update(nullptr, rootFrame.rootTransform(), IntSize(), IntSize(), false, false);
+namespace {
+    TransformPaintPropertyNode* rootTransformNode()
+    {
+        DEFINE_STATIC_REF(TransformPaintPropertyNode, rootTransform, (TransformPaintPropertyNode::create(nullptr, TransformationMatrix(), FloatPoint3D())));
+        return rootTransform;
     }
 
-    context.current.transform = context.absolutePosition.transform = context.fixedPosition.transform = rootFrame.rootTransform();
-    context.current.scroll = rootFrame.rootScroll();
-    context.current.clip = context.absolutePosition.clip = context.fixedPosition.clip = rootFrame.rootClip();
-    context.currentEffect = rootFrame.rootEffect();
+    ClipPaintPropertyNode* rootClipNode()
+    {
+        DEFINE_STATIC_REF(ClipPaintPropertyNode, rootClip, (ClipPaintPropertyNode::create(nullptr, rootTransformNode(), FloatRoundedRect(LayoutRect::infiniteIntRect()))));
+        return rootClip;
+    }
+
+    EffectPaintPropertyNode* rootEffectNode()
+    {
+        DEFINE_STATIC_REF(EffectPaintPropertyNode, rootEffect, (EffectPaintPropertyNode::create(nullptr, 1.0)));
+        return rootEffect;
+    }
+
+    ScrollPaintPropertyNode* rootScrollNode()
+    {
+        DEFINE_STATIC_REF(ScrollPaintPropertyNode, rootScroll, (ScrollPaintPropertyNode::create(nullptr, rootTransformNode(), IntSize(), IntSize(), false, false)));
+        return rootScroll;
+    }
+}
+
+PaintPropertyTreeBuilderContext PaintPropertyTreeBuilder::setupInitialContext()
+{
+    PaintPropertyTreeBuilderContext context;
+
+    // TODO(pdr): Update the root layer scrolling paths to use the static root nodes.
+    if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
+        return context;
+
+    context.current.transform = context.absolutePosition.transform = context.fixedPosition.transform = rootTransformNode();
+    context.current.scroll = context.absolutePosition.scroll = context.fixedPosition.scroll = rootScrollNode();
+    context.current.clip = context.absolutePosition.clip = context.fixedPosition.clip = rootClipNode();
+    context.currentEffect = rootEffectNode();
+
+    // Ensure scroll tree properties are reset. They will be rebuilt during the tree walk.
+    rootScrollNode()->clearMainThreadScrollingReasons();

[jbroman, 2016/09/22 14:20:52]

This one confuses me a little. If there's a global root, presumably it should be
treated as immutable? Modifying it seems bad given that it's shared by several
FrameViews.

[pdr., 2016/09/22 19:48:20]

This patch was just matching the existing behavior here, this was previously
hidden in "rootFrame.rootScroll()->update(...)" but is now explicit. The reason
this occurs is we propagate the "has background attachment fixed" main thread
scroll reason all the way to the root, even though the root isn't used for
scrolling. We could change this to make the root nodes immutable
(dcheck(!isRoot() in all prop tree node update(...) functions), but I'd like to
defer that until the RLS and non-RLS codepaths both use these root nodes.

+
+    return context;
 }
 
 void createOrUpdateFrameViewPreTranslation(FrameView& frameView,
     PassRefPtr<const TransformPaintPropertyNode> parent,
     const TransformationMatrix& matrix,
     const FloatPoint3D& origin)
 {
     DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
     if (TransformPaintPropertyNode* existingPreTranslation = frameView.preTranslation())
         existingPreTranslation->update(std::move(parent), matrix, origin);
@@ skipping 94 matching lines @@
     context.current.paintOffset = LayoutPoint();
     context.current.clip = frameView.contentClip();
     context.current.scroll = frameView.scroll() ? frameView.scroll() : initialScroll;
     context.current.renderingContextID = 0;
     context.current.shouldFlattenInheritedTransform = true;
     context.absolutePosition = context.current;
     context.containerForAbsolutePosition = nullptr;
     context.fixedPosition = context.current;
     context.fixedPosition.transform = frameView.preTranslation();
     context.fixedPosition.scroll = initialScroll;
+
+    std::unique_ptr<PropertyTreeState> contentsState(new PropertyTreeState(context.current.transform, context.current.clip, context.currentEffect, context.current.scroll));
+    frameView.setTotalPropertyTreeStateForContents(std::move(contentsState));
 }
 
 void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.isBoxModelObject() && context.current.paintOffset != LayoutPoint()) {
         // TODO(trchen): Eliminate PaintLayer dependency.
         PaintLayer* layer = toLayoutBoxModelObject(object).layer();
         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
@@ skipping 404 matching lines @@
         return;
 
     updateOverflowClip(object, context);
     updatePerspective(object, context);
     updateSvgLocalToBorderBoxTransform(object, context);
     updateScrollAndScrollTranslation(object, context);
     updateOutOfFlowContext(object, context);
 }
 
 } // namespace blink