Correct for enclosing layers scroll position in sticky_data->main_thread_offset

cc/layers/layer.cc

 // Copyright 2010 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 "cc/layers/layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 11 matching lines @@
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/scrollbar_layer_interface.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/mutable_properties.h"
 #include "cc/trees/mutator_host.h"
+#include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 base::StaticAtomicSequenceNumber g_next_layer_id;
 
 Layer::Inputs::Inputs(int layer_id)
@@ skipping 544 matching lines @@
                                        id())) {
     DCHECK_EQ(transform_tree_index(),
               property_trees->layer_id_to_transform_node_index[id()]);
     TransformNode* transform_node =
         property_trees->transform_tree.Node(transform_tree_index());
     transform_node->update_post_local_transform(position, transform_origin());
     if (transform_node->sticky_position_constraint_id >= 0) {
       StickyPositionNodeData* sticky_data =
           property_trees->transform_tree.StickyPositionData(
               transform_tree_index());
+      gfx::Point sticky_box_offset(
+          sticky_data->constraints.parent_relative_sticky_box_offset);
+
+      // The sticky box offset calculated in CompositedLayerMapping must be
+      // adjusted for the enclosing layer's scroll position.
+      ScrollNode* scroll_ancestor =
+          property_trees->scroll_tree.Node(scroll_tree_index());
+      if (scroll_ancestor->owning_layer_id == id()) {
+        // We are a scroller, so we need our parent's scroll_ancestor.

[flackr, 2017/02/16 22:23:59]

Can't we always get the node from the parent?

[smcgruer, 2017/02/17 13:55:31]

Yes, of course. Done.

+        scroll_ancestor =
+            property_trees->scroll_tree.Node(parent()->scroll_tree_index());
+      }
+      if (parent()->id() != scroll_ancestor->owning_layer_id) {
+        sticky_box_offset -= gfx::ScrollOffsetToFlooredVector2d(

[flackr, 2017/02/16 22:23:59]

Do we know that this floored scroll offset matches the main thread offset? There
might be a similar bug to https://crbug.com/681951 here.

I wonder if it might be better to adjust what we send for the parent relative
sticky box offset on the blink side since we will have consistent scroll
snapping there.

[smcgruer, 2017/02/17 13:55:31]

So the |enclosingLayerOffset| that is calculated blink-side is a LayoutPoint
which is an integer (as is location()). It is added to |stickyBoxOffset| which
is a FloatPoint, but the float here comes from the fact that
scrollContainerRelativeStickyBoxRect() is a FloatRect.

I think we could try to do it blink side if it would feel better, but the offset
from main for scroll (via location()) is coming in as an integer. (FYI the
scroll offset in blink-side updateLayerPosition is
"containingLayer->layoutBox()->scrolledContentOffset();" which is an IntPoint
too.)

[flackr, 2017/02/21 00:41:30]

This definitely belongs blink side. If there are cases where blink and cc
disagree about the scroll position (i.e. https://crbug.com/681951) we want to
use the one that blink is using when it sets the layer position of the sticky
layer.

[smcgruer, 2017/02/21 19:17:21]

Done.

+            property_trees->scroll_tree.current_scroll_offset(
+                scroll_ancestor->owning_layer_id));
+      }
+
       sticky_data->main_thread_offset =
-          position.OffsetFromOrigin() -
-          sticky_data->constraints.parent_relative_sticky_box_offset
-              .OffsetFromOrigin();
+          position.OffsetFromOrigin() - sticky_box_offset.OffsetFromOrigin();
     }
     transform_node->needs_local_transform_update = true;
     transform_node->transform_changed = true;
     layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
     SetNeedsCommitNoRebuild();
     return;
   }
 
   SetNeedsCommit();
 }
@@ skipping 969 matching lines @@
       ->num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, TransformTree::kInvalidNodeId);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc