Handle nested position:sticky elements correctly (main thread)

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

[flackr, 2017/02/24 01:33:33]

Maybe we should pass ancestorOverflowLayer in since it must be the same for all
of the passed in layout objects and it will save us doing this lookup and early
exit check.

[smcgruer, 2017/02/24 14:17:43]

Done, although we still need to null-check |o| as the code is designed to act
sensibly when you have no nearestStickyBoxShifting{StickyBox,ContainingBlock}.

+    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;
+}
+
+// Inclusive of |from|, exclusive of |to|.
+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;
+}
+}  // 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 105 matching lines @@
 
 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());
+
   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.setNearestStickyBoxShiftingStickyBox(
+      findFirstStickyBetween(locationContainer, containingBlock));
+  // We cannot use |scrollAncestor| here as it disregards the root
+  // ancestorOverflowLayer(), which we should include.
+  constraints.setNearestStickyBoxShiftingContainingBlock(findFirstStickyBetween(
+      containingBlock, &layer()->ancestorOverflowLayer()->layoutObject()));
+
   // 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 69 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* shiftingStickyBoxConstraints =
+      stickyConstraintsForLayoutObject(
+          constraints->nearestStickyBoxShiftingStickyBox());
+
+  StickyPositionScrollingConstraints* shiftingContainingBlockConstraints =
+      stickyConstraintsForLayoutObject(
+          constraints->nearestStickyBoxShiftingContainingBlock());
 
   // 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, shiftingStickyBoxConstraints,
+      shiftingContainingBlockConstraints));
 }
 
 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