Implement position: sticky updates on 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>
 #include <unordered_map>
 #include <vector>
 
 #include "cc/animation/element_id.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/synced_property.h"
+#include "cc/layers/layer_sticky_position_constraint.h"
 #include "cc/output/filter_operations.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/transform.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace cc {
 
 namespace proto {
 class PropertyTree;
 class PropertyTrees;
 class ScrollNodeData;
+class StickyPositionNodeData;
 class TreeNode;
 }  // namespace proto
 
 class CopyOutputRequest;
 class LayerTreeImpl;
 class ScrollState;
 struct ClipNode;
 struct EffectNode;
 struct ScrollAndScaleSet;
 struct ScrollNode;
@@ skipping 71 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) {}
+  void ToProtobuf(proto::StickyPositionNodeData* proto) const;
+  void FromProtobuf(const proto::StickyPositionNodeData& proto);
+};
+
 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;
   ~TransformTree();
@@ skipping 113 matching lines @@
   int TargetId(int node_id) const;
   void SetTargetId(int node_id, int target_id);
 
   int ContentTargetId(int node_id) const;
   void SetContentTargetId(int node_id, int content_target_id);
 
   const std::vector<TransformCachedNodeData>& cached_data() const {
     return cached_data_;
   }
 
+  StickyPositionNodeData* StickyPositionData(int node_id);
+
   void ToProtobuf(proto::PropertyTree* proto) const;
   void FromProtobuf(const proto::PropertyTree& proto,
                     std::unordered_map<int, int>* node_id_to_index_map);
 
   // Computes the combined transform between |source_id| and |dest_id|. These
   // two nodes must be on the same ancestor chain.
   void CombineTransformsBetween(int source_id,
                                 int dest_id,
                                 gfx::Transform* transform) const;
 
@@ skipping 28 matching lines @@
   bool source_to_parent_updates_allowed_;
   // When to_screen transform has perspective, the transform node's sublayer
   // scale is calculated using page scale factor, device scale factor and the
   // 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_;
 };
 
 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 311 matching lines @@
   gfx::Vector2dF inner_viewport_container_bounds_delta_;
   gfx::Vector2dF outer_viewport_container_bounds_delta_;
   gfx::Vector2dF inner_viewport_scroll_bounds_delta_;
 
   PropertyTreesCachedData cached_data_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_