Incrementally build main thread scrolling reasons [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/LayoutView.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/paint/FindPropertiesNeedingUpdate.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 {
 
 PaintPropertyTreeBuilderContext
 PaintPropertyTreeBuilder::setupInitialContext() {
   PaintPropertyTreeBuilderContext context;
-
   context.current.clip = context.absolutePosition.clip =
       context.fixedPosition.clip = ClipPaintPropertyNode::root();
   context.currentEffect = EffectPaintPropertyNode::root();
   context.current.transform = context.absolutePosition.transform =
       context.fixedPosition.transform = TransformPaintPropertyNode::root();
   context.current.scroll = context.absolutePosition.scroll =
       context.fixedPosition.scroll = ScrollPaintPropertyNode::root();
-
-  // Ensure scroll tree properties are reset. They will be rebuilt during the
-  // tree walk.
-  ScrollPaintPropertyNode::root()->clearMainThreadScrollingReasons();
-
   return context;
 }
 
 void updateFrameViewPreTranslation(
     FrameView& frameView,
     PassRefPtr<const TransformPaintPropertyNode> parent,
     const TransformationMatrix& matrix,
     const FloatPoint3D& origin) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingPreTranslation = frameView.preTranslation()) {
@@ skipping 28 matching lines @@
   if (auto* existingScrollTranslation = frameView.scrollTranslation()) {
     existingScrollTranslation->update(std::move(parent), matrix, origin);
   } else {
     frameView.setScrollTranslation(
         TransformPaintPropertyNode::create(std::move(parent), matrix, origin));
   }
 }
 
 void updateFrameViewScroll(
     FrameView& frameView,
-    PassRefPtr<ScrollPaintPropertyNode> parent,
+    PassRefPtr<const ScrollPaintPropertyNode> parent,
     PassRefPtr<const TransformPaintPropertyNode> scrollOffset,
     const IntSize& clip,
     const IntSize& bounds,
     bool userScrollableHorizontal,
-    bool userScrollableVertical) {
+    bool userScrollableVertical,
+    MainThreadScrollingReasons mainThreadScrollingReasons) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingScroll = frameView.scroll()) {
     existingScroll->update(std::move(parent), std::move(scrollOffset), clip,
                            bounds, userScrollableHorizontal,
-                           userScrollableVertical);
+                           userScrollableVertical, mainThreadScrollingReasons);
   } else {
     frameView.setScroll(ScrollPaintPropertyNode::create(
         std::move(parent), std::move(scrollOffset), clip, bounds,
-        userScrollableHorizontal, userScrollableVertical));
+        userScrollableHorizontal, userScrollableVertical,
+        mainThreadScrollingReasons));
   }
 }
 
 void PaintPropertyTreeBuilder::updateProperties(
     FrameView& frameView,
     PaintPropertyTreeBuilderContext& context) {
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // With root layer scrolling, the LayoutView (a LayoutObject) properties are
     // updated like other objects (see updatePropertiesAndContextForSelf and
     // updatePropertiesAndContextForChildren) instead of needing LayoutView-
@@ skipping 29 matching lines @@
       frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
       updateFrameViewScrollTranslation(frameView, frameView.preTranslation(),
                                        frameScroll, FloatPoint3D());
 
       IntSize scrollClip = frameView.visibleContentSize();
       IntSize scrollBounds = frameView.contentsSize();
       bool userScrollableHorizontal =
           frameView.userInputScrollable(HorizontalScrollbar);
       bool userScrollableVertical =
           frameView.userInputScrollable(VerticalScrollbar);
+
+      MainThreadScrollingReasons reasons = 0;
+      if (!frameView.frame().settings()->threadedScrollingEnabled())
+        reasons |= MainThreadScrollingReason::kThreadedScrollingDisabled;
+      if (frameView.hasBackgroundAttachmentFixedObjects()) {
+        reasons |=
+            MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
+      }
       updateFrameViewScroll(frameView, context.current.scroll,
                             frameView.scrollTranslation(), scrollClip,
                             scrollBounds, userScrollableHorizontal,
-                            userScrollableVertical);
+                            userScrollableVertical, reasons);
     } else {
       // Ensure pre-existing properties are cleared when there is no scrolling.
       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 auto* fixedTransformNode = frameView.preTranslation()
                                        ? frameView.preTranslation()
                                        : context.current.transform;
   auto* fixedScrollNode = context.current.scroll;
   DCHECK(frameView.preTranslation());
   context.current.transform = frameView.preTranslation();
   DCHECK(frameView.contentClip());
   context.current.clip = frameView.contentClip();
   if (const auto* scrollTranslation = frameView.scrollTranslation())
     context.current.transform = scrollTranslation;
-  if (auto* scroll = frameView.scroll())
+  if (const auto* scroll = frameView.scroll())
     context.current.scroll = scroll;
   context.current.paintOffset = LayoutPoint();
   context.current.renderingContextID = 0;
   context.current.shouldFlattenInheritedTransform = true;
   context.absolutePosition = context.current;
   context.containerForAbsolutePosition = nullptr;
   context.fixedPosition = context.current;
   context.fixedPosition.transform = fixedTransformNode;
   context.fixedPosition.scroll = fixedScrollNode;
 
@@ skipping 304 matching lines @@
         needsScrollbarPaintOffset = true;
       }
     }
   }
 
   auto* properties = object.getMutableForPainting().paintProperties();
   if (!needsScrollbarPaintOffset && properties)
     properties->clearScrollbarPaintOffset();
 }
 
-void PaintPropertyTreeBuilder::updateMainThreadScrollingReasons(
-    const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
-  // TODO(pdr): Mark properties as needing an update for main thread scroll
-  // reasons and ensure reason changes are propagated to ancestors to account
-  // for the parent walk below. https://crbug.com/664672.
-
-  if (context.current.scroll &&
-      !object.document().settings()->threadedScrollingEnabled()) {
-    context.current.scroll->addMainThreadScrollingReasons(
-        MainThreadScrollingReason::kThreadedScrollingDisabled);
-  }
-
-  if (object.isBackgroundAttachmentFixedObject()) {
-    auto* scrollNode = context.current.scroll;
-    while (
-        scrollNode &&
-        !scrollNode->hasMainThreadScrollingReasons(
-            MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects)) {
-      scrollNode->addMainThreadScrollingReasons(
-          MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
-      scrollNode = scrollNode->parent();
-    }
-  }
-}
-
 void PaintPropertyTreeBuilder::updateOverflowClip(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isBox())
     return;
 
   if (object.needsPaintPropertyUpdate()) {
     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
@@ skipping 127 matching lines @@
                 context.current.transform, matrix, FloatPoint3D(),
                 context.current.shouldFlattenInheritedTransform,
                 context.current.renderingContextID);
 
         IntSize scrollClip = scrollableArea->visibleContentRect().size();
         IntSize scrollBounds = scrollableArea->contentsSize();
         bool userScrollableHorizontal =
             scrollableArea->userInputScrollable(HorizontalScrollbar);
         bool userScrollableVertical =
             scrollableArea->userInputScrollable(VerticalScrollbar);
+        MainThreadScrollingReasons reasons = 0;
+        if (!object.document().settings()->threadedScrollingEnabled())
+          reasons |= MainThreadScrollingReason::kThreadedScrollingDisabled;
+        // Checking for descendants in the layout tree has two downsides:
+        // 1) There can be more descendants in layout order than in paint
+        //    order (e.g., fixed position objects).
+        // 2) Iterating overall all background attachment fixed objects for
+        //    every scroll node can be slow, though there will be no objects
+        //    in the common case.
+        const FrameView& frameView = *object.frameView();
+        if (frameView.hasBackgroundAttachmentFixedDescendants(object)) {
+          reasons |=
+              MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
+        }
         object.getMutableForPainting().ensurePaintProperties().updateScroll(
             context.current.scroll,
             object.paintProperties()->scrollTranslation(), scrollClip,
-            scrollBounds, userScrollableHorizontal, userScrollableVertical);
+            scrollBounds, userScrollableHorizontal, userScrollableVertical,
+            reasons);
       } else {
         // Ensure pre-existing properties are cleared when there is no
         // scrolling.
         auto* properties = object.getMutableForPainting().paintProperties();
         if (properties) {
           properties->clearScrollTranslation();
           properties->clearScroll();
         }
       }
     }
   }
 
   if (object.paintProperties() && object.paintProperties()->scroll()) {
     context.current.transform = object.paintProperties()->scrollTranslation();
-    const auto* scroll = object.paintProperties()->scroll();
-    // TODO(pdr): Remove this const cast.
-    context.current.scroll = const_cast<ScrollPaintPropertyNode*>(scroll);
+    context.current.scroll = object.paintProperties()->scroll();
     context.current.shouldFlattenInheritedTransform = false;
   }
 }
 
 void PaintPropertyTreeBuilder::updateOutOfFlowContext(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.canContainAbsolutePositionObjects()) {
     context.absolutePosition = context.current;
     context.containerForAbsolutePosition = &object;
   }
 
   if (object.isLayoutView()) {
     if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       const auto* initialFixedTransform = context.fixedPosition.transform;
-      auto* initialFixedScroll = context.fixedPosition.scroll;
+      const auto* initialFixedScroll = context.fixedPosition.scroll;
 
       context.fixedPosition = context.current;
 
       // Fixed position transform and scroll nodes should not be affected.
       context.fixedPosition.transform = initialFixedTransform;
       context.fixedPosition.scroll = initialFixedScroll;
     }
   } else if (object.canContainFixedPositionObjects()) {
     context.fixedPosition = context.current;
   } else if (object.getMutableForPainting().paintProperties() &&
@@ skipping 55 matching lines @@
       containingBlock.paintProperties()->localBorderBoxProperties();
   DCHECK(properties);
 
   context.transform = properties->propertyTreeState.transform();
   context.paintOffset = properties->paintOffset;
   context.shouldFlattenInheritedTransform =
       context.transform && context.transform->flattensInheritedTransform();
   context.renderingContextID =
       context.transform ? context.transform->renderingContextID() : 0;
   context.clip = properties->propertyTreeState.clip();
-  context.scroll = const_cast<ScrollPaintPropertyNode*>(
-      properties->propertyTreeState.scroll());
+  context.scroll = properties->propertyTreeState.scroll();
 }
 
 static void deriveBorderBoxFromContainerContext(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isBoxModelObject())
     return;
 
   const LayoutBoxModelObject& boxModelObject = toLayoutBoxModelObject(object);
 
@@ skipping 84 matching lines @@
 #endif
 
   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::updatePropertiesForChildren(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isBoxModelObject() && !object.isSVG())
     return;
 
 #if DCHECK_IS_ON()
   FindObjectPropertiesNeedingUpdateScope checkNeedsUpdateScope(object);
 #endif
 
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 }
 
 }  // namespace blink