Unify the calculation of main thread offset of sticky element

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 579 matching lines @@
 
   if (!layer_tree_host_)
     return;
 
   SetSubtreePropertyChanged();
   PropertyTrees* property_trees = layer_tree_host_->property_trees();
   if (TransformNode* transform_node =
           property_trees->transform_tree.UpdateNodeFromOwningLayerId(id())) {
     DCHECK_EQ(transform_tree_index(), transform_node->id);
     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());
-      // TODO(smcgruer): Pass main thread sticky-shifting offsets of
-      // non-promoted ancestors, or promote all ancestor sticky elements.
-      // See http://crbug.com/702229
-      sticky_data->main_thread_offset =
-          position.OffsetFromOrigin() -
-          sticky_data->constraints.parent_relative_sticky_box_offset
-              .OffsetFromOrigin();
-    }
     transform_node->needs_local_transform_update = true;
     transform_node->transform_changed = true;
     layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
   }
 
   SetNeedsCommit();
 }
 
 bool Layer::IsContainerForFixedPositionLayers() const {
   return inputs_.is_container_for_fixed_position_layers;
@@ skipping 479 matching lines @@
 void Layer::SetStickyPositionConstraint(
     const LayerStickyPositionConstraint& constraint) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.sticky_position_constraint == constraint)
     return;
   inputs_.sticky_position_constraint = constraint;
   SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
 
+void Layer::SetStickyMainThreadOffset(const gfx::Size& offset) {
+  DCHECK(IsPropertyChangeAllowed());
+  if (inputs_.sticky_main_thread_offset == offset)
+    return;
+  inputs_.sticky_main_thread_offset = offset;
+  SetPropertyTreesNeedRebuild();

[smcgruer, 2017/05/26 17:14:12]

Do we definitely need to rebuild property trees here? Could we not propagate to
the existing TransformNode in this method instead?

[yigu, 2017/05/26 18:04:21]

We don't need to rebuild the tree. Done.

+  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 306 matching lines @@
       ->subtree_has_copy_request;
 }
 
 gfx::Transform Layer::ScreenSpaceTransform() const {
   DCHECK_NE(transform_tree_index_, TransformTree::kInvalidNodeId);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc