Clean LayerImpl's scroll offset callers in unit tests.

cc/layers/layer_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/layers/layer_impl.h"
 
 #include "cc/animation/mutable_properties.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/output/filter_operation.h"
@@ skipping 70 matching lines @@
 
 #define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test)             \
   root->ResetAllChangeTrackingForSubtree();                              \
   host_impl.active_tree()->property_trees()->needs_rebuild = true;       \
   host_impl.active_tree()->BuildPropertyTreesForTesting();               \
   host_impl.ForcePrepareToDraw();                                        \
   EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties()); \
   code_to_test;                                                          \
   EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties());
 
+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());
+}
+
 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   //
   // This test checks that layerPropertyChanged() has the correct behavior.
   //
 
   // The constructor on this will fake that we are on the correct thread.
   // Create a simple LayerImpl tree:
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
@@ skipping 61 matching lines @@
       root->SetUpdateRect(arbitrary_rect));
   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(arbitrary_size));
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
   // Changing these properties affects the entire subtree of layers.
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->OnFilterAnimated(arbitrary_filters));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
       root->OnFilterAnimated(FilterOperations()));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d));
-  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d()));
-  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->PushScrollOffsetFromMainThread(
-      gfx::ScrollOffset(arbitrary_vector2d)));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->OnOpacityAnimated(arbitrary_number));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
       root->OnTransformAnimated(arbitrary_transform));
   // SetBoundsDelta changes subtree only when masks_to_bounds is true and it
   // doesn't set needs_push_properties as it is always called on active tree.
   root->SetMasksToBounds(true);
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBoundsDelta(arbitrary_vector2d);
                                      root->SetNeedsPushProperties());
 
   // Changing these properties only affects the layer itself.
@@ skipping 41 matching lines @@
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetMasksToBounds(true));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetPosition(arbitrary_point_f));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetShouldFlattenTransform(false));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->Set3dSortingContextId(1));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetTransform(arbitrary_transform));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetDoubleSided(false));  // constructor initializes it to "true".
-  EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
-      root->SetScrollDelta(gfx::Vector2d()));
-  EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
-      root->PushScrollOffsetFromMainThread(
-          gfx::ScrollOffset(arbitrary_vector2d)));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetContentsOpaque(true));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetOpacity(arbitrary_number));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetBlendMode(arbitrary_blend_mode));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetIsRootForIsolatedGroup(true));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(bounds_size));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetScrollParent(scroll_parent.get()));
@@ skipping 71 matching lines @@
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
       root->OnFilterAnimated(FilterOperations()));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
       root->OnFilterAnimated(arbitrary_filters));
 
   // Related scrolling functions.
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(arbitrary_vector2d));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(gfx::Vector2d()));
-  layer->SetScrollDelta(gfx::Vector2d(0, 0));
-  host_impl.ForcePrepareToDraw();
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      layer->SetScrollDelta(arbitrary_vector2d));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      layer->SetScrollDelta(arbitrary_vector2d));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->PushScrollOffsetFromMainThread(
-      gfx::ScrollOffset(arbitrary_vector2d)));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->DidUpdateScrollOffset());
+  layer->SetCurrentScrollOffset(layer->synced_scroll_offset()->ActiveBase() +
+                                gfx::ScrollOffset());
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetCurrentScrollOffset(
+      gfx::ScrollOffset(arbitrary_vector2d.x(), arbitrary_vector2d.y())));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetCurrentScrollOffset(
+      gfx::ScrollOffset(arbitrary_vector2d.x(), arbitrary_vector2d.y())));
 
   // Unrelated functions, always set to new values, always set needs update.
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
       layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4));
       layer->NoteLayerPropertyChanged());
   host_impl.active_tree()->BuildPropertyTreesForTesting();
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true);
                                       layer->NoteLayerPropertyChanged());
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true);
                                       layer->NoteLayerPropertyChanged());
@@ skipping 141 matching lines @@
     host_impl_.active_tree()->root_layer()->SetBounds(gfx::Size(1, 1));
     gfx::Vector2d max_scroll_offset(51, 81);
     layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y()));
     host_impl_.active_tree()->BuildPropertyTreesForTesting();
   }
 
   LayerImpl* layer() {
     return host_impl_.active_tree()->root_layer()->children()[0].get();
   }
 
+  ScrollTree* scroll_tree(LayerImpl* layer_impl) {
+    return &layer_impl->layer_tree_impl()->property_trees()->scroll_tree;
+  }
+
   LayerTreeHostImpl& host_impl() { return host_impl_; }
 
   LayerTreeImpl* tree() { return host_impl_.active_tree(); }
 
   LayerTreeSettings settings() {
     LayerTreeSettings settings;
     return settings;
   }
 
  private:
   FakeImplTaskRunnerProvider task_runner_provider_;
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   FakeLayerTreeHostImpl host_impl_;
   int root_id_;
 };
 
 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) {
   // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll
   // offset is bounded by the range [0, max scroll offset].
 
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->CurrentScrollOffset());
-  EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->BaseScrollOffset());
-  EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(),
+      scroll_tree(layer())->GetScrollOffsetBaseForTesting(layer()->id()));
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(), ScrollDelta(layer()));
 
   layer()->ScrollBy(gfx::Vector2dF(-100, 100));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->CurrentScrollOffset());
 
-  EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->CurrentScrollOffset());
-  EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->BaseScrollOffset());
+  EXPECT_VECTOR_EQ(ScrollDelta(layer()), layer()->CurrentScrollOffset());
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(),
+      scroll_tree(layer())->GetScrollOffsetBaseForTesting(layer()->id()));
 
   layer()->ScrollBy(gfx::Vector2dF(100, -100));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->CurrentScrollOffset());
 
-  EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->CurrentScrollOffset());
-  EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->BaseScrollOffset());
+  EXPECT_VECTOR_EQ(ScrollDelta(layer()), layer()->CurrentScrollOffset());
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(),
+      scroll_tree(layer())->GetScrollOffsetBaseForTesting(layer()->id()));
 }
 
 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) {
   gfx::ScrollOffset scroll_offset(10, 5);
-  layer()->PushScrollOffsetFromMainThread(scroll_offset);
+  scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->id(),
+                                                         scroll_offset);
 
   EXPECT_VECTOR_EQ(scroll_offset, layer()->CurrentScrollOffset());
-  EXPECT_VECTOR_EQ(scroll_offset, layer()->BaseScrollOffset());
-  EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
+  EXPECT_VECTOR_EQ(
+      scroll_offset,
+      scroll_tree(layer())->GetScrollOffsetBaseForTesting(layer()->id()));
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(), ScrollDelta(layer()));
 
   layer()->ScrollBy(gfx::Vector2dF(-100, 100));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->CurrentScrollOffset());
 
   EXPECT_VECTOR_EQ(
-      gfx::ScrollOffsetWithDelta(scroll_offset, layer()->ScrollDelta()),
+      gfx::ScrollOffsetWithDelta(scroll_offset, ScrollDelta(layer())),
       layer()->CurrentScrollOffset());
-  EXPECT_VECTOR_EQ(scroll_offset, layer()->BaseScrollOffset());
+  EXPECT_VECTOR_EQ(
+      scroll_offset,
+      scroll_tree(layer())->GetScrollOffsetBaseForTesting(layer()->id()));
 
   layer()->ScrollBy(gfx::Vector2dF(100, -100));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->CurrentScrollOffset());
 
   EXPECT_VECTOR_EQ(
-      gfx::ScrollOffsetWithDelta(scroll_offset, layer()->ScrollDelta()),
+      gfx::ScrollOffsetWithDelta(scroll_offset, ScrollDelta(layer())),
       layer()->CurrentScrollOffset());
-  EXPECT_VECTOR_EQ(scroll_offset, layer()->BaseScrollOffset());
+  EXPECT_VECTOR_EQ(
+      scroll_offset,
+      scroll_tree(layer())->GetScrollOffsetBaseForTesting(layer()->id()));
 }
 
 TEST_F(LayerImplScrollTest, ApplySentScrollsNoListener) {
   gfx::ScrollOffset scroll_offset(10, 5);
   gfx::Vector2dF scroll_delta(20.5f, 8.5f);
   gfx::Vector2d sent_scroll_delta(12, -3);
 
-  layer()->PushScrollOffsetFromMainThread(scroll_offset);
+  scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->id(),
+                                                         scroll_offset);
   layer()->ScrollBy(sent_scroll_delta);
   layer()->synced_scroll_offset()->PullDeltaForMainThread();
   layer()->SetCurrentScrollOffset(scroll_offset +
                                   gfx::ScrollOffset(scroll_delta));
 
   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
                    layer()->CurrentScrollOffset());
-  EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta());
-  EXPECT_VECTOR_EQ(scroll_offset, layer()->BaseScrollOffset());
+  EXPECT_VECTOR_EQ(scroll_delta, ScrollDelta(layer()));
+  EXPECT_VECTOR_EQ(
+      scroll_offset,
+      scroll_tree(layer())->GetScrollOffsetBaseForTesting(layer()->id()));
 
   layer()->synced_scroll_offset()->AbortCommit();
 
   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
                    layer()->CurrentScrollOffset());
-  EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta());
-  EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, sent_scroll_delta),
-                   layer()->BaseScrollOffset());
+  EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, ScrollDelta(layer()));
+  EXPECT_VECTOR_EQ(
+      gfx::ScrollOffsetWithDelta(scroll_offset, sent_scroll_delta),
+      scroll_tree(layer())->GetScrollOffsetBaseForTesting(layer()->id()));
 }
 
 TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) {
   gfx::ScrollOffset scroll_offset(10, 5);
   gfx::Vector2dF scroll_delta(20.5f, 8.5f);
 
   layer()->set_user_scrollable_vertical(false);
-  layer()->PushScrollOffsetFromMainThread(scroll_offset);
+  scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->id(),
+                                                         scroll_offset);
   gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
 
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f), unscrolled);
   EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f, 5), layer()->CurrentScrollOffset());
 }
 
 TEST_F(LayerImplScrollTest, PushPropertiesToMirrorsCurrentScrollOffset) {
   gfx::ScrollOffset scroll_offset(10, 5);
   gfx::Vector2dF scroll_delta(12, 18);
 
   host_impl().CreatePendingTree();
 
-  layer()->PushScrollOffsetFromMainThread(scroll_offset);
+  scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->id(),
+                                                         scroll_offset);
   gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
 
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), unscrolled);
   EXPECT_VECTOR_EQ(gfx::Vector2dF(22, 23), layer()->CurrentScrollOffset());
 
   layer()->synced_scroll_offset()->PullDeltaForMainThread();
 
   scoped_ptr<LayerImpl> pending_layer =
       LayerImpl::Create(host_impl().sync_tree(), layer()->id());
-  pending_layer->PushScrollOffsetFromMainThread(layer()->CurrentScrollOffset());
+  scroll_tree(pending_layer.get())
+      ->UpdateScrollOffsetBaseForTesting(pending_layer->id(),
+                                         layer()->CurrentScrollOffset());
 
   pending_layer->PushPropertiesTo(layer());
 
   EXPECT_VECTOR_EQ(gfx::Vector2dF(22, 23), layer()->CurrentScrollOffset());
   EXPECT_VECTOR_EQ(layer()->CurrentScrollOffset(),
                    pending_layer->CurrentScrollOffset());
 }
 
 }  // namespace
 }  // namespace cc