Clean LayerImpl's scroll offset callers in unit tests.

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 327 matching lines @@
                                false);
   scoped_ptr<LayerImpl> clip_layer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 4));
   LayerImpl* clip_layer = clip_layer_scoped_ptr.get();
 
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   clip_layer->SetBounds(
       gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(),
                 scroll_layer->bounds().height() + kMaxScrollOffset.y()));
   scroll_layer->SetScrollClipLayer(clip_layer->id());
-  scroll_layer->SetScrollDelta(kScrollDelta);
+  SetScrollOffsetDelta(scroll_layer, kScrollDelta);
   gfx::Transform impl_transform;
   scroll_layer->AddChild(std::move(sublayer_scoped_ptr));
   LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get();
   clip_layer->AddChild(std::move(scroll_layer_scoped_ptr));
-  scroll_layer_raw_ptr->PushScrollOffsetFromMainThread(kScrollOffset);
+  scroll_layer_raw_ptr->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer_raw_ptr->id(),
+                                                     kScrollOffset);
 
   scoped_ptr<LayerImpl> root(LayerImpl::Create(host_impl.active_tree(), 3));
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(3, 4), true, false,
                                false);
   root->AddChild(std::move(clip_layer_scoped_ptr));
   root->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(
       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
@@ skipping 6789 matching lines @@
   container->SetDrawsContent(true);
   scroller->SetDrawsContent(true);
   fixed->SetDrawsContent(true);
   scroller->AddChild(std::move(fixed));
   container->AddChild(std::move(scroller));
   root->AddChild(std::move(container));
 
   // Rounded to integers already.
   {
     gfx::Vector2dF scroll_delta(3.0, 5.0);
-    scroll_layer->SetScrollDelta(scroll_delta);
+    SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
     LayerImplList render_surface_layer_list;
     root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list,
         root->layer_tree_impl()->current_render_surface_list_id());
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - scroll_delta);
   }
 
   // Scroll delta requiring rounding.
   {
     gfx::Vector2dF scroll_delta(4.1f, 8.1f);
-    scroll_layer->SetScrollDelta(scroll_delta);
+    SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
     gfx::Vector2dF rounded_scroll_delta(4.f, 8.f);
 
     LayerImplList render_surface_layer_list;
     root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list,
         root->layer_tree_impl()->current_render_surface_list_id());
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
@@ skipping 12 matching lines @@
   {
     gfx::Transform scaled_container_transform = container_transform;
     scaled_container_transform.Scale3d(2.0, 2.0, 1.0);
     container_layer->SetTransform(scaled_container_transform);
     root->layer_tree_impl()->property_trees()->needs_rebuild = true;
     root->layer_tree_impl()
         ->property_trees()
         ->transform_tree.set_source_to_parent_updates_allowed(true);
 
     gfx::Vector2dF scroll_delta(4.5f, 8.5f);
-    scroll_layer->SetScrollDelta(scroll_delta);
+    SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
     LayerImplList render_surface_layer_list;
     root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list,
         root->layer_tree_impl()->current_render_surface_list_id());
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
@@ skipping 59 matching lines @@
                                gfx::Size(30, 30), true, false, false);
 
   gfx::ScrollOffset scroll_offset(3.3, 4.2);
   gfx::Vector2dF main_scroll_fractional_part(0.3f, 0.2f);
   gfx::Vector2dF scroll_delta(0.1f, 0.4f);
   // Blink only uses the integer part of the scroll_offset for fixed
   // position layer.
   SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(3.0f, 4.0f), gfx::Size(50, 50), true,
                                false, false);
-  scroll_layer->PushScrollOffsetFromMainThread(scroll_offset);
-  scroll_layer->SetScrollDelta(scroll_delta);
+  scroll_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
+                                                     scroll_offset);
+  SetScrollOffsetDelta(scroll_layer, scroll_delta);
   scroll_layer->SetScrollCompensationAdjustment(main_scroll_fractional_part);
 
   scroller->AddChild(std::move(fixed));
   container->AddChild(std::move(scroller));
   root->AddChild(std::move(container));
 
   LayerImplList render_surface_layer_list;
   root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list,
@@ skipping 62 matching lines @@
   end_operations.AppendMatrix(end_scale);
   if (layer_settings().use_compositor_animation_timelines) {
     AddAnimatedTransformToLayerWithPlayer(animated_layer->id(), timeline_impl(),
                                           1.0, start_operations,
                                           end_operations);
   } else {
     AddAnimatedTransformToLayer(animated_layer, 1.0, start_operations,
                                 end_operations);
   }
   gfx::Vector2dF scroll_delta(5.f, 9.f);
-  scroller->SetScrollDelta(scroll_delta);
+  SetScrollOffsetDelta(scroller, scroll_delta);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Vector2dF expected_draw_transform_translation(-7.5f, -13.5f);
   EXPECT_VECTOR2DF_EQ(expected_draw_transform_translation,
                       scroller->DrawTransform().To2dTranslation());
 }
 
 class AnimationScaleFactorTrackingLayerImpl : public LayerImpl {
  public:
@@ skipping 2805 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc