Unify the calculation of main thread offset of sticky element

cc/trees/property_tree.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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 360 matching lines @@
     // The scroll position does not include snapping which shifts the scroll
     // offset to align to a pixel boundary, we need to manually include it here.
     // In this case, snapping is caused by a scroll.
     scroll_position -= transform_node->snap_amount;
   }
 
   gfx::RectF clip(
       scroll_position,
       gfx::SizeF(property_trees.scroll_tree.scroll_clip_layer_bounds(
           scroll_node->id)));
-  gfx::Vector2dF layer_offset(sticky_data->main_thread_offset);
 
   gfx::Vector2dF ancestor_sticky_box_offset;
   if (sticky_data->nearest_node_shifting_sticky_box !=
       TransformTree::kInvalidNodeId) {
     ancestor_sticky_box_offset =
         tree->StickyPositionData(sticky_data->nearest_node_shifting_sticky_box)
             ->total_sticky_box_sticky_offset;
   }
 
   gfx::Vector2dF ancestor_containing_block_offset;
   if (sticky_data->nearest_node_shifting_containing_block !=
       TransformTree::kInvalidNodeId) {
     ancestor_containing_block_offset =
         tree->StickyPositionData(
                 sticky_data->nearest_node_shifting_containing_block)
             ->total_containing_block_sticky_offset;
   }
 
   // Compute the current position of the constraint rects based on the original
   // positions and the offsets from ancestor sticky elements.
   gfx::RectF sticky_box_rect =
       gfx::RectF(constraint.scroll_container_relative_sticky_box_rect) +
       ancestor_sticky_box_offset + ancestor_containing_block_offset;
   gfx::RectF containing_block_rect =
       gfx::RectF(constraint.scroll_container_relative_containing_block_rect) +
       ancestor_containing_block_offset;
 
-  gfx::Vector2dF sticky_offset(sticky_box_rect.OffsetFromOrigin());
+  gfx::Vector2dF sticky_offset;
 
   // In each of the following cases, we measure the limit which is the point
   // that the element should stick to, clamping on one side to 0 (because sticky
   // only pushes elements in one direction). Then we clamp to how far we can
   // push the element in that direction without being pushed outside of its
   // containing block.
   //
   // Note: The order of applying the sticky constraints is applied such that
   // left offset takes precedence over right offset, and top takes precedence
   // over bottom offset.
@@ skipping 30 matching lines @@
     float top_limit = clip.y() + constraint.top_offset;
     float top_delta = std::max<float>(0, top_limit - sticky_box_rect.y());
     float available_space = std::max<float>(
         0, containing_block_rect.bottom() - sticky_box_rect.bottom());
     if (top_delta > available_space)
       top_delta = available_space;
     sticky_offset.set_y(sticky_offset.y() + top_delta);
   }
 
   sticky_data->total_sticky_box_sticky_offset =
-      ancestor_sticky_box_offset + sticky_offset -
-      sticky_box_rect.OffsetFromOrigin();
+      ancestor_sticky_box_offset + sticky_offset;
   sticky_data->total_containing_block_sticky_offset =
       ancestor_sticky_box_offset + ancestor_containing_block_offset +
-      sticky_offset - sticky_box_rect.OffsetFromOrigin();
+      sticky_offset;
 
-  return sticky_offset - layer_offset - node->source_to_parent -
-         sticky_box_rect.OffsetFromOrigin();
+  return sticky_offset - node->offset_for_sticky_position_from_main_thread;
 }
 
 void TransformTree::UpdateLocalTransform(TransformNode* node) {
   gfx::Transform transform = node->post_local;
   if (NeedsSourceToParentUpdate(node)) {
     gfx::Transform to_parent;
     ComputeTranslation(node->source_node_id, node->parent_id, &to_parent);
     gfx::Vector2dF unsnapping;
     TransformNode* current;
     TransformNode* parent_node;
@@ skipping 1718 matching lines @@
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   if (effect_node->surface_contents_scale.x() != 0.0 &&
       effect_node->surface_contents_scale.y() != 0.0)
     screen_space_transform.Scale(1.0 / effect_node->surface_contents_scale.x(),
                                  1.0 / effect_node->surface_contents_scale.y());
   return screen_space_transform;
 }
 
 }  // namespace cc