Rewrite how paint properties are built with bg:fixed main thread scrolling

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/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 67 matching lines @@
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingScrollTranslation = frameView.scrollTranslation()) {
     existingScrollTranslation->update(std::move(parent), matrix, origin);
     return false;
   }
   frameView.setScrollTranslation(
       TransformPaintPropertyNode::create(std::move(parent), matrix, origin));
   return true;
 }
 
-// True if a new property was created, false if an existing one was updated.
+// True if a new property was created or a main thread scrolling reason changed
+// (which can affect descendants), false if an existing one was updated.
 bool updateScroll(FrameView& frameView,
                   PassRefPtr<const ScrollPaintPropertyNode> parent,
                   PassRefPtr<const TransformPaintPropertyNode> scrollOffset,
                   const IntSize& clip,
                   const IntSize& bounds,
                   bool userScrollableHorizontal,
                   bool userScrollableVertical,
                   MainThreadScrollingReasons mainThreadScrollingReasons) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingScroll = frameView.scroll()) {
+    auto existingReasons = existingScroll->mainThreadScrollingReasons();
     existingScroll->update(std::move(parent), std::move(scrollOffset), clip,
                            bounds, userScrollableHorizontal,
                            userScrollableVertical, mainThreadScrollingReasons);
-    return false;
+    return existingReasons != mainThreadScrollingReasons;
   }
   frameView.setScroll(ScrollPaintPropertyNode::create(
       std::move(parent), std::move(scrollOffset), clip, bounds,
       userScrollableHorizontal, userScrollableVertical,
       mainThreadScrollingReasons));
   return true;
 }
 
+MainThreadScrollingReasons mainThreadScrollingReasons(
+    const FrameView& frameView,
+    MainThreadScrollingReasons ancestorReasons) {
+  auto reasons = ancestorReasons;
+  if (!frameView.frame().settings()->getThreadedScrollingEnabled())
+    reasons |= MainThreadScrollingReason::kThreadedScrollingDisabled;
+  if (frameView.hasBackgroundAttachmentFixedObjects())
+    reasons |= MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
+  return reasons;
+}
+
 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-
     // specific property updates here.
     context.current.paintOffset.moveBy(frameView.location());
     context.current.renderingContextId = 0;
@@ skipping 28 matching lines @@
       context.forceSubtreeUpdate |= updateScrollTranslation(
           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()->getThreadedScrollingEnabled())
-        reasons |= MainThreadScrollingReason::kThreadedScrollingDisabled;
-      if (frameView.hasBackgroundAttachmentFixedObjects()) {
-        reasons |=
-            MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
-      }
+      auto ancestorReasons =
+          context.current.scroll->mainThreadScrollingReasons();
+      auto reasons = mainThreadScrollingReasons(frameView, ancestorReasons);
+
       context.forceSubtreeUpdate |= updateScroll(
           frameView, context.current.scroll, frameView.scrollTranslation(),
           scrollClip, scrollBounds, userScrollableHorizontal,
           userScrollableVertical, reasons);
     } else {
       if (frameView.scrollTranslation() || frameView.scroll()) {
         // Ensure pre-existing properties are cleared if there is no scrolling.
         frameView.setScrollTranslation(nullptr);
         frameView.setScroll(nullptr);
 
@@ skipping 551 matching lines @@
   if (properties && properties->svgLocalToBorderBoxTransform()) {
     context.current.transform = properties->svgLocalToBorderBoxTransform();
     context.current.shouldFlattenInheritedTransform = false;
     context.current.renderingContextId = 0;
   }
   // The paint offset is included in |transformToBorderBox| so SVG does not need
   // to handle paint offset internally.
   context.current.paintOffset = LayoutPoint();
 }
 
-MainThreadScrollingReasons mainScrollingReasons(const LayoutObject& object) {
-  MainThreadScrollingReasons reasons = 0;
-  if (!object.document().settings()->getThreadedScrollingEnabled())
-    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 none in the common case.
-  const FrameView& frameView = *object.frameView();
-  if (frameView.hasBackgroundAttachmentFixedDescendants(object))
-    reasons |= MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
-  return reasons;
+MainThreadScrollingReasons mainThreadScrollingReasons(
+    const LayoutObject& object,
+    MainThreadScrollingReasons ancestorReasons) {
+  // The current main thread scrolling reasons implementation only changes
+  // reasons at frame boundaries, so we can early-out when not at a LayoutView.
+  // TODO(pdr): Need to find a solution to the style-related main thread
+  // scrolling reasons such as opacity and transform which violate this.
+  if (!object.isLayoutView())
+    return ancestorReasons;
+  return mainThreadScrollingReasons(*object.frameView(), ancestorReasons);
 }
 
 void PaintPropertyTreeBuilder::updateScrollAndScrollTranslation(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     bool needsScrollProperties = false;
     if (object.hasOverflowClip()) {
-      auto mainThreadScrollingReasons = mainScrollingReasons(object);
+      auto ancestorReasons =
+          context.current.scroll->mainThreadScrollingReasons();
+      auto reasons = mainThreadScrollingReasons(object, ancestorReasons);
+      bool scrollNodeNeededForMainThreadReasons = ancestorReasons != reasons;
+
       const LayoutBox& box = toLayoutBox(object);
       const auto* scrollableArea = box.getScrollableArea();
       IntSize scrollOffset = box.scrolledContentOffset();
-      if (mainThreadScrollingReasons || !scrollOffset.isZero() ||
+      if (scrollNodeNeededForMainThreadReasons || !scrollOffset.isZero() ||
           scrollableArea->scrollsOverflow()) {
         needsScrollProperties = true;
         auto& properties =
             object.getMutableForPainting().ensurePaintProperties();
         TransformationMatrix matrix = TransformationMatrix().translate(
             -scrollOffset.width(), -scrollOffset.height());
         context.forceSubtreeUpdate |= properties.updateScrollTranslation(
             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);
+
+        // Main thread scrolling reasons depend on their ancestor's reasons
+        // so ensure the entire subtree is updated when reasons change.
+        if (auto* existingScrollNode = properties.scroll()) {
+          if (existingScrollNode->mainThreadScrollingReasons() != reasons)
+            context.forceSubtreeUpdate = true;
+        }
+
         context.forceSubtreeUpdate |= properties.updateScroll(
             context.current.scroll, properties.scrollTranslation(), scrollClip,
             scrollBounds, userScrollableHorizontal, userScrollableVertical,
-            mainThreadScrollingReasons);
+            reasons);
       }
     }
 
     if (!needsScrollProperties) {
       // Ensure pre-existing properties are cleared.
       if (auto* properties = object.getMutableForPainting().paintProperties()) {
         context.forceSubtreeUpdate |= properties->clearScrollTranslation();
         context.forceSubtreeUpdate |= properties->clearScroll();
       }
     }
@@ skipping 172 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink