Handle nested position:sticky elements

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 7030 matching lines @@
   EXPECT_VECTOR2DF_EQ(expected_scroller_screen_space_transform_translation,
                       scroller_impl->ScreenSpaceTransform().To2dTranslation());
 
   gfx::Transform expected_scroll_child_screen_space_transform;
   expected_scroll_child_screen_space_transform.Translate(-5.3f, -9.3f);
   expected_scroll_child_screen_space_transform.RotateAboutYAxis(30);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scroll_child_screen_space_transform,
                                   scroll_child_impl->ScreenSpaceTransform());
 }
 
+TEST_F(LayerTreeHostCommonTest, StickyPositionNested) {
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> container = Layer::Create();
+  scoped_refptr<Layer> scroller = Layer::Create();
+  scoped_refptr<Layer> outer_sticky = Layer::Create();
+  scoped_refptr<Layer> inner_sticky = Layer::Create();
+
+  root->AddChild(container);
+  container->AddChild(scroller);
+  scroller->AddChild(outer_sticky);
+  outer_sticky->AddChild(inner_sticky);
+  host()->SetRootLayer(root);
+  scroller->SetScrollClipLayerId(container->id());
+
+  root->SetBounds(gfx::Size(100, 100));
+  container->SetBounds(gfx::Size(100, 100));
+  scroller->SetBounds(gfx::Size(100, 1000));
+  outer_sticky->SetBounds(gfx::Size(10, 50));
+  outer_sticky->SetPosition(gfx::PointF(0, 50));
+  inner_sticky->SetBounds(gfx::Size(10, 10));
+  inner_sticky->SetPosition(gfx::PointF(0, 0));
+
+  LayerStickyPositionConstraint outer_sticky_pos;
+  outer_sticky_pos.is_sticky = true;
+  outer_sticky_pos.is_anchored_top = true;
+  outer_sticky_pos.top_offset = 10.0f;
+  outer_sticky_pos.parent_relative_sticky_box_offset = gfx::Point(0, 50);
+  outer_sticky_pos.scroll_container_relative_sticky_box_rect =
+      gfx::Rect(0, 50, 50, 50);
+  outer_sticky_pos.scroll_container_relative_containing_block_rect =
+      gfx::Rect(0, 0, 50, 200);
+  outer_sticky->SetStickyPositionConstraint(outer_sticky_pos);
+
+  LayerStickyPositionConstraint inner_sticky_pos;
+  inner_sticky_pos.is_sticky = true;
+  inner_sticky_pos.is_anchored_top = true;
+  inner_sticky_pos.top_offset = 25.0f;
+  inner_sticky_pos.parent_relative_sticky_box_offset = gfx::Point(0, 0);
+  inner_sticky_pos.scroll_container_relative_sticky_box_rect =
+      gfx::Rect(0, 50, 10, 10);
+  inner_sticky_pos.scroll_container_relative_containing_block_rect =
+      gfx::Rect(0, 50, 10, 50);
+  inner_sticky->SetStickyPositionConstraint(inner_sticky_pos);
+
+  ExecuteCalculateDrawProperties(root.get());
+  host()->host_impl()->CreatePendingTree();
+  host()->CommitAndCreatePendingTree();
+  host()->host_impl()->ActivateSyncTree();
+  LayerTreeImpl* layer_tree_impl = host()->host_impl()->active_tree();
+
+  LayerImpl* root_impl = layer_tree_impl->LayerById(root->id());
+  LayerImpl* scroller_impl = layer_tree_impl->LayerById(scroller->id());
+  LayerImpl* outer_sticky_impl = layer_tree_impl->LayerById(outer_sticky->id());
+  LayerImpl* inner_sticky_impl = layer_tree_impl->LayerById(inner_sticky->id());
+
+  ExecuteCalculateDrawProperties(root_impl);
+
+  // Before any scrolling is done, the sticky elements should still be at their
+  // original positions.
+  EXPECT_VECTOR2DF_EQ(
+      gfx::Vector2dF(0.f, 50.f),
+      outer_sticky_impl->ScreenSpaceTransform().To2dTranslation());
+  EXPECT_VECTOR2DF_EQ(
+      gfx::Vector2dF(0.f, 50.f),
+      inner_sticky_impl->ScreenSpaceTransform().To2dTranslation());
+
+  // Scroll less than the sticking point. Both sticky elements should move with
+  // scroll as we haven't gotten to the sticky item locations yet.
+  SetScrollOffsetDelta(scroller_impl, gfx::Vector2dF(0.f, 5.f));
+  ExecuteCalculateDrawProperties(root_impl);
+  EXPECT_VECTOR2DF_EQ(
+      gfx::Vector2dF(0.f, 45.f),
+      outer_sticky_impl->ScreenSpaceTransform().To2dTranslation());
+  EXPECT_VECTOR2DF_EQ(
+      gfx::Vector2dF(0.f, 45.f),
+      inner_sticky_impl->ScreenSpaceTransform().To2dTranslation());
+
+  // Scroll such that the inner sticky should stick, but the outer one should
+  // keep going as it hasnt reached its position yet.
+  SetScrollOffsetDelta(scroller_impl, gfx::Vector2dF(0.f, 30.f));
+  ExecuteCalculateDrawProperties(root_impl);
+  EXPECT_VECTOR2DF_EQ(
+      gfx::Vector2dF(0.f, 20.f),
+      outer_sticky_impl->ScreenSpaceTransform().To2dTranslation());
+  EXPECT_VECTOR2DF_EQ(
+      gfx::Vector2dF(0.f, 25.f),
+      inner_sticky_impl->ScreenSpaceTransform().To2dTranslation());
+
+  // Keep going, both should stick.
+  SetScrollOffsetDelta(scroller_impl, gfx::Vector2dF(0.f, 100.f));
+  ExecuteCalculateDrawProperties(root_impl);
+  EXPECT_VECTOR2DF_EQ(
+      gfx::Vector2dF(0.f, 10.f),
+      outer_sticky_impl->ScreenSpaceTransform().To2dTranslation());
+  // TODO(smcgruer): Fails. I'm not sure why. Value is actually [0,50].

[smcgruer, 2017/02/14 17:02:06]

flackr : Not sure why this fails. I'd expect it to be 0,25, but the test claims
its 0,50. The sticky offset returned from StickyPositionOffset for the inner
sticky also seems to be wrong to my eye, but I'm not yet sure if it means
there's a bug in the code or this test.

[112059:112059:0214/115758.594979:3107795674364:INFO:property_tree.cc(456)]
StickyPositionOffset for node 4: returning [0.000000 90.000000] - [0.000000
0.000000] - [0.000000 0.000000] - [0 50] = [0.000000 40.000000]

+  EXPECT_VECTOR2DF_EQ(
+      gfx::Vector2dF(0.f, 25.f),
+      inner_sticky_impl->ScreenSpaceTransform().To2dTranslation());
+}
+
 TEST_F(LayerTreeHostCommonTest, StickyPositionTop) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> container = Layer::Create();
   scoped_refptr<Layer> scroller = Layer::Create();
   scoped_refptr<Layer> sticky_pos = Layer::Create();
   root->AddChild(container);
   container->AddChild(scroller);
   scroller->AddChild(sticky_pos);
   host()->SetRootLayer(root);
   scroller->SetScrollClipLayerId(container->id());
@@ skipping 667 matching lines @@
   root_impl = layer_tree_impl->LayerById(root->id());
   scroller_impl = layer_tree_impl->LayerById(scroller->id());
   sticky_pos_impl = layer_tree_impl->LayerById(sticky_pos->id());
 
   // The element should still be where it was before. We reset the delta to
   // (0, 0) because we have synced a scroll offset of (0, 25) from the main
   // thread.
   SetScrollOffsetDelta(scroller_impl, gfx::Vector2dF(0.f, 0.f));
   ExecuteCalculateDrawProperties(root_impl);
   EXPECT_VECTOR2DF_EQ(
-      gfx::Vector2dF(20.f, 10.f),
+      gfx::Vector2dF(20.f, -15.f),

[smcgruer, 2017/02/14 17:02:06]

flackr : These changes are also suspicious. I just copied test output to input
to make them pass, but we need to figure out why this would be correct (or if it
isnt).

       sticky_pos_impl->ScreenSpaceTransform().To2dTranslation());
 
   // And if we scroll a little further it remains there.
   SetScrollOffsetDelta(scroller_impl, gfx::Vector2dF(0.f, 5.f));
   ExecuteCalculateDrawProperties(root_impl);
   EXPECT_VECTOR2DF_EQ(
-      gfx::Vector2dF(20.f, 10.f),
+      gfx::Vector2dF(20.f, -15.f),
       sticky_pos_impl->ScreenSpaceTransform().To2dTranslation());
 
   // And hits the bottom of the container.
   SetScrollOffsetDelta(scroller_impl, gfx::Vector2dF(0.f, 10.f));
   ExecuteCalculateDrawProperties(root_impl);
   EXPECT_VECTOR2DF_EQ(
-      gfx::Vector2dF(20.f, 5.f),
+      gfx::Vector2dF(20.f, -20.f),
       sticky_pos_impl->ScreenSpaceTransform().To2dTranslation());
 }
 
 // A transform on a sticky element should not affect its sticky position.
 TEST_F(LayerTreeHostCommonTest, StickyPositionScaledStickyBox) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> container = Layer::Create();
   scoped_refptr<Layer> scroller = Layer::Create();
   scoped_refptr<Layer> sticky_pos = Layer::Create();
   root->AddChild(container);
@@ skipping 2989 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc