Clean LayerImpl's scroll offset callers in unit tests.

cc/layers/layer_position_constraint_unittest.cc

 // Copyright 2013 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_position_constraint.h"
 
 #include <vector>
 
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 136 matching lines @@
                                                         root_->bounds());
     inputs.inner_viewport_scroll_layer =
         layer_tree_host_->inner_viewport_scroll_layer();
     inputs.outer_viewport_scroll_layer =
         layer_tree_host_->outer_viewport_scroll_layer();
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     // Since scroll deltas aren't sent back to the main thread in this test
     // setup, clear them to maintain consistent state.
     if (root_impl_) {
-      scroll_layer_impl_->SetScrollDelta(gfx::Vector2dF());
-      child_impl_->SetScrollDelta(gfx::Vector2dF());
-      grand_child_impl_->SetScrollDelta(gfx::Vector2dF());
+      SetScrollOffsetDelta(scroll_layer_impl_, gfx::Vector2dF());
+      SetScrollOffsetDelta(child_impl_, gfx::Vector2dF());
+      SetScrollOffsetDelta(grand_child_impl_, gfx::Vector2dF());
     }
     root_impl_ = layer_tree_host_->CommitAndCreateLayerImplTree();
     inner_viewport_container_layer_impl_ = root_impl_->children()[0].get();
     scroll_layer_impl_ =
         inner_viewport_container_layer_impl_->children()[0].get();
     outer_viewport_container_layer_impl_ =
         scroll_layer_impl_->children()[0].get();
     child_transform_layer_impl_ =
         outer_viewport_container_layer_impl_->children()[0].get();
     child_impl_ = child_transform_layer_impl_->children()[0].get();
@@ skipping 18 matching lines @@
   LayerImpl* inner_viewport_container_layer_impl_;
   LayerImpl* scroll_layer_impl_;
   LayerImpl* outer_viewport_container_layer_impl_;
   LayerImpl* child_transform_layer_impl_;
   LayerImpl* child_impl_;
   LayerImpl* grand_child_impl_;
   LayerImpl* great_grand_child_impl_;
 
   LayerPositionConstraint fixed_to_top_left_;
   LayerPositionConstraint fixed_to_bottom_right_;
+
+  // LayerImpl should not be aware of synced property logics, this function is
+  // a hack for the test to arbitrarily set the scroll delta for setting up.
+  static void SetScrollOffsetDelta(LayerImpl* layer_impl,
+                                   const gfx::Vector2dF& delta) {
+    layer_impl->SetCurrentScrollOffset(
+        layer_impl->synced_scroll_offset()->ActiveBase() +
+        gfx::ScrollOffset(delta));
+  }
 };
 
 namespace {
 
 void SetFixedContainerSizeDelta(LayerImpl* scroll_layer,
                                 const gfx::Vector2d& delta) {
   DCHECK(scroll_layer);
   DCHECK(scroll_layer->scrollable());
 
   LayerImpl* container_layer = scroll_layer->scroll_clip_layer();
   container_layer->SetBoundsDelta(delta);
 }
 }  // namespace
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithDirectContainer) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is the direct parent of the fixed-position layer.
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform = expected_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 10
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child is affected by scroll delta, but the fixed position
   // grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -10.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 
   // Case 3: fixed-container size delta of 20, 20
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
 
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_grand_child_transform.MakeIdentity();
   // Apply size delta from the child(container) layer.
   expected_grand_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithDistantContainer) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is NOT the direct parent of the fixed-position layer.
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   great_grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform;
   expected_grand_child_transform.Translate(8.0, 6.0);
 
   gfx::Transform expected_great_grand_child_transform =
       expected_grand_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 10
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child and grand_child are affected by scroll delta, but the fixed
   // position great_grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -10.0);
   expected_grand_child_transform.MakeIdentity();
   expected_grand_child_transform.Translate(-2.0, -4.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
@@ skipping 10 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   great_grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_great_grand_child_transform.MakeIdentity();
   // Apply size delta from the child(container) layer.
   expected_great_grand_child_transform.Translate(20.0, 20.0);
   // Apply layer position from the grand child layer.
   expected_great_grand_child_transform.Translate(8.0, 6.0);
 
@@ skipping 14 matching lines @@
   rotation_about_z.RotateAboutZAxis(90.0);
 
   child_transform_layer_->SetIsContainerForFixedPositionLayers(true);
   child_transform_layer_->SetTransform(rotation_about_z);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   great_grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   expected_child_transform.PreconcatTransform(rotation_about_z);
 
   gfx::Transform expected_grand_child_transform;
   expected_grand_child_transform.PreconcatTransform(
       rotation_about_z);  // child's local transform is inherited
   // translation because of position occurs before layer's local transform.
   expected_grand_child_transform.Translate(8.0, 6.0);
 
   gfx::Transform expected_great_grand_child_transform =
       expected_grand_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 20
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 0));
-  grand_child_impl_->SetScrollDelta(gfx::Vector2d(5, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 0));
+  SetScrollOffsetDelta(grand_child_impl_, gfx::Vector2d(5, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child and grand_child are affected by scroll delta, but the fixed
   // position great_grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.PreconcatTransform(rotation_about_z);
   expected_child_transform.Translate(-10.0, 0.0);  // scroll delta
 
   expected_grand_child_transform.MakeIdentity();
   expected_grand_child_transform.PreconcatTransform(
@@ skipping 24 matching lines @@
   grand_child_->SetForceRenderSurface(true);
   great_grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   gfx::Transform rotation_about_z;
   rotation_about_z.RotateAboutZAxis(90.0);
   great_grand_child_->SetTransform(rotation_about_z);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_surface_draw_transform;
   expected_surface_draw_transform.Translate(8.0, 6.0);
   gfx::Transform expected_grand_child_transform;
   gfx::Transform expected_great_grand_child_transform;
   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
   EXPECT_TRUE(grand_child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_surface_draw_transform,
       grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 30
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 30));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the grand_child remains unchanged, because it scrolls along with the
   // render surface, and the translation is actually in the render surface. But,
   // the fixed position great_grand_child is more awkward: its actually being
   // drawn with respect to the render surface, but it needs to remain fixed with
   // resepct to a container beyond that surface. So, the net result is that,
   // unlike previous tests where the fixed position layer's transform remains
   // unchanged, here the fixed position layer's transform explicitly contains
@@ skipping 31 matching lines @@
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   great_grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
 
   CommitAndUpdateImplPointers();
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 30));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
 
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_great_grand_child_transform.MakeIdentity();
   // explicit canceling out the scroll delta that gets embedded in the fixed
   // position layer's surface.
   expected_great_grand_child_transform.Translate(10.0, 30.0);
   // Also apply size delta in the child(container) layer space.
@@ skipping 40 matching lines @@
   rotation_about_z.Translate(50.0, 50.0);
   rotation_about_z.RotateAboutZAxis(90.0);
   rotation_about_z.Translate(-50.0, -50.0);
   fixed_position_child->SetTransform(rotation_about_z);
 
   CommitAndUpdateImplPointers();
   LayerImpl* fixed_position_child_impl =
       great_grand_child_impl_->children()[0].get();
 
   // Case 1: scroll delta of 0, 0
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
 
   gfx::Transform expected_grand_child_surface_draw_transform;
   expected_grand_child_surface_draw_transform.Translate(8.0, 6.0);
 
   gfx::Transform expected_grand_child_transform;
 
@@ skipping 16 matching lines @@
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_surface_draw_transform,
       great_grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
                                   fixed_position_child_impl->DrawTransform());
 
   // Case 2: scroll delta of 10, 30
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 30));
   ExecuteCalculateDrawProperties(root_impl_);
 
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -30.0);  // scroll delta
 
   expected_grand_child_surface_draw_transform.MakeIdentity();
   expected_grand_child_surface_draw_transform.Translate(-10.0,
                                                         -30.0);  // scroll delta
   expected_grand_child_surface_draw_transform.Translate(8.0, 6.0);
 
@@ skipping 36 matching lines @@
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
                                   fixed_position_child_impl->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   fixed_position_child->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
   fixed_position_child_impl = great_grand_child_impl_->children()[0].get();
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 30));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_fixed_position_child_transform.MakeIdentity();
   // explicit canceling out the scroll delta that gets embedded in the fixed
   // position layer's surface.
   expected_fixed_position_child_transform.Translate(10.0, 30.0);
   // Also apply size delta in the child(container) layer space.
   expected_fixed_position_child_transform.Translate(20.0, 20.0);
@@ skipping 43 matching lines @@
   rotation_about_z.RotateAboutZAxis(30.0);
   rotation_about_z.Translate(-50.0, -50.0);
   child_transform_layer_->SetTransform(rotation_about_z);
   fixed_position_child->SetTransform(rotation_about_z);
 
   CommitAndUpdateImplPointers();
   LayerImpl* fixed_position_child_impl =
       great_grand_child_impl_->children()[0].get();
 
   // Case 1: scroll delta of 0, 0
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   expected_child_transform.PreconcatTransform(rotation_about_z);
 
   gfx::Transform expected_grand_child_surface_draw_transform;
   expected_grand_child_surface_draw_transform.PreconcatTransform(
       rotation_about_z);
   expected_grand_child_surface_draw_transform.Translate(8.0, 6.0);
@@ skipping 19 matching lines @@
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_surface_draw_transform,
       great_grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
                                   fixed_position_child_impl->DrawTransform());
 
   // Case 2: scroll delta of 10, 30
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 30));
   ExecuteCalculateDrawProperties(root_impl_);
 
   expected_child_transform.MakeIdentity();
   expected_child_transform.PreconcatTransform(rotation_about_z);
   expected_child_transform.Translate(-10.0, -30.0);  // scroll delta
 
   expected_grand_child_surface_draw_transform.MakeIdentity();
   expected_grand_child_surface_draw_transform.PreconcatTransform(
       rotation_about_z);
   expected_grand_child_surface_draw_transform.Translate(-10.0,
@@ skipping 38 matching lines @@
   // should be treated like a layer that contributes to a render target, and
   // that render target is completely irrelevant; it should not affect the
   // scroll compensation.
   child_->SetIsContainerForFixedPositionLayers(true);
   child_->SetForceRenderSurface(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_surface_draw_transform;
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform;
   EXPECT_TRUE(child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_surface_draw_transform,
       child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 10
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // The surface is translated by scroll delta, the child transform doesn't
   // change because it scrolls along with the surface, but the fixed position
   // grand_child needs to compensate for the scroll translation.
   expected_surface_draw_transform.MakeIdentity();
   expected_surface_draw_transform.Translate(-10.0, -10.0);
   expected_grand_child_transform.MakeIdentity();
   expected_grand_child_transform.Translate(10.0, 10.0);
 
@@ skipping 12 matching lines @@
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_grand_child_transform.MakeIdentity();
   // The surface is translated by scroll delta, the child transform doesn't
   // change because it scrolls along with the surface, but the fixed position
   // grand_child needs to compensate for the scroll translation.
   expected_grand_child_transform.Translate(10.0, 10.0);
   // Apply size delta from the child(container) layer.
@@ skipping 13 matching lines @@
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   // This should not confuse the grand_child. If correct, the grand_child would
   // still be considered fixed to its container (i.e. "child").
   grand_child_->SetIsContainerForFixedPositionLayers(true);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 10
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child is affected by scroll delta, but the fixed position
   // grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -10.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 
   // Case 3: fixed-container size delta of 20, 20
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
 
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_grand_child_transform.MakeIdentity();
   // Apply size delta from the child(container) layer.
   expected_grand_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
@@ skipping 13 matching lines @@
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   // Note carefully - great_grand_child is fixed to bottom right, to test
   // sizeDelta being applied correctly; the compensation skips the grand_child
   // because it is fixed to top left.
   great_grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scrollDelta
-  child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 10));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child is affected by scroll delta, but the fixed position
   // grand_child should not be affected.
   gfx::Transform expected_child_transform;
   expected_child_transform.Translate(-10.0, -10.0);
 
   gfx::Transform expected_grand_child_transform;
   gfx::Transform expected_great_grand_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
 
   // Case 2: sizeDelta
-  child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   expected_child_transform.MakeIdentity();
 
   expected_grand_child_transform.MakeIdentity();
 
   // Fixed to bottom-right, size-delta compensation is applied.
   expected_great_grand_child_transform.MakeIdentity();
   expected_great_grand_child_transform.Translate(20.0, 20.0);
@@ skipping 24 matching lines @@
   great_grand_child_->SetScrollClipLayerId(root_->id());
   great_great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   LayerImpl* container1 = child_impl_;
   LayerImpl* fixed_to_container1 = grand_child_impl_;
   LayerImpl* container2 = great_grand_child_impl_;
   LayerImpl* fixed_to_container2 = container2->children()[0].get();
 
-  container1->SetScrollDelta(gfx::Vector2d(0, 15));
+  SetScrollOffsetDelta(container1, gfx::Vector2d(0, 15));
   container1->SetDrawsContent(true);
-  container2->SetScrollDelta(gfx::Vector2d(30, 0));
+  SetScrollOffsetDelta(container2, gfx::Vector2d(30, 0));
   container2->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_container1_transform;
   expected_container1_transform.Translate(0.0, -15.0);
 
   gfx::Transform expected_fixed_to_container1_transform;
 
   // Since the container is a descendant of the fixed layer above,
   // the expected draw transform for container2 would not
@@ skipping 25 matching lines @@
   fixed_child->SetBounds(gfx::Size(300, 300));
   scroll_layer_->AddChild(fixed_child);
   fixed_child->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   LayerImpl* fixed_child_impl =
       root_impl_->layer_tree_impl()->FindActiveTreeLayerById(fixed_child->id());
 
   // Case 1: fixed-container size delta of 20, 20
-  scroll_layer_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(scroll_layer_impl_, gfx::Vector2d(10, 10));
   scroll_layer_impl_->SetDrawsContent(true);
   SetFixedContainerSizeDelta(scroll_layer_impl_, gfx::Vector2d(20, 20));
   gfx::Transform expected_scroll_layer_transform;
   expected_scroll_layer_transform.Translate(-10.0, -10.0);
   gfx::Transform expected_fixed_child_transform;
 
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scroll_layer_transform,
                                   scroll_layer_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_child_transform,
                                   fixed_child_impl->DrawTransform());
 
   // Case 2: Bottom-right fixed-position layer.
   fixed_child->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
   fixed_child_impl =
       root_impl_->layer_tree_impl()->FindActiveTreeLayerById(fixed_child->id());
 
-  scroll_layer_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  SetScrollOffsetDelta(scroll_layer_impl_, gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(scroll_layer_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_fixed_child_transform.MakeIdentity();
   // Apply size delta.
   expected_fixed_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scroll_layer_transform,
                                   scroll_layer_impl_->DrawTransform());
@@ skipping 22 matching lines @@
   VerifySerializeAndDeserializeProto(true, false, true);
   VerifySerializeAndDeserializeProto(true, false, false);
   VerifySerializeAndDeserializeProto(false, true, true);
   VerifySerializeAndDeserializeProto(false, true, false);
   VerifySerializeAndDeserializeProto(false, false, true);
   VerifySerializeAndDeserializeProto(false, false, false);
 }
 
 }  // namespace
 }  // namespace cc