Handle nested position:sticky elements

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 855 matching lines @@
   // the container is our scroll ancestor, we also need to remove the border
   // box because we want the position from within the scroller border.
   FloatSize containerBorderOffset(containingBlock->borderLeft(),
                                   containingBlock->borderTop());
   stickyLocation -= containerBorderOffset;
   constraints.setScrollContainerRelativeStickyBoxRect(
       FloatRect(scrollContainerRelativePaddingBoxRect.location() +
                     toFloatSize(stickyLocation),
                 flippedStickyBoxRect.size()));
 
+  // To correctly compute the offsets, the constraints need to know about any
+  // nested position:sticky between themselves and their containingBlock, and
+  // between the containingBlock and their scrollAncestor.
+  //
+  // The respective search ranges are [parent(), containingBlock) and
+  // [containingBlock, scrollAncestor).
+
+  // TODO(smcgruer): Fold these into the walks to find the containingBlock and
+  // scrollAncestor.
+
+  LayoutObject* maybeStickyAncestor = parent();
+  while (maybeStickyAncestor && maybeStickyAncestor != containingBlock) {
+    if (maybeStickyAncestor->isStickyPositioned()) {
+      constraints.setNearestStickyElementToContainingBlock(
+          toLayoutBoxModelObject(maybeStickyAncestor));
+      break;
+    }
+    maybeStickyAncestor = maybeStickyAncestor->parent();
+  }
+
+  if (scrollAncestor) {

[flackr, 2017/01/20 02:42:44]

nullptr scrollAncestor just means the scroll ancestor is the FrameView - there
could still be elements between the containingblock and FrameView which would
move the containing block rect so we still need to do the walk then.

[smcgruer, 2017/01/20 17:18:14]

So I'm clear, we need to do something like:

    LayoutObject* ancestor = scrollAncestor ? scrollAncestor :
view()->frameView()->layoutView();

Or similar?

[flackr, 2017/01/23 16:45:42]

Yes, that would work, but probably simpler to use the ancestorOverflowLayer from
above.

[smcgruer, 2017/01/24 18:38:25]

Done.

+    maybeStickyAncestor = containingBlock;
+    while (maybeStickyAncestor && maybeStickyAncestor != scrollAncestor) {
+      if (maybeStickyAncestor->isStickyPositioned()) {
+        constraints.setNearestStickyElementFromContainingBlockToScrollContainer(
+            toLayoutBoxModelObject(maybeStickyAncestor));
+        break;
+      }
+      maybeStickyAncestor = maybeStickyAncestor->parent();
+    }
+  }
+
   // 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()) {
@@ skipping 83 matching lines @@
   FloatRect constrainingRect = computeStickyConstrainingRect();
   PaintLayerScrollableArea* scrollableArea =
       ancestorOverflowLayer->getScrollableArea();
 
   // The sticky offset is physical, so we can just return the delta computed in
   // absolute coords (though it may be wrong with transforms).
   // TODO: Force compositing input update if we ask for offset with stale
   // compositing inputs.
   if (!scrollableArea->stickyConstraintsMap().contains(layer()))
     return LayoutSize();
-  return LayoutSize(
-      scrollableArea->stickyConstraintsMap().get(layer()).computeStickyOffset(
-          constrainingRect));
+
+  auto it = scrollableArea->stickyConstraintsMap().find(layer());
+  DCHECK(it != scrollableArea->stickyConstraintsMap().end());

[flackr, 2017/01/20 02:42:44]

Please merge this with the check on 1009 above so that we don't look up layer()
in the constraints twice.

[smcgruer, 2017/01/24 18:38:25]

Done in PS4 (missed this comment.)

+
+  StickyPositionScrollingConstraints& constraints = it->value;
+
+  FloatSize accumulatedOffsetToContainingBlock;
+  FloatSize accumulatedOffsetToScrollContainer;
+
+  const LayoutBoxModelObject* toContainingBlock =
+      constraints.nearestStickyElementToContainingBlock();
+  if (toContainingBlock) {
+    accumulatedOffsetToContainingBlock =
+        scrollableArea->stickyConstraintsMap()
+            .get(toContainingBlock->layer())
+            .getAccumulatedStickyOffsetToContainingBlock();
+  }
+
+  const LayoutBoxModelObject* toViewport =
+      constraints.nearestStickyElementFromContainingBlockToScrollContainer();
+  if (toViewport) {
+    accumulatedOffsetToScrollContainer =
+        scrollableArea->stickyConstraintsMap()
+            .get(toViewport->layer())
+            .getAccumulatedStickyOffsetFromContainingBlockToScrollContainer();
+  }
+
+  return LayoutSize(constraints.computeStickyOffset(
+      constrainingRect, accumulatedOffsetToContainingBlock,
+      accumulatedOffsetToScrollContainer));
 }
 
 LayoutPoint LayoutBoxModelObject::adjustedPositionRelativeTo(
     const LayoutPoint& startPoint,
     const Element* offsetParent) 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();
 
@@ skipping 348 matching lines @@
   if (rootElementStyle->hasBackground())
     return false;
 
   if (node() != document().firstBodyElement())
     return false;
 
   return true;
 }
 
 }  // namespace blink