webview: Move calls to update the root scroll delegate to LTHI.

This moves the calls to update the delegate out to the LayerTreeHostImpl
instead of having it on LayerTreeImpl. This has a few benefits.

1) Things that are only for the active tree don't make the most sense
on LayerTreeImpl in general, since it's an abstraction around things
that occur on both the pending and active tree.
2) This avoids the needs to set the root scroll delegate to null and
back during activation and pinch updates. Instead of updating the root
delegate reactionarily when things change, we just call it at the end
of steps that might change the root scroll delegate's data (and early
out in BrowserViewRenderer if they are unchanged instead).
3) Avoids plumbing around concepts of the root scroll delegate through
LayerImpl and LayerTreeImpl.

R=boliu
BUG=531746
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

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

Cr-Commit-Position: refs/heads/master@{#349520}

9 files changed, 82 insertions, 123 deletions

diff --git a/android_webview/browser/browser_view_renderer.cc b/android_webview/browser/browser_view_renderer.cc
index deb9901..4bf5e4b 100644
--- a/android_webview/browser/browser_view_renderer.cc
+++ b/android_webview/browser/browser_view_renderer.cc
@@ -94,13 +94,14 @@ BrowserViewRenderer::BrowserViewRenderer(
       window_visible_(false),
       attached_to_window_(false),
       hardware_enabled_(false),
-      dip_scale_(0.0),
-      page_scale_factor_(1.0),
+      dip_scale_(0.f),
+      page_scale_factor_(1.f),
+      min_page_scale_factor_(0.f),
+      max_page_scale_factor_(0.f),
       on_new_picture_enable_(false),
       clear_view_(false),
       offscreen_pre_raster_(false),
-      fallback_tick_pending_(false) {
-}
+      fallback_tick_pending_(false) {}
 
 BrowserViewRenderer::~BrowserViewRenderer() {
 }
@@ -530,11 +531,8 @@ void BrowserViewRenderer::DidUpdateContent() {
 
 void BrowserViewRenderer::SetTotalRootLayerScrollOffset(
     gfx::Vector2dF scroll_offset_dip) {
-  // TOOD(mkosiba): Add a DCHECK to say that this does _not_ get called during
-  // DrawGl when http://crbug.com/249972 is fixed.
   if (scroll_offset_dip_ == scroll_offset_dip)
     return;
-
   scroll_offset_dip_ = scroll_offset_dip;
 
   gfx::Vector2d max_offset = max_scroll_offset();
@@ -573,20 +571,27 @@ void BrowserViewRenderer::UpdateRootLayerState(
       "state",
       RootLayerStateAsValue(total_scroll_offset_dip, scrollable_size_dip));
 
+  DCHECK_GE(max_scroll_offset_dip.x(), 0.f);
+  DCHECK_GE(max_scroll_offset_dip.y(), 0.f);
+  DCHECK_GT(page_scale_factor, 0.f);
+  // SetDipScale should have been called at least once before this is called.
   DCHECK_GT(dip_scale_, 0.f);
 
-  max_scroll_offset_dip_ = max_scroll_offset_dip;
-  DCHECK_LE(0.f, max_scroll_offset_dip_.x());
-  DCHECK_LE(0.f, max_scroll_offset_dip_.y());
-
-  page_scale_factor_ = page_scale_factor;
-  DCHECK_GT(page_scale_factor_, 0.f);
-
-  client_->UpdateScrollState(max_scroll_offset(),
-                             scrollable_size_dip,
-                             page_scale_factor,
-                             min_page_scale_factor,
-                             max_page_scale_factor);
+  if (max_scroll_offset_dip_ != max_scroll_offset_dip ||
+      scrollable_size_dip_ != scrollable_size_dip ||
+      page_scale_factor_ != page_scale_factor ||
+      min_page_scale_factor_ != min_page_scale_factor ||
+      max_page_scale_factor_ != max_page_scale_factor) {
+    max_scroll_offset_dip_ = max_scroll_offset_dip;
+    scrollable_size_dip_ = scrollable_size_dip;
+    page_scale_factor_ = page_scale_factor;
+    min_page_scale_factor_ = min_page_scale_factor;
+    max_page_scale_factor_ = max_page_scale_factor;
+
+    client_->UpdateScrollState(max_scroll_offset(), scrollable_size_dip,
+                               page_scale_factor, min_page_scale_factor,
+                               max_page_scale_factor);
+  }
   SetTotalRootLayerScrollOffset(total_scroll_offset_dip);
 }
 
diff --git a/android_webview/browser/browser_view_renderer.h b/android_webview/browser/browser_view_renderer.h
index 2dc0d23..97737aa 100644
--- a/android_webview/browser/browser_view_renderer.h
+++ b/android_webview/browser/browser_view_renderer.h
@@ -14,6 +14,7 @@
 #include "content/public/browser/android/synchronous_compositor_client.h"
 #include "skia/ext/refptr.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size_f.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
 class SkCanvas;
@@ -165,6 +166,8 @@ class BrowserViewRenderer : public content::SynchronousCompositorClient {
   bool hardware_enabled_;
   float dip_scale_;
   float page_scale_factor_;
+  float min_page_scale_factor_;
+  float max_page_scale_factor_;
   bool on_new_picture_enable_;
   bool clear_view_;
 
@@ -179,6 +182,8 @@ class BrowserViewRenderer : public content::SynchronousCompositorClient {
 
   gfx::Size size_;
 
+  gfx::SizeF scrollable_size_dip_;
+
   // Current scroll offset in CSS pixels.
   // TODO(miletus): Make scroll_offset_dip_ a gfx::ScrollOffset.
   gfx::Vector2dF scroll_offset_dip_;
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index c1509b0..49eaf8c 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -1384,14 +1384,7 @@ void LayerImpl::AddDamageRect(const gfx::Rect& damage_rect) {
 void LayerImpl::SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsActive());
   if (scroll_offset_->SetCurrent(scroll_offset))
-    DidUpdateScrollOffset(false);
-}
-
-void LayerImpl::SetCurrentScrollOffsetFromDelegate(
-    const gfx::ScrollOffset& scroll_offset) {
-  DCHECK(IsActive());
-  if (scroll_offset_->SetCurrent(scroll_offset))
-    DidUpdateScrollOffset(true);
+    DidUpdateScrollOffset();
 }
 
 void LayerImpl::PushScrollOffsetFromMainThread(
@@ -1461,7 +1454,7 @@ void LayerImpl::PushScrollOffset(const gfx::ScrollOffset* scroll_offset) {
   }
 
   if (changed)
-    DidUpdateScrollOffset(false);
+    DidUpdateScrollOffset();
 }
 
 void LayerImpl::UpdatePropertyTreeScrollOffset() {
@@ -1480,11 +1473,9 @@ void LayerImpl::UpdatePropertyTreeScrollOffset() {
   }
 }
 
-void LayerImpl::DidUpdateScrollOffset(bool is_from_root_delegate) {
+void LayerImpl::DidUpdateScrollOffset() {
   DCHECK(scroll_offset_);
 
-  if (!is_from_root_delegate)
-    layer_tree_impl()->DidUpdateScrollOffset(id());
   NoteLayerPropertyChangedForSubtree();
   ScrollbarParametersDidChange(false);
 
@@ -1494,7 +1485,7 @@ void LayerImpl::DidUpdateScrollOffset(bool is_from_root_delegate) {
   if (layer_tree_impl()->IsActiveTree()) {
     LayerImpl* pending_twin = layer_tree_impl()->FindPendingTreeLayerById(id());
     if (pending_twin)
-      pending_twin->DidUpdateScrollOffset(is_from_root_delegate);
+      pending_twin->DidUpdateScrollOffset();
   }
 }
 
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index b5f60e9..5755a75 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -440,8 +440,6 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   gfx::Vector2dF bounds_delta() const { return bounds_delta_; }
 
   void SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset);
-  void SetCurrentScrollOffsetFromDelegate(
-      const gfx::ScrollOffset& scroll_offset);
   void PushScrollOffsetFromMainThread(const gfx::ScrollOffset& scroll_offset);
   // This method is similar to PushScrollOffsetFromMainThread but will cause the
   // scroll offset given to clobber any scroll changes on the active tree in the
@@ -715,10 +713,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   void ValidateQuadResourcesInternal(DrawQuad* quad) const;
 
   void PushScrollOffset(const gfx::ScrollOffset* scroll_offset);
-  // If the new scroll offset is assigned from the root scroll offset delegate,
-  // LayerImpl won't inform the root scroll offset delegate about the scroll
-  // change to avoid feedback.
-  void DidUpdateScrollOffset(bool is_from_root_delegate);
+  void DidUpdateScrollOffset();
   void NoteLayerPropertyChangedForDescendantsInternal();
 
   virtual const char* LayerTypeAsString() const;
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index c69d8ea..24bf756 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -185,7 +185,7 @@ LayerTreeHostImpl::LayerTreeHostImpl(
       scroll_affects_scroll_handler_(false),
       scroll_layer_id_when_mouse_over_scrollbar_(0),
       tile_priorities_dirty_(false),
-      root_layer_scroll_offset_delegate_(NULL),
+      root_layer_scroll_offset_delegate_(nullptr),
       settings_(settings),
       visible_(true),
       cached_managed_memory_policy_(
@@ -424,6 +424,9 @@ void LayerTreeHostImpl::Animate() {
   AnimateLayers(monotonic_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
+
+  // Animating stuff can change the root scroll offset, so inform the delegate.
+  NotifyRootLayerScrollOffsetDelegate();
 }
 
 bool LayerTreeHostImpl::PrepareTiles() {
@@ -1872,7 +1875,6 @@ void LayerTreeHostImpl::ActivateSyncTree() {
   if (pending_tree_) {
     TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_.get());
 
-    active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
     // Process any requests in the UI resource queue.  The request queue is
     // given in LayerTreeHost::FinishCommitOnImplThread.  This must take place
     // before the swap.
@@ -1896,9 +1898,6 @@ void LayerTreeHostImpl::ActivateSyncTree() {
 
     UpdateViewportContainerSizes();
 
-    active_tree_->SetRootLayerScrollOffsetDelegate(
-        root_layer_scroll_offset_delegate_);
-
     // If we commit to the active tree directly, this is already done during
     // commit.
     ActivateAnimations();
@@ -1930,6 +1929,8 @@ void LayerTreeHostImpl::ActivateSyncTree() {
         pending_page_scale_animation->scale,
         pending_page_scale_animation->duration);
   }
+  // Activation can change the root scroll offset, so inform the delegate.
+  NotifyRootLayerScrollOffsetDelegate();
 }
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
@@ -2706,6 +2707,10 @@ InputHandlerScrollResult LayerTreeHostImpl::ScrollBy(
   scroll_result.did_overscroll_root = !unused_root_delta.IsZero();
   scroll_result.accumulated_root_overscroll = accumulated_root_overscroll_;
   scroll_result.unused_scroll_delta = unused_root_delta;
+
+  // Scrolling can change the root scroll offset, so inform the delegate.
+  NotifyRootLayerScrollOffsetDelegate();
+
   return scroll_result;
 }
 
@@ -2754,15 +2759,17 @@ bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
 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_);
+  // When first set, clobber the delegate's scroll offset with compositor's.
+  NotifyRootLayerScrollOffsetDelegate();
 }
 
 void LayerTreeHostImpl::OnRootLayerDelegatedScrollOffsetChanged(
     const gfx::ScrollOffset& root_offset) {
-  DCHECK(root_layer_scroll_offset_delegate_);
   active_tree_->DistributeRootScrollOffset(root_offset);
   client_->SetNeedsCommitOnImplThread();
+  // After applying the delegate's scroll offset, tell it what we ended up with.
+  DCHECK(root_layer_scroll_offset_delegate_);
+  NotifyRootLayerScrollOffsetDelegate();
   // No need to SetNeedsRedraw, this is for WebView and every frame has redraw
   // requested by the WebView embedder already.
 }
@@ -2894,24 +2901,15 @@ void LayerTreeHostImpl::PinchGestureBegin() {
 
 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
                                            const gfx::Point& anchor) {
+  TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
   if (!InnerViewportScrollLayer())
     return;
-
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
-
-  // For a moment the scroll offset ends up being outside of the max range. This
-  // confuses the delegate so we switch it off till after we're done processing
-  // the pinch update.
-  active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
-
   viewport()->PinchUpdate(magnify_delta, anchor);
-
-  active_tree_->SetRootLayerScrollOffsetDelegate(
-      root_layer_scroll_offset_delegate_);
-
   client_->SetNeedsCommitOnImplThread();
   SetNeedsRedraw();
   client_->RenewTreePriority();
+  // Pinching can change the root scroll offset, so inform the delegate.
+  NotifyRootLayerScrollOffsetDelegate();
 }
 
 void LayerTreeHostImpl::PinchGestureEnd() {
@@ -3387,6 +3385,16 @@ void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
     (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
 }
 
+void LayerTreeHostImpl::NotifyRootLayerScrollOffsetDelegate() {
+  if (!root_layer_scroll_offset_delegate_)
+    return;
+  root_layer_scroll_offset_delegate_->UpdateRootLayerState(
+      active_tree_->TotalScrollOffset(), active_tree_->TotalMaxScrollOffset(),
+      active_tree_->ScrollableSize(), active_tree_->current_page_scale_factor(),
+      active_tree_->min_page_scale_factor(),
+      active_tree_->max_page_scale_factor());
+}
+
 void LayerTreeHostImpl::ScrollAnimationCreate(
     LayerImpl* layer_impl,
     const gfx::ScrollOffset& target_offset,
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 1fbd92d..876bf66 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -674,6 +674,7 @@ class CC_EXPORT LayerTreeHostImpl
 
   void NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   void NotifySwapPromiseMonitorsOfForwardingToMainThread();
+  void NotifyRootLayerScrollOffsetDelegate();
 
   void ScrollAnimationCreate(LayerImpl* layer_impl,
                              const gfx::ScrollOffset& target_offset,
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 458af34..f3f494a 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -4580,19 +4580,28 @@ TEST_F(LayerTreeHostImplTest, RootLayerScrollOffsetDelegation) {
   EXPECT_EQ(1.f, scroll_delegate.min_page_scale_factor());
   EXPECT_EQ(1.f, scroll_delegate.max_page_scale_factor());
 
-  // Updating page scale immediately updates the delegate.
+  // Put a page scale on the tree.
   host_impl_->active_tree()->PushPageScaleFromMainThread(2.f, 0.5f, 4.f);
+  EXPECT_EQ(1.f, scroll_delegate.page_scale_factor());
+  EXPECT_EQ(1.f, scroll_delegate.min_page_scale_factor());
+  EXPECT_EQ(1.f, scroll_delegate.max_page_scale_factor());
+  // Activation will update the delegate.
+  host_impl_->ActivateSyncTree();
   EXPECT_EQ(2.f, scroll_delegate.page_scale_factor());
-  EXPECT_EQ(0.5f, scroll_delegate.min_page_scale_factor());
-  EXPECT_EQ(4.f, scroll_delegate.max_page_scale_factor());
-  host_impl_->active_tree()->SetPageScaleOnActiveTree(2.f * 1.5f);
-  EXPECT_EQ(3.f, scroll_delegate.page_scale_factor());
-  EXPECT_EQ(0.5f, scroll_delegate.min_page_scale_factor());
+  EXPECT_EQ(.5f, scroll_delegate.min_page_scale_factor());
   EXPECT_EQ(4.f, scroll_delegate.max_page_scale_factor());
-  host_impl_->active_tree()->SetPageScaleOnActiveTree(2.f);
+
+  // Reset the page scale for the rest of the test.
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
+  EXPECT_EQ(2.f, scroll_delegate.page_scale_factor());
+  EXPECT_EQ(.5f, scroll_delegate.min_page_scale_factor());
+  EXPECT_EQ(4.f, scroll_delegate.max_page_scale_factor());
+
+  // Animating page scale can change the root offset, so it should update the
+  // delegate.
+  host_impl_->Animate();
   EXPECT_EQ(1.f, scroll_delegate.page_scale_factor());
-  EXPECT_EQ(0.5f, scroll_delegate.min_page_scale_factor());
+  EXPECT_EQ(.5f, scroll_delegate.min_page_scale_factor());
   EXPECT_EQ(4.f, scroll_delegate.max_page_scale_factor());
 
   // The pinch gesture doesn't put the delegate into a state where the scroll
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index b63ed4f..00db0a6 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -47,7 +47,6 @@ LayerTreeImpl::LayerTreeImpl(
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       hud_layer_(0),
-      root_layer_scroll_offset_delegate_(NULL),
       background_color_(0),
       has_transparent_background_(false),
       currently_scrolling_layer_id_(Layer::INVALID_ID),
@@ -114,24 +113,6 @@ void LayerTreeImpl::GatherFrameTimingRequestIds(
       });
 }
 
-void LayerTreeImpl::DidUpdateScrollOffset(int layer_id) {
-  int inner_layer_id = InnerViewportScrollLayer()
-                           ? InnerViewportScrollLayer()->id()
-                           : Layer::INVALID_ID;
-  int outer_layer_id = OuterViewportScrollLayer()
-                           ? OuterViewportScrollLayer()->id()
-                           : Layer::INVALID_ID;
-  if (layer_id != outer_layer_id && layer_id != inner_layer_id)
-    return;
-
-  if (root_layer_scroll_offset_delegate_) {
-    root_layer_scroll_offset_delegate_->UpdateRootLayerState(
-        TotalScrollOffset(), TotalMaxScrollOffset(), ScrollableSize(),
-        current_page_scale_factor(), min_page_scale_factor(),
-        max_page_scale_factor());
-  }
-}
-
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
   root_layer_ = layer.Pass();
 
@@ -443,13 +424,6 @@ void LayerTreeImpl::DidUpdatePageScale() {
 
   set_needs_update_draw_properties();
 
-  if (root_layer_scroll_offset_delegate_) {
-    root_layer_scroll_offset_delegate_->UpdateRootLayerState(
-        TotalScrollOffset(), TotalMaxScrollOffset(), ScrollableSize(),
-        current_page_scale_factor(), min_page_scale_factor(),
-        max_page_scale_factor());
-  }
-
   if (PageScaleLayer() && PageScaleLayer()->transform_tree_index() != -1) {
     TransformNode* node = property_trees_.transform_tree.Node(
         PageScaleLayer()->transform_tree_index());
@@ -1031,25 +1005,8 @@ void LayerTreeImpl::AsValueInto(base::trace_event::TracedValue* state) const {
   state->EndArray();
 }
 
-void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
-    LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
-  if (root_layer_scroll_offset_delegate_ == root_layer_scroll_offset_delegate)
-    return;
-
-  root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
-
-  if (root_layer_scroll_offset_delegate_) {
-    root_layer_scroll_offset_delegate_->UpdateRootLayerState(
-        TotalScrollOffset(), TotalMaxScrollOffset(), ScrollableSize(),
-        current_page_scale_factor(), min_page_scale_factor(),
-        max_page_scale_factor());
-  }
-}
-
 void LayerTreeImpl::DistributeRootScrollOffset(
     const gfx::ScrollOffset& root_offset) {
-  DCHECK(root_layer_scroll_offset_delegate_);
-
   if (!InnerViewportScrollLayer())
     return;
 
@@ -1074,16 +1031,9 @@ void LayerTreeImpl::DistributeRootScrollOffset(
   outer_viewport_offset.SetToMin(max_outer_viewport_scroll_offset);
   outer_viewport_offset.SetToMax(gfx::ScrollOffset());
 
-  OuterViewportScrollLayer()->SetCurrentScrollOffsetFromDelegate(
-      outer_viewport_offset);
+  OuterViewportScrollLayer()->SetCurrentScrollOffset(outer_viewport_offset);
   inner_viewport_offset = root_offset - outer_viewport_offset;
-  InnerViewportScrollLayer()->SetCurrentScrollOffsetFromDelegate(
-      inner_viewport_offset);
-
-  root_layer_scroll_offset_delegate_->UpdateRootLayerState(
-      TotalScrollOffset(), TotalMaxScrollOffset(), ScrollableSize(),
-      current_page_scale_factor(), min_page_scale_factor(),
-      max_page_scale_factor());
+  InnerViewportScrollLayer()->SetCurrentScrollOffset(inner_viewport_offset);
 }
 
 void LayerTreeImpl::QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise) {
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 3f8b564..c9bd64b 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -270,8 +270,6 @@ class CC_EXPORT LayerTreeImpl {
   // Useful for debug assertions, probably shouldn't be used for anything else.
   Proxy* proxy() const;
 
-  void SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate);
   // Distribute the root scroll between outer and inner viewport scroll layer.
   // The outer viewport scroll layer scrolls first.
   void DistributeRootScrollOffset(const gfx::ScrollOffset& root_offset);
@@ -363,8 +361,6 @@ class CC_EXPORT LayerTreeImpl {
 
   void GatherFrameTimingRequestIds(std::vector<int64_t>* request_ids);
 
-  void DidUpdateScrollOffset(int layer_id);
-
   bool IsAnimatingFilterProperty(const LayerImpl* layer) const;
   bool IsAnimatingOpacityProperty(const LayerImpl* layer) const;
   bool IsAnimatingTransformProperty(const LayerImpl* layer) const;
@@ -417,7 +413,6 @@ class CC_EXPORT LayerTreeImpl {
   scoped_ptr<LayerImpl> root_layer_;
   HeadsUpDisplayLayerImpl* hud_layer_;
   PropertyTrees property_trees_;
-  LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
   SkColor background_color_;
   bool has_transparent_background_;