Unify the calculation of main thread offset of sticky element

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 264 matching lines @@
   graphics_layer_->SetFilters(
       OwningLayer().CreateCompositorFilterOperationsForFilter(style));
 }
 
 void CompositedLayerMapping::UpdateBackdropFilters(const ComputedStyle& style) {
   graphics_layer_->SetBackdropFilters(
       OwningLayer().CreateCompositorFilterOperationsForBackdropFilter(style));
 }
 
 void CompositedLayerMapping::UpdateStickyConstraints(
-    const ComputedStyle& style,
-    const PaintLayer* compositing_container) {
+    const ComputedStyle& style) {
   bool sticky = style.GetPosition() == EPosition::kSticky;
   const PaintLayer* ancestor_overflow_layer =
       owning_layer_.AncestorOverflowLayer();
   // TODO(flackr): Do we still need this?
   if (sticky) {
     if (!ancestor_overflow_layer->IsRootLayer()) {
       sticky = ancestor_overflow_layer->NeedsCompositedScrolling();
     } else {
       sticky = GetLayoutObject().View()->GetFrameView()->IsScrollable();
     }
   }
 
   WebLayerStickyPositionConstraint web_constraint;
+  WebSize sticky_main_thread_offset;

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

Nit; this method is explicitly about sticky, we could just name this
'main_thread_offset' within this method.

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

Done.

   if (sticky) {
     const StickyConstraintsMap& constraints_map =
         ancestor_overflow_layer->GetScrollableArea()->GetStickyConstraintsMap();
     const StickyPositionScrollingConstraints& constraints =
         constraints_map.at(&owning_layer_);
 
     // Find the layout offset of the unshifted sticky box within its parent
     // composited layer. This information is used by the compositor side to
     // compute the additional offset required to keep the element stuck under
     // compositor scrolling.
-    //
-    // Starting from the scroll container relative location, removing the
-    // enclosing layer's offset and the content offset in the composited layer
-    // results in the parent-layer relative offset.
-    FloatPoint parent_relative_sticky_box_offset =
-        constraints.ScrollContainerRelativeStickyBoxRect().Location();
-
-    // The enclosing layers offset returned from |convertToLayerCoords| must be
-    // adjusted for both scroll and ancestor sticky elements.
-    LayoutPoint enclosing_layer_offset;
-    compositing_container->ConvertToLayerCoords(ancestor_overflow_layer,
-                                                enclosing_layer_offset);
-    DCHECK(!ScrollParent() || ScrollParent() == ancestor_overflow_layer);
-    if (!ScrollParent() && compositing_container != ancestor_overflow_layer) {
-      enclosing_layer_offset += LayoutSize(
-          ancestor_overflow_layer->GetScrollableArea()->GetScrollOffset());
-    }
-    // TODO(smcgruer): Until http://crbug.com/702229 is fixed, the nearest
-    // sticky ancestor may be non-composited which will make this offset wrong.
-    if (const LayoutBoxModelObject* ancestor =
-            constraints.NearestStickyAncestor()) {
-      enclosing_layer_offset -=
-          RoundedIntSize(constraints_map.at(ancestor->Layer())
-                             .GetTotalContainingBlockStickyOffset());
-    }
-
-    DCHECK(!content_offset_in_compositing_layer_dirty_);
-    parent_relative_sticky_box_offset.MoveBy(
-        FloatPoint(-enclosing_layer_offset) -
-        FloatSize(ContentOffsetInCompositingLayer()));
-
-    if (compositing_container != ancestor_overflow_layer) {
-      parent_relative_sticky_box_offset.MoveBy(
-          FloatPoint(compositing_container->GetCompositedLayerMapping()
-                         ->ContentOffsetInCompositingLayer()));
-    }
+    sticky_main_thread_offset =
+        RoundedIntSize(GetLayoutObject().StickyPositionOffset());
 
     web_constraint.is_sticky = true;
     web_constraint.is_anchored_left =
         constraints.GetAnchorEdges() &
         StickyPositionScrollingConstraints::kAnchorEdgeLeft;
     web_constraint.is_anchored_right =
         constraints.GetAnchorEdges() &
         StickyPositionScrollingConstraints::kAnchorEdgeRight;
     web_constraint.is_anchored_top =
         constraints.GetAnchorEdges() &
         StickyPositionScrollingConstraints::kAnchorEdgeTop;
     web_constraint.is_anchored_bottom =
         constraints.GetAnchorEdges() &
         StickyPositionScrollingConstraints::kAnchorEdgeBottom;
     web_constraint.left_offset = constraints.LeftOffset();
     web_constraint.right_offset = constraints.RightOffset();
     web_constraint.top_offset = constraints.TopOffset();
     web_constraint.bottom_offset = constraints.BottomOffset();
-    web_constraint.parent_relative_sticky_box_offset =
-        RoundedIntPoint(parent_relative_sticky_box_offset);
     web_constraint.scroll_container_relative_sticky_box_rect =
         EnclosingIntRect(constraints.ScrollContainerRelativeStickyBoxRect());
     web_constraint.scroll_container_relative_containing_block_rect =
         EnclosingIntRect(
             constraints.ScrollContainerRelativeContainingBlockRect());
     // TODO(smcgruer): Until http://crbug.com/702229 is fixed, the nearest
     // sticky layers may not be composited and we may incorrectly end up with
     // invalid layer IDs.
     LayoutBoxModelObject* sticky_box_shifting_ancestor =
         constraints.NearestStickyBoxShiftingStickyBox();
@@ skipping 14 matching lines @@
       web_constraint.nearest_layer_shifting_containing_block =
           containing_block_shifting_ancestor->Layer()
               ->GetCompositedLayerMapping()
               ->MainGraphicsLayer()
               ->PlatformLayer()
               ->Id();
     }
   }
 
   graphics_layer_->SetStickyPositionConstraint(web_constraint);
+  graphics_layer_->SetStickyMainThreadOffset(sticky_main_thread_offset);
 }
 
 void CompositedLayerMapping::UpdateLayerBlendMode(const ComputedStyle& style) {
   SetBlendMode(style.BlendMode());
 }
 
 void CompositedLayerMapping::UpdateIsRootForIsolatedGroup() {
   bool isolate = owning_layer_.ShouldIsolateCompositedDescendants();
 
   // non stacking context layers should never isolate
@@ skipping 696 matching lines @@
   FloatSize contents_size(relative_compositing_bounds.Size());
 
   UpdateMainGraphicsLayerGeometry(relative_compositing_bounds,
                                   local_compositing_bounds,
                                   graphics_layer_parent_location);
   UpdateOverflowControlsHostLayerGeometry(compositing_stacking_context,
                                           compositing_container,
                                           graphics_layer_parent_location);
   UpdateContentsOffsetInCompositingLayer(
       snapped_offset_from_composited_ancestor, graphics_layer_parent_location);
-  UpdateStickyConstraints(GetLayoutObject().StyleRef(), compositing_container);
+  UpdateStickyConstraints(GetLayoutObject().StyleRef());
   UpdateSquashingLayerGeometry(
       graphics_layer_parent_location, compositing_container, squashed_layers_,
       squashing_layer_.get(),
       &squashing_layer_offset_from_transformed_ancestor_,
       layers_needing_paint_invalidation);
 
   // If we have a layer that clips children, position it.
   IntRect clipping_box;
   if (child_containment_layer_ && GetLayoutObject().IsBox())
     clipping_box = ClipBox(ToLayoutBox(GetLayoutObject()));
@@ skipping 2535 matching lines @@
   } else if (graphics_layer == decoration_outline_layer_.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink