Handle nested position:sticky elements

third_party/WebKit/Source/core/page/scrolling/StickyPositionScrollingConstraints.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/page/scrolling/StickyPositionScrollingConstraints.h"
 
 namespace blink {
 
 FloatSize StickyPositionScrollingConstraints::computeStickyOffset(
-    const FloatRect& viewportRect) const {
-  FloatRect boxRect = m_scrollContainerRelativeStickyBoxRect;
+    const FloatRect& viewportRect,
+    const FloatSize& accumulatedToCB,
+    const FloatSize& accumulatedToVP) {
+  // TODO(smcgruer): Explain what this is doing.
+  // TODO(smcgruer): Determine which we need to move for what (fairly sure
+  // moving both by both is incorrect, but currently done because I don't

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

I think the stickyBoxRect does need to be moved by both because both offsets
come from ancestors, but the containing block rect should only be moved by the
ToVP offset.

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

Done.

+  // accumulate properly.)
+  FloatRect stickyBoxRect = m_scrollContainerRelativeStickyBoxRect;
+  FloatRect containingBlockRect = m_scrollContainerRelativeContainingBlockRect;
+  stickyBoxRect.move(accumulatedToCB);
+  stickyBoxRect.move(accumulatedToVP);
+  containingBlockRect.move(accumulatedToCB);

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

The containing block rect should only be moved by the accumulatedToVP, the
accumulatedToCB should be from a descendant node (i.e. not affect the containing
block).

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

Done.

+  containingBlockRect.move(accumulatedToVP);
+
+  FloatRect boxRect = stickyBoxRect;
 
   if (hasAnchorEdge(AnchorEdgeRight)) {
     float rightLimit = viewportRect.maxX() - m_rightOffset;
-    float rightDelta = std::min<float>(
-        0, rightLimit - m_scrollContainerRelativeStickyBoxRect.maxX());
+    float rightDelta = std::min<float>(0, rightLimit - stickyBoxRect.maxX());
     float availableSpace =
-        std::min<float>(0, m_scrollContainerRelativeContainingBlockRect.x() -
-                               m_scrollContainerRelativeStickyBoxRect.x());
+        std::min<float>(0, containingBlockRect.x() - stickyBoxRect.x());
     if (rightDelta < availableSpace)
       rightDelta = availableSpace;
 
     boxRect.move(rightDelta, 0);
   }
 
   if (hasAnchorEdge(AnchorEdgeLeft)) {
     float leftLimit = viewportRect.x() + m_leftOffset;
-    float leftDelta = std::max<float>(
-        0, leftLimit - m_scrollContainerRelativeStickyBoxRect.x());
+    float leftDelta = std::max<float>(0, leftLimit - stickyBoxRect.x());
     float availableSpace =
-        std::max<float>(0, m_scrollContainerRelativeContainingBlockRect.maxX() -
-                               m_scrollContainerRelativeStickyBoxRect.maxX());
+        std::max<float>(0, containingBlockRect.maxX() - stickyBoxRect.maxX());
     if (leftDelta > availableSpace)
       leftDelta = availableSpace;
 
     boxRect.move(leftDelta, 0);
   }
 
   if (hasAnchorEdge(AnchorEdgeBottom)) {
     float bottomLimit = viewportRect.maxY() - m_bottomOffset;
-    float bottomDelta = std::min<float>(
-        0, bottomLimit - m_scrollContainerRelativeStickyBoxRect.maxY());
+    float bottomDelta = std::min<float>(0, bottomLimit - stickyBoxRect.maxY());
     float availableSpace =
-        std::min<float>(0, m_scrollContainerRelativeContainingBlockRect.y() -
-                               m_scrollContainerRelativeStickyBoxRect.y());
+        std::min<float>(0, containingBlockRect.y() - stickyBoxRect.y());
     if (bottomDelta < availableSpace)
       bottomDelta = availableSpace;
 
     boxRect.move(0, bottomDelta);
   }
 
   if (hasAnchorEdge(AnchorEdgeTop)) {
     float topLimit = viewportRect.y() + m_topOffset;
-    float topDelta = std::max<float>(
-        0, topLimit - m_scrollContainerRelativeStickyBoxRect.y());
+    float topDelta = std::max<float>(0, topLimit - stickyBoxRect.y());
     float availableSpace =
-        std::max<float>(0, m_scrollContainerRelativeContainingBlockRect.maxY() -
-                               m_scrollContainerRelativeStickyBoxRect.maxY());
+        std::max<float>(0, containingBlockRect.maxY() - stickyBoxRect.maxY());
+
     if (topDelta > availableSpace)
       topDelta = availableSpace;
 
     boxRect.move(0, topDelta);
   }
 
-  return boxRect.location() - m_scrollContainerRelativeStickyBoxRect.location();
+  FloatSize stickyOffset = boxRect.location() - stickyBoxRect.location();
+
+  // TODO(smcgruer): Determine what exactly we need to accumulate.
+  m_cachedAccumulatedStickyOffset.setWidth(stickyOffset.width());
+  m_cachedAccumulatedStickyOffset.setHeight(stickyOffset.height());

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

I think we need to add the ToCB and ToVP offsets here, since any descendants
which rely on this offset need to know about the ancestor offsets as well.

+
+  return stickyOffset;
 }
 
 }  // namespace blink