Adapt and reland old position sticky implementation

third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp

Index: third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp
diff --git a/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp b/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp
index b9ca8b1f631afbef88431a5d1bf0b4e7d39a9e96..59b65b06a3eb2a96ffabc44e2ed7270c9191b8e0 100644
--- a/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp
@@ -38,7 +38,8 @@
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
-#include "core/page/scrolling/ScrollingConstraints.h"
+#include "core/page/scrolling/StickyPositionViewportConstraints.h"
+#include "core/page/scrolling/ViewportConstraints.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/BorderEdge.h"
 #include "core/style/ShadowList.h"
@@ -177,6 +178,31 @@ void LayoutBoxModelObject::styleWillChange(StyleDifference diff, const ComputedS
     LayoutObject::styleWillChange(diff, newStyle);
 }
 
+static inline LayoutBox* findScrollAncestor(const LayoutObject* startObject)
+{
+    // If compositing inputs should be fresh, we can get the scroll parent from
+    // the PaintLayer.
+    PaintLayer* layer = startObject->enclosingLayer();
+    if (layer && !layer->needsCompositingInputsUpdate()) {

[chrishtr, 2016/01/30 01:49:02]

The computations for position:sticky should be done after the compositing update
is done, which means you can rely on this.

[flackr, 2016/02/03 22:48:38]

Currently this is also called during styleChanged to determine if the sticky
object needs to be added to the viewportconstrained objects. I will move
updating viewport constrained objects to where we compute the sticky constraints
so that we can rely on this.

+        const PaintLayer* scrollAncestor = layer->ancestorScrollingLayer();
+        if (!scrollAncestor)
+            return nullptr;
+        return toLayoutBox(scrollAncestor->layoutObject());
+    }
+
+    LayoutBox* curBox = startObject->containingBlock();
+    // Scrolling propagates along the containing block chain.
+    // TODO(flackr): We could add scroll ancestor as an input to layout so that

[chrishtr, 2016/01/30 01:49:03]

PaintLayer's scrollParent ancestor-dependent input does this.

+    // we don't have to walk up to find the scroll ancestor.
+    while (curBox && !curBox->isLayoutView()) {
+        if (curBox->hasOverflowClip())
+            return curBox;
+        curBox = curBox->containingBlock();
+    }
+
+    return nullptr;
+}
+
 void LayoutBoxModelObject::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     bool hadTransform = hasTransformRelatedProperty();
@@ -267,14 +293,32 @@ void LayoutBoxModelObject::styleDidChange(StyleDifference diff, const ComputedSt
     }
 
     if (FrameView *frameView = view()->frameView()) {
-        bool newStyleIsViewportConstained = style()->hasViewportConstrainedPosition();
-        bool oldStyleIsViewportConstrained = oldStyle && oldStyle->hasViewportConstrainedPosition();
+        bool newStyleIsViewportConstained = style()->position() == FixedPosition;
+        bool oldStyleIsViewportConstrained = oldStyle && oldStyle->position() == FixedPosition;
+        bool newStyleIsSticky = style()->position() == StickyPosition;
+        bool oldStyleIsSticky = oldStyle && oldStyle->position() == StickyPosition;
+
+        // Sticky positioned elements are only viewport constrained if they have no ancestor scroller.
+        if (newStyleIsSticky || oldStyleIsSticky) {
+            if (!findScrollAncestor(this)) {
+                newStyleIsViewportConstained |= newStyleIsSticky;
+                oldStyleIsViewportConstrained |= oldStyleIsSticky;
+            }
+        }
+
         if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
             if (newStyleIsViewportConstained && layer())
                 frameView->addViewportConstrainedObject(this);
             else
                 frameView->removeViewportConstrainedObject(this);
         }
+
+        if (newStyleIsSticky != oldStyleIsSticky) {
+            if (newStyleIsSticky)
+                frameView->addStickyPositionObject();
+            else
+                frameView->removeStickyPositionObject();
+        }
     }
 }
 
@@ -596,6 +640,126 @@ LayoutSize LayoutBoxModelObject::relativePositionOffset() const
     return offset;
 }
 
+void LayoutBoxModelObject::computeStickyPositionConstraints(StickyPositionViewportConstraints& constraints, const FloatRect& constrainingRect) const
+{
+    FloatSize skippedContainersOffset;
+    LayoutBlock* containingBlock = this->containingBlock();
+    // Skip anonymous containing blocks.
+    while (containingBlock->isAnonymous()) {

[chrishtr, 2016/01/30 01:49:02]

Why exactly? Is there a test for this?

[flackr, 2016/02/03 22:48:38]

I was matching firefox and safari on
http://flackr.github.io/compositor-worker/sticky/sticky.html. In particular, the
top sticky element is contained by an anonymous block above the spacer div,
which on other browsers does not constrain it. That being said, I don't see any
specific language in the spec about this. I will add a test for it.

[chrishtr, 2016/02/23 16:31:51]

And file a spec bug?

[flackr, 2016/03/07 19:07:33]

Done: bug is here https://www.w3.org/Bugs/Public/show_bug.cgi?id=29510
and test is
third_party/WebKit/LayoutTests/fast/css/sticky/inline-sticky-anonymous-container.html

+        skippedContainersOffset += toFloatSize(FloatPoint(containingBlock->frameRect().location()));
+        containingBlock = containingBlock->containingBlock();
+    }
+    LayoutBox* scrollAncestor = findScrollAncestor(this);
+
+    LayoutRect containerContentRect = containingBlock->contentBoxRect();
+    LayoutUnit maxWidth = containingBlock->availableLogicalWidth();
+
+    // Sticky positioned element ignore any override logical width on the containing block (as they don't call
+    // containingBlockLogicalWidthForContent). It's unclear whether this is totally fine.
+    // Compute the container-relative area within which the sticky element is allowed to move.
+    containerContentRect.contractEdges(
+        minimumValueForLength(style()->marginTop(), maxWidth),
+        minimumValueForLength(style()->marginRight(), maxWidth),
+        minimumValueForLength(style()->marginBottom(), maxWidth),
+        minimumValueForLength(style()->marginLeft(), maxWidth));
+
+    // Map to the scroll ancestor.
+    constraints.setAbsoluteContainingBlockRect(containingBlock->localToAncestorQuad(FloatRect(containerContentRect), scrollAncestor).boundingBox());
+
+    FloatRect stickyBoxRect = isLayoutInline()
+        ? FloatRect(toLayoutInline(this)->linesBoundingBox())
+        : FloatRect(toLayoutBox(this)->frameRect());
+    FloatRect flippedStickyBoxRect = stickyBoxRect;
+    containingBlock->flipForWritingMode(flippedStickyBoxRect);
+    FloatPoint stickyLocation = flippedStickyBoxRect.location() + skippedContainersOffset;
+
+    // FIXME: sucks to call localToAbsolute again, but we can't just offset from the previously computed rect if there are transforms.

[chrishtr, 2016/01/30 01:49:02]

s/localToAbsolute/localToAncestorQuad

[flackr, 2016/02/22 22:55:23]

Done.

+    // Map to the view to avoid including page scale factor.
+    FloatRect absContainerFrame = containingBlock->localToAncestorQuad(FloatRect(FloatPoint(), FloatSize(containingBlock->size())), scrollAncestor).boundingBox();

[chrishtr, 2016/01/30 01:49:02]

s/absContainerFrame/stickyBoxRect/

[flackr, 2016/02/22 22:55:23]

This is the container's frame rect which we add to the sticky box's location
within it in order to get the sticky box's absolute location within the
scroller. I was just playing with Firefox and Safari to see how they handle
transforms and it looks like Safari accounts for the transformed position of the
container while in firefox sticky seems to apply before transforms and then
things are transformed afterwards.

+
+    // If the containing block is our scroll ancestor, its location will not include the scroll offset which we need to include as
+    // part of the sticky box rect so we include it here.
+    if (containingBlock->hasOverflowClip()) {
+        FloatSize scrollOffset(toFloatSize(containingBlock->layer()->scrollableArea()->adjustedScrollOffset()));
+        stickyLocation -= scrollOffset;
+    }
+
+    // We can't call localToAbsolute on |this| because that will recur. FIXME: For now, assume that |this| is not transformed.

[chrishtr, 2016/01/30 01:49:02]

What is this comment about again? Why a need to map coordinates?
absContainerFrame is already in scroller space.

[flackr, 2016/02/22 22:55:23]

This actually seems unnecessary. If there is a transform on the sticky element
it is expected to be offset from its stuck position so we don't need to account
for that.

+    constraints.setAbsoluteStickyBoxRect(FloatRect(absContainerFrame.location() + toFloatSize(stickyLocation), flippedStickyBoxRect.size()));
+
+    LayoutUnit horizontalOffsets = minimumValueForLength(style()->right(), constrainingRect.width()) +
+        minimumValueForLength(style()->left(), constrainingRect.width());
+    bool skipRight = false;
+    bool skipLeft = false;
+    if (!style()->left().isAuto() && !style()->right().isAuto()) {

[chrishtr, 2016/01/30 01:49:02]

Document this code and what it's for.

[flackr, 2016/02/22 22:55:23]

Done.

+        if (horizontalOffsets > containerContentRect.width()
+            || horizontalOffsets + containerContentRect.width() > constrainingRect.width()) {
+            skipRight = style()->isLeftToRightDirection();
+            skipLeft = !skipRight;
+        }
+    }
+
+    if (!style()->left().isAuto() && !skipLeft) {
+        constraints.setLeftOffset(minimumValueForLength(style()->left(), constrainingRect.width()));
+        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeLeft);
+    }
+
+    if (!style()->right().isAuto() && !skipRight) {
+        constraints.setRightOffset(minimumValueForLength(style()->right(), constrainingRect.width()));
+        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeRight);
+    }
+
+    bool skipBottom = false;
+    // FIXME(ostap): Exclude top or bottom edge offset depending on the writing mode when related

[chrishtr, 2016/01/30 01:49:02]

s/FIXME/TODO/ throughout, and replace names with flakr

[flackr, 2016/02/22 22:55:23]

Done.

+    // sections are fixed in spec: http://lists.w3.org/Archives/Public/www-style/2014May/0286.html
+    LayoutUnit verticalOffsets = minimumValueForLength(style()->top(), constrainingRect.width()) +
+        minimumValueForLength(style()->bottom(), constrainingRect.width());
+    if (!style()->top().isAuto() && !style()->bottom().isAuto()) {
+        if (verticalOffsets > containerContentRect.height()
+            || verticalOffsets + containerContentRect.height() > constrainingRect.height()) {
+            skipBottom = true;
+        }
+    }
+
+    if (!style()->top().isAuto()) {
+        constraints.setTopOffset(minimumValueForLength(style()->top(), constrainingRect.height()));
+        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeTop);
+    }
+
+    if (!style()->bottom().isAuto() && !skipBottom) {
+        constraints.setBottomOffset(minimumValueForLength(style()->bottom(), constrainingRect.height()));
+        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeBottom);
+    }
+}
+
+FloatRect LayoutBoxModelObject::computeStickyConstrainingRect() const
+{
+    FloatRect constrainingRect;
+
+    ASSERT(hasLayer());
+    LayoutBox* enclosingClippingBox = findScrollAncestor(this);
+    if (enclosingClippingBox) {
+        constrainingRect = FloatRect(enclosingClippingBox->overflowClipRect(LayoutPoint()));
+        constrainingRect.move(enclosingClippingBox->paddingLeft(), enclosingClippingBox->paddingTop());
+        constrainingRect.contract(FloatSize(enclosingClippingBox->paddingLeft() + enclosingClippingBox->paddingRight(),
+            enclosingClippingBox->paddingTop() + enclosingClippingBox->paddingBottom()));
+    } else {
+        constrainingRect = view()->frameView()->visibleContentRect();
+    }
+
+    return constrainingRect;
+}
+
+LayoutSize LayoutBoxModelObject::stickyPositionOffset() const
+{
+    FloatRect constrainingRect = computeStickyConstrainingRect();
+    StickyPositionViewportConstraints constraints;
+    computeStickyPositionConstraints(constraints, constrainingRect);
+
+    // The sticky offset is physical, so we can just return the delta computed in absolute coords (though it may be wrong with transforms).
+    return LayoutSize(constraints.computeStickyOffset(constrainingRect));
+}
+
 LayoutPoint LayoutBoxModelObject::adjustedPositionRelativeToOffsetParent(const LayoutPoint& startPoint) const
 {
     // If the element is the HTML body element or doesn't have a parent
@@ -618,7 +782,7 @@ LayoutPoint LayoutBoxModelObject::adjustedPositionRelativeToOffsetParent(const L
             referencePoint.move(-toLayoutBox(offsetParent)->borderLeft(), -toLayoutBox(offsetParent)->borderTop());
         if (!isOutOfFlowPositioned() || flowThreadContainingBlock()) {
             if (isInFlowPositioned())
-                referencePoint.move(relativePositionOffset());
+                referencePoint.move(offsetForInFlowPosition());
 
             LayoutObject* current;
             for (current = parent(); current != offsetParent && current->parent(); current = current->parent()) {
@@ -640,7 +804,13 @@ LayoutPoint LayoutBoxModelObject::adjustedPositionRelativeToOffsetParent(const L
 
 LayoutSize LayoutBoxModelObject::offsetForInFlowPosition() const
 {
-    return isRelPositioned() ? relativePositionOffset() : LayoutSize();
+    if (isRelPositioned())
+        return relativePositionOffset();
+
+    if (isStickyPositioned())
+        return stickyPositionOffset();
+
+    return LayoutSize();
 }
 
 LayoutUnit LayoutBoxModelObject::offsetLeft() const
@@ -963,7 +1133,7 @@ const LayoutObject* LayoutBoxModelObject::pushMappingToContainer(const LayoutBox
         return nullptr;
 
     bool isInline = isLayoutInline();
-    bool isFixedPos = !isInline && style()->position() == FixedPosition;
+    bool isFixedPosition = !isInline && style()->position() == FixedPosition;
     bool hasTransform = !isInline && hasLayer() && layer()->transform();
 
     LayoutSize adjustmentForSkippedAncestor;
@@ -975,16 +1145,19 @@ const LayoutObject* LayoutBoxModelObject::pushMappingToContainer(const LayoutBox
 
     bool offsetDependsOnPoint = false;
     LayoutSize containerOffset = offsetFromContainer(container, LayoutPoint(), &offsetDependsOnPoint);
+    LayoutSize stickyOffset;
+    if (style()->position() == StickyPosition)
+        stickyOffset = offsetForInFlowPosition();
 
     bool preserve3D = container->style()->preserves3D() || style()->preserves3D();
     if (shouldUseTransformFromContainer(container)) {
         TransformationMatrix t;
         getTransformFromContainer(container, containerOffset, t);
         t.translateRight(adjustmentForSkippedAncestor.width().toFloat(), adjustmentForSkippedAncestor.height().toFloat());
-        geometryMap.push(this, t, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform);
+        geometryMap.push(this, t, preserve3D, offsetDependsOnPoint, isFixedPosition, hasTransform, LayoutSize(), stickyOffset);
     } else {
         containerOffset += adjustmentForSkippedAncestor;
-        geometryMap.push(this, containerOffset, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform);
+        geometryMap.push(this, containerOffset, preserve3D, offsetDependsOnPoint, isFixedPosition, hasTransform, LayoutSize(), stickyOffset);
     }
 
     return ancestorSkipped ? ancestorToStopAt : container;