cc: Impl thread scroll on ScrollNode instead of LayerImpl

cc/layers/layer_impl.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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 189 matching lines @@
       scroll_state->delta_consumed_for_scroll_sequence() &&
       scroll_state->current_native_scrolling_node()->owner_id != id()) {
     return;
   }
 
   ApplyScroll(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) {
   if (num_descendants_that_draw_content_ == num_descendants)
     return;
   num_descendants_that_draw_content_ = num_descendants;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetClipParent(LayerImpl* ancestor) {
@@ skipping 199 matching lines @@
   }
 }
 
 void LayerImpl::GetContentsResourceId(ResourceId* resource_id,
                                       gfx::Size* resource_size) const {
   NOTREACHED();
   *resource_id = 0;
 }
 
 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) {
   if (scroll_clip_layer_id_ == scroll_clip_layer_id)
     return;
 
   layer_tree_impl()->UnregisterScrollLayer(this);
   scroll_clip_layer_id_ = scroll_clip_layer_id;
   layer_tree_impl()->RegisterScrollLayer(this);
 }
 
 LayerImpl* LayerImpl::scroll_clip_layer() const {
   return layer_tree_impl()->LayerById(scroll_clip_layer_id_);
 }
 
 bool LayerImpl::scrollable() const {
   return scroll_clip_layer_id_ != Layer::INVALID_ID;
 }
 
+void LayerImpl::set_user_scrollable_horizontal(bool scrollable) {
+  user_scrollable_horizontal_ = scrollable;
+  if (!layer_tree_impl_->property_trees()->needs_rebuild && layer_tree_impl_ &&

[ajuma, 2016/03/16 21:49:24]

Horizontal/vertical scrollability should never change on the compositor thread
outside of tests, so rather than trying to update the scroll tree here, tests
that want to change this should just rebuild property trees.

[sunxd, 2016/03/16 23:30:23]

Done.

+      scroll_tree_index_ != -1)
+    layer_tree_impl_->property_trees()
+        ->scroll_tree.Node(scroll_tree_index_)
+        ->data.user_scrollable_horizontal = scrollable;
+}
+
+void LayerImpl::set_user_scrollable_vertical(bool scrollable) {
+  user_scrollable_vertical_ = scrollable;
+  if (!layer_tree_impl_->property_trees()->needs_rebuild && layer_tree_impl_ &&
+      scroll_tree_index_ != -1)
+    layer_tree_impl_->property_trees()
+        ->scroll_tree.Node(scroll_tree_index_)
+        ->data.user_scrollable_vertical = scrollable;
+}
+
 bool LayerImpl::user_scrollable(ScrollbarOrientation orientation) const {
   return (orientation == HORIZONTAL) ? user_scrollable_horizontal_
                                      : user_scrollable_vertical_;
 }
 
 skia::RefPtr<SkPicture> LayerImpl::GetPicture() {
   return skia::RefPtr<SkPicture>();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::CreateLayerImpl(LayerTreeImpl* tree_impl) {
@@ skipping 1108 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc