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 51 matching lines @@
         }
     }
     return false;
 }
 
 void CompositingInputsUpdater::updateRecursive(PaintLayer* layer, UpdateType updateType, AncestorInfo info)
 {
     if (!layer->childNeedsCompositingInputsUpdate() && updateType != ForceUpdate)
         return;
 
+    const PaintLayer* previousOverflowLayer = layer->ancestorOverflowLayer();
+    layer->updateAncestorOverflowLayer(info.lastOverflowLayer);
+    if (layer->needsCompositingInputsUpdate() && layer->layoutObject()->style()->position() == StickyPosition) {
+        if (info.lastOverflowLayer != previousOverflowLayer) {
+            // Remove sticky constraints from old ancestor scroller if there was a change.
+            if (previousOverflowLayer)
+                previousOverflowLayer->scrollableArea()->stickyConstraintsMap().remove(layer);
+
+            if (info.lastOverflowLayer->isRootLayer())
+                layer->layoutObject()->view()->frameView()->addViewportConstrainedObject(layer->layoutObject());
+            else if (previousOverflowLayer && previousOverflowLayer->isRootLayer())
+                layer->layoutObject()->view()->frameView()->removeViewportConstrainedObject(layer->layoutObject());
+        }
+        layer->layoutObject()->updateStickyPositionConstraints(info.lastOverflowLayer);
+
+        // Layer position needs to be updated before mapping clippedAbsoluteBoundingBox.

[chrishtr, 2016/03/09 16:53:08]

Why is the layer position not already up-to-date at this point?

[flackr, 2016/03/14 19:04:26]

The overflow layer may have just changed - and the sticky position is dependent
on this.

[chrishtr, 2016/03/16 21:52:39]

But layer positions should be set before the compositing step of the lifecycle,
no?

[flackr, 2016/03/22 21:44:32]

Yes, but without correct ancestor information. We can't accurately set the layer
position for sticky elements until we have the correct ancestor overflow
scroller. Perhaps we should skip sticky offsets during
updateLayerPositionRecursive?

Alternately, it seems like compositing inputs and layer position updates would
have to become part of the same walk.

+        layer->updateLayerPosition();
+    }
+
     m_geometryMap.pushMappingsToAncestor(layer, layer->parent());
 
     if (layer->hasCompositedLayerMapping())
         info.enclosingCompositedLayer = layer;
 
     if (layer->needsCompositingInputsUpdate()) {
         if (info.enclosingCompositedLayer)
             info.enclosingCompositedLayer->compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
         updateType = ForceUpdate;
     }
@@ skipping 46 matching lines @@
                     rareProperties.scrollParent = rareProperties.ancestorScrollingLayer;
             }
         }
 
         layer->updateAncestorDependentCompositingInputs(properties, rareProperties, info.hasAncestorWithClipPath);
     }
 
     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