Switch to null 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());
-    }
-
-    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();
-}
-
 void createOrUpdateFrameViewPreTranslation(FrameView& frameView,
     PassRefPtr<const TransformPaintPropertyNode> parent,
     const TransformationMatrix& matrix,
     const FloatPoint3D& origin)
 {
     DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
     if (TransformPaintPropertyNode* existingPreTranslation = frameView.preTranslation())
         existingPreTranslation->update(parent, matrix, origin);
     else
         frameView.setPreTranslation(TransformPaintPropertyNode::create(parent, matrix, origin));
@@ skipping 43 matching lines @@
         LayoutView* layoutView = frameView.layoutView();
         if (!layoutView)
             return;
 
         TransformationMatrix frameTranslate;
         frameTranslate.translate(
             frameView.x() + layoutView->location().x() + context.current.paintOffset.x(),
             frameView.y() + layoutView->location().y() + context.current.paintOffset.y());
         context.current.transform = layoutView->getMutableForPainting().ensureObjectPaintProperties().createOrUpdatePaintOffsetTranslation(
             context.current.transform, frameTranslate, FloatPoint3D());
-        context.current.scroll = layoutView->getMutableForPainting().ensureObjectPaintProperties().createOrUpdateScroll(
-            context.current.scroll, context.current.transform, IntSize(), IntSize(), false, false);
         context.current.paintOffset = LayoutPoint();
         context.current.renderingContextID = 0;
         context.current.shouldFlattenInheritedTransform = true;
         context.absolutePosition = context.current;
         context.containerForAbsolutePosition = nullptr; // This will get set in updateOutOfFlowContext().
         context.fixedPosition = context.current;
         return;
     }
 
     TransformationMatrix frameTranslate;
     frameTranslate.translate(frameView.x() + context.current.paintOffset.x(), frameView.y() + context.current.paintOffset.y());
     createOrUpdateFrameViewPreTranslation(frameView, context.current.transform, frameTranslate, FloatPoint3D());
 
     FloatRoundedRect contentClip(IntRect(IntPoint(), frameView.visibleContentSize()));
     createOrUpdateFrameViewContentClip(frameView, context.current.clip, frameView.preTranslation(), contentClip);
 
     DoubleSize scrollOffset = frameView.scrollOffsetDouble();
-    TransformationMatrix frameScroll;
-    frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
-    // TODO(pdr): A scroll translation should not be needed when frameView.isScrollable() is false.
-    createOrUpdateFrameViewScrollTranslation(frameView, frameView.preTranslation(), frameScroll, FloatPoint3D());
+    if (frameView.isScrollable() || !scrollOffset.isZero()) {
+        TransformationMatrix frameScroll;
+        frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
+        createOrUpdateFrameViewScrollTranslation(frameView, frameView.preTranslation(), frameScroll, FloatPoint3D());
 
-    if (frameView.isScrollable()) {
         IntSize scrollClip = frameView.visibleContentSize();
         IntSize scrollBounds = frameView.contentsSize();
         bool userScrollableHorizontal = frameView.userInputScrollable(HorizontalScrollbar);
         bool userScrollableVertical = frameView.userInputScrollable(VerticalScrollbar);
         createOrUpdateFrameViewScroll(frameView, context.current.scroll, frameView.scrollTranslation(), scrollClip, scrollBounds, userScrollableHorizontal, userScrollableVertical);
     } else {
+        frameView.setScrollTranslation(nullptr);
         frameView.setScroll(nullptr);
     }
 
     // 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 ScrollPaintPropertyNode* initialScroll = context.current.scroll;
-    context.current.transform = frameView.scrollTranslation();
+    context.current.transform = frameView.scrollTranslation() ? frameView.scrollTranslation() : frameView.preTranslation();
     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;
@@ skipping 88 matching lines @@
             return;
         }
     }
 
     if (ObjectPaintProperties* properties = object.getMutableForPainting().objectPaintProperties())
         properties->clearTransform();
 }
 
 void PaintPropertyTreeBuilder::updateEffect(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    if (object.isLayoutView() && !context.currentEffect) {
-        const LayoutView& layoutView = toLayoutView(object);
-        DCHECK(RuntimeEnabledFeatures::rootLayerScrollingEnabled());
-        DCHECK(layoutView.frameView()->frame().isMainFrame());
-        context.currentEffect = layoutView.getMutableForPainting().ensureObjectPaintProperties().createOrUpdateEffect(nullptr, 1.0);
-        return;
-    }
-
     if (!object.styleRef().hasOpacity()) {
         if (ObjectPaintProperties* properties = object.getMutableForPainting().objectPaintProperties())
             properties->clearEffect();
         return;
     }
 
     context.currentEffect = object.getMutableForPainting().ensureObjectPaintProperties().createOrUpdateEffect(
         context.currentEffect, object.styleRef().opacity());
 }
 
@@ skipping 20 matching lines @@
     // 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->geometryPropertyTreeState = GeometryPropertyTreeState(context.current.transform, context.current.clip, context.currentEffect);
     borderBoxContext->scroll = context.current.scroll;
 
-    if (!context.current.clip) {
-        DCHECK(object.isLayoutView());
-        DCHECK(toLayoutView(object).frameView()->frame().isMainFrame());
-        DCHECK(RuntimeEnabledFeatures::rootLayerScrollingEnabled());
-        borderBoxContext->geometryPropertyTreeState.clip = ClipPaintPropertyNode::create(nullptr, context.current.transform, FloatRoundedRect(LayoutRect::infiniteIntRect()));
-        context.current.clip = borderBoxContext->geometryPropertyTreeState.clip.get();
-    }
-
     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() && object.isBoxModelObject()) {
         if (PaintLayerScrollableArea* scrollableArea = toLayoutBoxModelObject(object).getScrollableArea()) {
@@ skipping 94 matching lines @@
     context.current.shouldFlattenInheritedTransform = false;
     context.current.renderingContextID = 0;
 }
 
 void PaintPropertyTreeBuilder::updateScrollAndScrollTranslation(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.isBoxModelObject() && object.hasOverflowClip()) {
         PaintLayer* layer = toLayoutBoxModelObject(object).layer();
         DCHECK(layer);
         DoubleSize scrollOffset = layer->getScrollableArea()->scrollOffset();
-        bool forceScrollingForLayoutView = object.isLayoutView() && RuntimeEnabledFeatures::rootLayerScrollingEnabled();
-        if (forceScrollingForLayoutView || !scrollOffset.isZero() || layer->scrollsOverflow()) {
+        if (!scrollOffset.isZero() || layer->scrollsOverflow()) {
             TransformationMatrix matrix = TransformationMatrix().translate(-scrollOffset.width(), -scrollOffset.height());
             context.current.transform = object.getMutableForPainting().ensureObjectPaintProperties().createOrUpdateScrollTranslation(
                 context.current.transform, matrix, FloatPoint3D(), context.current.shouldFlattenInheritedTransform, context.current.renderingContextID);
 
             IntSize scrollClip = layer->getScrollableArea()->visibleContentRect().size();
             IntSize scrollBounds = layer->getScrollableArea()->contentsSize();
             bool userScrollableHorizontal = layer->getScrollableArea()->userInputScrollable(HorizontalScrollbar);
             bool userScrollableVertical = layer->getScrollableArea()->userInputScrollable(VerticalScrollbar);
-            const ScrollPaintPropertyNode* parentScrollNode = forceScrollingForLayoutView ? nullptr : context.current.scroll;
             context.current.scroll = object.getMutableForPainting().ensureObjectPaintProperties().createOrUpdateScroll(
-                parentScrollNode, context.current.transform, scrollClip, scrollBounds, userScrollableHorizontal, userScrollableVertical);
+                context.current.scroll, context.current.transform, scrollClip, scrollBounds, userScrollableHorizontal, userScrollableVertical);
 
             context.current.shouldFlattenInheritedTransform = false;
             return;
         }
     }
 
     if (ObjectPaintProperties* properties = object.getMutableForPainting().objectPaintProperties()) {
         properties->clearScrollTranslation();
         properties->clearScroll();
     }
 }
 
 void PaintPropertyTreeBuilder::updateOutOfFlowContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.canContainAbsolutePositionObjects()) {
         context.absolutePosition = context.current;
         context.containerForAbsolutePosition = &object;
     }
 
     if (object.isLayoutView()) {
         if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
             context.fixedPosition = context.current;
             const TransformPaintPropertyNode* transform = object.objectPaintProperties()->paintOffsetTranslation();
             DCHECK(transform);
             context.fixedPosition.transform = transform;
+            context.fixedPosition.scroll = nullptr;
         }
     } else if (object.canContainFixedPositionObjects()) {
         context.fixedPosition = context.current;
     } else if (object.getMutableForPainting().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.getMutableForPainting().objectPaintProperties()->cssClip();
@@ skipping 83 matching lines @@
         return;
 
     updateOverflowClip(object, context);
     updatePerspective(object, context);
     updateSvgLocalToBorderBoxTransform(object, context);
     updateScrollAndScrollTranslation(object, context);
     updateOutOfFlowContext(object, context);
 }
 
 } // namespace blink