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 1110 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) {
+  // composited layer. This information is used to shift layer position to
+  // keep the element stuck under compositor scrolling.
+  FloatSize offset_for_sticky_position;
+  if (GetLayoutObject().Style()->GetPosition() == EPosition::kSticky &&

[flackr, 2017/06/08 18:56:19]

This definitely needs a comment at a minimum, although I think to ensure that we
don't make the wrong decision we should use the same condition to determine
whether we set sticky position constraints on the graphics layer.

I.e. add a method bool CompositedLayerMapping::UsesCompositedStickyPosition, and
then check that this returns true before unshifting the graphics layer position
here and before transferring the sticky position constraints in
CompositedLayerMapping::UpdateStickyConstraints. That way we don't risk doing
composited sticky position on the compositor with an unshifted layer.

[yigu, 2017/06/08 23:30:03]

Done.

+      (owning_layer_.AncestorOverflowLayer()->IsRootLayer() ||
+       owning_layer_.AncestorOverflowLayer()->NeedsCompositedScrolling())) {

[flackr, 2017/06/08 22:26:55]

chrishtr, trchen, I'm wondering if it's safe to try to determine the compositing
state of the scrolling ancestor at this point.

[chrishtr, 2017/06/08 22:38:40]

Yes, it is safe. Paint layer compositor works in this sequence:

1. Compute compositing inputs (including sticky position constraints, for
example)
2. Compute compositing requirements (triggers for compositing)
3. Assign  composited layers
4. Update graphics layer configurations

Step 4 is where this function lies. Step 3 determined everything needed to
answer
NeedsCompositedScrolling.

     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