Add background attachment fixed main thread scrolling reason [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"
@@ skipping 15 matching lines @@
         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);
     }
 
     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,
@@ skipping 25 matching lines @@
     const FloatPoint3D& origin)
 {
     DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
     if (TransformPaintPropertyNode* existingScrollTranslation = frameView.scrollTranslation())
         existingScrollTranslation->update(parent, matrix, origin);
     else
         frameView.setScrollTranslation(TransformPaintPropertyNode::create(parent, matrix, origin));
 }
 
 void createOrUpdateFrameViewScroll(FrameView& frameView,
-    PassRefPtr<const ScrollPaintPropertyNode> parent,
+    PassRefPtr<ScrollPaintPropertyNode> parent,
     PassRefPtr<const TransformPaintPropertyNode> scrollOffset,
     const IntSize& clip, const IntSize& bounds,
     bool userScrollableHorizontal,
     bool userScrollableVertical)
 {
     DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
     if (ScrollPaintPropertyNode* existingScroll = frameView.scroll())
         existingScroll->update(parent, scrollOffset, clip, bounds, userScrollableHorizontal, userScrollableVertical);
     else
         frameView.setScroll(ScrollPaintPropertyNode::create(parent, scrollOffset, clip, bounds, userScrollableHorizontal, userScrollableVertical));
@@ skipping 42 matching lines @@
         bool userScrollableHorizontal = frameView.userInputScrollable(HorizontalScrollbar);
         bool userScrollableVertical = frameView.userInputScrollable(VerticalScrollbar);
         createOrUpdateFrameViewScroll(frameView, context.current.scroll, frameView.scrollTranslation(), scrollClip, scrollBounds, userScrollableHorizontal, userScrollableVertical);
     } else {
         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;
+    ScrollPaintPropertyNode* initialScroll = context.current.scroll;
     context.current.transform = frameView.scrollTranslation();
     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();
@@ skipping 168 matching lines @@
                     context.current.transform, paintOffset, FloatPoint3D());
                 return;
             }
         }
     }
 
     if (ObjectPaintProperties* properties = object.getMutableForPainting().objectPaintProperties())
         properties->clearScrollbarPaintOffset();
 }
 
+void PaintPropertyTreeBuilder::updateMainThreadScrollingReasons(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+{
+    if (object.isBackgroundAttachmentFixedObject()) {
+        auto* scrollNode = context.current.scroll;
+        while (scrollNode && !scrollNode->hasBackgroundAttachmentFixedMainThreadScrollingReason()) {
+            scrollNode->setBackgroundAttachmentFixedMainThreadScrollingReason();
+            scrollNode = scrollNode->parent();
+        }
+    }
+}
+
 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.
@@ skipping 81 matching lines @@
         bool forceScrollingForLayoutView = object.isLayoutView() && RuntimeEnabledFeatures::rootLayerScrollingEnabled();
         if (forceScrollingForLayoutView || !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;
+            ScrollPaintPropertyNode* parentScrollNode = forceScrollingForLayoutView ? nullptr : context.current.scroll;
             context.current.scroll = object.getMutableForPainting().ensureObjectPaintProperties().createOrUpdateScroll(
                 parentScrollNode, context.current.transform, scrollClip, scrollBounds, userScrollableHorizontal, userScrollableVertical);
 
             context.current.shouldFlattenInheritedTransform = false;
             return;
         }
     }
 
     if (ObjectPaintProperties* properties = object.getMutableForPainting().objectPaintProperties()) {
         properties->clearScrollTranslation();
@@ skipping 95 matching lines @@
         return;
 
     deriveBorderBoxFromContainerContext(object, context);
 
     updatePaintOffsetTranslation(object, context);
     updateTransform(object, context);
     updateEffect(object, context);
     updateCssClip(object, context);
     updateLocalBorderBoxContext(object, context);
     updateScrollbarPaintOffset(object, context);
+    updateMainThreadScrollingReasons(object, context);
 }
 
 void PaintPropertyTreeBuilder::buildTreeNodesForChildren(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.isBoxModelObject() && !object.isSVG())
         return;
 
     updateOverflowClip(object, context);
     updatePerspective(object, context);
     updateSvgLocalToBorderBoxTransform(object, context);
     updateScrollAndScrollTranslation(object, context);
     updateOutOfFlowContext(object, context);
 }
 
 } // namespace blink