Create scroll properties for main thread scrolling even w/o 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/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 622 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()->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 none in the common case.
+  const FrameView& frameView = *object.frameView();
+  if (frameView.hasBackgroundAttachmentFixedDescendants(object))
+    reasons |= MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
+  return reasons;
+}
+
 void PaintPropertyTreeBuilder::updateScrollAndScrollTranslation(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
+    bool needsScrollProperties = false;
     if (object.hasOverflowClip()) {
+      auto mainThreadScrollingReasons = mainScrollingReasons(object);
       const LayoutBox& box = toLayoutBox(object);
-      const PaintLayerScrollableArea* scrollableArea = box.getScrollableArea();
+      const auto* scrollableArea = box.getScrollableArea();
       IntSize scrollOffset = box.scrolledContentOffset();
-      if (!scrollOffset.isZero() || scrollableArea->scrollsOverflow()) {
+      if (mainThreadScrollingReasons || !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);
-        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;
-        }
         context.forceSubtreeUpdate |= properties.updateScroll(
             context.current.scroll, properties.scrollTranslation(), scrollClip,
             scrollBounds, userScrollableHorizontal, userScrollableVertical,
-            reasons);
-      } else {
-        // Ensure pre-existing properties are cleared when there is no
-        // scrolling.
-        auto* properties = object.getMutableForPainting().paintProperties();
-        if (properties) {
-          context.forceSubtreeUpdate |= properties->clearScrollTranslation();
-          context.forceSubtreeUpdate |= properties->clearScroll();
-        }
+            mainThreadScrollingReasons);
+      }
+    }
+
+    if (!needsScrollProperties) {
+      // Ensure pre-existing properties are cleared.
+      if (auto* properties = object.getMutableForPainting().paintProperties()) {
+        context.forceSubtreeUpdate |= properties->clearScrollTranslation();
+        context.forceSubtreeUpdate |= properties->clearScroll();
       }
     }
   }
 
   if (object.paintProperties() && object.paintProperties()->scroll()) {
     context.current.transform = object.paintProperties()->scrollTranslation();
     context.current.scroll = object.paintProperties()->scroll();
     context.current.shouldFlattenInheritedTransform = false;
   }
 }
@@ skipping 202 matching lines @@
 #endif
 
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 }
 
 }  // namespace blink