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 28 matching lines @@
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ShadowList.h"
 #include "platform/LengthFunctions.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/scroll/MainThreadScrollingReason.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
+namespace {
+inline bool isOutOfFlowPositionedWithImplicitHeight(
+    const LayoutBoxModelObject* child) {
+  return child->isOutOfFlowPositioned() &&
+         !child->style()->logicalTop().isAuto() &&
+         !child->style()->logicalBottom().isAuto();
+}
+
+StickyPositionScrollingConstraints* stickyConstraintsForLayoutObject(
+    const LayoutBoxModelObject* o) {
+  if (!o || !o->layer()->ancestorOverflowLayer())
+    return nullptr;
+
+  PaintLayerScrollableArea* scrollableArea =
+      o->layer()->ancestorOverflowLayer()->getScrollableArea();
+  auto it = scrollableArea->stickyConstraintsMap().find(o->layer());
+  if (it == scrollableArea->stickyConstraintsMap().end())
+    return nullptr;
+
+  return &it->value;
+}
+}  // namespace
+
 class FloatStateForStyleChange {
  public:
   static void setWasFloating(LayoutBoxModelObject* boxModelObject,
                              bool wasFloating) {
     s_wasFloating = wasFloating;
     s_boxModelObject = boxModelObject;
   }
 
   static bool wasFloating(LayoutBoxModelObject* boxModelObject) {
     ASSERT(boxModelObject == s_boxModelObject);
@@ skipping 596 matching lines @@
 }
 
 void LayoutBoxModelObject::updateFromStyle() {
   const ComputedStyle& styleToUse = styleRef();
   setHasBoxDecorationBackground(styleToUse.hasBoxDecorationBackground());
   setInline(styleToUse.isDisplayInlineType());
   setPositionState(styleToUse.position());
   setHorizontalWritingMode(styleToUse.isHorizontalWritingMode());
 }
 
-static inline bool isOutOfFlowPositionedWithImplicitHeight(
-    const LayoutBoxModelObject* child) {
-  return child->isOutOfFlowPositioned() &&
-         !child->style()->logicalTop().isAuto() &&
-         !child->style()->logicalBottom().isAuto();
-}
-
 LayoutBlock* LayoutBoxModelObject::containingBlockForAutoHeightDetection(
     Length logicalHeight) const {
   // For percentage heights: The percentage is calculated with respect to the
   // height of the generated box's containing block. If the height of the
   // containing block is not specified explicitly (i.e., it depends on content
   // height), and this element is not absolutely positioned, the used height is
   // calculated as if 'auto' was specified.
   if (!logicalHeight.isPercentOrCalc() || isOutOfFlowPositioned())
     return nullptr;
 
@@ skipping 96 matching lines @@
            (!containingBlock->hasAutoHeightOrContainingBlockWithAutoHeight() ||
             !style()->bottom().isPercentOrCalc() ||
             containingBlock->stretchesToViewport()))
     offset.expand(
         LayoutUnit(),
         -valueForLength(style()->bottom(), containingBlock->availableHeight()));
 
   return offset;
 }
 
+// Inclusive of |from|, exclusive of |to|.
+static LayoutBoxModelObject* findFirstStickyBetween(LayoutObject* from,
+                                                    LayoutObject* to) {
+  LayoutObject* maybeStickyAncestor = from;
+  while (maybeStickyAncestor && maybeStickyAncestor != to) {
+    if (maybeStickyAncestor->isStickyPositioned()) {
+      return toLayoutBoxModelObject(maybeStickyAncestor);
+    }
+    maybeStickyAncestor =
+        maybeStickyAncestor->isLayoutInline()
+            ? maybeStickyAncestor->containingBlock()
+            : toLayoutBox(maybeStickyAncestor)->locationContainer();
+  }
+
+  return nullptr;
+}
+
 void LayoutBoxModelObject::updateStickyPositionConstraints() const {
   const FloatSize constrainingSize = computeStickyConstrainingRect().size();
 
   PaintLayerScrollableArea* scrollableArea =
       layer()->ancestorOverflowLayer()->getScrollableArea();
   StickyPositionScrollingConstraints constraints;
   FloatSize skippedContainersOffset;
   LayoutBlock* containingBlock = this->containingBlock();
   // The location container for boxes is not always the containing block.
-  LayoutBox* locationContainer = isLayoutInline()
-                                     ? containingBlock
-                                     : toLayoutBox(this)->locationContainer();
+  LayoutObject* locationContainer =
+      isLayoutInline() ? container() : toLayoutBox(this)->locationContainer();
   // Skip anonymous containing blocks.
   while (containingBlock->isAnonymous()) {
     containingBlock = containingBlock->containingBlock();
   }
-  MapCoordinatesFlags flags = 0;
+  MapCoordinatesFlags flags = IgnoreStickyOffset;
   skippedContainersOffset =
       toFloatSize(locationContainer
                       ->localToAncestorQuadWithoutTransforms(
                           FloatQuad(), containingBlock, flags)
                       .boundingBox()
                       .location());
   LayoutBox* scrollAncestor =
       layer()->ancestorOverflowLayer()->isRootLayer()
           ? nullptr
           : toLayoutBox(layer()->ancestorOverflowLayer()->layoutObject());
@@ skipping 59 matching lines @@
       minimumValueForLength(containingBlock->style()->paddingLeft(),
                             maxContainerWidth) +
           minimumValueForLength(style()->marginLeft(), maxWidth));
 
   constraints.setScrollContainerRelativeContainingBlockRect(
       FloatRect(scrollContainerRelativeContainingBlockRect));
 
   FloatRect stickyBoxRect =
       isLayoutInline() ? FloatRect(toLayoutInline(this)->linesBoundingBox())
                        : FloatRect(toLayoutBox(this)->frameRect());
+
+  // If we have an anonymous container, then |skippedContainersOffset| above can
+  // incorrectly exclude the scrollOffset if our non-anonymous containing block
+  // is the direct child of the scrollAncestor. Add it back here.
+  // TODO(smcgruer): I think this is not quite the right conditional check.
+  // TODO(smcgruer): Refactor into the code above.
+  if (locationContainer != scrollAncestor &&
+      containingBlock == scrollAncestor) {
+    ScrollOffset scrollOffset(
+        scrollAncestor
+            ? toFloatSize(scrollAncestor->getScrollableArea()->scrollPosition())
+            : FloatSize());
+    stickyBoxRect.move(scrollOffset);
+  }
+
   FloatRect flippedStickyBoxRect = stickyBoxRect;
   containingBlock->flipForWritingMode(flippedStickyBoxRect);
   FloatPoint stickyLocation =
       flippedStickyBoxRect.location() + skippedContainersOffset;
 
   // The scrollContainerRelativePaddingBoxRect's position is the padding box so
   // we need to remove the border when finding the position of the sticky box
   // within the scroll ancestor if the container is not our scroll ancestor. If
   // 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 elements between themselves and their
+  // containingBlock, and between the containingBlock and their scrollAncestor.
+  //
+  // The respective search ranges are [container, containingBlock) and
+  // [containingBlock, scrollAncestor).
+  constraints.setNearestStickyElementShiftingStickyBox(
+      findFirstStickyBetween(locationContainer, containingBlock));
+  // We cannot use |scrollAncestor| here as it disregards the root
+  // ancestorOverflowLayer(), which we should include.
+  LayoutObject* ancestorOverflowLayer =
+      layer()->ancestorOverflowLayer()->layoutObject();
+  constraints.setNearestStickyElementShiftingContainingBlock(
+      findFirstStickyBetween(containingBlock, ancestorOverflowLayer));
+
   // 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 68 matching lines @@
       -enclosingClippingBox->borderTop() + 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?
-  if (!ancestorOverflowLayer)
+  StickyPositionScrollingConstraints* constraints =
+      stickyConstraintsForLayoutObject(this);
+  if (!constraints)
     return LayoutSize();
-  FloatRect constrainingRect = computeStickyConstrainingRect();
-  PaintLayerScrollableArea* scrollableArea =
-      ancestorOverflowLayer->getScrollableArea();
+
+  StickyPositionScrollingConstraints* toContainingBlockConstraints =
+      stickyConstraintsForLayoutObject(
+          constraints->nearestStickyElementShiftingStickyBox());
+
+  StickyPositionScrollingConstraints* toViewportConstraints =
+      stickyConstraintsForLayoutObject(
+          constraints->nearestStickyElementShiftingContainingBlock());
 
   // 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));
+  FloatRect constrainingRect = computeStickyConstrainingRect();
+  return LayoutSize(constraints->computeStickyOffset(
+      constrainingRect, toContainingBlockConstraints, toViewportConstraints));
 }
 
 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 349 matching lines @@
   if (rootElementStyle->hasBackground())
     return false;
 
   if (node() != document().firstBodyElement())
     return false;
 
   return true;
 }
 
 }  // namespace blink