Implement position: sticky updates on compositor

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 593 matching lines @@
 
   SetSubtreePropertyChanged();
   PropertyTrees* property_trees = layer_tree_->property_trees();
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                        id())) {
     DCHECK_EQ(transform_tree_index(),
               property_trees->transform_id_to_index_map[id()]);
     TransformNode* transform_node =
         property_trees->transform_tree.Node(transform_tree_index());
     transform_node->update_post_local_transform(position, transform_origin());
+    if (transform_node->sticky_position_constraint_id >= 0) {
+      StickyPositionNodeData* sticky_data =
+          property_trees->transform_tree.StickyPositionData(
+              transform_tree_index());
+      sticky_data->main_thread_offset =
+          position.OffsetFromOrigin() -
+          sticky_data->constraints.absolute_sticky_box_rect.OffsetFromOrigin();
+    }
     transform_node->needs_local_transform_update = true;
     transform_node->transform_changed = true;
     layer_tree_->property_trees()->transform_tree.set_needs_update(true);
     SetNeedsCommitNoRebuild();
     return;
   }
 
   SetNeedsCommit();
 }
 
@@ skipping 478 matching lines @@
 }
 
 void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.position_constraint == constraint)
     return;
   inputs_.position_constraint = constraint;
   SetNeedsCommit();
 }
 
+void Layer::SetStickyPositionConstraint(
+    const LayerStickyPositionConstraint& constraint) {
+  DCHECK(IsPropertyChangeAllowed());
+  if (inputs_.sticky_position_constraint == constraint)
+    return;
+  inputs_.sticky_position_constraint = constraint;
+  SetNeedsCommit();
+}
+
 static void RunCopyCallbackOnMainThread(
     std::unique_ptr<CopyOutputRequest> request,
     std::unique_ptr<CopyOutputResult> result) {
   request->SendResult(std::move(result));
 }
 
 static void PostCopyCallbackToMainThread(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
     std::unique_ptr<CopyOutputRequest> request,
     std::unique_ptr<CopyOutputResult> result) {
@@ skipping 38 matching lines @@
   layer->SetMasksToBounds(inputs_.masks_to_bounds);
   layer->set_main_thread_scrolling_reasons(
       inputs_.main_thread_scrolling_reasons);
   layer->SetNonFastScrollableRegion(inputs_.non_fast_scrollable_region);
   layer->SetTouchEventHandlerRegion(inputs_.touch_event_handler_region);
   layer->SetContentsOpaque(inputs_.contents_opaque);
   layer->SetPosition(inputs_.position);
   layer->set_should_flatten_transform_from_property_tree(
       should_flatten_transform_from_property_tree_);
   layer->set_draw_blend_mode(draw_blend_mode_);
+  layer->SetStickyPositionConstraint(inputs_.sticky_position_constraint);
   layer->SetUseParentBackfaceVisibility(inputs_.use_parent_backface_visibility);
   layer->SetUseLocalTransformForBackfaceVisibility(
       use_local_transform_for_backface_visibility_);
   layer->SetShouldCheckBackfaceVisibility(should_check_backface_visibility_);
   layer->Set3dSortingContextId(inputs_.sorting_context_id);
 
   layer->SetScrollClipLayer(inputs_.scroll_clip_layer_id);
   layer->set_user_scrollable_horizontal(inputs_.user_scrollable_horizontal);
   layer->set_user_scrollable_vertical(inputs_.user_scrollable_vertical);
   layer->SetElementId(inputs_.element_id);
@@ skipping 702 matching lines @@
   DCHECK_NE(transform_tree_index_, TransformTree::kInvalidNodeId);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_->property_trees()->transform_tree);
 }
 
 LayerTree* Layer::GetLayerTree() const {
   return layer_tree_;
 }
 
 }  // namespace cc