diff options
-rw-r--r-- | cc/input/scroll_state.h | 1 | ||||
-rw-r--r-- | cc/layers/layer_impl.cc | 29 | ||||
-rw-r--r-- | cc/layers/layer_impl.h | 8 | ||||
-rw-r--r-- | cc/layers/layer_impl_unittest.cc | 2 | ||||
-rw-r--r-- | cc/layers/viewport.cc | 20 | ||||
-rw-r--r-- | cc/trees/layer_tree_host_impl.cc | 76 | ||||
-rw-r--r-- | cc/trees/layer_tree_host_impl.h | 18 | ||||
-rw-r--r-- | cc/trees/layer_tree_host_impl_unittest.cc | 13 | ||||
-rw-r--r-- | cc/trees/layer_tree_impl.h | 4 | ||||
-rw-r--r-- | cc/trees/property_tree.cc | 49 | ||||
-rw-r--r-- | cc/trees/property_tree.h | 8 |
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 { |