Move sticky position constraints update to the pre-paint tree walk.

third_party/WebKit/Source/core/paint/PrePaintTreeWalk.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/PrePaintTreeWalk.h"
 
 #include "core/dom/DocumentLifecycle.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
+#include "core/paint/PaintLayer.h"
 
 namespace blink {
 
 struct PrePaintTreeWalkContext {
-  PrePaintTreeWalkContext() : paintInvalidatorContext(treeBuilderContext) {}
+  PrePaintTreeWalkContext()
+      : paintInvalidatorContext(treeBuilderContext),
+        ancestorOverflowPaintLayer(nullptr) {}
   PrePaintTreeWalkContext(const PrePaintTreeWalkContext& parentContext)
       : treeBuilderContext(parentContext.treeBuilderContext),
         paintInvalidatorContext(treeBuilderContext,
-                                parentContext.paintInvalidatorContext) {}
+                                parentContext.paintInvalidatorContext),
+        ancestorOverflowPaintLayer(parentContext.ancestorOverflowPaintLayer) {}
 
   PaintPropertyTreeBuilderContext treeBuilderContext;
   PaintInvalidatorContext paintInvalidatorContext;
+
+  // The ancestor in the PaintLayer tree which has overflow clip, or

[pdr., 2016/12/09 00:04:10]

The PrePaintTreeWalk is shared by paint invalidation, property tree building,
and compositing thingers. Unfortunately, there is a little paint property logic
spilling over (paint offset diffing) but otherwise we've kept real logic in
other classes. In the interest of keeping the prepaint tree walk as simple as
possible, WDYT of moving this into a helper file?

[chrishtr, 2016/12/09 01:22:54]

Are you suggesting making an AuxiliaryObjectPropertiesContext struct, and moving
the updateAuxiliaryObjectProperties() into that file?

+  // is the root layer. Note that it is tree ancestor, not containing
+  // block or stacking ancestor.
+  PaintLayer* ancestorOverflowPaintLayer;
 };
 
 void PrePaintTreeWalk::walk(FrameView& rootFrame) {
   DCHECK(rootFrame.frame().document()->lifecycle().state() ==
          DocumentLifecycle::InPrePaint);
 
   PrePaintTreeWalkContext initialContext;
   initialContext.treeBuilderContext =
       m_propertyTreeBuilder.setupInitialContext();
   walk(rootFrame, initialContext);
@@ skipping 20 matching lines @@
 #if DCHECK_IS_ON()
     frameView.layoutView()->assertSubtreeClearedPaintInvalidationFlags();
 #endif
     // If descendants were not fully updated, do not clear flags. During the
     // next PrePaintTreeWalk, these flags will be used again.
     frameView.clearNeedsPaintPropertyUpdate();
   }
   return descendantsFullyUpdated;
 }
 
+static void updateAuxiliaryObjectProperties(
+    const LayoutObject& object,
+    PrePaintTreeWalkContext& localContext) {
+  PaintLayer* paintLayer = nullptr;
+
+  if (object.isBoxModelObject() && object.hasLayer())
+    paintLayer = object.enclosingLayer();
+
+  if (paintLayer) {
+    paintLayer->updateAncestorOverflowLayer(
+        localContext.ancestorOverflowPaintLayer);
+  }
+
+  if (object.styleRef().position() == StickyPosition && paintLayer) {
+    paintLayer->layoutObject()->updateStickyPositionConstraints();
+
+    // Sticky position constraints and ancestor overflow scroller affect
+    // the sticky layer position, so we need to update it again here.
+    // TODO(flackr): This should be refactored in the future to be clearer
+    // (i.e. update layer position and ancestor inputs updates in the
+    // same walk)
+    paintLayer->updateLayerPosition();
+  }
+
+  if (object.hasOverflowClip() || (paintLayer && paintLayer->isRootLayer())) {
+    DCHECK(paintLayer);
+    localContext.ancestorOverflowPaintLayer = paintLayer;
+  }
+}
+
 bool PrePaintTreeWalk::walk(const LayoutObject& object,
                             const PrePaintTreeWalkContext& context) {
   PrePaintTreeWalkContext localContext(context);
 
   // TODO(pdr): Ensure multi column works with incremental property tree
   // construction.
   if (object.isLayoutMultiColumnSpannerPlaceholder()) {
     // Walk multi-column spanner as if it replaces the placeholder.
     // Set the flag so that the tree builder can specially handle out-of-flow
     // positioned descendants if their containers are between the multi-column
@@ skipping 36 matching lines @@
     return true;
   }
 
   m_propertyTreeBuilder.updatePropertiesForSelf(
       object, localContext.treeBuilderContext);
   m_paintInvalidator.invalidatePaintIfNeeded(
       object, localContext.paintInvalidatorContext);
   m_propertyTreeBuilder.updatePropertiesForChildren(
       object, localContext.treeBuilderContext);
 
+  updateAuxiliaryObjectProperties(object, localContext);
+
   bool descendantsFullyUpdated = true;
   for (const LayoutObject* child = object.slowFirstChild(); child;
        child = child->nextSibling()) {
     // Column spanners are walked through their placeholders. See above.
     if (child->isColumnSpanAll())
       continue;
     bool childFullyUpdated = walk(*child, localContext);
     if (!childFullyUpdated)
       descendantsFullyUpdated = false;
   }
@@ skipping 18 matching lines @@
     // If descendants were not updated, do not clear flags. During the next
     // PrePaintTreeWalk, these flags will be used again.
     object.getMutableForPainting().clearPaintInvalidationFlags();
     object.getMutableForPainting().clearNeedsPaintPropertyUpdate();
     object.getMutableForPainting().clearDescendantNeedsPaintPropertyUpdate();
   }
   return descendantsFullyUpdated;
 }
 
 }  // namespace blink