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 the viewport.
+
+  LayoutObject* maybeStickyAncestor = parent();
+  while (maybeStickyAncestor &&
+         maybeStickyAncestor != containingBlock->parent()) {

[flackr, 2017/01/18 16:09:47]

We should stop before the containing block, the containing block's to viewport
ancestor should be able to point to itself if the containing block is sticky.

[smcgruer, 2017/01/18 19:10:50]

Not sure I follow: no element should have itself as an ancestor as far as I can
tell.

Are you saying that you would want to change the bounds to be inclusive
different, e.g. so that m_nearestStickyElementToContainingBlock *cannot* be the
containingBlock, and m_nearestStickyElementFromContainingBlockToScrollContainer
*can* be the containingBlock?

[flackr, 2017/01/19 01:44:41]

Not true. For the purposes of sticky position, the containing block can be its
own nearest sticky ancestor to the viewport because all that means is you have
to offset the containing block rect by its sticky offset for its sticky
descendants.
Yes.

[smcgruer, 2017/01/19 19:28:01]

Done.

+    if (maybeStickyAncestor->isStickyPositioned()) {
+      constraints.setNearestStickyElementToContainingBlock(
+          toLayoutBoxModelObject(maybeStickyAncestor));
+      break;
+    }
+    maybeStickyAncestor = maybeStickyAncestor->parent();
+  }

[flackr, 2017/01/18 14:42:56]

We should try combining this with the walk to find the containing block. I.e.
walk up looking for containing block criteria and/or sticky.

+
+  maybeStickyAncestor = containingBlock->parent();
+  while (maybeStickyAncestor &&
+         maybeStickyAncestor != scrollAncestor->parent()) {

[flackr, 2017/01/18 14:42:56]

I don't think we need to track if the ancestor scroller is sticky, do we? If
it's moved the positions in the constraints are all relative to that ancestor so
they should be unchanged.

[smcgruer, 2017/01/18 19:10:51]

Good spot! Fixed and added a test. Also had to wrap this in a check to make sure
there is an ancestor sticky.

+    if (maybeStickyAncestor->isStickyPositioned()) {
+      constraints.setNearestStickyElementFromContainingBlockToViewport(

[flackr, 2017/01/18 14:42:56]

for consistency s/ToViewport/ToScrollContainer (I realize these names are
getting ridiculously long :( )

[smcgruer, 2017/01/18 19:10:50]

Done.

+          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());

[flackr, 2017/01/18 14:42:56]

Out of curiosity, why not stickyConstraintsMap().get(layer())?

[smcgruer, 2017/01/18 19:10:51]

As far as I can tell, WTF::HashMap::get() returns a 'MappedPeekType', which
doesn't allow you to take a non-const reference to it. And the reference has to
be non-const to allow the call to computeStickyOffset to work.

See WTF::GenericHashTraits in HashTraits.h.

[flackr, 2017/01/19 01:44:41]

Okay no problem.

+  DCHECK(it != scrollableArea->stickyConstraintsMap().end());
+
+  StickyPositionScrollingConstraints& constraints = it->value;
+
+  FloatSize accumulatedOffsetToContainingBlock;
+  FloatSize accumulatedOffsetToViewport;
+
+  const LayoutBoxModelObject* toContainingBlock =
+      constraints.nearestStickyElementToContainingBlock();
+  if (toContainingBlock) {
+    accumulatedOffsetToContainingBlock =
+        scrollableArea->stickyConstraintsMap()
+            .get(toContainingBlock->layer())
+            .getCachedAccumulatedStickyOffset();
+  }
+
+  const LayoutBoxModelObject* toViewport =
+      constraints.nearestStickyElementFromContainingBlockToViewport();
+  if (toViewport) {
+    accumulatedOffsetToViewport = scrollableArea->stickyConstraintsMap()
+                                      .get(toViewport->layer())
+                                      .getCachedAccumulatedStickyOffset();
+  }
+
+  return LayoutSize(constraints.computeStickyOffset(
+      constrainingRect, accumulatedOffsetToContainingBlock,
+      accumulatedOffsetToViewport));
 }
 
 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