Clean LayerImpl's scroll offset callers in unit tests.

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 209 matching lines @@
 
   void SetupRootLayerImpl(scoped_ptr<LayerImpl> root) {
     root->SetPosition(gfx::PointF());
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(true);
     root->draw_properties().visible_layer_rect = gfx::Rect(0, 0, 10, 10);
     root->SetForceRenderSurface(true);
     host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
 
+  static gfx::Vector2dF ScrollDelta(LayerImpl* layer_impl) {
+    if (layer_impl->IsActive())
+      return gfx::Vector2dF(layer_impl->synced_scroll_offset()->Delta().x(),
+                            layer_impl->synced_scroll_offset()->Delta().y());
+    else
+      return gfx::Vector2dF(
+          layer_impl->synced_scroll_offset()->PendingDelta().get().x(),
+          layer_impl->synced_scroll_offset()->PendingDelta().get().y());
+  }
+
   static void ExpectClearedScrollDeltasRecursive(LayerImpl* layer) {
-    ASSERT_EQ(layer->ScrollDelta(), gfx::Vector2d());
+    ASSERT_EQ(ScrollDelta(layer), gfx::Vector2d());
     for (size_t i = 0; i < layer->children().size(); ++i)
       ExpectClearedScrollDeltasRecursive(layer->children()[i].get());
   }
 
   static ::testing::AssertionResult ScrollInfoContains(
       const ScrollAndScaleSet& scroll_info,
       int id,
       const gfx::Vector2d& scroll_delta) {
     int times_encountered = 0;
 
@@ skipping 40 matching lines @@
 
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(layer_tree_impl, 1);
     root->SetBounds(content_size);
     root->SetPosition(gfx::PointF());
     root->SetForceRenderSurface(true);
 
     scoped_ptr<LayerImpl> inner_scroll =
         LayerImpl::Create(layer_tree_impl, kInnerViewportScrollLayerId);
     inner_scroll->SetIsContainerForFixedPositionLayers(true);
-    inner_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
+    inner_scroll->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(inner_scroll->id(),
+                                                       gfx::ScrollOffset());
 
     scoped_ptr<LayerImpl> inner_clip =
         LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
     inner_clip->SetBounds(
         gfx::Size(content_size.width() / 2, content_size.height() / 2));
 
     scoped_ptr<LayerImpl> page_scale =
         LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
     inner_scroll->SetBounds(content_size);
     inner_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> outer_clip =
         LayerImpl::Create(layer_tree_impl, kOuterViewportClipLayerId);
     outer_clip->SetBounds(content_size);
     outer_clip->SetIsContainerForFixedPositionLayers(true);
 
     scoped_ptr<LayerImpl> outer_scroll =
         LayerImpl::Create(layer_tree_impl, kOuterViewportScrollLayerId);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
-    outer_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
+    outer_scroll->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(outer_scroll->id(),
+                                                       gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, kContentLayerId);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
     outer_scroll->AddChild(std::move(contents));
@@ skipping 127 matching lines @@
   virtual scoped_ptr<OutputSurface> CreateOutputSurface() {
     return FakeOutputSurface::Create3d();
   }
 
   void DrawOneFrame() {
     LayerTreeHostImpl::FrameData frame_data;
     PrepareToDrawFrame(&frame_data);
     host_impl_->DidDrawAllLayers(frame_data);
   }
 
+  static void SetScrollOffsetDelta(LayerImpl* layer_impl,
+                                   const gfx::Vector2dF& delta) {
+    layer_impl->SetCurrentScrollOffset(
+        layer_impl->synced_scroll_offset()->ActiveBase() +
+        gfx::ScrollOffset(delta));
+  }
+
   FakeImplTaskRunnerProvider task_runner_provider_;
   DebugScopedSetMainThreadBlocked always_main_thread_blocked_;
 
   TestSharedBitmapManager shared_bitmap_manager_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   TestTaskGraphRunner task_graph_runner_;
   scoped_ptr<OutputSurface> output_surface_;
   scoped_ptr<LayerTreeHostImpl> host_impl_;
   FakeRenderingStatsInstrumentation stats_instrumentation_;
   bool on_can_draw_state_changed_called_;
@@ skipping 121 matching lines @@
   {
     scoped_ptr<LayerImpl> root_clip =
         LayerImpl::Create(host_impl_->active_tree(), 2);
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root_clip->SetBounds(gfx::Size(10, 10));
     LayerImpl* root_layer = root.get();
     root_clip->AddChild(std::move(root));
     root_layer->SetBounds(gfx::Size(110, 110));
     root_layer->SetScrollClipLayer(root_clip->id());
-    root_layer->PushScrollOffsetFromMainThread(scroll_offset);
+    root_layer->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(root_layer->id(),
+                                                       scroll_offset);
     host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
     host_impl_->active_tree()->BuildPropertyTreesForTesting();
     root_layer->ScrollBy(scroll_delta);
   }
 
   LayerImpl* root =
       host_impl_->active_tree()->root_layer()->children()[0].get();
 
   scoped_ptr<ScrollAndScaleSet> scroll_info;
 
@@ skipping 497 matching lines @@
   host_impl_->InnerViewportScrollLayer()->set_user_scrollable_vertical(false);
   EXPECT_FALSE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_FORWARD));
   EXPECT_FALSE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_BACKWARD));
 
   host_impl_->InnerViewportScrollLayer()->set_user_scrollable_vertical(true);
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_FORWARD));
   EXPECT_FLOAT_EQ(875.f,
-                  host_impl_->InnerViewportScrollLayer()->ScrollDelta().y());
+                  ScrollDelta(host_impl_->InnerViewportScrollLayer()).y());
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_BACKWARD));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(200, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   gfx::Size overflow_size(400, 400);
   ASSERT_EQ(1u, scroll_layer->children().size());
   LayerImpl* overflow = scroll_layer->children()[0].get();
   overflow->SetBounds(overflow_size);
   overflow->SetScrollClipLayer(scroll_layer->parent()->parent()->id());
-  overflow->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
+  overflow->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(overflow->id(),
+                                                     gfx::ScrollOffset());
   overflow->SetPosition(gfx::PointF());
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   gfx::Point scroll_position(10, 10);
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(scroll_position).get(),
                                     InputHandler::WHEEL)
                 .thread);
@@ skipping 325 matching lines @@
   EXPECT_EQ(gfx::Size(50, 50), container_layer->bounds());
 
   float min_page_scale = 1.f, max_page_scale = 4.f;
   float page_scale_factor = 1.f;
 
   // The impl-based pinch zoom should adjust the max scroll position.
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(
         page_scale_factor, min_page_scale, max_page_scale);
     host_impl_->active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
 
     float page_scale_delta = 2.f;
 
     host_impl_->ScrollBegin(BeginState(gfx::Point(50, 50)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(50, 50));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_TRUE(did_request_redraw_);
     EXPECT_TRUE(did_request_commit_);
     EXPECT_EQ(gfx::Size(50, 50), container_layer->bounds());
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
 
     EXPECT_EQ(gfx::ScrollOffset(75.0, 75.0).ToString(),
               scroll_layer->MaxScrollOffset().ToString());
   }
 
   // Scrolling after a pinch gesture should always be in local space.  The
   // scroll deltas have the page scale factor applied.
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(
         page_scale_factor, min_page_scale, max_page_scale);
     host_impl_->active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
 
     float page_scale_delta = 2.f;
     host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point());
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     gfx::Vector2d scroll_delta(0, 10);
@@ skipping 218 matching lines @@
   host_impl_->PinchGestureUpdate(2, anchor);
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd(EndState().get());
 
   EXPECT_VECTOR_EQ(
       gfx::Vector2dF(250, 250),
       host_impl_->InnerViewportScrollLayer()->CurrentScrollOffset());
 
   // Reset.
   host_impl_->active_tree()->SetPageScaleOnActiveTree(1.f);
-  host_impl_->InnerViewportScrollLayer()->SetScrollDelta(gfx::Vector2d());
-  host_impl_->OuterViewportScrollLayer()->SetScrollDelta(gfx::Vector2d());
+  SetScrollOffsetDelta(host_impl_->InnerViewportScrollLayer(), gfx::Vector2d());
+  SetScrollOffsetDelta(host_impl_->OuterViewportScrollLayer(), gfx::Vector2d());
 
   // Pinch in within the margins. The scroll should stay exactly locked to the
   // top and left.
   anchor = gfx::Point(offsetFromEdge, offsetFromEdge);
   host_impl_->ScrollBegin(BeginState(anchor).get(), InputHandler::GESTURE);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(2, anchor);
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd(EndState().get());
 
   EXPECT_VECTOR_EQ(
       gfx::Vector2dF(0, 0),
       host_impl_->InnerViewportScrollLayer()->CurrentScrollOffset());
 
   // Reset.
   host_impl_->active_tree()->SetPageScaleOnActiveTree(1.f);
-  host_impl_->InnerViewportScrollLayer()->SetScrollDelta(gfx::Vector2d());
-  host_impl_->OuterViewportScrollLayer()->SetScrollDelta(gfx::Vector2d());
+  SetScrollOffsetDelta(host_impl_->InnerViewportScrollLayer(), gfx::Vector2d());
+  SetScrollOffsetDelta(host_impl_->OuterViewportScrollLayer(), gfx::Vector2d());
 
   // Pinch in just outside the margin. There should be no snapping.
   offsetFromEdge = Viewport::kPinchZoomSnapMarginDips;
   anchor = gfx::Point(offsetFromEdge, offsetFromEdge);
   host_impl_->ScrollBegin(BeginState(anchor).get(), InputHandler::GESTURE);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(2, anchor);
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd(EndState().get());
 
   EXPECT_VECTOR_EQ(
       gfx::Vector2dF(50, 50),
       host_impl_->InnerViewportScrollLayer()->CurrentScrollOffset());
 
   // Reset.
   host_impl_->active_tree()->SetPageScaleOnActiveTree(1.f);
-  host_impl_->InnerViewportScrollLayer()->SetScrollDelta(gfx::Vector2d());
-  host_impl_->OuterViewportScrollLayer()->SetScrollDelta(gfx::Vector2d());
+  SetScrollOffsetDelta(host_impl_->InnerViewportScrollLayer(), gfx::Vector2d());
+  SetScrollOffsetDelta(host_impl_->OuterViewportScrollLayer(), gfx::Vector2d());
 
   // Pinch in just outside the margin. There should be no snapping.
   offsetFromEdge = Viewport::kPinchZoomSnapMarginDips;
   anchor = gfx::Point(viewport_size.width() - offsetFromEdge,
                       viewport_size.height() - offsetFromEdge);
   host_impl_->ScrollBegin(BeginState(anchor).get(), InputHandler::GESTURE);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(2, anchor);
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd(EndState().get());
@@ skipping 187 matching lines @@
   LayerImpl* scroll_layer = host_impl_->InnerViewportScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 1.f;
   float max_page_scale = 4.f;
 
   // Basic pinch zoom in gesture
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
 
     float page_scale_delta = 2.f;
     host_impl_->ScrollBegin(BeginState(gfx::Point(50, 50)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(50, 50));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_TRUE(did_request_redraw_);
     EXPECT_TRUE(did_request_commit_);
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
   }
 
   // Zoom-in clamping
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
     float page_scale_delta = 10.f;
 
     host_impl_->ScrollBegin(BeginState(gfx::Point(50, 50)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(50, 50));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, max_page_scale);
   }
 
   // Zoom-out clamping
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
     scroll_layer->synced_scroll_offset()->PullDeltaForMainThread();
-    scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
+    scroll_layer->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+            scroll_layer->id(), gfx::ScrollOffset(50, 50));
 
     float page_scale_delta = 0.1f;
     host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point());
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, min_page_scale);
 
     EXPECT_TRUE(scroll_info->scrolls.empty());
   }
 
   // Two-finger panning should not happen based on pinch events only
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
     scroll_layer->synced_scroll_offset()->PullDeltaForMainThread();
-    scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(20, 20));
+    scroll_layer->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+            scroll_layer->id(), gfx::ScrollOffset(20, 20));
 
     float page_scale_delta = 1.f;
     host_impl_->ScrollBegin(BeginState(gfx::Point(10, 10)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(10, 10));
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(20, 20));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
     EXPECT_TRUE(scroll_info->scrolls.empty());
   }
 
   // Two-finger panning should work with interleaved scroll events
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
     scroll_layer->synced_scroll_offset()->PullDeltaForMainThread();
-    scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(20, 20));
+    scroll_layer->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+            scroll_layer->id(), gfx::ScrollOffset(20, 20));
 
     float page_scale_delta = 1.f;
     host_impl_->ScrollBegin(BeginState(gfx::Point(10, 10)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(10, 10));
     host_impl_->ScrollBy(
         UpdateState(gfx::Point(10, 10), gfx::Vector2d(-10, -10)).get());
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(20, 20));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
     EXPECT_TRUE(ScrollInfoContains(*scroll_info, scroll_layer->id(),
                                    gfx::Vector2d(-10, -10)));
   }
 
   // Two-finger panning should work when starting fully zoomed out.
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(0.5f, 0.5f, 4.f);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
     scroll_layer->synced_scroll_offset()->PullDeltaForMainThread();
-    scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 0));
+    scroll_layer->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
+                                                       gfx::ScrollOffset(0, 0));
 
     host_impl_->ScrollBegin(BeginState(gfx::Point(0, 0)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(2.f, gfx::Point(0, 0));
     host_impl_->PinchGestureUpdate(1.f, gfx::Point(0, 0));
 
     // Needed so layer transform includes page scale.
     DrawFrame();
 
@@ skipping 27 matching lines @@
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
 
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
 
   // Non-anchor zoom-in
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
-    scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
+    scroll_layer->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+            scroll_layer->id(), gfx::ScrollOffset(50, 50));
 
     did_request_redraw_ = false;
     did_request_next_frame_ = false;
     host_impl_->active_tree()->SetPendingPageScaleAnimation(
         scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
             gfx::Vector2d(),
             false,
             2.f,
             duration)));
     host_impl_->ActivateSyncTree();
@@ skipping 36 matching lines @@
   }
 
   start_time += base::TimeDelta::FromSeconds(10);
   halfway_through_animation += base::TimeDelta::FromSeconds(10);
   end_time += base::TimeDelta::FromSeconds(10);
 
   // Anchor zoom-out
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
-    scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
+    scroll_layer->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+            scroll_layer->id(), gfx::ScrollOffset(50, 50));
 
     did_request_redraw_ = false;
     did_request_next_frame_ = false;
     host_impl_->active_tree()->SetPendingPageScaleAnimation(
         scoped_ptr<PendingPageScaleAnimation> (new PendingPageScaleAnimation(
             gfx::Vector2d(25, 25),
             true,
             min_page_scale,
             duration)));
     host_impl_->ActivateSyncTree();
@@ skipping 45 matching lines @@
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
 
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
 
   // Anchor zoom with unchanged page scale should not change scroll or scale.
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
-    scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
+    scroll_layer->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+            scroll_layer->id(), gfx::ScrollOffset(50, 50));
 
     host_impl_->active_tree()->SetPendingPageScaleAnimation(
         scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
             gfx::Vector2d(),
             true,
             1.f,
             duration)));
     host_impl_->ActivateSyncTree();
     begin_frame_args.frame_time = start_time;
     host_impl_->WillBeginImplFrame(begin_frame_args);
@@ skipping 42 matching lines @@
                                base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks third_through_animation = start_time + duration / 3;
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
   float target_scale = 2.f;
 
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
 
-  scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
+  scroll_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
+                                                     gfx::ScrollOffset(50, 50));
 
   // Make sure TakePageScaleAnimation works properly.
 
   host_impl_->sync_tree()->SetPendingPageScaleAnimation(
       scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
           gfx::Vector2d(),
           false,
           target_scale,
           duration)));
   scoped_ptr<PendingPageScaleAnimation> psa =
@@ skipping 91 matching lines @@
   base::TimeTicks start_time =
       base::TimeTicks() + base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
 
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
 
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
-  scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
+  scroll_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
+                                                     gfx::ScrollOffset(50, 50));
 
   did_complete_page_scale_animation_ = false;
   host_impl_->active_tree()->SetPendingPageScaleAnimation(
       scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
           gfx::Vector2d(), false, 2.f, duration)));
   host_impl_->ActivateSyncTree();
   begin_frame_args.frame_time = start_time;
   host_impl_->WillBeginImplFrame(begin_frame_args);
   host_impl_->Animate();
   EXPECT_FALSE(did_complete_page_scale_animation_);
@@ skipping 189 matching lines @@
     EXPECT_TRUE(did_request_next_frame_);
     did_request_next_frame_ = false;
     EXPECT_TRUE(did_request_redraw_);
     did_request_redraw_ = false;
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
     host_impl_->DidFinishImplFrame();
 
     // Setting the scroll offset outside a scroll should also cause the
     // scrollbar to appear and to schedule a scrollbar animation.
-    host_impl_->InnerViewportScrollLayer()->PushScrollOffsetFromMainThread(
-        gfx::ScrollOffset(5, 5));
+    if (host_impl_->active_tree()
+            ->property_trees()
+            ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+                host_impl_->InnerViewportScrollLayer()->id(),
+                gfx::ScrollOffset(5, 5)))
+      host_impl_->InnerViewportScrollLayer()->DidUpdateScrollOffset();
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
               requested_animation_delay_);
     EXPECT_FALSE(animation_task_.Equals(base::Closure()));
     requested_animation_delay_ = base::TimeDelta();
     animation_task_ = base::Closure();
 
     // Scrolling should have stopped the animation, so we should not be getting
     // redraws.
@@ skipping 1009 matching lines @@
                                 gfx::Size(100, 100));
   host_impl_->pending_tree()->BuildPropertyTreesForTesting();
   host_impl_->ActivateSyncTree();
 
   host_impl_->CreatePendingTree();
   const gfx::ScrollOffset pending_scroll = gfx::ScrollOffset(-100, -100);
   LayerImpl* active_outer_layer =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   LayerImpl* pending_outer_layer =
       host_impl_->pending_tree()->OuterViewportScrollLayer();
-  pending_outer_layer->PushScrollOffsetFromMainThread(pending_scroll);
+  pending_outer_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(pending_outer_layer->id(),
+                                                     pending_scroll);
 
   host_impl_->ActivateSyncTree();
   // Scrolloffsets on the active tree will be clamped after activation.
   EXPECT_EQ(active_outer_layer->CurrentScrollOffset(), gfx::ScrollOffset(0, 0));
 }
 
 class LayerTreeHostImplTopControlsTest : public LayerTreeHostImplTest {
  public:
   LayerTreeHostImplTopControlsTest()
       // Make the clip size the same as the layer (content) size so the layer is
@@ skipping 360 matching lines @@
       LayerImpl::Create(host_impl_->active_tree(), id + 3);
 
   child_clip->SetBounds(sub_content_layer_size);
   child->SetScrollClipLayer(child_clip->id());
   child->SetBounds(sub_content_size);
   child->SetPosition(gfx::PointF());
   child->SetDrawsContent(true);
   child->SetIsContainerForFixedPositionLayers(true);
 
   // scroll child to limit
-  child->SetScrollDelta(gfx::Vector2dF(0, 100.f));
+  SetScrollOffsetDelta(child.get(), gfx::Vector2dF(0, 100.f));
   child_clip->AddChild(std::move(child));
   outer_viewport_scroll_layer->AddChild(std::move(child_clip));
 
   // Scroll 25px to hide top controls
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   host_impl_->active_tree()->property_trees()->needs_rebuild = true;
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::GESTURE)
@@ skipping 139 matching lines @@
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   DrawFrame();
 
   EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
 
   LayerImpl* outer_scroll = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
 
   // Scroll the viewports to max scroll offset.
-  outer_scroll->SetScrollDelta(gfx::Vector2dF(0, 200.f));
-  inner_scroll->SetScrollDelta(gfx::Vector2dF(100, 100.f));
+  SetScrollOffsetDelta(outer_scroll, gfx::Vector2dF(0, 200.f));
+  SetScrollOffsetDelta(inner_scroll, gfx::Vector2dF(100, 100.f));
 
   gfx::ScrollOffset viewport_offset =
       host_impl_->active_tree()->TotalScrollOffset();
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(), viewport_offset);
 
   // Hide the top controls by 25px.
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::GESTURE)
@@ skipping 27 matching lines @@
                                     InputHandler::GESTURE)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
   host_impl_->ScrollEnd(EndState().get());
 
   // The viewport offset shouldn't have changed.
   EXPECT_EQ(viewport_offset,
             host_impl_->active_tree()->TotalScrollOffset());
 
   // Scroll the viewports to max scroll offset.
-  outer_scroll->SetScrollDelta(gfx::Vector2dF(0, 200.f));
-  inner_scroll->SetScrollDelta(gfx::Vector2dF(100, 100.f));
+  SetScrollOffsetDelta(outer_scroll, gfx::Vector2dF(0, 200.f));
+  SetScrollOffsetDelta(inner_scroll, gfx::Vector2dF(100, 100.f));
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(),
             host_impl_->active_tree()->TotalScrollOffset());
 }
 
 // Test that the top controls coming in and out maintains the same aspect ratio
 // between the inner and outer viewports.
 TEST_F(LayerTreeHostImplTopControlsTest, TopControlsAspectRatio) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 2.f);
@@ skipping 67 matching lines @@
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
 
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ContentTopOffset());
   EXPECT_EQ(host_impl_->InnerViewportScrollLayer(),
             host_impl_->CurrentlyScrollingLayer());
 
   host_impl_->ScrollEnd(EndState().get());
 
   // Position the viewports such that the inner viewport will be scrolled.
   gfx::Vector2dF inner_viewport_offset(0.f, 25.f);
-  host_impl_->OuterViewportScrollLayer()->SetScrollDelta(gfx::Vector2dF());
-  host_impl_->InnerViewportScrollLayer()->SetScrollDelta(inner_viewport_offset);
+  SetScrollOffsetDelta(host_impl_->OuterViewportScrollLayer(),
+                       gfx::Vector2dF());
+  SetScrollOffsetDelta(host_impl_->InnerViewportScrollLayer(),
+                       inner_viewport_offset);
 
   scroll_delta = gfx::Vector2dF(0.f, -65.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::GESTURE)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
 
   EXPECT_EQ(top_controls_height_,
             host_impl_->top_controls_manager()->ContentTopOffset());
   EXPECT_FLOAT_EQ(
       inner_viewport_offset.y() + (scroll_delta.y() + top_controls_height_),
-      host_impl_->InnerViewportScrollLayer()->ScrollDelta().y());
+      ScrollDelta(host_impl_->InnerViewportScrollLayer()).y());
 
   host_impl_->ScrollEnd(EndState().get());
 }
 
 TEST_F(LayerTreeHostImplTopControlsTest,
        ScrollNonScrollableRootWithTopControls) {
   settings_ = DefaultSettings();
   CreateHostImpl(settings_, CreateOutputSurface());
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       layer_size_, layer_size_, layer_size_);
@@ skipping 404 matching lines @@
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root.get());
   LayerImpl* grand_child_layer = grand_child.get();
   child->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
   root->AddChild(std::move(child));
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
-  grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 5));
-  child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(3, 0));
+  grand_child_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child_layer->id(),
+                                                     gfx::ScrollOffset(0, 5));
+  child_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(child_layer->id(),
+                                                     gfx::ScrollOffset(3, 0));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(-8, -7);
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                       InputHandler::WHEEL)
                   .thread);
     host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
@@ skipping 40 matching lines @@
   root_scrolling->AddChild(std::move(child));
   root_clip->AddChild(std::move(root_scrolling));
   EXPECT_EQ(viewport_size, root_clip->bounds());
   root_ptr->AddChild(std::move(root_clip));
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 3,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(viewport_size);
 
-  grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 2));
-  child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 3));
+  grand_child_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child_layer->id(),
+                                                     gfx::ScrollOffset(0, 2));
+  child_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(child_layer->id(),
+                                                     gfx::ScrollOffset(0, 3));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, -10);
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                       InputHandler::NON_BUBBLING_GESTURE)
                   .thread);
     host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
@@ skipping 198 matching lines @@
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), gesture_scroll_delta).get());
   host_impl_->ScrollEnd(EndState().get());
 
   // The layer should have scrolled down in its local coordinates.
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   EXPECT_TRUE(ScrollInfoContains(*scroll_info.get(), scroll_layer->id(),
                                  gfx::Vector2d(0, gesture_scroll_delta.x())));
 
   // Reset and scroll down with the wheel.
-  scroll_layer->SetScrollDelta(gfx::Vector2dF());
+  SetScrollOffsetDelta(scroll_layer, gfx::Vector2dF());
   gfx::Vector2d wheel_scroll_delta(0, 10);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::WHEEL)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), wheel_scroll_delta).get());
   host_impl_->ScrollEnd(EndState().get());
 
   // The layer should have scrolled down in its local coordinates.
   scroll_info = host_impl_->ProcessScrollDeltas();
@@ skipping 53 matching lines @@
         host_impl_->ProcessScrollDeltas();
     EXPECT_TRUE(ScrollInfoContains(*scroll_info.get(), child_layer_id,
                                    expected_scroll_delta));
 
     // The root scroll layer should not have scrolled, because the input delta
     // was close to the layer's axis of movement.
     EXPECT_EQ(scroll_info->scrolls.size(), 1u);
   }
   {
     // Now reset and scroll the same amount horizontally.
-    child_ptr->SetScrollDelta(gfx::Vector2dF());
+    SetScrollOffsetDelta(child_ptr, gfx::Vector2dF());
     gfx::Vector2d gesture_scroll_delta(10, 0);
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_->ScrollBegin(BeginState(gfx::Point(1, 1)).get(),
                                       InputHandler::GESTURE)
                   .thread);
     host_impl_->ScrollBy(UpdateState(gfx::Point(), gesture_scroll_delta).get());
     host_impl_->ScrollEnd(EndState().get());
 
     // The child layer shouldn't have scrolled.
     gfx::Vector2d expected_scroll_delta(
@@ skipping 60 matching lines @@
   expected_scroll_deltas[2] = gfx::Vector2d(4, 0);
   expected_scroll_deltas[3] = gfx::Vector2d(4, 0);
 
   gfx::Point viewport_point(1, 1);
 
   SetNeedsRebuildPropertyTrees();
   // Scroll in screen coordinates with a gesture. Each scroll starts
   // where the previous scroll ended, but the scroll position is reset
   // for each scroll.
   for (int i = 0; i < 4; ++i) {
-    child_ptr->SetScrollDelta(gfx::Vector2dF());
+    SetScrollOffsetDelta(child_ptr, gfx::Vector2dF());
     DrawFrame();
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_->ScrollBegin(BeginState(viewport_point).get(),
                                       InputHandler::GESTURE)
                   .thread);
     host_impl_->ScrollBy(
         UpdateState(viewport_point, gesture_scroll_deltas[i]).get());
     viewport_point += gesture_scroll_deltas[i];
     host_impl_->ScrollEnd(EndState().get());
 
@@ skipping 31 matching lines @@
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
   host_impl_->ScrollEnd(EndState().get());
 
   // The layer should have scrolled down in its local coordinates, but half the
   // amount.
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   EXPECT_TRUE(ScrollInfoContains(*scroll_info.get(), scroll_layer->id(),
                                  gfx::Vector2d(0, scroll_delta.y() / scale)));
 
   // Reset and scroll down with the wheel.
-  scroll_layer->SetScrollDelta(gfx::Vector2dF());
+  SetScrollOffsetDelta(scroll_layer, gfx::Vector2dF());
   gfx::Vector2d wheel_scroll_delta(0, 10);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::WHEEL)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), wheel_scroll_delta).get());
   host_impl_->ScrollEnd(EndState().get());
 
   // It should apply the scale factor to the scroll delta for the wheel event.
   scroll_info = host_impl_->ProcessScrollDeltas();
@@ skipping 87 matching lines @@
   host_impl_->SetViewportSize(gfx::Size(10, 20));
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   LayerImpl* clip_layer = scroll_layer->parent()->parent();
   SetNeedsRebuildPropertyTrees();
   clip_layer->SetBounds(gfx::Size(10, 20));
   RebuildPropertyTrees();
 
   host_impl_->BindToClient(&scroll_watcher);
 
   gfx::Vector2dF initial_scroll_delta(10.f, 10.f);
-  scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
-  scroll_layer->SetScrollDelta(initial_scroll_delta);
+  scroll_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
+                                                     gfx::ScrollOffset());
+  SetScrollOffsetDelta(scroll_layer, initial_scroll_delta);
 
   EXPECT_EQ(gfx::ScrollOffset(), scroll_watcher.last_set_scroll_offset());
 
   // Requesting an update results in the current scroll offset being set.
   host_impl_->RequestUpdateForSynchronousInputHandler();
   EXPECT_EQ(gfx::ScrollOffset(initial_scroll_delta),
             scroll_watcher.last_set_scroll_offset());
 
   // Setting the delegate results in the scrollable_size, max_scroll_offset,
   // page_scale_factor and {min|max}_page_scale_factor being set.
@@ skipping 250 matching lines @@
       CreateScrollableLayer(3, surface_size, root_clip.get());
 
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root_clip.get());
   LayerImpl* grand_child_layer = grand_child.get();
   child->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
   root->AddChild(std::move(child));
   root_clip->AddChild(std::move(root));
-  child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 3));
-  grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 2));
+  child_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(child_layer->id(),
+                                                     gfx::ScrollOffset(0, 3));
+  grand_child_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child_layer->id(),
+                                                     gfx::ScrollOffset(0, 2));
   host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, -10);
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                       InputHandler::NON_BUBBLING_GESTURE)
@@ skipping 1513 matching lines @@
                                                    3, raster_source);
   LayerImpl* content_layer = scoped_content_layer.get();
   scrolling_layer->AddChild(std::move(scoped_content_layer));
   content_layer->SetBounds(content_layer_bounds);
   content_layer->SetDrawsContent(true);
 
   root->SetBounds(root_size);
 
   gfx::ScrollOffset scroll_offset(100000, 0);
   scrolling_layer->SetScrollClipLayer(root->id());
-  scrolling_layer->PushScrollOffsetFromMainThread(scroll_offset);
+  scrolling_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(scrolling_layer->id(),
+                                                     scroll_offset);
 
   host_impl_->pending_tree()->BuildPropertyTreesForTesting();
   host_impl_->ActivateSyncTree();
 
   bool update_lcd_text = false;
   host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
   ASSERT_EQ(1u, host_impl_->active_tree()->RenderSurfaceLayerList().size());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
@@ skipping 380 matching lines @@
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // the scroll doesn't bubble up to the parent layer.
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetForceRenderSurface(true);
   scoped_ptr<LayerImpl> root_scrolling =
       CreateScrollableLayer(2, surface_size, root.get());
 
   scoped_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(4, surface_size, root.get());
-  grand_child->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 2));
+  grand_child->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child->id(),
+                                                     gfx::ScrollOffset(0, 2));
 
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(3, surface_size, root.get());
-  child->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 4));
+  child->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(child->id(),
+                                                     gfx::ScrollOffset(0, 4));
   child->AddChild(std::move(grand_child));
 
   root_scrolling->AddChild(std::move(child));
   root->AddChild(std::move(root_scrolling));
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
@@ skipping 533 matching lines @@
     host_impl_->active_tree()->SetCurrentTopControlsShownRatio(1.f);
   }
 
  protected:
   static const int top_controls_height_;
 };
 
 const int LayerTreeHostImplWithTopControlsTest::top_controls_height_ = 50;
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, NoIdleAnimations) {
-  SetupScrollAndContentsLayers(gfx::Size(100, 100))
-      ->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 10));
+  LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
+  scroll_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
+                                                     gfx::ScrollOffset(0, 10));
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
   host_impl_->WillBeginImplFrame(begin_frame_args);
   host_impl_->Animate();
   EXPECT_FALSE(did_request_redraw_);
   host_impl_->DidFinishImplFrame();
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsHeightIsCommitted) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
@@ skipping 14 matching lines @@
   host_impl_->ActivateSyncTree();
   EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ControlsTopOffset());
 
   host_impl_->CreatePendingTree();
   host_impl_->sync_tree()->set_top_controls_height(50);
   host_impl_->ActivateSyncTree();
   EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ControlsTopOffset());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsAnimationScheduling) {
-  SetupScrollAndContentsLayers(gfx::Size(100, 100))
-      ->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 10));
+  LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
+  scroll_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
+                                                     gfx::ScrollOffset(0, 10));
   host_impl_->DidChangeTopControlsPosition();
   EXPECT_TRUE(did_request_next_frame_);
   EXPECT_TRUE(did_request_redraw_);
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, ScrollHandledByTopControls) {
   InputHandlerScrollResult result;
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
   host_impl_->top_controls_manager()->UpdateTopControlsState(
@@ skipping 176 matching lines @@
   }
   EXPECT_FALSE(host_impl_->top_controls_manager()->has_animation());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsAnimationAfterScroll) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
   host_impl_->top_controls_manager()->UpdateTopControlsState(
       BOTH, SHOWN, false);
   float initial_scroll_offset = 50;
-  scroll_layer->PushScrollOffsetFromMainThread(
-      gfx::ScrollOffset(0, initial_scroll_offset));
+  scroll_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+          scroll_layer->id(), gfx::ScrollOffset(0, initial_scroll_offset));
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::GESTURE)
                 .thread);
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
@@ skipping 49 matching lines @@
             host_impl_->top_controls_manager()->ControlsTopOffset());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest,
        TopControlsAnimationAfterMainThreadFlingStopped) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
   host_impl_->top_controls_manager()->UpdateTopControlsState(BOTH, SHOWN,
                                                              false);
   float initial_scroll_offset = 50;
-  scroll_layer->PushScrollOffsetFromMainThread(
-      gfx::ScrollOffset(0, initial_scroll_offset));
+  scroll_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(
+          scroll_layer->id(), gfx::ScrollOffset(0, initial_scroll_offset));
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::GESTURE)
                 .thread);
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
@@ skipping 131 matching lines @@
     LayerTreeImpl* layer_tree_impl = host_impl_->active_tree();
     const int kOuterViewportClipLayerId = 6;
     const int kOuterViewportScrollLayerId = 7;
     const int kInnerViewportScrollLayerId = 2;
     const int kInnerViewportClipLayerId = 4;
     const int kPageScaleLayerId = 5;
 
     scoped_ptr<LayerImpl> inner_scroll =
         LayerImpl::Create(layer_tree_impl, kInnerViewportScrollLayerId);
     inner_scroll->SetIsContainerForFixedPositionLayers(true);
-    inner_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
+    inner_scroll->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(inner_scroll->id(),
+                                                       gfx::ScrollOffset());
 
     scoped_ptr<LayerImpl> inner_clip =
         LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
     inner_clip->SetBounds(inner_viewport);
 
     scoped_ptr<LayerImpl> page_scale =
         LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
     inner_scroll->SetBounds(outer_viewport);
     inner_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> outer_clip =
         LayerImpl::Create(layer_tree_impl, kOuterViewportClipLayerId);
     outer_clip->SetBounds(outer_viewport);
     outer_clip->SetIsContainerForFixedPositionLayers(true);
 
     scoped_ptr<LayerImpl> outer_scroll =
         LayerImpl::Create(layer_tree_impl, kOuterViewportScrollLayerId);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
-    outer_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
+    outer_scroll->layer_tree_impl()
+        ->property_trees()
+        ->scroll_tree.UpdateScrollOffsetBaseForTesting(outer_scroll->id(),
+                                                       gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, 8);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
     outer_scroll->AddChild(std::move(contents));
@@ skipping 1079 matching lines @@
   EXPECT_EQ(scroll_layer, host_impl_->InnerViewportScrollLayer());
 
   float min_page_scale = 1.f, max_page_scale = 4.f;
   float page_scale_factor = 1.f;
 
   // The scroll deltas should have the page scale factor applied.
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(
         page_scale_factor, min_page_scale, max_page_scale);
     host_impl_->active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
-    scroll_layer->SetScrollDelta(gfx::Vector2d());
+    SetScrollOffsetDelta(scroll_layer, gfx::Vector2d());
 
     float page_scale_delta = 2.f;
     host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point());
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     gfx::Vector2dF scroll_delta(0, 5);
@@ skipping 452 matching lines @@
     // There should not be any jitter measured till we hit the fixed point hits
     // threshold.
     float expected_jitter =
         (i == pending_tree->kFixedPointHitsThreshold) ? 500 : 0;
     EXPECT_EQ(jitter, expected_jitter);
   }
 }
 
 }  // namespace
 }  // namespace cc