Slightly refactor StickyPositionScrollingConstraints API and add documentation

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/LayoutTestHelper.h"
 #include "core/page/scrolling/StickyPositionScrollingConstraints.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 class LayoutBoxModelObjectTest : public RenderingTest {
  protected:
+  PaintLayer* GetPaintLayerByElementId(const char* id) {
+    return ToLayoutBoxModelObject(GetLayoutObjectByElementId(id))->Layer();
+  }
+
   const FloatRect& GetScrollContainerRelativeContainingBlockRect(
       const StickyPositionScrollingConstraints& constraints) const {
     return constraints.ScrollContainerRelativeContainingBlockRect();
   }
 
   const FloatRect& GetScrollContainerRelativeStickyBoxRect(
       const StickyPositionScrollingConstraints& constraints) const {
     return constraints.ScrollContainerRelativeStickyBoxRect();
   }
 };
@@ skipping 318 matching lines @@
       "<div id='stickyOuterDiv'>"
       "  <div id='stickyOuterInline'>"
       "   <div id='unanchoredSticky'>"
       "      <div class='inline'>"
       "        <div id='stickyInnerInline'></div>"
       "      </div>"
       "    </div>"
       "  </div>"
       "</div>");
 
-  LayoutBoxModelObject* sticky_outer_div =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyOuterDiv"));
-  LayoutBoxModelObject* sticky_outer_inline =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyOuterInline"));
-  LayoutBoxModelObject* unanchored_sticky =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("unanchoredSticky"));
-  LayoutBoxModelObject* sticky_inner_inline =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyInnerInline"));
+  PaintLayer* sticky_outer_div = GetPaintLayerByElementId("stickyOuterDiv");
+  PaintLayer* sticky_outer_inline =
+      GetPaintLayerByElementId("stickyOuterInline");
+  PaintLayer* unanchored_sticky = GetPaintLayerByElementId("unanchoredSticky");
+  PaintLayer* sticky_inner_inline =
+      GetPaintLayerByElementId("stickyInnerInline");
 
   PaintLayerScrollableArea* scrollable_area =
-      sticky_outer_div->Layer()->AncestorOverflowLayer()->GetScrollableArea();
+      sticky_outer_div->AncestorOverflowLayer()->GetScrollableArea();
   ASSERT_TRUE(scrollable_area);
   StickyConstraintsMap constraints_map =
       scrollable_area->GetStickyConstraintsMap();
 
-  ASSERT_TRUE(constraints_map.Contains(sticky_outer_div->Layer()));
-  ASSERT_TRUE(constraints_map.Contains(sticky_outer_inline->Layer()));
-  ASSERT_FALSE(constraints_map.Contains(unanchored_sticky->Layer()));
-  ASSERT_TRUE(constraints_map.Contains(sticky_inner_inline->Layer()));
+  ASSERT_TRUE(constraints_map.Contains(sticky_outer_div));
+  ASSERT_TRUE(constraints_map.Contains(sticky_outer_inline));
+  ASSERT_FALSE(constraints_map.Contains(unanchored_sticky));
+  ASSERT_TRUE(constraints_map.Contains(sticky_inner_inline));
 
   // The outer block element trivially has no sticky-box shifting ancestor.
-  EXPECT_FALSE(constraints_map.at(sticky_outer_div->Layer())
-                   .NearestStickyBoxShiftingStickyBox());
+  EXPECT_FALSE(constraints_map.at(sticky_outer_div)
+                   .NearestStickyLayerShiftingStickyBox());
 
   // Neither does the outer inline element, as its parent element is also its
   // containing block.
-  EXPECT_FALSE(constraints_map.at(sticky_outer_inline->Layer())
-                   .NearestStickyBoxShiftingStickyBox());
+  EXPECT_FALSE(constraints_map.at(sticky_outer_inline)
+                   .NearestStickyLayerShiftingStickyBox());
 
   // However the inner inline element does have a sticky-box shifting ancestor,
   // as its containing block is the ancestor block element, above its ancestor
   // sticky element.
-  EXPECT_EQ(sticky_outer_inline,
-            constraints_map.at(sticky_inner_inline->Layer())
-                .NearestStickyBoxShiftingStickyBox());
+  EXPECT_EQ(sticky_outer_inline, constraints_map.at(sticky_inner_inline)
+                                     .NearestStickyLayerShiftingStickyBox());
 }
 
 // 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; 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* sticky_parent =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyParent"));
-  LayoutBoxModelObject* sticky_child =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyChild"));
-  LayoutBoxModelObject* sticky_nested_child =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyNestedChild"));
+  PaintLayer* scroller = GetPaintLayerByElementId("scroller");
+  PaintLayer* sticky_parent = GetPaintLayerByElementId("stickyParent");
+  PaintLayer* sticky_child = GetPaintLayerByElementId("stickyChild");
+  PaintLayer* sticky_nested_child =
+      GetPaintLayerByElementId("stickyNestedChild");
 
-  PaintLayerScrollableArea* scrollable_area =
-      scroller->Layer()->GetScrollableArea();
+  PaintLayerScrollableArea* scrollable_area = scroller->GetScrollableArea();
   ASSERT_TRUE(scrollable_area);
   StickyConstraintsMap constraints_map =
       scrollable_area->GetStickyConstraintsMap();
 
-  ASSERT_FALSE(constraints_map.Contains(scroller->Layer()));
-  ASSERT_TRUE(constraints_map.Contains(sticky_parent->Layer()));
-  ASSERT_TRUE(constraints_map.Contains(sticky_child->Layer()));
-  ASSERT_TRUE(constraints_map.Contains(sticky_nested_child->Layer()));
+  ASSERT_FALSE(constraints_map.Contains(scroller));
+  ASSERT_TRUE(constraints_map.Contains(sticky_parent));
+  ASSERT_TRUE(constraints_map.Contains(sticky_child));
+  ASSERT_TRUE(constraints_map.Contains(sticky_nested_child));
 
   // The outer <div> should not detect the scroller as its containing-block
   // shifting ancestor.
-  EXPECT_FALSE(constraints_map.at(sticky_parent->Layer())
-                   .NearestStickyBoxShiftingContainingBlock());
+  EXPECT_FALSE(constraints_map.at(sticky_parent)
+                   .NearestStickyLayerShiftingContainingBlock());
 
   // Both inner children should detect the parent <div> as their
   // containing-block shifting ancestor. They skip past unanchored sticky
   // because it will never have a non-zero offset.
-  EXPECT_EQ(sticky_parent, constraints_map.at(sticky_child->Layer())
-                               .NearestStickyBoxShiftingContainingBlock());
-  EXPECT_EQ(sticky_parent, constraints_map.at(sticky_nested_child->Layer())
-                               .NearestStickyBoxShiftingContainingBlock());
+  EXPECT_EQ(sticky_parent, constraints_map.at(sticky_child)
+                               .NearestStickyLayerShiftingContainingBlock());
+  EXPECT_EQ(sticky_parent, constraints_map.at(sticky_nested_child)
+                               .NearestStickyLayerShiftingContainingBlock());
 }
 
 // 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; top: 0;}"
       "#stickyGrandchild { position: sticky; top: 0;}</style>"
       "<div id='stickyParent'><div><div id='stickyGrandchild'></div></div>"
       "</div>");
 
-  LayoutBoxModelObject* sticky_parent =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyParent"));
-  LayoutBoxModelObject* sticky_grandchild =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyGrandchild"));
+  PaintLayer* sticky_parent = GetPaintLayerByElementId("stickyParent");
+  PaintLayer* sticky_grandchild = GetPaintLayerByElementId("stickyGrandchild");
 
   PaintLayerScrollableArea* scrollable_area =
-      sticky_parent->Layer()->AncestorOverflowLayer()->GetScrollableArea();
+      sticky_parent->AncestorOverflowLayer()->GetScrollableArea();
   ASSERT_TRUE(scrollable_area);
   StickyConstraintsMap constraints_map =
       scrollable_area->GetStickyConstraintsMap();
 
-  ASSERT_TRUE(constraints_map.Contains(sticky_parent->Layer()));
-  ASSERT_TRUE(constraints_map.Contains(sticky_grandchild->Layer()));
+  ASSERT_TRUE(constraints_map.Contains(sticky_parent));
+  ASSERT_TRUE(constraints_map.Contains(sticky_grandchild));
 
   // The grandchild sticky should detect the parent as its containing-block
   // shifting ancestor.
-  EXPECT_EQ(sticky_parent, constraints_map.at(sticky_grandchild->Layer())
-                               .NearestStickyBoxShiftingContainingBlock());
+  EXPECT_EQ(sticky_parent, constraints_map.at(sticky_grandchild)
+                               .NearestStickyLayerShiftingContainingBlock());
 }
 
 // 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; 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* sticky_outer =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyOuter"));
-  LayoutBoxModelObject* sticky_th =
-      ToLayoutBoxModelObject(GetLayoutObjectByElementId("stickyTh"));
+  PaintLayer* scroller = GetPaintLayerByElementId("scroller");
+  PaintLayer* sticky_outer = GetPaintLayerByElementId("stickyOuter");
+  PaintLayer* sticky_th = GetPaintLayerByElementId("stickyTh");
 
-  PaintLayerScrollableArea* scrollable_area =
-      scroller->Layer()->GetScrollableArea();
+  PaintLayerScrollableArea* scrollable_area = scroller->GetScrollableArea();
   ASSERT_TRUE(scrollable_area);
   StickyConstraintsMap constraints_map =
       scrollable_area->GetStickyConstraintsMap();
 
-  ASSERT_FALSE(constraints_map.Contains(scroller->Layer()));
-  ASSERT_TRUE(constraints_map.Contains(sticky_outer->Layer()));
-  ASSERT_TRUE(constraints_map.Contains(sticky_th->Layer()));
+  ASSERT_FALSE(constraints_map.Contains(scroller));
+  ASSERT_TRUE(constraints_map.Contains(sticky_outer));
+  ASSERT_TRUE(constraints_map.Contains(sticky_th));
 
   // The table cell should detect the outer <div> as its containing-block
   // shifting ancestor.
-  EXPECT_EQ(sticky_outer, constraints_map.at(sticky_th->Layer())
-                              .NearestStickyBoxShiftingContainingBlock());
+  EXPECT_EQ(sticky_outer, constraints_map.at(sticky_th)
+                              .NearestStickyLayerShiftingContainingBlock());
 }
 
 // Verifies that the calculated position:sticky offsets are correct when we have
 // a simple case of nested sticky elements.
 TEST_F(LayoutBoxModelObjectTest, StickyPositionNested) {
   SetBodyInnerHTML(
       "<style>#scroller { height: 100px; width: 100px; overflow-y: auto; }"
       "#prePadding { height: 50px }"
       "#stickyParent { position: sticky; top: 0; height: 50px; }"
       "#stickyChild { position: sticky; top: 0; height: 25px; }"
@@ skipping 392 matching lines @@
       ToLayoutBoxModelObject(GetLayoutObjectByElementId("scroller"));
   PaintLayerScrollableArea* scrollable_area = scroller->GetScrollableArea();
 
   StickyConstraintsMap constraints_map =
       scrollable_area->GetStickyConstraintsMap();
   ASSERT_TRUE(constraints_map.Contains(outer_sticky->Layer()));
   ASSERT_TRUE(constraints_map.Contains(inner_sticky->Layer()));
 
   // The inner sticky should not detect the outer one as any sort of ancestor.
   EXPECT_FALSE(constraints_map.at(inner_sticky->Layer())
-                   .NearestStickyBoxShiftingStickyBox());
+                   .NearestStickyLayerShiftingStickyBox());
   EXPECT_FALSE(constraints_map.at(inner_sticky->Layer())
-                   .NearestStickyBoxShiftingContainingBlock());
+                   .NearestStickyLayerShiftingContainingBlock());
 
   // Scroll the page down.
   scrollable_area->ScrollToAbsolutePosition(
       FloatPoint(scrollable_area->ScrollPosition().X(), 100));
   ASSERT_EQ(100.0, scrollable_area->ScrollPosition().Y());
 
   // TODO(smcgruer): Until http://crbug.com/686164 is fixed, we need to update
   // the constraints here before calculations will be correct.
   inner_sticky->UpdateStickyPositionConstraints();
 
   EXPECT_EQ(LayoutSize(0, 100), outer_sticky->StickyPositionOffset());
   EXPECT_EQ(LayoutSize(0, 25), inner_sticky->StickyPositionOffset());
 }
 
 TEST_F(LayoutBoxModelObjectTest, NoCrashStackingContextChangeNonRooted) {
   SetBodyInnerHTML("<div id='target'></div>");
   auto& object = *GetLayoutObjectByElementId("target");
   auto* parent = object.Parent();
   object.SetDangerousOneWayParent(nullptr);
   EXPECT_FALSE(object.IsRooted());
 
   auto style = ComputedStyle::Create();
   style->SetIsStackingContext(true);
   object.SetStyle(style);  // This should not crash.
   object.SetDangerousOneWayParent(parent);
 }
 
 }  // namespace blink