Adapt and reland old position sticky implementation

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 160 matching lines @@
         if (parent() && diff.needsPaintInvalidationLayer()) {
             if (oldStyle->hasAutoClip() != newStyle.hasAutoClip()
                 || oldStyle->clip() != newStyle.clip())
                 layer()->clipper().clearClipRectsIncludingDescendants();
         }
     }
 
     LayoutObject::styleWillChange(diff, newStyle);
 }
 
+static inline LayoutBox* findScrollAncestor(const Node* startNode)
+{
+    ASSERT(startNode->layoutObject());
+    LayoutBox* curBox = startNode->layoutObject()->containingBlock();
+
+    // Scrolling propagates along the containing block chain.
+    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();
     bool hadLayer = hasLayer();
     bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer();
     bool wasFloatingBeforeStyleChanged = FloatStateForStyleChange::wasFloating(this);
 
     LayoutObject::styleDidChange(diff, oldStyle);
     updateFromStyle();
 
@@ skipping 70 matching lines @@
             bool newStoleBodyBackground = toLayoutBoxModelObject(bodyLayout)->backgroundStolenForBeingBody(style());
             bool oldStoleBodyBackground = oldStyle && toLayoutBoxModelObject(bodyLayout)->backgroundStolenForBeingBody(oldStyle);
             if (newStoleBodyBackground != oldStoleBodyBackground
                 && bodyLayout->style() && bodyLayout->style()->hasBackground()) {
                 bodyLayout->setShouldDoFullPaintInvalidation();
             }
         }
     }
 
     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;
+
+        // Sticky positioned elements are only viewport constrained if they have no ancestor scroller.
+        if (style()->position() == StickyPosition || (oldStyle && oldStyle->position() == StickyPosition)) {
+            if (!findScrollAncestor(node())) {
+                newStyleIsViewportConstained |= style()->position() == StickyPosition;
+                oldStyleIsViewportConstrained |= oldStyle && oldStyle->position() == StickyPosition;
+            }
+        }
+
         if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
             if (newStyleIsViewportConstained && layer())
                 frameView->addViewportConstrainedObject(this);
             else
                 frameView->removeViewportConstrainedObject(this);
         }
     }
 }
 
 void LayoutBoxModelObject::createLayer(PaintLayerType type)
@@ skipping 318 matching lines @@
 
     else if (!style()->bottom().isAuto()
         && (!containingBlock->hasAutoHeightOrContainingBlockWithAutoHeight()
             || !style()->bottom().hasPercent()
             || containingBlock->stretchesToViewport()))
         offset.expand(0, -valueForLength(style()->bottom(), containingBlock->availableHeight()));
 
     return offset;
 }
 
+void LayoutBoxModelObject::computeStickyPositionConstraints(StickyPositionViewportConstraints& constraints, const LayoutRect& constrainingRect) const

[chrishtr, 2015/12/09 00:37:38]

I have a bunch of questions about this method. The best way forward though is to
do a VC to discuss in person, which will make the review much faster. Could you
schedule a meeting for tomorrow?

[flackr, 2015/12/10 23:43:15]

Acknowledged.

+{
+    LayoutBlock* containingBlock = this->containingBlock();
+
+    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 view to avoid including page scale factor.
+    constraints.setAbsoluteContainingBlockRect(LayoutRect(containingBlock->localToContainerQuad(FloatRect(containerContentRect), view()).boundingBox()));
+
+    LayoutRect stickyBoxRect = isLayoutInline()
+        ? LayoutRect(toLayoutInline(this)->linesBoundingBox())
+        : toLayoutBox(this)->frameRect();
+    LayoutRect flippedStickyBoxRect = stickyBoxRect;
+    containingBlock->flipForWritingMode(flippedStickyBoxRect);
+    LayoutPoint stickyLocation = flippedStickyBoxRect.location();
+
+    // FIXME: sucks to call localToAbsolute again, but we can't just offset from the previously computed rect if there are transforms.
+    // Map to the view to avoid including page scale factor.
+    LayoutRect absContainerFrame = LayoutRect(containingBlock->localToContainerQuad(FloatRect(FloatPoint(), FloatSize(containingBlock->size())), view()).boundingBox());
+
+    if (containingBlock->hasOverflowClip()) {
+        LayoutSize scrollOffset(containingBlock->layer()->scrollableArea()->adjustedScrollOffset());

[chrishtr, 2015/12/09 19:12:21]

Is this code useless? Can the containing block be a scroller without also being
the sticky scroll container?

[flackr, 2015/12/10 23:43:15]

No, the containing block can't be a scroller without also being the sticky
scroll container afaik, but this is necessary. If the containing block is also
the scroller, absContainerFrame.location() is the location of the scroller which
does not include the scroll offset. When we go to set the absoluteStickyBoxRect
it then thinks that it's always at the same "absolute" position regardless of
how much the container has been scrolled.

[chrishtr, 2015/12/11 02:06:11]

Ok please add a comment explaining this then.

[flackr, 2016/01/19 15:40:48]

Done.

+        stickyLocation -= scrollOffset;
+    }
+
+    // We can't call localToAbsolute on |this| because that will recur. FIXME: For now, assume that |this| is not transformed.
+    constraints.setAbsoluteStickyBoxRect(LayoutRect(LayoutPoint(absContainerFrame.location()) + 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()) {
+        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
+    // 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);
+    }
+}
+
+LayoutRect LayoutBoxModelObject::computeStickyConstrainingRect() const
+{
+    LayoutRect constrainingRect;
+
+    ASSERT(hasLayer());
+    LayoutBox* enclosingClippingBox = findScrollAncestor(node());
+    if (enclosingClippingBox) {
+        LayoutRect clipRect = enclosingClippingBox->overflowClipRect(LayoutPoint());
+        clipRect.move(enclosingClippingBox->paddingLeft(), enclosingClippingBox->paddingTop());
+        clipRect.contract(LayoutSize(enclosingClippingBox->paddingLeft() + enclosingClippingBox->paddingRight(),

[chrishtr, 2015/12/09 19:12:21]

Why is special code needed to remove padding?

[flackr, 2015/12/10 23:43:15]

The padding is not clipped from an overflow box, so we need to remove it here.
In the spec it says that we stick to the flow box rect which I think means the
rect in which the scroller's content flows in, and this is consistent with how
its implemented by Firefox and Safari.

+            enclosingClippingBox->paddingTop() + enclosingClippingBox->paddingBottom()));
+        constrainingRect = LayoutRect(enclosingClippingBox->localToContainerQuad(FloatRect(clipRect), view()).boundingBox());
+    } else {
+        constrainingRect = LayoutRect(view()->frameView()->visibleContentRect());
+    }
+
+    return constrainingRect;
+}
+
+LayoutSize LayoutBoxModelObject::stickyPositionOffset() const
+{
+    LayoutRect 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
     // return 0 and stop this algorithm.
     if (isBody() || !parent())
         return LayoutPoint();
 
     LayoutPoint referencePoint = startPoint;
     referencePoint.move(parent()->columnOffset(referencePoint));
 
     // If the offsetParent of the element is null, or is the HTML body element,
     // return the distance between the canvas origin and the left border edge
     // of the element and stop this algorithm.
     Element* element = offsetParent();
     if (!element)
         return referencePoint;
 
     if (const LayoutBoxModelObject* offsetParent = element->layoutBoxModelObject()) {
         if (offsetParent->isBox() && !offsetParent->isBody())
             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()) {
                 // FIXME: What are we supposed to do inside SVG content?
                 if (!isOutOfFlowPositioned()) {
                     if (current->isBox() && !current->isTableRow())
                         referencePoint.moveBy(toLayoutBox(current)->topLeftLocation());
                     referencePoint.move(current->parent()->columnOffset(referencePoint));
                 }
             }
 
             if (offsetParent->isBox() && offsetParent->isBody() && !offsetParent->isPositioned())
                 referencePoint.moveBy(toLayoutBox(offsetParent)->topLeftLocation());
         }
     }
 
     return referencePoint;
 }
 
 LayoutSize LayoutBoxModelObject::offsetForInFlowPosition() const
 {
-    return isRelPositioned() ? relativePositionOffset() : LayoutSize();
+    if (isRelPositioned())
+        return relativePositionOffset();
+
+    if (isStickyPositioned())
+        return stickyPositionOffset();
+
+    return LayoutSize();
 }
 
 LayoutUnit LayoutBoxModelObject::offsetLeft() const
 {
     // Note that LayoutInline and LayoutBox override this to pass a different
     // startPoint to adjustedPositionRelativeToOffsetParent.
     return adjustedPositionRelativeToOffsetParent(LayoutPoint()).x();
 }
 
 LayoutUnit LayoutBoxModelObject::offsetTop() const
@@ skipping 302 matching lines @@
 const LayoutObject* LayoutBoxModelObject::pushMappingToContainer(const LayoutBoxModelObject* ancestorToStopAt, LayoutGeometryMap& geometryMap) const
 {
     ASSERT(ancestorToStopAt != this);
 
     bool ancestorSkipped;
     LayoutObject* container = this->container(ancestorToStopAt, &ancestorSkipped);
     if (!container)
         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;
     if (ancestorSkipped) {
         // There can't be a transform between paintInvalidationContainer and ancestorToStopAt, because transforms create containers, so it should be safe
         // to just subtract the delta between the ancestor and ancestorToStopAt.
         adjustmentForSkippedAncestor = -ancestorToStopAt->offsetFromAncestorContainer(container);
     }
 
     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;
 }
 
 void LayoutBoxModelObject::moveChildTo(LayoutBoxModelObject* toBoxModelObject, LayoutObject* child, LayoutObject* beforeChild, bool fullRemoveInsert)
 {
     // We assume that callers have cleared their positioned objects list for child moves (!fullRemoveInsert) so the
     // positioned layoutObject maps don't become stale. It would be too slow to do the map lookup on each call.
     ASSERT(!fullRemoveInsert || !isLayoutBlock() || !toLayoutBlock(this)->hasPositionedObjects());
@@ skipping 47 matching lines @@
     if (rootElementStyle->hasBackground())
         return false;
 
     if (node() != document().firstBodyElement())
         return false;
 
     return true;
 }
 
 } // namespace blink