Clean LayerImpl's scroll offset callers in unit tests.

cc/trees/layer_tree_host_unittest_scroll.cc

 // Copyright 2012 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.h"
 
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 38 matching lines @@
   return scroll_state;
 }
 
 scoped_ptr<ScrollState> EndState() {
   ScrollStateData scroll_state_data;
   scroll_state_data.is_ending = true;
   scoped_ptr<ScrollState> scroll_state(new ScrollState(scroll_state_data));
   return scroll_state;
 }
 
+static ScrollTree* ScrollTreeForLayer(LayerImpl* layer_impl) {
+  return &layer_impl->layer_tree_impl()->property_trees()->scroll_tree;
+}
+
 class LayerTreeHostScrollTest : public LayerTreeTest {
  protected:
   void SetupTree() override {
     LayerTreeTest::SetupTree();
     Layer* root_layer = layer_tree_host()->root_layer();
 
     // Create an effective max_scroll_offset of (100, 100).
     gfx::Size scroll_layer_bounds(root_layer->bounds().width() + 100,
                                   root_layer->bounds().height() + 100);
 
@@ skipping 30 matching lines @@
                        scroll_layer->scroll_offset());
 
       // Pretend like Javascript updated the scroll position itself.
       scroll_layer->SetScrollOffset(second_scroll_);
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
-    EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
+    EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(scroll_layer));
 
     scroll_layer->SetScrollClipLayer(root->children()[0]->id());
     scroll_layer->SetBounds(
         gfx::Size(root->bounds().width() + 100, root->bounds().height() + 100));
     scroll_layer->ScrollBy(scroll_amount_);
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
+        EXPECT_VECTOR_EQ(initial_scroll_, ScrollTreeForLayer(scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  scroll_layer->id()));
+        EXPECT_VECTOR_EQ(scroll_amount_, ScrollDelta(scroll_layer));
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(second_scroll_, scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
+        EXPECT_VECTOR_EQ(second_scroll_, ScrollTreeForLayer(scroll_layer)
+                                             ->GetScrollOffsetBaseForTesting(
+                                                 scroll_layer->id()));
+        EXPECT_VECTOR_EQ(scroll_amount_, ScrollDelta(scroll_layer));
         EndTest();
         break;
     }
   }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale,
                            float top_controls_delta) override {
@@ skipping 41 matching lines @@
         break;
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* scroll_layer =
         impl->active_tree()->LayerById(scroll_layer_->id());
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumberForTesting() == 1) {
       // First draw after first commit.
-      EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
+      EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(scroll_layer));
       scroll_layer->ScrollBy(scroll_amount_);
-      EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
+      EXPECT_VECTOR_EQ(scroll_amount_, ScrollDelta(scroll_layer));
 
-      EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
+      EXPECT_VECTOR_EQ(initial_scroll_,
+                       ScrollTreeForLayer(scroll_layer)
+                           ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
       PostSetNeedsRedrawToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumberForTesting() == 2) {
       // Second draw after first commit.
-      EXPECT_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
+      EXPECT_EQ(ScrollDelta(scroll_layer), scroll_amount_);
       scroll_layer->ScrollBy(scroll_amount_);
       EXPECT_VECTOR_EQ(scroll_amount_ + scroll_amount_,
-                       scroll_layer->ScrollDelta());
+                       ScrollDelta(scroll_layer));
 
       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer_->scroll_offset());
       PostSetNeedsCommitToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 1) {
       // Third or later draw after second commit.
       EXPECT_GE(impl->SourceAnimationFrameNumberForTesting(), 3u);
-      EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer_->ScrollDelta());
       EXPECT_VECTOR_EQ(
           gfx::ScrollOffsetWithDelta(initial_scroll_,
                                      scroll_amount_ + scroll_amount_),
           scroll_layer_->scroll_offset());
       EndTest();
     }
   }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
@@ skipping 105 matching lines @@
   void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     num_impl_commits_++;
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root_scroll_layer = impl->OuterViewportScrollLayer();
 
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumberForTesting() == 1) {
       // First draw
-      EXPECT_VECTOR_EQ(gfx::Vector2d(), root_scroll_layer->ScrollDelta());
+      EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(root_scroll_layer));
       root_scroll_layer->ScrollBy(impl_scroll_);
-      EXPECT_VECTOR_EQ(impl_scroll_, root_scroll_layer->ScrollDelta());
-      EXPECT_VECTOR_EQ(initial_scroll_, root_scroll_layer->BaseScrollOffset());
+      EXPECT_VECTOR_EQ(impl_scroll_, ScrollDelta(root_scroll_layer));
+      EXPECT_VECTOR_EQ(initial_scroll_, ScrollTreeForLayer(root_scroll_layer)
+                                            ->GetScrollOffsetBaseForTesting(
+                                                root_scroll_layer->id()));
 
       EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
       impl->active_tree()->SetPageScaleOnActiveTree(impl_scale_);
       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_, impl->active_tree()->current_page_scale_factor());
 
       // To simplify the testing flow, don't redraw here, just commit.
       impl->SetNeedsCommit();
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumberForTesting() == 2) {
       // Test a second draw after an aborted commit.
       // The scroll/scale values should be baked into the offset/scale factor
       // since the main thread consumed but aborted the begin frame.
-      EXPECT_VECTOR_EQ(gfx::Vector2d(), root_scroll_layer->ScrollDelta());
+      EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(root_scroll_layer));
       root_scroll_layer->ScrollBy(impl_scroll_);
-      EXPECT_VECTOR_EQ(impl_scroll_, root_scroll_layer->ScrollDelta());
+      EXPECT_VECTOR_EQ(impl_scroll_, ScrollDelta(root_scroll_layer));
       EXPECT_VECTOR_EQ(
           gfx::ScrollOffsetWithDelta(initial_scroll_, impl_scroll_),
-          root_scroll_layer->BaseScrollOffset());
+          ScrollTreeForLayer(root_scroll_layer)
+              ->GetScrollOffsetBaseForTesting(root_scroll_layer->id()));
 
       EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_, impl->active_tree()->current_page_scale_factor());
       impl->active_tree()->SetPageScaleOnActiveTree(impl_scale_ * impl_scale_);
       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_ * impl_scale_,
                 impl->active_tree()->current_page_scale_factor());
 
       impl->SetNeedsCommit();
     } else if (impl->active_tree()->source_frame_number() == 1) {
       // Commit for source frame 1 is aborted.
       NOTREACHED();
     } else if (impl->active_tree()->source_frame_number() == 2 &&
                impl->SourceAnimationFrameNumberForTesting() == 3) {
       // Third draw after the second full commit.
-      EXPECT_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
+      EXPECT_EQ(ScrollDelta(root_scroll_layer), gfx::Vector2d());
       root_scroll_layer->ScrollBy(impl_scroll_);
       impl->SetNeedsCommit();
-      EXPECT_VECTOR_EQ(impl_scroll_, root_scroll_layer->ScrollDelta());
+      EXPECT_VECTOR_EQ(impl_scroll_, ScrollDelta(root_scroll_layer));
       gfx::Vector2dF delta = impl_scroll_ + impl_scroll_ + second_main_scroll_;
-      EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
-                       root_scroll_layer->BaseScrollOffset());
+      EXPECT_VECTOR_EQ(
+          gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
+          ScrollTreeForLayer(root_scroll_layer)
+              ->GetScrollOffsetBaseForTesting(root_scroll_layer->id()));
     } else if (impl->active_tree()->source_frame_number() == 2 &&
                impl->SourceAnimationFrameNumberForTesting() == 4) {
       // Final draw after the second aborted commit.
-      EXPECT_VECTOR_EQ(gfx::Vector2d(), root_scroll_layer->ScrollDelta());
+      EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(root_scroll_layer));
       gfx::Vector2dF delta =
           impl_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_;
-      EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
-                       root_scroll_layer->BaseScrollOffset());
+      EXPECT_VECTOR_EQ(
+          gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
+          ScrollTreeForLayer(root_scroll_layer)
+              ->GetScrollOffsetBaseForTesting(root_scroll_layer->id()));
       EndTest();
     } else {
       // Commit for source frame 3 is aborted.
       NOTREACHED();
     }
   }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
@@ skipping 39 matching lines @@
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
 
     // Check that a fractional scroll delta is correctly accumulated over
     // multiple commits.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(gfx::Vector2d(0, 0), scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(gfx::Vector2d(0, 0), scroll_layer->ScrollDelta());
+        EXPECT_VECTOR_EQ(
+            gfx::Vector2d(0, 0),
+            ScrollTreeForLayer(scroll_layer)
+                ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
+        EXPECT_VECTOR_EQ(gfx::Vector2d(0, 0), ScrollDelta(scroll_layer));
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(gfx::ToFlooredVector2d(scroll_amount_),
-                         scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(
+            gfx::ToFlooredVector2d(scroll_amount_),
+            ScrollTreeForLayer(scroll_layer)
+                ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
         EXPECT_VECTOR_EQ(gfx::Vector2dF(fmod(scroll_amount_.x(), 1.0f), 0.0f),
-                         scroll_layer->ScrollDelta());
+                         ScrollDelta(scroll_layer));
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_VECTOR_EQ(
             gfx::ToFlooredVector2d(scroll_amount_ + scroll_amount_),
-            scroll_layer->BaseScrollOffset());
+            ScrollTreeForLayer(scroll_layer)
+                ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
         EXPECT_VECTOR_EQ(
             gfx::Vector2dF(fmod(2.0f * scroll_amount_.x(), 1.0f), 0.0f),
-            scroll_layer->ScrollDelta());
+            ScrollDelta(scroll_layer));
         EndTest();
         break;
     }
     scroll_layer->ScrollBy(scroll_amount_);
   }
 
   void AfterTest() override {}
 
  private:
   gfx::Vector2dF scroll_amount_;
@@ skipping 126 matching lines @@
     LayerImpl* expected_scroll_layer_impl = NULL;
     LayerImpl* expected_no_scroll_layer_impl = NULL;
     if (scroll_child_layer_) {
       expected_scroll_layer_impl = child_layer_impl;
       expected_no_scroll_layer_impl = root_scroll_layer_impl;
     } else {
       expected_scroll_layer_impl = root_scroll_layer_impl;
       expected_no_scroll_layer_impl = child_layer_impl;
     }
 
-    EXPECT_VECTOR_EQ(gfx::Vector2d(), inner_scroll->ScrollDelta());
+    EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(inner_scroll));
     EXPECT_VECTOR_EQ(gfx::Vector2d(),
-                     expected_no_scroll_layer_impl->ScrollDelta());
+                     ScrollDelta(expected_no_scroll_layer_impl));
 
     // Ensure device scale factor matches the active tree.
     EXPECT_EQ(device_scale_factor_, impl->active_tree()->device_scale_factor());
     switch (impl->active_tree()->source_frame_number()) {
       case 0: {
         // GESTURE scroll on impl thread. Also tests that the last scrolled
         // layer id is stored even after the scrolling ends.
         gfx::Point scroll_point =
             gfx::ToCeiledPoint(expected_scroll_layer_impl->position() -
                                gfx::Vector2dF(0.5f, 0.5f));
         InputHandler::ScrollStatus status = impl->ScrollBegin(
             BeginState(scroll_point).get(), InputHandler::GESTURE);
         EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread);
         impl->ScrollBy(UpdateState(gfx::Point(), scroll_amount_).get());
         LayerImpl* scrolling_layer = impl->CurrentlyScrollingLayer();
         CHECK(scrolling_layer);
         impl->ScrollEnd(EndState().get());
         CHECK(!impl->CurrentlyScrollingLayer());
         EXPECT_EQ(scrolling_layer->id(),
                   impl->active_tree()->LastScrolledLayerId());
 
         // Check the scroll is applied as a delta.
         EXPECT_VECTOR_EQ(initial_offset_,
-                         expected_scroll_layer_impl->BaseScrollOffset());
+                         ScrollTreeForLayer(expected_scroll_layer_impl)
+                             ->GetScrollOffsetBaseForTesting(
+                                 expected_scroll_layer_impl->id()));
         EXPECT_VECTOR_EQ(scroll_amount_,
-                         expected_scroll_layer_impl->ScrollDelta());
+                         ScrollDelta(expected_scroll_layer_impl));
         break;
       }
       case 1: {
         // WHEEL scroll on impl thread.
         gfx::Point scroll_point =
             gfx::ToCeiledPoint(expected_scroll_layer_impl->position() +
                                gfx::Vector2dF(0.5f, 0.5f));
         InputHandler::ScrollStatus status = impl->ScrollBegin(
             BeginState(scroll_point).get(), InputHandler::WHEEL);
         EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread);
         impl->ScrollBy(UpdateState(gfx::Point(), scroll_amount_).get());
         impl->ScrollEnd(EndState().get());
 
         // Check the scroll is applied as a delta.
         EXPECT_VECTOR_EQ(javascript_scroll_,
-                         expected_scroll_layer_impl->BaseScrollOffset());
+                         ScrollTreeForLayer(expected_scroll_layer_impl)
+                             ->GetScrollOffsetBaseForTesting(
+                                 expected_scroll_layer_impl->id()));
         EXPECT_VECTOR_EQ(scroll_amount_,
-                         expected_scroll_layer_impl->ScrollDelta());
+                         ScrollDelta(expected_scroll_layer_impl));
         break;
       }
       case 2:
 
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(javascript_scroll_, scroll_amount_),
-            expected_scroll_layer_impl->BaseScrollOffset());
+            ScrollTreeForLayer(expected_scroll_layer_impl)
+                ->GetScrollOffsetBaseForTesting(
+                    expected_scroll_layer_impl->id()));
         EXPECT_VECTOR_EQ(gfx::Vector2d(),
-                         expected_scroll_layer_impl->ScrollDelta());
+                         ScrollDelta(expected_scroll_layer_impl));
 
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {
     if (scroll_child_layer_) {
       EXPECT_EQ(0, num_scrolls_);
       EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(javascript_scroll_,
@@ skipping 157 matching lines @@
 
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
     LayerImpl* pending_root =
         impl->active_tree()->FindPendingTreeLayerById(root->id());
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         if (!impl->pending_tree()) {
           impl->BlockNotifyReadyToActivateForTesting(true);
-          EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
+          EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(scroll_layer));
           scroll_layer->ScrollBy(impl_thread_scroll1_);
 
-          EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
-          EXPECT_VECTOR_EQ(impl_thread_scroll1_, scroll_layer->ScrollDelta());
+          EXPECT_VECTOR_EQ(initial_scroll_, ScrollTreeForLayer(scroll_layer)
+                                                ->GetScrollOffsetBaseForTesting(
+                                                    scroll_layer->id()));
+          EXPECT_VECTOR_EQ(impl_thread_scroll1_, ScrollDelta(scroll_layer));
           PostSetNeedsCommitToMainThread();
 
           // CommitCompleteOnThread will trigger this function again
           // and cause us to take the else clause.
         } else {
           impl->BlockNotifyReadyToActivateForTesting(false);
           ASSERT_TRUE(pending_root);
           EXPECT_EQ(impl->pending_tree()->source_frame_number(), 1);
 
           scroll_layer->ScrollBy(impl_thread_scroll2_);
-          EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
+          EXPECT_VECTOR_EQ(initial_scroll_, ScrollTreeForLayer(scroll_layer)
+                                                ->GetScrollOffsetBaseForTesting(
+                                                    scroll_layer->id()));
           EXPECT_VECTOR_EQ(impl_thread_scroll1_ + impl_thread_scroll2_,
-                           scroll_layer->ScrollDelta());
+                           ScrollDelta(scroll_layer));
 
           LayerImpl* pending_scroll_layer =
               impl->pending_tree()->OuterViewportScrollLayer();
           EXPECT_VECTOR_EQ(
               gfx::ScrollOffsetWithDelta(
                   initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_),
-              pending_scroll_layer->BaseScrollOffset());
+              ScrollTreeForLayer(pending_scroll_layer)
+                  ->GetScrollOffsetBaseForTesting(pending_scroll_layer->id()));
           EXPECT_VECTOR_EQ(impl_thread_scroll2_,
-                           pending_scroll_layer->ScrollDelta());
+                           ScrollDelta(pending_scroll_layer));
         }
         break;
       case 1:
         EXPECT_FALSE(impl->pending_tree());
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(
                 initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_),
-            scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(impl_thread_scroll2_, scroll_layer->ScrollDelta());
+            ScrollTreeForLayer(scroll_layer)
+                ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
+        EXPECT_VECTOR_EQ(impl_thread_scroll2_, ScrollDelta(scroll_layer));
         EndTest();
         break;
     }
   }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale,
                            float top_controls_delta) override {
@@ skipping 67 matching lines @@
     LayerImpl* active_scroll_layer =
         active_root ? impl->OuterViewportScrollLayer() : NULL;
     LayerImpl* pending_root = impl->pending_tree()->root_layer();
     LayerImpl* pending_scroll_layer =
         impl->pending_tree()->OuterViewportScrollLayer();
 
     ASSERT_TRUE(pending_root);
     ASSERT_TRUE(pending_scroll_layer);
     switch (impl->pending_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(initial_scroll_,
-                         pending_scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(gfx::Vector2d(), pending_scroll_layer->ScrollDelta());
+        EXPECT_VECTOR_EQ(
+            initial_scroll_,
+            ScrollTreeForLayer(pending_scroll_layer)
+                ->GetScrollOffsetBaseForTesting(pending_scroll_layer->id()));
+        EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(pending_scroll_layer));
         EXPECT_FALSE(active_root);
         break;
       case 1:
         // Even though the scroll happened during the commit, both layers
         // should have the appropriate scroll delta.
-        EXPECT_VECTOR_EQ(initial_scroll_,
-                         pending_scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(
+            initial_scroll_,
+            ScrollTreeForLayer(pending_scroll_layer)
+                ->GetScrollOffsetBaseForTesting(pending_scroll_layer->id()));
         EXPECT_VECTOR_EQ(impl_thread_scroll_,
-                         pending_scroll_layer->ScrollDelta());
+                         ScrollDelta(pending_scroll_layer));
         ASSERT_TRUE(active_root);
-        EXPECT_VECTOR_EQ(initial_scroll_,
-                         active_scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(impl_thread_scroll_,
-                         active_scroll_layer->ScrollDelta());
+        EXPECT_VECTOR_EQ(
+            initial_scroll_,
+            ScrollTreeForLayer(active_scroll_layer)
+                ->GetScrollOffsetBaseForTesting(active_scroll_layer->id()));
+        EXPECT_VECTOR_EQ(impl_thread_scroll_, ScrollDelta(active_scroll_layer));
         break;
       case 2:
         // On the next commit, this delta should have been sent and applied.
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(initial_scroll_, impl_thread_scroll_),
-            pending_scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(gfx::Vector2d(), pending_scroll_layer->ScrollDelta());
+            ScrollTreeForLayer(pending_scroll_layer)
+                ->GetScrollOffsetBaseForTesting(pending_scroll_layer->id()));
+        EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(pending_scroll_layer));
         break;
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (impl->pending_tree())
       impl->SetNeedsRedraw();
 
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
+        EXPECT_VECTOR_EQ(initial_scroll_, ScrollTreeForLayer(scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  scroll_layer->id()));
+        EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(scroll_layer));
         EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
         EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
-        EXPECT_VECTOR_EQ(impl_thread_scroll_, scroll_layer->ScrollDelta());
+        EXPECT_VECTOR_EQ(initial_scroll_, ScrollTreeForLayer(scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  scroll_layer->id()));
+        EXPECT_VECTOR_EQ(impl_thread_scroll_, ScrollDelta(scroll_layer));
         EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
         EXPECT_EQ(impl_scale_,
                   impl->active_tree()->current_page_scale_factor());
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
         EXPECT_EQ(impl_scale_,
                   impl->active_tree()->current_page_scale_factor());
         EndTest();
@@ skipping 287 matching lines @@
     CreateScrollLayer(root_scroll_layer, &child_scroll_layer_client_);
     fake_content_layer_client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->OuterViewportScrollLayer();
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        root->child_at(0)->SetScrollDelta(gfx::Vector2dF(5, 5));
-        root->child_at(0)->child_at(0)->SetScrollDelta(gfx::Vector2dF(5, 5));
-        root->child_at(1)->SetScrollDelta(gfx::Vector2dF(5, 5));
+        SetScrollOffsetDelta(root->child_at(0), gfx::Vector2dF(5, 5));
+        SetScrollOffsetDelta(root->child_at(0)->child_at(0),
+                             gfx::Vector2dF(5, 5));
+        SetScrollOffsetDelta(root->child_at(1), gfx::Vector2dF(5, 5));
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 27 matching lines @@
     scroll_layer->SetBounds(gfx::Size(parent->bounds().width() + 100,
                                       parent->bounds().height() + 100));
     scroll_layer->set_did_scroll_callback(base::Bind(
         &FakeLayerScrollClient::DidScroll, base::Unretained(client)));
     client->owner_ = this;
     client->layer_ = scroll_layer.get();
     parent->AddChild(scroll_layer);
     return scroll_layer.get();
   }
 
+  static void SetScrollOffsetDelta(LayerImpl* layer_impl,
+                                   const gfx::Vector2dF& delta) {
+    layer_impl->SetCurrentScrollOffset(
+        layer_impl->synced_scroll_offset()->ActiveBase() +
+        gfx::ScrollOffset(delta));
+  }
+
   FakeLayerScrollClient root_scroll_layer_client_;
   FakeLayerScrollClient sibling_scroll_layer_client_;
   FakeLayerScrollClient child_scroll_layer_client_;
 
   FakeContentLayerClient fake_content_layer_client_;
 
   bool scroll_destroy_whole_tree_;
 };
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyLayer) {
   RunTest(CompositorMode::THREADED, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
   scroll_destroy_whole_tree_ = true;
   RunTest(CompositorMode::THREADED, false);
 }
 
 }  // namespace
 }  // namespace cc