Implement position: sticky updates on compositor

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 63 matching lines @@
 };
 
 static LayerPositionConstraint PositionConstraint(Layer* layer) {
   return layer->position_constraint();
 }
 
 static LayerPositionConstraint PositionConstraint(LayerImpl* layer) {
   return layer->test_properties()->position_constraint;
 }
 
+static LayerStickyPositionConstraint StickyPositionConstraint(Layer* layer) {
+  return layer->sticky_position_constraint();
+}
+
+static LayerStickyPositionConstraint StickyPositionConstraint(
+    LayerImpl* layer) {
+  return layer->test_properties()->sticky_position_constraint;
+}
+
 struct PreCalculateMetaInformationRecursiveData {
   size_t num_unclipped_descendants;
   int num_descendants_that_draw_content;
 
   PreCalculateMetaInformationRecursiveData()
       : num_unclipped_descendants(0),
         num_descendants_that_draw_content(0) {}
 
   void Merge(const PreCalculateMetaInformationRecursiveData& data) {
     num_unclipped_descendants += data.num_unclipped_descendants;
@@ skipping 390 matching lines @@
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     bool created_render_surface,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !Parent(layer);
   const bool is_page_scale_layer = layer == data_from_ancestor.page_scale_layer;
   const bool is_overscroll_elasticity_layer =
       layer == data_from_ancestor.overscroll_elasticity_layer;
   const bool is_scrollable = layer->scrollable();
   const bool is_fixed = PositionConstraint(layer).is_fixed_position();
+  const bool is_sticky = StickyPositionConstraint(layer).is_sticky;
 
   const bool has_significant_transform =
       !Transform(layer).IsIdentityOr2DTranslation();
 
   const bool has_potentially_animated_transform =
       HasPotentiallyRunningTransformAnimation(layer);
 
   // A transform node is needed even for a finished animation, since differences
   // in the timing of animation state updates can mean that an animation that's
   // in the Finished state at tree-building time on the main thread is still in
@@ skipping 14 matching lines @@
       Parent(layer)->effect_tree_index() !=
           ScrollParent(layer)->effect_tree_index();
 
   const bool is_at_boundary_of_3d_rendering_context =
       IsAtBoundaryOf3dRenderingContext(layer);
 
   bool requires_node = is_root || is_scrollable || has_significant_transform ||
                        has_any_transform_animation || has_surface || is_fixed ||
                        is_page_scale_layer || is_overscroll_elasticity_layer ||
                        has_proxied_transform_related_property ||
-                       scroll_child_has_different_target ||
+                       scroll_child_has_different_target || is_sticky ||
                        is_at_boundary_of_3d_rendering_context;
 
   LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
   DCHECK(is_root || transform_parent);
 
   int parent_index = kRootPropertyTreeNodeId;
   if (transform_parent)
     parent_index = transform_parent->transform_tree_index();
 
   int source_index = parent_index;
@@ skipping 146 matching lines @@
           node->affected_by_outer_viewport_bounds_delta_y) {
         data_for_children->property_trees->transform_tree
             .AddNodeAffectedByOuterViewportBoundsDelta(node->id);
       }
     }
   }
 
   node->local = Transform(layer);
   node->update_pre_local_transform(TransformOrigin(layer));
 
+  if (StickyPositionConstraint(layer).is_sticky) {
+    StickyPositionNodeData* sticky_data =
+        data_for_children->property_trees->transform_tree.StickyPositionData(
+            node->id);
+    sticky_data->constraints = StickyPositionConstraint(layer);
+    sticky_data->scroll_ancestor = GetScrollParentId(data_from_ancestor, layer);
+    sticky_data->main_thread_offset =
+        layer->position().OffsetFromOrigin() -
+        sticky_data->constraints.scroll_container_relative_sticky_box_rect
+            .OffsetFromOrigin();
+  }
+
   node->needs_local_transform_update = true;
   data_from_ancestor.property_trees->transform_tree.UpdateTransforms(node->id);
 
   layer->set_offset_to_transform_parent(gfx::Vector2dF());
 
   // Flattening (if needed) will be handled by |node|.
   layer->set_should_flatten_transform_from_property_tree(false);
 
   node->owner_id = layer->id();
 
@@ skipping 774 matching lines @@
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
   property_trees->ResetCachedData();
 }
 
 }  // namespace cc