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;
   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

[chrishtr, 2017/06/05 15:23:27]

It seems it turned out that this logic was equivalent to what was already
computed
in the sticky constraints map code. Was this just a case of not fully realizing
that at the time this original code was written?

[flackr, 2017/06/05 16:45:12]

Well this logic is actually just trying to work out the relative position of the
sticky box and ancestor scroller so that it can figure out how much the main
thread has already pushed this sticky element down from setting the layer
position. We had thought about just passing this main thread offset through
initially and at the time it seemed simple enough to work out what it was from
the layer position but has since proven to be rather hard to get right with all
of the various ways the tree can be constructed.

So it's not that the main thread does this, it doesn't need to because it's
using the layout boxes and if we just pass the main thread offset the only thing
we need from the compositor is the current ancestor scroll position to work out
the additional sticky offset.

-    // 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()));
-    }
-
     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 730 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 41 matching lines @@
 }
 
 void CompositedLayerMapping::UpdateMainGraphicsLayerGeometry(
     const IntRect& relative_compositing_bounds,
     const IntRect& local_compositing_bounds,
     const IntPoint& graphics_layer_parent_location) {
   graphics_layer_->SetPosition(FloatPoint(
       relative_compositing_bounds.Location() - graphics_layer_parent_location));
   graphics_layer_->SetOffsetFromLayoutObject(
       ToIntSize(local_compositing_bounds.Location()));
+  // 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.
+  FloatSize main_thread_sticky_offset;
+  if (GetLayoutObject().Style()->GetPosition() == EPosition::kSticky) {
+    const StickyConstraintsMap& constraints_map =
+        owning_layer_.AncestorOverflowLayer()
+            ->GetScrollableArea()
+            ->GetStickyConstraintsMap();
+    const StickyPositionScrollingConstraints& constraints =
+        constraints_map.at(&owning_layer_);
+
+    main_thread_sticky_offset =
+        constraints.GetLocalStickyOffset(constraints_map);
+  }
+  graphics_layer_->SetStickyMainThreadOffset(
+      RoundedIntSize(main_thread_sticky_offset));
 
   FloatSize old_size = graphics_layer_->Size();
   const FloatSize contents_size(relative_compositing_bounds.Size());
   if (old_size != contents_size)
     graphics_layer_->SetSize(contents_size);
 
   // m_graphicsLayer is the corresponding GraphicsLayer for this PaintLayer and
   // its non-compositing descendants. So, the visibility flag for
   // m_graphicsLayer should be true if there are any non-compositing visible
   // layers.
@@ skipping 2475 matching lines @@
   } else if (graphics_layer == decoration_outline_layer_.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink