Fix sticky constraints and update sticky layer positions recursively after scroll.

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 603 matching lines @@
         && (!containingBlock->hasAutoHeightOrContainingBlockWithAutoHeight()
             || !style()->bottom().hasPercent()
             || containingBlock->stretchesToViewport()))
         offset.expand(LayoutUnit(), -valueForLength(style()->bottom(), containingBlock->availableHeight()));
 
     return offset;
 }
 
 void LayoutBoxModelObject::updateStickyPositionConstraints() const
 {
-    // TODO(flackr): This method is reasonably complicated and should have some direct unit testing.
     const FloatSize constrainingSize = computeStickyConstrainingRect().size();
 
     PaintLayerScrollableArea* scrollableArea = layer()->ancestorOverflowLayer()->getScrollableArea();
     StickyPositionScrollingConstraints constraints;
     FloatSize skippedContainersOffset;
     LayoutBlock* containingBlock = this->containingBlock();
     // Skip anonymous containing blocks.
     while (containingBlock->isAnonymous()) {
         skippedContainersOffset += toFloatSize(FloatPoint(containingBlock->frameRect().location()));
         containingBlock = containingBlock->containingBlock();
     }
     LayoutBox* scrollAncestor = layer()->ancestorOverflowLayer()->isRootLayer() ? nullptr : toLayoutBox(layer()->ancestorOverflowLayer()->layoutObject());
 
-    LayoutRect containerContentRect = containingBlock->contentBoxRect();
-    LayoutUnit maxWidth = containingBlock->availableLogicalWidth();
-
+    LayoutRect containerContentRect = containingBlock->layoutOverflowRect();
+    LayoutUnit maxContainerWidth = containingBlock->containingBlockLogicalWidthForContent();
     // 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.
+    LayoutUnit maxWidth = containingBlock->availableLogicalWidth();
+
+    // This is removing the padding of the containing block's overflow rect to get the flow
+    // box rectangle and removing the margin of the sticky element to ensure that space between
+    // the sticky element and its containing flow box. It is an open issue whether the margin
+    // should collapse (See https://www.w3.org/TR/css-position-3/#sticky-pos).
     containerContentRect.contractEdges(
-        minimumValueForLength(style()->marginTop(), maxWidth),
-        minimumValueForLength(style()->marginRight(), maxWidth),
-        minimumValueForLength(style()->marginBottom(), maxWidth),
-        minimumValueForLength(style()->marginLeft(), maxWidth));
+        minimumValueForLength(containingBlock->style()->paddingTop(), maxContainerWidth) + minimumValueForLength(style()->marginTop(), maxWidth),
+        minimumValueForLength(containingBlock->style()->paddingRight(), maxContainerWidth) + minimumValueForLength(style()->marginRight(), maxWidth),
+        minimumValueForLength(containingBlock->style()->paddingBottom(), maxContainerWidth) + minimumValueForLength(style()->marginBottom(), maxWidth),
+        minimumValueForLength(containingBlock->style()->paddingLeft(), maxContainerWidth) + minimumValueForLength(style()->marginLeft(), maxWidth));
 
     // Map to the scroll ancestor.
-    constraints.setScrollContainerRelativeContainingBlockRect(containingBlock->localToAncestorQuad(FloatRect(containerContentRect), scrollAncestor).boundingBox());
+    FloatRect scrollContainerRelativeContainingBlockRect(containingBlock->localToAncestorQuad(FloatRect(containerContentRect), scrollAncestor).boundingBox());
+    FloatSize scrollOffset(scrollAncestor ? toFloatSize(scrollAncestor->getScrollableArea()->adjustedScrollOffset()) : FloatSize());
+
+    // The sticky position constraint rects should be independent of the current scroll position, so after
+    // mapping we add in the scroll position to get the container's position within the ancestor scroller's
+    // unscrolled layout overflow.
+    if (containingBlock != scrollAncestor)
+        scrollContainerRelativeContainingBlockRect.move(scrollOffset);
+    constraints.setScrollContainerRelativeContainingBlockRect(scrollContainerRelativeContainingBlockRect);
 
     FloatRect stickyBoxRect = isLayoutInline()
         ? FloatRect(toLayoutInline(this)->linesBoundingBox())
         : FloatRect(toLayoutBox(this)->frameRect());
     FloatRect flippedStickyBoxRect = stickyBoxRect;
     containingBlock->flipForWritingMode(flippedStickyBoxRect);
     FloatPoint stickyLocation = flippedStickyBoxRect.location() + skippedContainersOffset;
 
     // TODO(flackr): Unfortunate to call localToAncestorQuad again, but we can't just offset from the previously computed rect if there are transforms.
     // Map to the scroll ancestor.
     FloatRect scrollContainerRelativeContainerFrame = containingBlock->localToAncestorQuad(FloatRect(FloatPoint(), FloatSize(containingBlock->size())), scrollAncestor).boundingBox();
-
-    // 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()->getScrollableArea()->adjustedScrollOffset()));
-        stickyLocation -= scrollOffset;
-    }
+    // The sticky position constraint rects should be independent of the current scroll position, so after
+    // mapping we add in the scroll position to get the container's position within the ancestor scroller's
+    // unscrolled layout overflow.
+    if (containingBlock != scrollAncestor)
+        scrollContainerRelativeContainerFrame.move(scrollOffset);
 
     constraints.setScrollContainerRelativeStickyBoxRect(FloatRect(scrollContainerRelativeContainerFrame.location() + toFloatSize(stickyLocation), flippedStickyBoxRect.size()));
 
     // We skip the right or top sticky offset if there is not enough space to honor both the left/right or top/bottom offsets.
     LayoutUnit horizontalOffsets = minimumValueForLength(style()->right(), LayoutUnit(constrainingSize.width())) +
         minimumValueForLength(style()->left(), LayoutUnit(constrainingSize.width()));
     bool skipRight = false;
     bool skipLeft = false;
     if (!style()->left().isAuto() && !style()->right().isAuto()) {
         if (horizontalOffsets > containerContentRect.width()
@@ skipping 37 matching lines @@
     scrollableArea->stickyConstraintsMap().set(layer(), constraints);
 }
 
 FloatRect LayoutBoxModelObject::computeStickyConstrainingRect() const
 {
     if (layer()->ancestorOverflowLayer()->isRootLayer())
         return view()->frameView()->visibleContentRect();
 
     LayoutBox* enclosingClippingBox = toLayoutBox(layer()->ancestorOverflowLayer()->layoutObject());
     FloatRect constrainingRect;
-    constrainingRect = FloatRect(enclosingClippingBox->overflowClipRect(LayoutPoint()));
+    constrainingRect = FloatRect(enclosingClippingBox->overflowClipRect(LayoutPoint(DoublePoint(enclosingClippingBox->getScrollableArea()->adjustedScrollOffset()))));
     constrainingRect.move(enclosingClippingBox->paddingLeft(), enclosingClippingBox->paddingTop());
     constrainingRect.contract(FloatSize(enclosingClippingBox->paddingLeft() + enclosingClippingBox->paddingRight(),
         enclosingClippingBox->paddingTop() + enclosingClippingBox->paddingBottom()));
     return constrainingRect;
 }
 
 LayoutSize LayoutBoxModelObject::stickyPositionOffset() const
 {
     const PaintLayer* ancestorOverflowLayer = layer()->ancestorOverflowLayer();
     // TODO: Force compositing input update if we ask for offset before compositing inputs have been computed?
@@ skipping 377 matching lines @@
     if (rootElementStyle->hasBackground())
         return false;
 
     if (node() != document().firstBodyElement())
         return false;
 
     return true;
 }
 
 } // namespace blink