Only create sticky position constraints for constrained sticky position.

third_party/WebKit/Source/core/layout/LayoutBoxModelObjectTest.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/layout/LayoutBoxModelObject.h"
 
 #include "core/dom/DOMTokenList.h"
 #include "core/dom/DocumentLifecycle.h"
 #include "core/html/HTMLElement.h"
 #include "core/layout/ImageQualityController.h"
@@ skipping 321 matching lines @@
 // computing the sticky constraints. Any such ancestor is the first sticky
 // element between you and your containing block (exclusive).
 //
 // In most cases, this pointer should be null since your parent is normally your
 // containing block. However there are cases where this is not true, including
 // inline blocks and tables. The latter is currently irrelevant since only table
 // cells can be sticky in CSS2.1, but we can test the former.
 TEST_F(LayoutBoxModelObjectTest,
        StickyPositionFindsCorrectStickyBoxShiftingAncestor) {
   setBodyInnerHTML(
-      "<style>#stickyOuterDiv { position: sticky; }"
-      "#stickyOuterInline { position: sticky; display: inline; }"
-      "#stickyInnerInline { position: sticky; display: inline; }</style>"
-      "<div id='stickyOuterDiv'><div id='stickyOuterInline'>"
-      "<div id='stickyInnerInline'></div></div></div>");
+      "<style>#stickyOuterDiv { position: sticky; top: 0;}"
+      "#stickyOuterInline { position: sticky; top: 0; display: inline; }"
+      "#unanchoredSticky { position: sticky; display: inline; }"
+      "#stickyInnerInline { position: sticky; top: 0; display: inline; "
+      "}</style>"
+      "<div id='stickyOuterDiv'>"
+      "  <div id='stickyOuterInline'>"
+      "    <div id='unanchoredSticky'>"
+      "      <div id='stickyInnerInline'></div>"
+      "    </div>"
+      "  </div>"
+      "</div>");
 
   LayoutBoxModelObject* stickyOuterDiv =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyOuterDiv"));
   LayoutBoxModelObject* stickyOuterInline =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyOuterInline"));
   LayoutBoxModelObject* stickyInnerInline =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyInnerInline"));
 
   PaintLayerScrollableArea* scrollableArea =
       stickyOuterDiv->layer()->ancestorOverflowLayer()->getScrollableArea();
   ASSERT_TRUE(scrollableArea);
   StickyConstraintsMap constraintsMap = scrollableArea->stickyConstraintsMap();
 
   ASSERT_TRUE(constraintsMap.contains(stickyOuterDiv->layer()));
   ASSERT_TRUE(constraintsMap.contains(stickyOuterInline->layer()));
   ASSERT_TRUE(constraintsMap.contains(stickyInnerInline->layer()));

[chrishtr, 2017/03/27 16:28:07]

ASSERT_FALSE for unanchoredSticky?

[flackr, 2017/04/07 18:15:45]

Done.

 
   // The outer block element trivially has no sticky-box shifting ancestor.
   EXPECT_FALSE(constraintsMap.at(stickyOuterDiv->layer())
                    .nearestStickyBoxShiftingStickyBox());
 
   // Neither does the outer inline element, as its parent element is also its
   // containing block.
   EXPECT_FALSE(constraintsMap.at(stickyOuterInline->layer())
                    .nearestStickyBoxShiftingStickyBox());
 
   // However the inner inline element does have a sticky-box shifting ancestor,
   // as its containing block is the ancestor block element, not its parent.
   EXPECT_EQ(stickyOuterInline,
             constraintsMap.at(stickyInnerInline->layer())
                 .nearestStickyBoxShiftingStickyBox());
 }
 
 // Verifies that the correct containing-block shifting ancestor is found when
 // computing the sticky constraints. Any such ancestor is the first sticky
 // element between your containing block (inclusive) and your ancestor overflow
 // layer (exclusive).
 TEST_F(LayoutBoxModelObjectTest,
        StickyPositionFindsCorrectContainingBlockShiftingAncestor) {
   // We make the scroller itself sticky in order to check that elements do not
   // detect it as their containing-block shifting ancestor.
   setBodyInnerHTML(
-      "<style>#scroller { overflow-y: scroll; position: sticky; }"
-      "#stickyParent { position: sticky; }"
-      "#stickyChild { position: sticky; }"
-      "#stickyNestedChild { position: sticky; }</style>"
-      "<div id='scroller'><div id='stickyParent'><div id='stickyChild'></div>"
-      "<div><div id='stickyNestedChild'></div></div></div></div>");
+      "<style>#scroller { overflow-y: scroll; position: sticky; top: 0;}"
+      "#stickyParent { position: sticky; top: 0;}"
+      "#stickyChild { position: sticky; top: 0;}"
+      "#unanchoredSticky { position: sticky; }"
+      "#stickyNestedChild { position: sticky; top: 0;}</style>"
+      "<div id='scroller'>"
+      "  <div id='stickyParent'>"
+      "    <div id='unanchoredSticky'>"
+      "      <div id='stickyChild'></div>"
+      "      <div><div id='stickyNestedChild'></div></div>"
+      "    </div>"
+      "  </div>"
+      "</div>");
 
   LayoutBoxModelObject* scroller =
       toLayoutBoxModelObject(getLayoutObjectByElementId("scroller"));
   LayoutBoxModelObject* stickyParent =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyParent"));
   LayoutBoxModelObject* stickyChild =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyChild"));
   LayoutBoxModelObject* stickyNestedChild =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyNestedChild"));
 
   PaintLayerScrollableArea* scrollableArea =
       scroller->layer()->getScrollableArea();
   ASSERT_TRUE(scrollableArea);
   StickyConstraintsMap constraintsMap = scrollableArea->stickyConstraintsMap();
 
   ASSERT_FALSE(constraintsMap.contains(scroller->layer()));
   ASSERT_TRUE(constraintsMap.contains(stickyParent->layer()));
   ASSERT_TRUE(constraintsMap.contains(stickyChild->layer()));
   ASSERT_TRUE(constraintsMap.contains(stickyNestedChild->layer()));
 
   // The outer <div> should not detect the scroller as its containing-block
   // shifting ancestor.
   EXPECT_FALSE(constraintsMap.at(stickyParent->layer())
                    .nearestStickyBoxShiftingContainingBlock());
 
   // Both inner children should detect the parent <div> as their
-  // containing-block shifting ancestor.
+  // containing-block shifting ancestor. They skip past unanchored sticky
+  // because it will never have a non-zero offset.
   EXPECT_EQ(stickyParent,
             constraintsMap.at(stickyChild->layer())
                 .nearestStickyBoxShiftingContainingBlock());
   EXPECT_EQ(stickyParent,
             constraintsMap.at(stickyNestedChild->layer())
                 .nearestStickyBoxShiftingContainingBlock());
 }
 
 // Verifies that the correct containing-block shifting ancestor is found when
 // computing the sticky constraints, in the case where the overflow ancestor is
 // the page itself. This is a special-case version of the test above, as we
 // often treat the root page as special when it comes to scroll logic. It should
 // not make a difference for containing-block shifting ancestor calculations.
 TEST_F(LayoutBoxModelObjectTest,
        StickyPositionFindsCorrectContainingBlockShiftingAncestorRoot) {
   setBodyInnerHTML(
-      "<style>#stickyParent { position: sticky; }"
-      "#stickyGrandchild { position: sticky; }</style>"
+      "<style>#stickyParent { position: sticky; top: 0;}"
+      "#stickyGrandchild { position: sticky; top: 0;}</style>"
       "<div id='stickyParent'><div><div id='stickyGrandchild'></div></div>"
       "</div>");
 
   LayoutBoxModelObject* stickyParent =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyParent"));
   LayoutBoxModelObject* stickyGrandchild =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyGrandchild"));
 
   PaintLayerScrollableArea* scrollableArea =
       stickyParent->layer()->ancestorOverflowLayer()->getScrollableArea();
@@ skipping 11 matching lines @@
 }
 
 // Verifies that the correct containing-block shifting ancestor is found when
 // computing the sticky constraints, in the case of tables. Tables are unusual
 // because the containing block for all table elements is the <table> itself, so
 // we have to skip over elements to find the correct ancestor.
 TEST_F(LayoutBoxModelObjectTest,
        StickyPositionFindsCorrectContainingBlockShiftingAncestorTable) {
   setBodyInnerHTML(
       "<style>#scroller { overflow-y: scroll; }"
-      "#stickyOuter { position: sticky; }"
-      "#stickyTh { position: sticky; }</style>"
+      "#stickyOuter { position: sticky; top: 0;}"
+      "#stickyTh { position: sticky; top: 0;}</style>"
       "<div id='scroller'><div id='stickyOuter'><table><thead><tr>"
       "<th id='stickyTh'></th></tr></thead></table></div></div>");
 
   LayoutBoxModelObject* scroller =
       toLayoutBoxModelObject(getLayoutObjectByElementId("scroller"));
   LayoutBoxModelObject* stickyOuter =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyOuter"));
   LayoutBoxModelObject* stickyTh =
       toLayoutBoxModelObject(getLayoutObjectByElementId("stickyTh"));
 
@@ skipping 353 matching lines @@
   EXPECT_EQ(LayoutSize(0, 25), innerStickyTh->stickyPositionOffset());
 }
 
 // Verifies that the calculated position:sticky offsets are correct in the case
 // of nested inline elements.
 TEST_F(LayoutBoxModelObjectTest, StickyPositionNestedInlineElements) {
   setBodyInnerHTML(
       "<style>#scroller { width: 100px; height: 100px; overflow-y: scroll; }"
       "#paddingBefore { height: 50px; }"
       "#outerInline { display: inline; position: sticky; top: 0; }"
+      "#unanchoredSticky { position: sticky; display: inline; }"
       "#innerInline { display: inline; position: sticky; top: 25px; }"
       "#paddingAfter { height: 200px; }</style>"
-      "<div id='scroller'><div id='paddingBefore'></div><div id='outerInline'>"
-      "<div id='innerInline'></div></div><div id='paddingAfter'></div></div>");
+      "<div id='scroller'>"
+      "  <div id='paddingBefore'></div>"
+      "  <div id='outerInline'>"
+      "    <div id='unanchoredSticky'>"
+      "      <div id='innerInline'></div>"
+      "    </div>"
+      "  </div>"
+      "  <div id='paddingAfter'></div>"
+      "</div>");
 
   LayoutBoxModelObject* outerInline =
       toLayoutBoxModelObject(getLayoutObjectByElementId("outerInline"));
   LayoutBoxModelObject* innerInline =
       toLayoutBoxModelObject(getLayoutObjectByElementId("innerInline"));
 
   // Scroll the page down.
   LayoutBoxModelObject* scroller =
       toLayoutBoxModelObject(getLayoutObjectByElementId("scroller"));
   PaintLayerScrollableArea* scrollableArea = scroller->getScrollableArea();
@@ skipping 45 matching lines @@
 
   // TODO(smcgruer): Until http://crbug.com/686164 is fixed, we need to update
   // the constraints here before calculations will be correct.
   innerSticky->updateStickyPositionConstraints();
 
   EXPECT_EQ(LayoutSize(0, 100), outerSticky->stickyPositionOffset());
   EXPECT_EQ(LayoutSize(0, 25), innerSticky->stickyPositionOffset());
 }
 
 }  // namespace blink