Adapt and reland old position sticky implementation

third_party/WebKit/Source/core/layout/compositing/CompositingInputsUpdater.cpp

 // Copyright 2014 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/layout/compositing/CompositingInputsUpdater.h"
 
+#include "core/frame/FrameView.h"
 #include "core/layout/LayoutBlock.h"
+#include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/TraceEvent.h"
 
 namespace blink {
 
 CompositingInputsUpdater::CompositingInputsUpdater(PaintLayer* rootLayer)
     : m_geometryMap(UseTransforms)
     , m_rootLayer(rootLayer)
 {
 }
 
 CompositingInputsUpdater::~CompositingInputsUpdater()
 {
 }
 
 void CompositingInputsUpdater::update()
 {
     TRACE_EVENT0("blink", "CompositingInputsUpdater::update");
-    updateRecursive(m_rootLayer, DoNotForceUpdate, AncestorInfo());
+    updateRecursive(m_rootLayer, DoNotForceUpdate, AncestorInfo(m_rootLayer));
 }
 
 static const PaintLayer* findParentLayerOnClippingContainerChain(const PaintLayer* layer)
 {
     LayoutObject* current = layer->layoutObject();
     while (current) {
         if (current->style()->position() == FixedPosition) {
             for (current = current->parent(); current && !current->canContainFixedPositionObjects(); current = current->parent()) {
                 // All types of clips apply to fixed-position descendants of other fixed-position elements.
                 // Note: it's unclear whether this is what the spec says. Firefox does not clip, but Chrome does.
@@ skipping 90 matching lines @@
             rareProperties.filterAncestor = parent->hasFilter() ? parent : parent->filterAncestor();
             bool layerIsFixedPosition = layer->layoutObject()->style()->position() == FixedPosition;
             rareProperties.nearestFixedPositionLayer = layerIsFixedPosition ? layer : parent->nearestFixedPositionLayer();
 
             if (info.hasAncestorWithClipRelatedProperty) {
                 const PaintLayer* parentLayerOnClippingContainerChain = findParentLayerOnClippingContainerChain(layer);
                 const bool parentHasClipRelatedProperty = parentLayerOnClippingContainerChain->layoutObject()->hasClipRelatedProperty();
                 properties.clippingContainer = parentHasClipRelatedProperty ? parentLayerOnClippingContainerChain->layoutObject() : parentLayerOnClippingContainerChain->clippingContainer();
             }
 
+            const LayoutObject* containingBlock = layer->layoutObject()->containingBlock();
+            const PaintLayer* parentLayerOnContainingBlockChain = findParentLayerOnContainingBlockChain(containingBlock);
+
+            rareProperties.ancestorOverflowLayer = parentLayerOnContainingBlockChain->ancestorOverflowLayer();
+            if (parentLayerOnContainingBlockChain->layoutObject()->hasOverflowClip())
+                rareProperties.ancestorOverflowLayer = parentLayerOnContainingBlockChain;
+
             if (info.lastScrollingAncestor) {
-                const LayoutObject* containingBlock = layer->layoutObject()->containingBlock();
-                const PaintLayer* parentLayerOnContainingBlockChain = findParentLayerOnContainingBlockChain(containingBlock);
 
                 rareProperties.ancestorScrollingLayer = parentLayerOnContainingBlockChain->ancestorScrollingLayer();
                 if (parentLayerOnContainingBlockChain->scrollsOverflow())
                     rareProperties.ancestorScrollingLayer = parentLayerOnContainingBlockChain;
 
                 if (layer->layoutObject()->isOutOfFlowPositioned() && !layer->subtreeIsInvisible()) {
                     const PaintLayer* clippingLayer = properties.clippingContainer ? properties.clippingContainer->enclosingLayer() : layer->compositor()->rootLayer();
                     if (hasClippedStackingAncestor(layer, clippingLayer))
                         rareProperties.clipParent = clippingLayer;
                 }
 
                 if (layer->stackingNode()->isTreatedAsOrStackingContext()
                     && rareProperties.ancestorScrollingLayer
                     && !info.ancestorStackingContext->layoutObject()->isDescendantOf(rareProperties.ancestorScrollingLayer->layoutObject()))
                     rareProperties.scrollParent = rareProperties.ancestorScrollingLayer;
             }
+        } else {
+            rareProperties.ancestorOverflowLayer = info.lastOverflowLayer;
         }
 
+        // TODO: Clear sticky constraints from old scroll ancestor when scroll ancestor changes.
         layer->updateAncestorDependentCompositingInputs(properties, rareProperties, info.hasAncestorWithClipPath);
+        if (layer->layoutObject()->style()->position() == StickyPosition) {
+            if (info.lastOverflowLayer->isRootLayer())
+                layer->layoutObject()->view()->frameView()->addViewportConstrainedObject(layer->layoutObject());
+            else
+                layer->layoutObject()->view()->frameView()->removeViewportConstrainedObject(layer->layoutObject());
+            layer->layoutObject()->ensureStickyPositionConstraints(layer->layoutObject()->computeStickyConstrainingRect().size());
+        }
     }
 
     if (layer->stackingNode()->isStackingContext())
         info.ancestorStackingContext = layer;
 
+    if (layer->layoutObject()->hasOverflowClip())
+        info.lastOverflowLayer = layer;
+
     if (layer->scrollsOverflow())
         info.lastScrollingAncestor = layer;
 
     if (layer->layoutObject()->hasClipRelatedProperty())
         info.hasAncestorWithClipRelatedProperty = true;
 
     if (layer->layoutObject()->hasClipPath())
         info.hasAncestorWithClipPath = true;
 
     bool hasDescendantWithClipPath = false;
@@ skipping 18 matching lines @@
     ASSERT(!layer->childNeedsCompositingInputsUpdate());
     ASSERT(!layer->needsCompositingInputsUpdate());
 
     for (PaintLayer* child = layer->firstChild(); child; child = child->nextSibling())
         assertNeedsCompositingInputsUpdateBitsCleared(child);
 }
 
 #endif
 
 } // namespace blink