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 335 matching lines @@
   // from the destination to the source, with flattening, and then invert the
   // result.
   gfx::Transform dest_to_source;
   CombineTransformsBetween(dest_id, source_id, &dest_to_source);
   gfx::Transform source_to_dest;
   bool all_are_invertible = dest_to_source.GetInverse(&source_to_dest);
   transform->PreconcatTransform(source_to_dest);
   return all_are_invertible;
 }
 
 gfx::Vector2dF StickyPositionOffset(TransformTree* tree, TransformNode* node) {

[trchen, 2017/06/06 21:17:21]

nits: I think it'd be nice to add a comment here to tell this function should
match StickyPositionScrollingConstraints::ComputeStickyOffset().

Extra question: Can we assume in absence of impl-side scroll delta, this
function will always return (0, 0)? If yes, is it possible to add a DCHECK for
it? If not, could you make an example?

Extra question 2: Can we just offset layer position by
-sticky_main_thread_offset in CLM, as if the main thread never applied its
sticky offset? That way sticky_main_thread_offset will always be 0 thus one less
variable to pass around, no?

[yigu, 2017/06/07 15:52:32]

This function doesn't really match the one from blink. It returns the delta.
e.g. function from blink returns (0,100) then this function returns (0, 100) -
(0, 100) = (0, 0).
This is not true due to snapping and rounding.
This is actually a very good suggestion. Shifting the layer position works when
the scroller is composited and it has scrolling layer. We tried to add condition
checks to make it work in all cases but it seems that we need further
investigation on this. Will open a bug and start to work on it.

   if (node->sticky_position_constraint_id == -1)
     return gfx::Vector2dF();
   StickyPositionNodeData* sticky_data = tree->StickyPositionData(node->id);
   const LayerStickyPositionConstraint& constraint = sticky_data->constraints;
   auto& property_trees = *tree->property_trees();
   ScrollNode* scroll_node =
       property_trees.scroll_tree.Node(sticky_data->scroll_ancestor);
   TransformNode* transform_node =
       property_trees.transform_tree.Node(scroll_node->transform_id);
   const auto& scroll_offset = transform_node->scroll_offset;
   DCHECK(property_trees.scroll_tree.current_scroll_offset(
              scroll_node->owning_layer_id) == scroll_offset);
   gfx::PointF scroll_position(scroll_offset.x(), scroll_offset.y());
   if (transform_node->scrolls) {
     // 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->sticky_main_thread_offset;
 }
 
 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 1713 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