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 26 matching lines @@
     const FloatPoint3D& origin) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingScrollTranslation = frameView.scrollTranslation()) {
     existingScrollTranslation->update(std::move(parent), matrix, origin);
   } else {
     frameView.setScrollTranslation(
         TransformPaintPropertyNode::create(std::move(parent), matrix, origin));
   }
 }
 
 void updateFrameViewScroll(

[Xianzhu, 2016/11/17 19:03:04]

Nit not necessarily to be addressed in this CL: we should put these global
functions into anonymous namespace or prefix them with 'static'. BTW, can we
also remove the declarations of private functions in PaintPropertyTreeBuilder.h
and make them also file-visibility functions?

[pdr., 2016/11/17 21:01:36]

Good ideas all around. I'll do this in a followup CL.

[pdr., 2016/11/17 22:30:03]

I started this in parallel and found out why we didn't do this: We use c++
friendship to allow PaintPropertyTreeBuilder to access MutableForPainting in
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/layout/La....
I think these have to be setup the way they are for that to work.

     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,
+    bool threadedScrollingDisabled,
+    bool hasBackgroundAttachmentFixedDescendants) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingScroll = frameView.scroll()) {
     existingScroll->update(std::move(parent), std::move(scrollOffset), clip,
                            bounds, userScrollableHorizontal,
-                           userScrollableVertical);
+                           userScrollableVertical, threadedScrollingDisabled,
+                           hasBackgroundAttachmentFixedDescendants);
   } else {
     frameView.setScroll(ScrollPaintPropertyNode::create(
         std::move(parent), std::move(scrollOffset), clip, bounds,
-        userScrollableHorizontal, userScrollableVertical));
+        userScrollableHorizontal, userScrollableVertical,
+        threadedScrollingDisabled, hasBackgroundAttachmentFixedDescendants));
   }
 }
 
 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);
+      bool threadedScrollingDisabled =
+          !frameView.frame().settings()->threadedScrollingEnabled();
+      bool hasBackgroundAttachmentFixedDescendants =
+          frameView.hasBackgroundAttachmentFixedObjects();

[Xianzhu, 2016/11/17 19:03:04]

Can the above code be moved into updateFrameViewScroll() to reduce the number of
parameters? It seems that we can just pass two parameters (frameView, context).

[pdr., 2016/11/17 21:01:36]

I'd prefer if we leave them here because this code matches the pattern used in
updateScrollAndScrollTranslation. Do you think that's okay?

Fortunately, most of the FrameView property code will go away when
RootLayerScrolls launches.

[Xianzhu, 2016/11/17 21:25:02]

Sounds good.

       updateFrameViewScroll(frameView, context.current.scroll,
                             frameView.scrollTranslation(), scrollClip,
                             scrollBounds, userScrollableHorizontal,
-                            userScrollableVertical);
+                            userScrollableVertical, threadedScrollingDisabled,
+                            hasBackgroundAttachmentFixedDescendants);
     } 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 309 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);
+        bool threadedScrollingDisabled =
+            !object.document().settings()->threadedScrollingEnabled();
+        // 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.
+        bool hasBackgroundAttachmentFixedDescendants =
+            object.frameView()->hasBackgroundAttachmentFixedDescendants(object);
         object.getMutableForPainting().ensurePaintProperties().updateScroll(
             context.current.scroll,
             object.paintProperties()->scrollTranslation(), scrollClip,
-            scrollBounds, userScrollableHorizontal, userScrollableVertical);
+            scrollBounds, userScrollableHorizontal, userScrollableVertical,
+            threadedScrollingDisabled, hasBackgroundAttachmentFixedDescendants);
       } 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 88 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