Handle nested position:sticky elements correctly (compositor)

cc/trees/draw_property_utils.cc

 // Copyright 2014 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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 1482 matching lines @@
                                   elastic_overscroll);
 }
 
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
+gfx::Vector2dF CalculateTotalStickyOffsetToScroller(
+    Layer* layer,
+    int scroll_ancestor_layer_id) {
+  // Find nearest ancestor which is sticky, up to the scroller.

[flackr, 2017/03/09 20:22:08]

Isn't this ancestor part of the constraints passed in?

[smcgruer, 2017/03/10 16:37:10]

|layer| might not be sticky.

[smcgruer, 2017/03/10 16:38:38]

Oh I think I just realized what you meant. We only call this on the parent() of
a sticky layer, so instead we can just pass in the nearest ancestor. I can fix
that.

[smcgruer, 2017/03/14 22:04:06]

Done.

+  while (layer && !layer->sticky_position_constraint().is_sticky) {
+    layer = layer->parent();

[flackr, 2017/03/09 20:22:08]

Can you verify whether this chain is correct in the case of a fixed position
ancestor? (i.e. given sticky > fixed > sticky the internal sticky should not
account for the outer sticky because the fixed is not contained by it).

[smcgruer, 2017/03/14 22:04:05]

No longer relevant, we don't do this walk.

+    if (!layer || layer->id() == scroll_ancestor_layer_id)
+      return gfx::Vector2dF();
+  }
+
+  // Walk all sticky layers from the current layer to the ancestor scroller
+  // layer. We achieve this by walking the |nearest_layer_shifting_sticky_box|
+  // when available (which is the nearest sticky element between us and our
+  // containing block), and |nearest_layer_shifting_containing_block| otherwise
+  // (which is the nearest sticky element between our containing block and the
+  // ancestor scroller).
+  //
+  // Once both of these are null, we have no more sticky ancestors to our scroll
+  // ancestor layer.
+  LayerStickyPositionConstraint constraints =
+      layer->sticky_position_constraint();
+  gfx::Vector2dF sticky_to_remove(constraints.local_sticky_offset);
+  Layer* nextSticky = constraints.nearest_layer_shifting_sticky_box
+                          ? constraints.nearest_layer_shifting_sticky_box
+                          : constraints.nearest_layer_shifting_containing_block;
+  while (nextSticky) {

[flackr, 2017/03/09 20:22:08]

Can we cache the accumulated offset like we do on the blink side so that we can
just grab the total offset from the nearest sticky ancestor?

[smcgruer, 2017/03/14 22:04:06]

No longer relevant, this code is gone.

+    constraints = nextSticky->sticky_position_constraint();
+    sticky_to_remove += constraints.local_sticky_offset;
+    nextSticky = constraints.nearest_layer_shifting_sticky_box
+                     ? constraints.nearest_layer_shifting_sticky_box
+                     : constraints.nearest_layer_shifting_containing_block;
+  }
+  return sticky_to_remove;
+}
+
 }  // namespace draw_property_utils
 
 }  // namespace cc