Handle nested position:sticky elements correctly (compositor)

cc/trees/property_tree.h

 // 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.
 
 #ifndef CC_TREES_PROPERTY_TREE_H_
 #define CC_TREES_PROPERTY_TREE_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 86 matching lines @@
 
   void AsValueInto(base::trace_event::TracedValue* value) const;
 
  private:
   std::vector<T> nodes_;
 
   bool needs_update_;
   PropertyTrees* property_trees_;
 };
 
-struct StickyPositionNodeData {
-  int scroll_ancestor;
-  LayerStickyPositionConstraint constraints;
-
-  // This is the offset that blink has already applied to counteract the main
-  // thread scroll offset of the scroll ancestor. We need to account for this
-  // by computing the additional offset necessary to keep the element stuck.
-  gfx::Vector2dF main_thread_offset;
-
-  StickyPositionNodeData() : scroll_ancestor(-1) {}
-};
+struct StickyPositionNodeData;
 
 class CC_EXPORT TransformTree final : public PropertyTree<TransformNode> {
  public:
   TransformTree();
 
   // These C++ special member functions cannot be implicit inline because
   // they are exported by CC_EXPORT. They will be instantiated in every
   // compilation units that included this header, and compilation can fail
   // because TransformCachedNodeData may be incomplete.
   TransformTree(const TransformTree&) = delete;
@@ skipping 142 matching lines @@
   // scale factor of device transform. So we need to store them explicitly.
   float page_scale_factor_;
   float device_scale_factor_;
   float device_transform_scale_factor_;
   std::vector<int> nodes_affected_by_inner_viewport_bounds_delta_;
   std::vector<int> nodes_affected_by_outer_viewport_bounds_delta_;
   std::vector<TransformCachedNodeData> cached_data_;
   std::vector<StickyPositionNodeData> sticky_position_data_;
 };
 
+struct StickyPositionNodeData {
+  int scroll_ancestor;
+  LayerStickyPositionConstraint constraints;
+
+  // This is the offset that blink has already applied to counteract the main
+  // thread scroll offset of the scroll ancestor. We need to account for this
+  // by computing the additional offset necessary to keep the element stuck.
+  gfx::Vector2dF main_thread_offset;
+
+  // In order to properly compute the sticky offset, we need to know if we have
+  // any sticky ancestors both between ourselves and our containing block and
+  // between our containing block and the viewport. These ancestors are then
+  // used to correct the constraining rect locations.
+  int nearest_node_shifting_sticky_box;
+  int nearest_node_shifting_containing_block;
+
+  // For performance we cache our accumulated sticky offset to allow descendant
+  // sticky elements to offset their constraint rects. Because we can either
+  // affect the sticky box constraint rect or the containing block constraint
+  // rect, we need to accumulate both.
+  gfx::Vector2dF total_sticky_box_sticky_offset;
+  gfx::Vector2dF total_containing_block_sticky_offset;
+
+  StickyPositionNodeData()
+      : scroll_ancestor(TransformTree::kInvalidNodeId),
+        nearest_node_shifting_sticky_box(TransformTree::kInvalidNodeId),
+        nearest_node_shifting_containing_block(TransformTree::kInvalidNodeId) {}
+};
+
 class CC_EXPORT ClipTree final : public PropertyTree<ClipNode> {
  public:
   bool operator==(const ClipTree& other) const;
 
   static const int kViewportNodeId = 1;
 
   void SetViewportClip(gfx::RectF viewport_rect);
   gfx::RectF ViewportClip() const;
 };
 
@@ skipping 372 matching lines @@
   DrawTransforms& GetDrawTransforms(int transform_id, int effect_id) const;
   DrawTransformData& FetchDrawTransformsDataFromCache(int transform_id,
                                                       int effect_id) const;
 
   PropertyTreesCachedData cached_data_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_