Shifting layer position for sticky element to avoid passing unnessary variable to cc

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 263 matching lines @@
 void CompositedLayerMapping::UpdateFilters(const ComputedStyle& style) {
   graphics_layer_->SetFilters(
       OwningLayer().CreateCompositorFilterOperationsForFilter(style));
 }
 
 void CompositedLayerMapping::UpdateBackdropFilters(const ComputedStyle& style) {
   graphics_layer_->SetBackdropFilters(
       OwningLayer().CreateCompositorFilterOperationsForBackdropFilter(style));
 }
 
+bool CompositedLayerMapping::UsesCompositedStickyPosition() const {
+  return GetLayoutObject().Style()->GetPosition() == EPosition::kSticky &&
+         (owning_layer_.AncestorOverflowLayer()->IsRootLayer()
+              ? GetLayoutObject().View()->GetFrameView()->IsScrollable()
+              : owning_layer_.AncestorOverflowLayer()
+                    ->NeedsCompositedScrolling());
+}
+
 void CompositedLayerMapping::UpdateStickyConstraints(
     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;
+  const StickyConstraintsMap& constraints_map =
+      ancestor_overflow_layer->GetScrollableArea()->GetStickyConstraintsMap();
+  const StickyPositionScrollingConstraints& constraints =
+      constraints_map.at(&owning_layer_);
+
+  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.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();
+  if (sticky_box_shifting_ancestor &&
+      sticky_box_shifting_ancestor->Layer()->GetCompositedLayerMapping()) {
+    web_constraint.nearest_layer_shifting_sticky_box =
+        sticky_box_shifting_ancestor->Layer()
+            ->GetCompositedLayerMapping()
+            ->MainGraphicsLayer()
+            ->PlatformLayer()
+            ->Id();
   }
-
-  WebLayerStickyPositionConstraint web_constraint;
-  if (sticky) {
-    const StickyConstraintsMap& constraints_map =
-        ancestor_overflow_layer->GetScrollableArea()->GetStickyConstraintsMap();
-    const StickyPositionScrollingConstraints& constraints =
-        constraints_map.at(&owning_layer_);
-
-    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.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();
-    if (sticky_box_shifting_ancestor &&
-        sticky_box_shifting_ancestor->Layer()->GetCompositedLayerMapping()) {
-      web_constraint.nearest_layer_shifting_sticky_box =
-          sticky_box_shifting_ancestor->Layer()
-              ->GetCompositedLayerMapping()
-              ->MainGraphicsLayer()
-              ->PlatformLayer()
-              ->Id();
-    }
-    LayoutBoxModelObject* containing_block_shifting_ancestor =
-        constraints.NearestStickyBoxShiftingContainingBlock();
-    if (containing_block_shifting_ancestor &&
+  LayoutBoxModelObject* containing_block_shifting_ancestor =
+      constraints.NearestStickyBoxShiftingContainingBlock();
+  if (containing_block_shifting_ancestor &&
+      containing_block_shifting_ancestor->Layer()
+          ->GetCompositedLayerMapping()) {
+    web_constraint.nearest_layer_shifting_containing_block =
         containing_block_shifting_ancestor->Layer()
-            ->GetCompositedLayerMapping()) {
-      web_constraint.nearest_layer_shifting_containing_block =
-          containing_block_shifting_ancestor->Layer()
-              ->GetCompositedLayerMapping()
-              ->MainGraphicsLayer()
-              ->PlatformLayer()
-              ->Id();
-    }
+            ->GetCompositedLayerMapping()
+            ->MainGraphicsLayer()
+            ->PlatformLayer()
+            ->Id();
   }
 
   graphics_layer_->SetStickyPositionConstraint(web_constraint);
 }
 
 void CompositedLayerMapping::UpdateLayerBlendMode(const ComputedStyle& style) {
   SetBlendMode(style.BlendMode());
 }
 
 void CompositedLayerMapping::UpdateIsRootForIsolatedGroup() {
@@ skipping 700 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());
+  if (UsesCompositedStickyPosition())
+    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 37 matching lines @@
   UpdateScrollParent(ScrollParent());
   RegisterScrollingLayers();
 
   UpdateCompositingReasons();
 }
 
 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) {
+  // Find and remove the offset applied for sticky position if the compositor
+  // will shift the layer for sticky position to avoid offsetting the layer
+  // twice.
+  FloatSize offset_for_sticky_position;
+  if (UsesCompositedStickyPosition()) {
     const StickyConstraintsMap& constraints_map =
         owning_layer_.AncestorOverflowLayer()
             ->GetScrollableArea()
             ->GetStickyConstraintsMap();
     const StickyPositionScrollingConstraints& constraints =
         constraints_map.at(&owning_layer_);
 
-    main_thread_sticky_offset =
+    offset_for_sticky_position =
         constraints.GetOffsetForStickyPosition(constraints_map);
   }
-  graphics_layer_->SetOffsetForStickyPosition(
-      RoundedIntSize(main_thread_sticky_offset));
+  graphics_layer_->SetPosition(
+      FloatPoint(relative_compositing_bounds.Location() -
+                 graphics_layer_parent_location) -
+      offset_for_sticky_position);
+  graphics_layer_->SetOffsetFromLayoutObject(
+      ToIntSize(local_compositing_bounds.Location()));
 
   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 2477 matching lines @@
   } else if (graphics_layer == decoration_outline_layer_.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink