Revert 197178 "Make it possible to delegate root layer scroll of..."

> Make it possible to delegate root layer scroll offset outside of cc.
> 
> This change makes it possible for the embedder to own the root layer
> scroll offset.
> 
> BUG=b/6029133
> 
> Review URL: https://chromiumcodereview.appspot.com/13869006

Fixes TreeCloser Bug 236675
TBR=mkosiba@chromium.org

Review URL: https://codereview.chromium.org/14564002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@197189 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 48 insertions, 175 deletions

diff --git a/cc/input/input_handler.h b/cc/input/input_handler.h
index b3f805e..982befa 100644
--- a/cc/input/input_handler.h
+++ b/cc/input/input_handler.h
@@ -19,8 +19,6 @@ class Vector2dF;
 
 namespace cc {
 
-class LayerScrollOffsetDelegate;
-
 // The InputHandler is a way for the embedders to interact with the impl thread
 // side of the compositor implementation. There is one InputHandler per
 // LayerTreeHost. To use the input handler, implement the InputHanderClient
@@ -64,16 +62,6 @@ class CC_EXPORT InputHandler {
   // returned ScrollStarted.
   virtual void ScrollEnd() = 0;
 
-  virtual void SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) = 0;
-
-  // Called when the value returned by
-  // LayerScrollOffsetDelegate.GetTotalScrollOffset has changed for reasons
-  // other than a SetTotalScrollOffset call.
-  // NOTE: This should only called after a valid delegate was set via a call to
-  // SetRootLayerScrollOffsetDelegate.
-  virtual void OnRootLayerDelegatedScrollOffsetChanged() = 0;
-
   virtual void PinchGestureBegin() = 0;
   virtual void PinchGestureUpdate(float magnify_delta, gfx::Point anchor) = 0;
   virtual void PinchGestureEnd() = 0;
diff --git a/cc/input/layer_scroll_offset_delegate.h b/cc/input/layer_scroll_offset_delegate.h
deleted file mode 100644
index 1431a80..0000000
--- a/cc/input/layer_scroll_offset_delegate.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CC_INPUT_LAYER_SCROLL_OFFSET_DELEGATE_H_
-#define CC_INPUT_LAYER_SCROLL_OFFSET_DELEGATE_H_
-
-namespace cc {
-
-// The LayerScrollOffsetDelegate allows for the embedder to take ownership of
-// the scroll offset of the root layer.
-//
-// The LayerScrollOffsetDelegate is only used on the impl thread.
-class LayerScrollOffsetDelegate {
- public:
-  // This is called by the compositor when the scroll offset of the layer would
-  // have otherwise changed.
-  virtual void SetTotalScrollOffset(gfx::Vector2dF new_value) = 0;
-
-  // This is called by the compositor to query the current scroll offset of the
-  // layer.
-  // There is no requirement that the return values of this method are
-  // stable in time (two subsequent calls may yield different results).
-  // The return value is not required to be related to the values passed in to
-  // the SetTotalScrollOffset method in any way.
-  virtual gfx::Vector2dF GetTotalScrollOffset() = 0;
-
- protected:
-  LayerScrollOffsetDelegate() {}
-  virtual ~LayerScrollOffsetDelegate() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LayerScrollOffsetDelegate);
-};
-
-}  // namespace cc
-
-#endif  // CC_INPUT_LAYER_SCROLL_OFFSET_DELEGATE_H_
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index b4a7ca7..4d1258d 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -696,11 +696,11 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
     // This code is identical to that in LayerImpl::SetScrollDelta.
     if (active_twin) {
       DCHECK(layer->sent_scroll_delta().IsZero());
-      layer->SetScrollDelta(active_twin->ScrollDelta() -
+      layer->SetScrollDelta(active_twin->scroll_delta() -
                             active_twin->sent_scroll_delta());
     }
   } else {
-    layer->SetScrollDelta(layer->ScrollDelta() - layer->sent_scroll_delta());
+    layer->SetScrollDelta(layer->scroll_delta() - layer->sent_scroll_delta());
     layer->SetSentScrollDelta(gfx::Vector2d());
   }
 
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index b3a1e82..f9d0cb5 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -245,7 +245,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   void SetForceRenderSurface(bool force_render_surface);
   bool force_render_surface() const { return force_render_surface_; }
 
-  gfx::Vector2d ScrollDelta() const { return gfx::Vector2d(); }
+  gfx::Vector2d scroll_delta() const { return gfx::Vector2d(); }
 
   void SetDoubleSided(bool double_sided);
   bool double_sided() const { return double_sided_; }
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 9ec16a5..b9db1140 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -13,7 +13,6 @@
 #include "cc/base/math_util.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/layer_tree_debug_state.h"
-#include "cc/input/layer_scroll_offset_delegate.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/quads/debug_border_draw_quad.h"
@@ -34,7 +33,6 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
       layer_tree_impl_(tree_impl),
       anchor_point_(0.5f, 0.5f),
       anchor_point_z_(0.f),
-      scroll_offset_delegate_(NULL),
       scrollable_(false),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
@@ -244,10 +242,10 @@ gfx::Vector2dF LayerImpl::ScrollBy(gfx::Vector2dF scroll) {
   gfx::Vector2dF min_delta = -scroll_offset_;
   gfx::Vector2dF max_delta = max_scroll_offset_ - scroll_offset_;
   // Clamp new_delta so that position + delta stays within scroll bounds.
-  gfx::Vector2dF new_delta = (ScrollDelta() + scroll);
+  gfx::Vector2dF new_delta = (scroll_delta_ + scroll);
   new_delta.ClampToMin(min_delta);
   new_delta.ClampToMax(max_delta);
-  gfx::Vector2dF unscrolled = ScrollDelta() + scroll - new_delta;
+  gfx::Vector2dF unscrolled = scroll_delta_ + scroll - new_delta;
 
   SetScrollDelta(new_delta);
   return unscrolled;
@@ -390,7 +388,7 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   update_rect_.Union(layer->update_rect());
   layer->set_update_rect(update_rect_);
 
-  layer->SetScrollDelta(layer->ScrollDelta() - layer->sent_scroll_delta());
+  layer->SetScrollDelta(layer->scroll_delta() - layer->sent_scroll_delta());
   layer->SetSentScrollDelta(gfx::Vector2d());
 
   layer->SetStackingOrderChanged(stacking_order_changed_);
@@ -831,7 +829,7 @@ void LayerImpl::CalculateContentsScale(
 }
 
 void LayerImpl::UpdateScrollbarPositions() {
-  gfx::Vector2dF current_offset = scroll_offset_ + ScrollDelta();
+  gfx::Vector2dF current_offset = scroll_offset_ + scroll_delta_;
 
   gfx::RectF viewport(PointAtOffsetFromOrigin(current_offset), bounds_);
   gfx::SizeF scrollable_size(max_scroll_offset_.x() + bounds_.width(),
@@ -869,39 +867,17 @@ void LayerImpl::UpdateScrollbarPositions() {
   }
 }
 
-void LayerImpl::SetScrollOffsetDelegate(
-    LayerScrollOffsetDelegate* scroll_offset_delegate) {
-  if (!scroll_offset_delegate && scroll_offset_delegate_) {
-    scroll_delta_ =
-        scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
-  }
-  gfx::Vector2dF total_offset = TotalScrollOffset();
-  scroll_offset_delegate_ = scroll_offset_delegate;
-  if (scroll_offset_delegate_)
-    scroll_offset_delegate_->SetTotalScrollOffset(total_offset);
-}
-
 void LayerImpl::SetScrollOffset(gfx::Vector2d scroll_offset) {
   if (scroll_offset_ == scroll_offset)
     return;
 
   scroll_offset_ = scroll_offset;
-
-  if (scroll_offset_delegate_)
-    scroll_offset_delegate_->SetTotalScrollOffset(TotalScrollOffset());
-
   NoteLayerPropertyChangedForSubtree();
   UpdateScrollbarPositions();
 }
 
-gfx::Vector2dF LayerImpl::ScrollDelta() const {
-  if (scroll_offset_delegate_)
-    return scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
-  return scroll_delta_;
-}
-
 void LayerImpl::SetScrollDelta(gfx::Vector2dF scroll_delta) {
-  if (ScrollDelta() == scroll_delta)
+  if (scroll_delta_ == scroll_delta)
     return;
 
   if (layer_tree_impl()->IsActiveTree()) {
@@ -917,19 +893,14 @@ void LayerImpl::SetScrollDelta(gfx::Vector2dF scroll_delta) {
     }
   }
 
-  if (scroll_offset_delegate_) {
-    scroll_offset_delegate_->SetTotalScrollOffset(
-        scroll_offset_ + scroll_delta);
-  } else {
-    scroll_delta_ = scroll_delta;
-  }
+  scroll_delta_ = scroll_delta;
   NoteLayerPropertyChangedForSubtree();
 
   UpdateScrollbarPositions();
 }
 
 gfx::Vector2dF LayerImpl::TotalScrollOffset() const {
-  return scroll_offset_ + ScrollDelta();
+  return scroll_offset_ + scroll_delta_;
 }
 
 void LayerImpl::SetDoubleSided(bool double_sided) {
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index d52d6fa..697676e 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -284,8 +284,6 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
                                       float* contents_scale_y,
                                       gfx::Size* content_bounds);
 
-  void SetScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* scroll_offset_delegate);
   void SetScrollOffset(gfx::Vector2d scroll_offset);
   gfx::Vector2d scroll_offset() const { return scroll_offset_; }
 
@@ -293,7 +291,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
   gfx::Vector2d max_scroll_offset() const { return max_scroll_offset_; }
 
   void SetScrollDelta(gfx::Vector2dF scroll_delta);
-  gfx::Vector2dF ScrollDelta() const;
+  gfx::Vector2dF scroll_delta() const { return scroll_delta_; }
 
   gfx::Vector2dF TotalScrollOffset() const;
 
@@ -458,7 +456,6 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
   float anchor_point_z_;
   gfx::Size bounds_;
   gfx::Vector2d scroll_offset_;
-  LayerScrollOffsetDelegate* scroll_offset_delegate_;
   bool scrollable_;
   bool should_scroll_on_main_thread_;
   bool have_wheel_event_handlers_;
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 2fb5fe1..da5fd63 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -505,8 +505,8 @@ gfx::Transform ComputeScrollCompensationForThisLayer(
   gfx::Transform scroll_compensation_for_this_layer =
       partial_layer_origin_transform;        // Step 3
   scroll_compensation_for_this_layer.Translate(
-      scrolling_layer->ScrollDelta().x(),
-      scrolling_layer->ScrollDelta().y());  // Step 2
+      scrolling_layer->scroll_delta().x(),
+      scrolling_layer->scroll_delta().y());  // Step 2
 
   gfx::Transform inverse_partial_layer_origin_transform(
       gfx::Transform::kSkipInitialization);
@@ -560,7 +560,7 @@ gfx::Transform ComputeScrollCompensationMatrixForChildren(
   // initialization/copy) if we know that the scroll compensation doesn't need
   // to be reset or adjusted.
   if (!layer->IsContainerForFixedPositionLayers() &&
-      layer->ScrollDelta().IsZero() && !layer->render_surface())
+      layer->scroll_delta().IsZero() && !layer->render_surface())
     return current_scroll_compensation_matrix;
 
   // Start as identity matrix.
@@ -574,7 +574,7 @@ gfx::Transform ComputeScrollCompensationMatrixForChildren(
   // If the current layer has a non-zero scroll_delta, then we should compute
   // its local scroll compensation and accumulate it to the
   // next_scroll_compensation_matrix.
-  if (!layer->ScrollDelta().IsZero()) {
+  if (!layer->scroll_delta().IsZero()) {
     gfx::Transform scroll_compensation_for_this_layer =
         ComputeScrollCompensationForThisLayer(
             layer, current_page_scale, parent_matrix);
@@ -956,7 +956,7 @@ static void CalculateDrawPropertiesInternal(
 
   gfx::Size bounds = layer->bounds();
   gfx::PointF anchor_point = layer->anchor_point();
-  gfx::PointF position = layer->position() - layer->ScrollDelta();
+  gfx::PointF position = layer->position() - layer->scroll_delta();
 
   gfx::Transform combined_transform = parent_matrix;
   if (!layer->transform().IsIdentity()) {
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index bdfcb95..e559c81 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -168,7 +168,6 @@ LayerTreeHostImpl::LayerTreeHostImpl(
       did_lock_scrolling_layer_(false),
       should_bubble_scrolls_(false),
       wheel_scrolling_(false),
-      root_layer_scroll_offset_delegate_(NULL),
       settings_(settings),
       overdraw_bottom_height_(0.f),
       device_scale_factor_(1.f),
@@ -309,7 +308,7 @@ void LayerTreeHostImpl::StartPageScaleAnimation(gfx::Vector2d target_offset,
     return;
 
   gfx::Vector2dF scroll_total =
-      RootScrollLayer()->scroll_offset() + RootScrollLayer()->ScrollDelta();
+      RootScrollLayer()->scroll_offset() + RootScrollLayer()->scroll_delta();
   gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
   gfx::SizeF viewport_size = VisibleViewportSize();
 
@@ -1283,7 +1282,6 @@ void LayerTreeHostImpl::ActivatePendingTree() {
   CHECK(pending_tree_);
   TRACE_EVENT_ASYNC_END0("cc", "PendingTree", pending_tree_.get());
 
-  active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
   active_tree_->PushPersistedState(pending_tree_.get());
   if (pending_tree_->needs_full_tree_sync()) {
     active_tree_->SetRootLayer(
@@ -1303,8 +1301,6 @@ void LayerTreeHostImpl::ActivatePendingTree() {
   pending_tree_.swap(recycle_tree_);
   recycle_tree_->ClearRenderSurfaces();
 
-  active_tree_->SetRootLayerScrollOffsetDelegate(
-      root_layer_scroll_offset_delegate_);
   active_tree_->DidBecomeActive();
 
   // Reduce wasted memory now that unlinked resources are guaranteed not
@@ -1587,13 +1583,13 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
   local_end_point.Scale(width_scale, height_scale);
 
   // Apply the scroll delta.
-  gfx::Vector2dF previous_delta = layer_impl->ScrollDelta();
+  gfx::Vector2dF previous_delta = layer_impl->scroll_delta();
   layer_impl->ScrollBy(local_end_point - local_start_point);
 
   // Get the end point in the layer's content space so we can apply its
   // ScreenSpaceTransform.
   gfx::PointF actual_local_end_point = local_start_point +
-                                       layer_impl->ScrollDelta() -
+                                       layer_impl->scroll_delta() -
                                        previous_delta;
   gfx::PointF actual_local_content_end_point =
       gfx::ScalePoint(actual_local_end_point,
@@ -1616,9 +1612,9 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
 
 static gfx::Vector2dF ScrollLayerWithLocalDelta(LayerImpl* layer_impl,
                                                 gfx::Vector2dF local_delta) {
-  gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
+  gfx::Vector2dF previous_delta(layer_impl->scroll_delta());
   layer_impl->ScrollBy(local_delta);
-  return layer_impl->ScrollDelta() - previous_delta;
+  return layer_impl->scroll_delta() - previous_delta;
 }
 
 bool LayerTreeHostImpl::ScrollBy(gfx::Point viewport_point,
@@ -1746,18 +1742,6 @@ bool LayerTreeHostImpl::ScrollVerticallyByPage(
   return false;
 }
 
-void LayerTreeHostImpl::SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
-  root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
-  active_tree_->SetRootLayerScrollOffsetDelegate(
-      root_layer_scroll_offset_delegate_);
-}
-
-void LayerTreeHostImpl::OnRootLayerDelegatedScrollOffsetChanged() {
-  DCHECK(root_layer_scroll_offset_delegate_ != NULL);
-  client_->SetNeedsCommitOnImplThread();
-}
-
 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
   active_tree_->ClearCurrentlyScrollingLayer();
   did_lock_scrolling_layer_ = false;
@@ -1829,7 +1813,7 @@ static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
     return;
 
   gfx::Vector2d scroll_delta =
-      gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
+      gfx::ToFlooredVector2d(layer_impl->scroll_delta());
   if (!scroll_delta.IsZero()) {
     LayerTreeHostCommon::ScrollUpdateInfo scroll;
     scroll.layer_id = layer_impl->id();
@@ -1862,7 +1846,7 @@ void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks time) {
 
   double monotonic_time = (time - base::TimeTicks()).InSecondsF();
   gfx::Vector2dF scroll_total = RootScrollLayer()->scroll_offset() +
-                                RootScrollLayer()->ScrollDelta();
+                                RootScrollLayer()->scroll_delta();
 
   active_tree_->SetPageScaleDelta(
       page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 9af1e4f..fc1e0e9 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -16,7 +16,6 @@
 #include "cc/base/cc_export.h"
 #include "cc/debug/latency_info.h"
 #include "cc/input/input_handler.h"
-#include "cc/input/layer_scroll_offset_delegate.h"
 #include "cc/input/top_controls_manager_client.h"
 #include "cc/layers/layer_lists.h"
 #include "cc/layers/render_pass_sink.h"
@@ -104,9 +103,6 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler,
   virtual bool ScrollVerticallyByPage(
       gfx::Point viewport_point,
       WebKit::WebScrollbar::ScrollDirection direction) OVERRIDE;
-  virtual void SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) OVERRIDE;
-  virtual void OnRootLayerDelegatedScrollOffsetChanged() OVERRIDE;
   virtual void ScrollEnd() OVERRIDE;
   virtual InputHandler::ScrollStatus FlingScrollBegin() OVERRIDE;
   virtual void NotifyCurrentFlingVelocity(gfx::Vector2dF velocity) OVERRIDE;
@@ -435,8 +431,6 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler,
   bool did_lock_scrolling_layer_;
   bool should_bubble_scrolls_;
   bool wheel_scrolling_;
-  // The optional delegate for the root layer scroll offset.
-  LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
   LayerTreeSettings settings_;
   LayerTreeDebugState debug_state_;
   gfx::Size device_viewport_size_;
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index c88b595..ce2add2 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -162,7 +162,7 @@ class LayerTreeHostImplTest : public testing::Test,
   }
 
   static void ExpectClearedScrollDeltasRecursive(LayerImpl* layer) {
-    ASSERT_EQ(layer->ScrollDelta(), gfx::Vector2d());
+    ASSERT_EQ(layer->scroll_delta(), gfx::Vector2d());
     for (size_t i = 0; i < layer->children().size(); ++i)
       ExpectClearedScrollDeltasRecursive(layer->children()[i]);
   }
@@ -681,7 +681,7 @@ TEST_F(LayerTreeHostImplTest, ScrollVerticallyByPageReturnsCorrectValue) {
   // Trying to scroll with a vertical scrollbar will succeed.
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), WebKit::WebScrollbar::ScrollForward));
-  EXPECT_FLOAT_EQ(875.f, host_impl_->RootScrollLayer()->ScrollDelta().y());
+  EXPECT_FLOAT_EQ(875.f, host_impl_->RootScrollLayer()->scroll_delta().y());
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), WebKit::WebScrollbar::ScrollBackward));
 }
diff --git a/cc/trees/layer_tree_host_unittest_scroll.cc b/cc/trees/layer_tree_host_unittest_scroll.cc
index d433c42..1d74ddf 100644
--- a/cc/trees/layer_tree_host_unittest_scroll.cc
+++ b/cc/trees/layer_tree_host_unittest_scroll.cc
@@ -52,7 +52,7 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
-    EXPECT_VECTOR_EQ(gfx::Vector2d(), root->ScrollDelta());
+    EXPECT_VECTOR_EQ(gfx::Vector2d(), root->scroll_delta());
 
     root->SetScrollable(true);
     root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
@@ -61,12 +61,12 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(initial_scroll_, root->scroll_offset());
-        EXPECT_VECTOR_EQ(scroll_amount_, root->ScrollDelta());
+        EXPECT_VECTOR_EQ(scroll_amount_, root->scroll_delta());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
         EXPECT_VECTOR_EQ(root->scroll_offset(), second_scroll_);
-        EXPECT_VECTOR_EQ(root->ScrollDelta(), scroll_amount_);
+        EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_);
         EndTest();
         break;
     }
@@ -133,25 +133,25 @@ class LayerTreeHostScrollTestScrollMultipleRedraw
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumber() == 1) {
       // First draw after first commit.
-      EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
+      EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
       root->ScrollBy(scroll_amount_);
-      EXPECT_VECTOR_EQ(root->ScrollDelta(), scroll_amount_);
+      EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_);
 
       EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
       PostSetNeedsRedrawToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumber() == 2) {
       // Second draw after first commit.
-      EXPECT_EQ(root->ScrollDelta(), scroll_amount_);
+      EXPECT_EQ(root->scroll_delta(), scroll_amount_);
       root->ScrollBy(scroll_amount_);
-      EXPECT_VECTOR_EQ(root->ScrollDelta(), scroll_amount_ + scroll_amount_);
+      EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_ + scroll_amount_);
 
       EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
       PostSetNeedsCommitToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 1) {
       // Third or later draw after second commit.
       EXPECT_GE(impl->SourceAnimationFrameNumber(), 3);
-      EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
+      EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
       EXPECT_VECTOR_EQ(
           root->scroll_offset(),
           initial_scroll_ + scroll_amount_ + scroll_amount_);
@@ -197,7 +197,7 @@ class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(root->scroll_offset(), gfx::Vector2d(0, 0));
-        EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d(0, 0));
+        EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d(0, 0));
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
@@ -205,7 +205,7 @@ class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
             root->scroll_offset(),
             gfx::ToFlooredVector2d(scroll_amount_));
         EXPECT_VECTOR_EQ(
-            root->ScrollDelta(),
+            root->scroll_delta(),
             gfx::Vector2dF(fmod(scroll_amount_.x(), 1.0f), 0.0f));
         PostSetNeedsCommitToMainThread();
         break;
@@ -214,7 +214,7 @@ class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
             root->scroll_offset(),
             gfx::ToFlooredVector2d(scroll_amount_ + scroll_amount_));
         EXPECT_VECTOR_EQ(
-            root->ScrollDelta(),
+            root->scroll_delta(),
             gfx::Vector2dF(fmod(2.0f * scroll_amount_.x(), 1.0f), 0.0f));
         EndTest();
         break;
@@ -349,10 +349,10 @@ class LayerTreeHostScrollTestCaseWithChild
       expected_no_scroll_layer_impl = child_layer_impl;
     }
 
-    EXPECT_VECTOR_EQ(gfx::Vector2d(), root_impl->ScrollDelta());
+    EXPECT_VECTOR_EQ(gfx::Vector2d(), root_impl->scroll_delta());
     EXPECT_VECTOR_EQ(
         gfx::Vector2d(),
-        expected_no_scroll_layer_impl->ScrollDelta());
+        expected_no_scroll_layer_impl->scroll_delta());
 
     // Ensure device scale factor is affecting the layers.
     gfx::Size expected_content_bounds = gfx::ToCeiledSize(
@@ -383,7 +383,7 @@ class LayerTreeHostScrollTestCaseWithChild
             expected_scroll_layer_impl->scroll_offset());
         EXPECT_VECTOR_EQ(
             scroll_amount_,
-            expected_scroll_layer_impl->ScrollDelta());
+            expected_scroll_layer_impl->scroll_delta());
         break;
       }
       case 1: {
@@ -403,7 +403,7 @@ class LayerTreeHostScrollTestCaseWithChild
             expected_scroll_layer_impl->scroll_offset());
         EXPECT_VECTOR_EQ(
             scroll_amount_,
-            expected_scroll_layer_impl->ScrollDelta());
+            expected_scroll_layer_impl->scroll_delta());
         break;
       }
       case 2:
@@ -413,7 +413,7 @@ class LayerTreeHostScrollTestCaseWithChild
             expected_scroll_layer_impl->scroll_offset());
         EXPECT_VECTOR_EQ(
             gfx::Vector2d(),
-            expected_scroll_layer_impl->ScrollDelta());
+            expected_scroll_layer_impl->scroll_delta());
 
         EndTest();
         break;
@@ -560,11 +560,11 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
       case 0:
         if (!impl->pending_tree()) {
           can_activate_ = false;
-          EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
+          EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
           root->ScrollBy(impl_thread_scroll1_);
 
           EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
-          EXPECT_VECTOR_EQ(root->ScrollDelta(), impl_thread_scroll1_);
+          EXPECT_VECTOR_EQ(root->scroll_delta(), impl_thread_scroll1_);
           EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
           PostSetNeedsCommitToMainThread();
 
@@ -577,13 +577,13 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
 
           root->ScrollBy(impl_thread_scroll2_);
           EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
-          EXPECT_VECTOR_EQ(root->ScrollDelta(),
+          EXPECT_VECTOR_EQ(root->scroll_delta(),
               impl_thread_scroll1_ + impl_thread_scroll2_);
           EXPECT_VECTOR_EQ(root->sent_scroll_delta(), impl_thread_scroll1_);
 
           EXPECT_VECTOR_EQ(pending_root->scroll_offset(),
               initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
-          EXPECT_VECTOR_EQ(pending_root->ScrollDelta(), impl_thread_scroll2_);
+          EXPECT_VECTOR_EQ(pending_root->scroll_delta(), impl_thread_scroll2_);
           EXPECT_VECTOR_EQ(pending_root->sent_scroll_delta(), gfx::Vector2d());
         }
         break;
@@ -591,7 +591,7 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
         EXPECT_FALSE(impl->pending_tree());
         EXPECT_VECTOR_EQ(root->scroll_offset(),
             initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
-        EXPECT_VECTOR_EQ(root->ScrollDelta(), impl_thread_scroll2_);
+        EXPECT_VECTOR_EQ(root->scroll_delta(), impl_thread_scroll2_);
         EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
         EndTest();
         break;
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 84cc96a..4b44a15 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -25,9 +25,8 @@ LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       hud_layer_(0),
-      root_scroll_layer_(NULL),
-      currently_scrolling_layer_(NULL),
-      root_layer_scroll_offset_delegate_(NULL),
+      root_scroll_layer_(0),
+      currently_scrolling_layer_(0),
       background_color_(0),
       has_transparent_background_(false),
       pinch_zoom_scrollbar_horizontal_layer_id_(Layer::INVALID_ID),
@@ -68,8 +67,6 @@ static LayerImpl* FindRootScrollLayerRecursive(LayerImpl* layer) {
 
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
   root_layer_ = layer.Pass();
-  if (root_scroll_layer_)
-    root_scroll_layer_->SetScrollOffsetDelegate(NULL);
   root_scroll_layer_ = NULL;
   currently_scrolling_layer_ = NULL;
 
@@ -79,11 +76,6 @@ void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
 void LayerTreeImpl::FindRootScrollLayer() {
   root_scroll_layer_ = FindRootScrollLayerRecursive(root_layer_.get());
 
-  if (root_scroll_layer_) {
-    root_scroll_layer_->SetScrollOffsetDelegate(
-        root_layer_scroll_offset_delegate_);
-  }
-
   if (root_layer_ && scrolling_layer_id_from_previous_tree_) {
     currently_scrolling_layer_ = LayerTreeHostCommon::FindLayerInSubtree(
         root_layer_.get(),
@@ -97,8 +89,6 @@ scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
   // Clear all data structures that have direct references to the layer tree.
   scrolling_layer_id_from_previous_tree_ =
     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
-  if (root_scroll_layer_)
-    root_scroll_layer_->SetScrollOffsetDelegate(NULL);
   root_scroll_layer_ = NULL;
   currently_scrolling_layer_ = NULL;
 
@@ -571,15 +561,6 @@ void LayerTreeImpl::DidEndScroll() {
     FadeOutPinchZoomScrollbars();
 }
 
-void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
-  root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
-  if (root_scroll_layer_) {
-    root_scroll_layer_->SetScrollOffsetDelegate(
-        root_layer_scroll_offset_delegate_);
-  }
-}
-
 void LayerTreeImpl::SetPinchZoomHorizontalLayerId(int layer_id) {
   pinch_zoom_scrollbar_horizontal_layer_id_ = layer_id;
 }
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 4681fc1..5ee9c46 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -197,9 +197,6 @@ class CC_EXPORT LayerTreeImpl {
   void DidUpdateScroll();
   void DidEndScroll();
 
-  void SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate);
-
   void SetLatencyInfo(const LatencyInfo& latency_info);
   const LatencyInfo& GetLatencyInfo();
   void ClearLatencyInfo();
@@ -225,7 +222,6 @@ class CC_EXPORT LayerTreeImpl {
   HeadsUpDisplayLayerImpl* hud_layer_;
   LayerImpl* root_scroll_layer_;
   LayerImpl* currently_scrolling_layer_;
-  LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
   SkColor background_color_;
   bool has_transparent_background_;