cc: Impl thread scroll on ScrollNode instead of LayerImpl

BUG=568830
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

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

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

11 files changed, 153 insertions, 75 deletions

diff --git a/cc/input/scroll_state.h b/cc/input/scroll_state.h
index 35a4f97..3e6f92c 100644
--- a/cc/input/scroll_state.h
+++ b/cc/input/scroll_state.h
@@ -93,6 +93,7 @@ class CC_EXPORT ScrollState {
   bool caused_scroll_x() const { return data_.caused_scroll_x; }
   bool caused_scroll_y() const { return data_.caused_scroll_y; }
 
+  LayerTreeImpl* layer_tree_impl() { return layer_tree_impl_; }
   ScrollStateData* data() { return &data_; }
 
  private:
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 6cdc423..dbfd5fc 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -207,7 +207,9 @@ void LayerImpl::DistributeScroll(ScrollState* scroll_state) {
 
 void LayerImpl::ApplyScroll(ScrollState* scroll_state) {
   DCHECK(scroll_state);
-  layer_tree_impl()->ApplyScroll(this, scroll_state);
+  ScrollNode* node = layer_tree_impl()->property_trees()->scroll_tree.Node(
+      scroll_tree_index());
+  layer_tree_impl()->ApplyScroll(node, scroll_state);
 }
 
 void LayerImpl::SetNumDescendantsThatDrawContent(int num_descendants) {
@@ -427,20 +429,9 @@ void LayerImpl::GetContentsResourceId(ResourceId* resource_id,
 }
 
 gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
-  gfx::ScrollOffset adjusted_scroll(scroll);
-  if (!user_scrollable_horizontal_)
-    adjusted_scroll.set_x(0);
-  if (!user_scrollable_vertical_)
-    adjusted_scroll.set_y(0);
-  DCHECK(scrollable());
-  gfx::ScrollOffset old_offset = CurrentScrollOffset();
-  gfx::ScrollOffset new_offset =
-      ClampScrollOffsetToLimits(old_offset + adjusted_scroll);
-  SetCurrentScrollOffset(new_offset);
-
-  gfx::ScrollOffset unscrolled =
-      old_offset + gfx::ScrollOffset(scroll) - new_offset;
-  return gfx::Vector2dF(unscrolled.x(), unscrolled.y());
+  ScrollTree& scroll_tree = layer_tree_impl()->property_trees()->scroll_tree;
+  ScrollNode* scroll_node = scroll_tree.Node(scroll_tree_index());
+  return scroll_tree.ScrollBy(scroll_node, scroll, layer_tree_impl());
 }
 
 void LayerImpl::SetScrollClipLayer(int scroll_clip_layer_id) {
@@ -460,6 +451,14 @@ bool LayerImpl::scrollable() const {
   return scroll_clip_layer_id_ != Layer::INVALID_ID;
 }
 
+void LayerImpl::set_user_scrollable_horizontal(bool scrollable) {
+  user_scrollable_horizontal_ = scrollable;
+}
+
+void LayerImpl::set_user_scrollable_vertical(bool scrollable) {
+  user_scrollable_vertical_ = scrollable;
+}
+
 bool LayerImpl::user_scrollable(ScrollbarOrientation orientation) const {
   return (orientation == HORIZONTAL) ? user_scrollable_horizontal_
                                      : user_scrollable_vertical_;
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index ef7db53..a8de2bb 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -441,15 +441,11 @@ class CC_EXPORT LayerImpl {
   LayerImpl* scroll_clip_layer() const;
   bool scrollable() const;
 
-  void set_user_scrollable_horizontal(bool scrollable) {
-    user_scrollable_horizontal_ = scrollable;
-  }
+  void set_user_scrollable_horizontal(bool scrollable);
   bool user_scrollable_horizontal() const {
     return user_scrollable_horizontal_;
   }
-  void set_user_scrollable_vertical(bool scrollable) {
-    user_scrollable_vertical_ = scrollable;
-  }
+  void set_user_scrollable_vertical(bool scrollable);
   bool user_scrollable_vertical() const { return user_scrollable_vertical_; }
 
   bool user_scrollable(ScrollbarOrientation orientation) const;
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index 15d8e94..e88d007 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -633,6 +633,8 @@ TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) {
   gfx::Vector2dF scroll_delta(20.5f, 8.5f);
 
   layer()->set_user_scrollable_vertical(false);
+  layer()->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  layer()->layer_tree_impl()->BuildPropertyTreesForTesting();
   scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->id(),
                                                          scroll_offset);
   gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
diff --git a/cc/layers/viewport.cc b/cc/layers/viewport.cc
index 3483d67..1b3cfe5 100644
--- a/cc/layers/viewport.cc
+++ b/cc/layers/viewport.cc
@@ -43,17 +43,21 @@ Viewport::ScrollResult Viewport::ScrollBy(const gfx::Vector2dF& delta,
 
   gfx::Vector2dF pending_content_delta = content_delta;
 
-  pending_content_delta -= host_impl_->ScrollLayer(InnerScrollLayer(),
-                                                   pending_content_delta,
-                                                   viewport_point,
-                                                   is_direct_manipulation);
+  ScrollTree& scroll_tree =
+      host_impl_->active_tree()->property_trees()->scroll_tree;
+  ScrollNode* inner_node =
+      scroll_tree.Node(InnerScrollLayer()->scroll_tree_index());
+  pending_content_delta -= host_impl_->ScrollSingleNode(
+      inner_node, pending_content_delta, viewport_point, is_direct_manipulation,
+      &scroll_tree);
 
   ScrollResult result;
 
-  pending_content_delta -= host_impl_->ScrollLayer(OuterScrollLayer(),
-                                                   pending_content_delta,
-                                                   viewport_point,
-                                                   is_direct_manipulation);
+  ScrollNode* outer_node =
+      scroll_tree.Node(OuterScrollLayer()->scroll_tree_index());
+  pending_content_delta -= host_impl_->ScrollSingleNode(
+      outer_node, pending_content_delta, viewport_point, is_direct_manipulation,
+      &scroll_tree);
   result.consumed_delta = delta - AdjustOverscroll(pending_content_delta);
 
   result.content_scrolled_delta = content_delta - pending_content_delta;
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 5e21974..0091ee5 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -2773,8 +2773,8 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
         if (!scroll_node->data.scrollable)
           continue;
 
-        LayerImpl* layer_impl = active_tree_->LayerById(scroll_node->owner_id);
-        gfx::ScrollOffset current_offset = layer_impl->CurrentScrollOffset();
+        gfx::ScrollOffset current_offset =
+            scroll_tree.current_scroll_offset(scroll_node->owner_id);
         gfx::ScrollOffset target_offset =
             ScrollOffsetWithDelta(current_offset, pending_delta);
         target_offset.SetToMax(gfx::ScrollOffset());
@@ -2795,7 +2795,7 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
                                  std::abs(actual_delta.y()) > kEpsilon);
 
         if (!can_layer_scroll) {
-          layer_impl->ScrollBy(actual_delta);
+          scroll_tree.ScrollBy(scroll_node, actual_delta, active_tree());
           pending_delta -= actual_delta;
           continue;
         }
@@ -2814,14 +2814,15 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
   return scroll_status;
 }
 
-gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
-    LayerImpl* layer_impl,
+gfx::Vector2dF LayerTreeHostImpl::ScrollNodeWithViewportSpaceDelta(
+    ScrollNode* scroll_node,
     const gfx::PointF& viewport_point,
-    const gfx::Vector2dF& viewport_delta) {
+    const gfx::Vector2dF& viewport_delta,
+    ScrollTree* scroll_tree) {
   // Layers with non-invertible screen space transforms should not have passed
   // the scroll hit test in the first place.
   const gfx::Transform screen_space_transform =
-      layer_impl->ScreenSpaceTransform();
+      scroll_tree->ScreenSpaceTransform(scroll_node->id);
   DCHECK(screen_space_transform.IsInvertible());
   gfx::Transform inverse_screen_space_transform(
       gfx::Transform::kSkipInitialization);
@@ -2859,10 +2860,13 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
     return gfx::Vector2dF();
 
   // Apply the scroll delta.
-  gfx::ScrollOffset previous_offset = layer_impl->CurrentScrollOffset();
-  layer_impl->ScrollBy(local_end_point - local_start_point);
+  gfx::ScrollOffset previous_offset =
+      scroll_tree->current_scroll_offset(scroll_node->owner_id);
+  scroll_tree->ScrollBy(scroll_node, local_end_point - local_start_point,
+                        active_tree());
   gfx::ScrollOffset scrolled =
-      layer_impl->CurrentScrollOffset() - previous_offset;
+      scroll_tree->current_scroll_offset(scroll_node->owner_id) -
+      previous_offset;
 
   // Get the end point in the layer's content space so we can apply its
   // ScreenSpaceTransform.
@@ -2881,16 +2885,20 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
   return actual_viewport_end_point - viewport_point;
 }
 
-static gfx::Vector2dF ScrollLayerWithLocalDelta(
-    LayerImpl* layer_impl,
+static gfx::Vector2dF ScrollNodeWithLocalDelta(
+    ScrollNode* scroll_node,
     const gfx::Vector2dF& local_delta,
-    float page_scale_factor) {
-  gfx::ScrollOffset previous_offset = layer_impl->CurrentScrollOffset();
+    float page_scale_factor,
+    LayerTreeImpl* layer_tree_impl) {
+  ScrollTree& scroll_tree = layer_tree_impl->property_trees()->scroll_tree;
+  gfx::ScrollOffset previous_offset =
+      scroll_tree.current_scroll_offset(scroll_node->owner_id);
   gfx::Vector2dF delta = local_delta;
   delta.Scale(1.f / page_scale_factor);
-  layer_impl->ScrollBy(delta);
+  scroll_tree.ScrollBy(scroll_node, delta, layer_tree_impl);
   gfx::ScrollOffset scrolled =
-      layer_impl->CurrentScrollOffset() - previous_offset;
+      scroll_tree.current_scroll_offset(scroll_node->owner_id) -
+      previous_offset;
   gfx::Vector2dF consumed_scroll(scrolled.x(), scrolled.y());
   consumed_scroll.Scale(page_scale_factor);
 
@@ -2899,10 +2907,12 @@ static gfx::Vector2dF ScrollLayerWithLocalDelta(
 
 // TODO(danakj): Make this into two functions, one with delta, one with
 // viewport_point, no bool required.
-gfx::Vector2dF LayerTreeHostImpl::ScrollLayer(LayerImpl* layer_impl,
-                                              const gfx::Vector2dF& delta,
-                                              const gfx::Point& viewport_point,
-                                              bool is_direct_manipulation) {
+gfx::Vector2dF LayerTreeHostImpl::ScrollSingleNode(
+    ScrollNode* scroll_node,
+    const gfx::Vector2dF& delta,
+    const gfx::Point& viewport_point,
+    bool is_direct_manipulation,
+    ScrollTree* scroll_tree) {
   // Events representing direct manipulation of the screen (such as gesture
   // events) need to be transformed from viewport coordinates to local layer
   // coordinates so that the scrolling contents exactly follow the user's
@@ -2911,14 +2921,15 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollLayer(LayerImpl* layer_impl,
   // can just apply them directly, but the page scale factor is applied to the
   // scroll delta.
   if (is_direct_manipulation) {
-    return ScrollLayerWithViewportSpaceDelta(
-        layer_impl, gfx::PointF(viewport_point), delta);
+    return ScrollNodeWithViewportSpaceDelta(
+        scroll_node, gfx::PointF(viewport_point), delta, scroll_tree);
   }
   float scale_factor = active_tree()->current_page_scale_factor();
-  return ScrollLayerWithLocalDelta(layer_impl, delta, scale_factor);
+  return ScrollNodeWithLocalDelta(scroll_node, delta, scale_factor,
+                                  active_tree());
 }
 
-void LayerTreeHostImpl::ApplyScroll(LayerImpl* layer,
+void LayerTreeHostImpl::ApplyScroll(ScrollNode* scroll_node,
                                     ScrollState* scroll_state) {
   DCHECK(scroll_state);
   gfx::Point viewport_point(scroll_state->start_position_x(),
@@ -2929,7 +2940,7 @@ void LayerTreeHostImpl::ApplyScroll(LayerImpl* layer,
   // details.
   const float kEpsilon = 0.1f;
 
-  if (layer == InnerViewportScrollLayer()) {
+  if (scroll_node->data.is_inner_viewport_scroll_layer) {
     bool affect_top_controls = !wheel_scrolling_;
     Viewport::ScrollResult result = viewport()->ScrollBy(
         delta, viewport_point, scroll_state->is_direct_manipulation(),
@@ -2940,15 +2951,17 @@ void LayerTreeHostImpl::ApplyScroll(LayerImpl* layer,
         std::abs(result.content_scrolled_delta.y()) > kEpsilon);
     scroll_state->ConsumeDelta(applied_delta.x(), applied_delta.y());
   } else {
-    applied_delta = ScrollLayer(layer, delta, viewport_point,
-                                scroll_state->is_direct_manipulation());
+    applied_delta = ScrollSingleNode(
+        scroll_node, delta, viewport_point,
+        scroll_state->is_direct_manipulation(),
+        &scroll_state->layer_tree_impl()->property_trees()->scroll_tree);
   }
 
   // If the layer wasn't able to move, try the next one in the hierarchy.
   bool scrolled = std::abs(applied_delta.x()) > kEpsilon;
   scrolled = scrolled || std::abs(applied_delta.y()) > kEpsilon;
 
-  if (scrolled && layer != InnerViewportScrollLayer()) {
+  if (scrolled && !scroll_node->data.is_inner_viewport_scroll_layer) {
     // If the applied delta is within 45 degrees of the input
     // delta, bail out to make it easier to scroll just one layer
     // in one direction without affecting any of its parents.
@@ -2969,9 +2982,7 @@ void LayerTreeHostImpl::ApplyScroll(LayerImpl* layer,
   if (!scrolled)
     return;
 
-  scroll_state->set_current_native_scrolling_node(
-      active_tree()->property_trees()->scroll_tree.Node(
-          layer->scroll_tree_index()));
+  scroll_state->set_current_native_scrolling_node(scroll_node);
 }
 
 void LayerTreeHostImpl::DistributeScrollDelta(ScrollState* scroll_state) {
@@ -3085,7 +3096,6 @@ bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
   if (scroll_node) {
     for (; scroll_tree.parent(scroll_node);
          scroll_node = scroll_tree.parent(scroll_node)) {
-      LayerImpl* layer_impl = active_tree_->LayerById(scroll_node->owner_id);
       // The inner viewport layer represents the viewport.
       if (!scroll_node->data.scrollable ||
           scroll_node->data.is_outer_viewport_scroll_layer)
@@ -3103,7 +3113,7 @@ bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
       gfx::Vector2dF delta = gfx::Vector2dF(0.f, page);
 
       gfx::Vector2dF applied_delta =
-          ScrollLayerWithLocalDelta(layer_impl, delta, 1.f);
+          ScrollNodeWithLocalDelta(scroll_node, delta, 1.f, active_tree());
 
       if (!applied_delta.IsZero()) {
         client_->SetNeedsCommitOnImplThread();
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 7a8aca72..026294b 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -170,7 +170,7 @@ class CC_EXPORT LayerTreeHostImpl
   InputHandler::ScrollStatus ScrollAnimated(
       const gfx::Point& viewport_point,
       const gfx::Vector2dF& scroll_delta) override;
-  void ApplyScroll(LayerImpl* layer, ScrollState* scroll_state);
+  void ApplyScroll(ScrollNode* scroll_node, ScrollState* scroll_state);
   InputHandlerScrollResult ScrollBy(ScrollState* scroll_state) override;
   bool ScrollVerticallyByPage(const gfx::Point& viewport_point,
                               ScrollDirection direction) override;
@@ -574,10 +574,11 @@ class CC_EXPORT LayerTreeHostImpl
     return frame_timing_tracker_.get();
   }
 
-  gfx::Vector2dF ScrollLayer(LayerImpl* layer_impl,
-                             const gfx::Vector2dF& delta,
-                             const gfx::Point& viewport_point,
-                             bool is_direct_manipulation);
+  gfx::Vector2dF ScrollSingleNode(ScrollNode* scroll_node,
+                                  const gfx::Vector2dF& delta,
+                                  const gfx::Point& viewport_point,
+                                  bool is_direct_manipulation,
+                                  ScrollTree* scroll_tree);
 
   // Record main frame timing information.
   // |start_of_main_frame_args| is the BeginFrameArgs of the beginning of the
@@ -636,10 +637,11 @@ class CC_EXPORT LayerTreeHostImpl
   BeginFrameTracker current_begin_frame_tracker_;
 
  private:
-  gfx::Vector2dF ScrollLayerWithViewportSpaceDelta(
-      LayerImpl* layer_impl,
+  gfx::Vector2dF ScrollNodeWithViewportSpaceDelta(
+      ScrollNode* scroll_node,
       const gfx::PointF& viewport_point,
-      const gfx::Vector2dF& viewport_delta);
+      const gfx::Vector2dF& viewport_delta,
+      ScrollTree* scroll_tree);
 
   void CreateAndSetRenderer();
   void CleanUpTileManagerAndUIResources();
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index e838eae..5be1b46 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -1131,12 +1131,16 @@ TEST_F(LayerTreeHostImplTest, ScrollVerticallyByPageReturnsCorrectValue) {
 
   // Trying to scroll if not user_scrollable_vertical will fail.
   host_impl_->InnerViewportScrollLayer()->set_user_scrollable_vertical(false);
+  SetNeedsRebuildPropertyTrees();
+  DrawFrame();
   EXPECT_FALSE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_FORWARD));
   EXPECT_FALSE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_BACKWARD));
 
   host_impl_->InnerViewportScrollLayer()->set_user_scrollable_vertical(true);
+  SetNeedsRebuildPropertyTrees();
+  DrawFrame();
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_FORWARD));
   EXPECT_FLOAT_EQ(875.f,
@@ -1178,6 +1182,8 @@ TEST_F(LayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) {
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 10), overflow->CurrentScrollOffset());
 
   overflow->set_user_scrollable_horizontal(false);
+  SetNeedsRebuildPropertyTrees();
+  DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(scroll_position).get(),
@@ -1192,6 +1198,8 @@ TEST_F(LayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) {
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 20), overflow->CurrentScrollOffset());
 
   overflow->set_user_scrollable_vertical(false);
+  SetNeedsRebuildPropertyTrees();
+  DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(scroll_position).get(),
@@ -9068,13 +9076,12 @@ TEST_F(LayerTreeHostImplVirtualViewportTest,
   gfx::Size outer_viewport = gfx::Size(50, 80);
   gfx::Size inner_viewport = gfx::Size(25, 40);
   SetupVirtualViewportLayers(content_size, outer_viewport, inner_viewport);
-  SetNeedsRebuildPropertyTrees();
-  DrawFrame();
-
   // Make inner viewport unscrollable.
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
   inner_scroll->set_user_scrollable_horizontal(false);
   inner_scroll->set_user_scrollable_vertical(false);
+  SetNeedsRebuildPropertyTrees();
+  DrawFrame();
 
   // Ensure inner viewport doesn't react to scrolls (test it's unscrollable).
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), inner_scroll->CurrentScrollOffset());
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 76ff68c..b6776ce 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -324,8 +324,8 @@ class CC_EXPORT LayerTreeImpl {
   // The outer viewport scroll layer scrolls first.
   bool DistributeRootScrollOffset(const gfx::ScrollOffset& root_offset);
 
-  void ApplyScroll(LayerImpl* layer, ScrollState* scroll_state) {
-    layer_tree_host_impl_->ApplyScroll(layer, scroll_state);
+  void ApplyScroll(ScrollNode* scroll_node, ScrollState* scroll_state) {
+    layer_tree_host_impl_->ApplyScroll(scroll_node, scroll_state);
   }
 
   // Call this function when you expect there to be a swap buffer.
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index c3514e1..7eea35e 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -10,6 +10,7 @@
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/input/main_thread_scrolling_reason.h"
+#include "cc/input/scroll_state.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/property_tree.pb.h"
@@ -1657,6 +1658,54 @@ const gfx::ScrollOffset ScrollTree::GetScrollOffsetDeltaForTesting(
     return gfx::ScrollOffset();
 }
 
+void ScrollTree::DistributeScroll(ScrollNode* scroll_node,
+                                  ScrollState* scroll_state) {
+  DCHECK(scroll_node && scroll_state);
+  if (scroll_state->FullyConsumed())
+    return;
+  scroll_state->DistributeToScrollChainDescendant();
+
+  // If the scroll doesn't propagate, and we're currently scrolling
+  // a node other than this one, prevent the scroll from
+  // propagating to this node.
+  if (!scroll_state->should_propagate() &&
+      scroll_state->delta_consumed_for_scroll_sequence() &&
+      scroll_state->current_native_scrolling_node()->id != scroll_node->id) {
+    return;
+  }
+
+  scroll_state->layer_tree_impl()->ApplyScroll(scroll_node, scroll_state);
+}
+
+gfx::Vector2dF ScrollTree::ScrollBy(ScrollNode* scroll_node,
+                                    const gfx::Vector2dF& scroll,
+                                    LayerTreeImpl* layer_tree_impl) {
+  gfx::ScrollOffset adjusted_scroll(scroll);
+  if (!scroll_node->data.user_scrollable_horizontal)
+    adjusted_scroll.set_x(0);
+  if (!scroll_node->data.user_scrollable_vertical)
+    adjusted_scroll.set_y(0);
+  DCHECK(scroll_node->data.scrollable);
+  gfx::ScrollOffset old_offset = current_scroll_offset(scroll_node->owner_id);
+  gfx::ScrollOffset new_offset =
+      ClampScrollOffsetToLimits(old_offset + adjusted_scroll, scroll_node);
+  if (SetScrollOffset(scroll_node->owner_id, new_offset))
+    layer_tree_impl->DidUpdateScrollOffset(scroll_node->owner_id,
+                                           scroll_node->data.transform_id);
+
+  gfx::ScrollOffset unscrolled =
+      old_offset + gfx::ScrollOffset(scroll) - new_offset;
+  return gfx::Vector2dF(unscrolled.x(), unscrolled.y());
+}
+
+gfx::ScrollOffset ScrollTree::ClampScrollOffsetToLimits(
+    gfx::ScrollOffset offset,
+    ScrollNode* scroll_node) const {
+  offset.SetToMin(MaxScrollOffset(scroll_node->id));
+  offset.SetToMax(gfx::ScrollOffset());
+  return offset;
+}
+
 PropertyTrees::PropertyTrees()
     : needs_rebuild(true),
       non_root_surfaces_enabled(true),
diff --git a/cc/trees/property_tree.h b/cc/trees/property_tree.h
index 96d8d8e..9115702 100644
--- a/cc/trees/property_tree.h
+++ b/cc/trees/property_tree.h
@@ -30,6 +30,7 @@ class TreeNode;
 }
 
 class LayerTreeImpl;
+class ScrollState;
 struct ScrollAndScaleSet;
 
 // ------------------------------*IMPORTANT*---------------------------------
@@ -596,6 +597,11 @@ class CC_EXPORT ScrollTree final : public PropertyTree<ScrollNode> {
   const gfx::ScrollOffset GetScrollOffsetDeltaForTesting(int layer_id) const;
   void CollectScrollDeltasForTesting();
 
+  void DistributeScroll(ScrollNode* scroll_node, ScrollState* scroll_state);
+  gfx::Vector2dF ScrollBy(ScrollNode* scroll_node,
+                          const gfx::Vector2dF& scroll,
+                          LayerTreeImpl* layer_tree_impl);
+
  private:
   int currently_scrolling_node_id_;
   ScrollOffsetMap layer_id_to_scroll_offset_map_;
@@ -606,6 +612,8 @@ class CC_EXPORT ScrollTree final : public PropertyTree<ScrollNode> {
   void UpdateScrollOffsetMapEntry(int key,
                                   ScrollOffsetMap* new_scroll_offset_map,
                                   LayerTreeImpl* layer_tree_impl);
+  gfx::ScrollOffset ClampScrollOffsetToLimits(gfx::ScrollOffset offset,
+                                              ScrollNode* scroll_node) const;
 };
 
 class CC_EXPORT PropertyTrees final {