summaryrefslogtreecommitdiffstats
path: root/cc
diff options
context:
space:
mode:
Diffstat (limited to 'cc')
-rw-r--r--cc/input/input_handler.h12
-rw-r--r--cc/input/layer_scroll_offset_delegate.h38
-rw-r--r--cc/layers/layer.cc4
-rw-r--r--cc/layers/layer.h2
-rw-r--r--cc/layers/layer_impl.cc43
-rw-r--r--cc/layers/layer_impl.h5
-rw-r--r--cc/trees/layer_tree_host_common.cc10
-rw-r--r--cc/trees/layer_tree_host_impl.cc30
-rw-r--r--cc/trees/layer_tree_host_impl.h6
-rw-r--r--cc/trees/layer_tree_host_impl_unittest.cc4
-rw-r--r--cc/trees/layer_tree_host_unittest_scroll.cc42
-rw-r--r--cc/trees/layer_tree_impl.cc25
-rw-r--r--cc/trees/layer_tree_impl.h4
13 files changed, 176 insertions, 49 deletions
diff --git a/cc/input/input_handler.h b/cc/input/input_handler.h
index 982befa..b3f805e 100644
--- a/cc/input/input_handler.h
+++ b/cc/input/input_handler.h
@@ -19,6 +19,8 @@ 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
@@ -62,6 +64,16 @@ 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
new file mode 100644
index 0000000..1431a80
--- /dev/null
+++ b/cc/input/layer_scroll_offset_delegate.h
@@ -0,0 +1,38 @@
+// 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 4d1258d..b4a7ca7 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->scroll_delta() -
+ layer->SetScrollDelta(active_twin->ScrollDelta() -
active_twin->sent_scroll_delta());
}
} else {
- layer->SetScrollDelta(layer->scroll_delta() - layer->sent_scroll_delta());
+ layer->SetScrollDelta(layer->ScrollDelta() - layer->sent_scroll_delta());
layer->SetSentScrollDelta(gfx::Vector2d());
}
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index f9d0cb5..b3a1e82 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 scroll_delta() const { return gfx::Vector2d(); }
+ gfx::Vector2d ScrollDelta() 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 b9db1140..9ec16a5 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -13,6 +13,7 @@
#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"
@@ -33,6 +34,7 @@ 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),
@@ -242,10 +244,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 = (scroll_delta_ + scroll);
+ gfx::Vector2dF new_delta = (ScrollDelta() + scroll);
new_delta.ClampToMin(min_delta);
new_delta.ClampToMax(max_delta);
- gfx::Vector2dF unscrolled = scroll_delta_ + scroll - new_delta;
+ gfx::Vector2dF unscrolled = ScrollDelta() + scroll - new_delta;
SetScrollDelta(new_delta);
return unscrolled;
@@ -388,7 +390,7 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
update_rect_.Union(layer->update_rect());
layer->set_update_rect(update_rect_);
- layer->SetScrollDelta(layer->scroll_delta() - layer->sent_scroll_delta());
+ layer->SetScrollDelta(layer->ScrollDelta() - layer->sent_scroll_delta());
layer->SetSentScrollDelta(gfx::Vector2d());
layer->SetStackingOrderChanged(stacking_order_changed_);
@@ -829,7 +831,7 @@ void LayerImpl::CalculateContentsScale(
}
void LayerImpl::UpdateScrollbarPositions() {
- gfx::Vector2dF current_offset = scroll_offset_ + scroll_delta_;
+ gfx::Vector2dF current_offset = scroll_offset_ + ScrollDelta();
gfx::RectF viewport(PointAtOffsetFromOrigin(current_offset), bounds_);
gfx::SizeF scrollable_size(max_scroll_offset_.x() + bounds_.width(),
@@ -867,17 +869,39 @@ 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 (scroll_delta_ == scroll_delta)
+ if (ScrollDelta() == scroll_delta)
return;
if (layer_tree_impl()->IsActiveTree()) {
@@ -893,14 +917,19 @@ void LayerImpl::SetScrollDelta(gfx::Vector2dF scroll_delta) {
}
}
- scroll_delta_ = scroll_delta;
+ if (scroll_offset_delegate_) {
+ scroll_offset_delegate_->SetTotalScrollOffset(
+ scroll_offset_ + scroll_delta);
+ } else {
+ scroll_delta_ = scroll_delta;
+ }
NoteLayerPropertyChangedForSubtree();
UpdateScrollbarPositions();
}
gfx::Vector2dF LayerImpl::TotalScrollOffset() const {
- return scroll_offset_ + scroll_delta_;
+ return scroll_offset_ + ScrollDelta();
}
void LayerImpl::SetDoubleSided(bool double_sided) {
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 697676e..d52d6fa 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -284,6 +284,8 @@ 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_; }
@@ -291,7 +293,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
gfx::Vector2d max_scroll_offset() const { return max_scroll_offset_; }
void SetScrollDelta(gfx::Vector2dF scroll_delta);
- gfx::Vector2dF scroll_delta() const { return scroll_delta_; }
+ gfx::Vector2dF ScrollDelta() const;
gfx::Vector2dF TotalScrollOffset() const;
@@ -456,6 +458,7 @@ 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 da5fd63..2fb5fe1 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->scroll_delta().x(),
- scrolling_layer->scroll_delta().y()); // Step 2
+ scrolling_layer->ScrollDelta().x(),
+ scrolling_layer->ScrollDelta().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->scroll_delta().IsZero() && !layer->render_surface())
+ layer->ScrollDelta().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->scroll_delta().IsZero()) {
+ if (!layer->ScrollDelta().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->scroll_delta();
+ gfx::PointF position = layer->position() - layer->ScrollDelta();
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 a3cf0d3..a465c32 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -168,6 +168,7 @@ 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),
@@ -308,7 +309,7 @@ void LayerTreeHostImpl::StartPageScaleAnimation(gfx::Vector2d target_offset,
return;
gfx::Vector2dF scroll_total =
- RootScrollLayer()->scroll_offset() + RootScrollLayer()->scroll_delta();
+ RootScrollLayer()->scroll_offset() + RootScrollLayer()->ScrollDelta();
gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
gfx::SizeF viewport_size = VisibleViewportSize();
@@ -1281,6 +1282,7 @@ 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(
@@ -1300,6 +1302,8 @@ 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
@@ -1582,13 +1586,13 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
local_end_point.Scale(width_scale, height_scale);
// Apply the scroll delta.
- gfx::Vector2dF previous_delta = layer_impl->scroll_delta();
+ gfx::Vector2dF previous_delta = layer_impl->ScrollDelta();
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->scroll_delta() -
+ layer_impl->ScrollDelta() -
previous_delta;
gfx::PointF actual_local_content_end_point =
gfx::ScalePoint(actual_local_end_point,
@@ -1611,9 +1615,9 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
static gfx::Vector2dF ScrollLayerWithLocalDelta(LayerImpl* layer_impl,
gfx::Vector2dF local_delta) {
- gfx::Vector2dF previous_delta(layer_impl->scroll_delta());
+ gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
layer_impl->ScrollBy(local_delta);
- return layer_impl->scroll_delta() - previous_delta;
+ return layer_impl->ScrollDelta() - previous_delta;
}
bool LayerTreeHostImpl::ScrollBy(gfx::Point viewport_point,
@@ -1741,6 +1745,18 @@ 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;
@@ -1812,7 +1828,7 @@ static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
return;
gfx::Vector2d scroll_delta =
- gfx::ToFlooredVector2d(layer_impl->scroll_delta());
+ gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
if (!scroll_delta.IsZero()) {
LayerTreeHostCommon::ScrollUpdateInfo scroll;
scroll.layer_id = layer_impl->id();
@@ -1845,7 +1861,7 @@ void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks time) {
double monotonic_time = (time - base::TimeTicks()).InSecondsF();
gfx::Vector2dF scroll_total = RootScrollLayer()->scroll_offset() +
- RootScrollLayer()->scroll_delta();
+ RootScrollLayer()->ScrollDelta();
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 fc1e0e9..9af1e4f 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -16,6 +16,7 @@
#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"
@@ -103,6 +104,9 @@ 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;
@@ -431,6 +435,8 @@ 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 ce2add2..c88b595 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->scroll_delta(), gfx::Vector2d());
+ ASSERT_EQ(layer->ScrollDelta(), 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()->scroll_delta().y());
+ EXPECT_FLOAT_EQ(875.f, host_impl_->RootScrollLayer()->ScrollDelta().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 1d74ddf..d433c42 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->scroll_delta());
+ EXPECT_VECTOR_EQ(gfx::Vector2d(), root->ScrollDelta());
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->scroll_delta());
+ EXPECT_VECTOR_EQ(scroll_amount_, root->ScrollDelta());
PostSetNeedsCommitToMainThread();
break;
case 1:
EXPECT_VECTOR_EQ(root->scroll_offset(), second_scroll_);
- EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_);
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), 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->scroll_delta(), gfx::Vector2d());
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
root->ScrollBy(scroll_amount_);
- EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_);
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), 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->scroll_delta(), scroll_amount_);
+ EXPECT_EQ(root->ScrollDelta(), scroll_amount_);
root->ScrollBy(scroll_amount_);
- EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_ + scroll_amount_);
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), 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->scroll_delta(), gfx::Vector2d());
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), 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->scroll_delta(), gfx::Vector2d(0, 0));
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), 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->scroll_delta(),
+ root->ScrollDelta(),
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->scroll_delta(),
+ root->ScrollDelta(),
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->scroll_delta());
+ EXPECT_VECTOR_EQ(gfx::Vector2d(), root_impl->ScrollDelta());
EXPECT_VECTOR_EQ(
gfx::Vector2d(),
- expected_no_scroll_layer_impl->scroll_delta());
+ expected_no_scroll_layer_impl->ScrollDelta());
// 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->scroll_delta());
+ expected_scroll_layer_impl->ScrollDelta());
break;
}
case 1: {
@@ -403,7 +403,7 @@ class LayerTreeHostScrollTestCaseWithChild
expected_scroll_layer_impl->scroll_offset());
EXPECT_VECTOR_EQ(
scroll_amount_,
- expected_scroll_layer_impl->scroll_delta());
+ expected_scroll_layer_impl->ScrollDelta());
break;
}
case 2:
@@ -413,7 +413,7 @@ class LayerTreeHostScrollTestCaseWithChild
expected_scroll_layer_impl->scroll_offset());
EXPECT_VECTOR_EQ(
gfx::Vector2d(),
- expected_scroll_layer_impl->scroll_delta());
+ expected_scroll_layer_impl->ScrollDelta());
EndTest();
break;
@@ -560,11 +560,11 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
case 0:
if (!impl->pending_tree()) {
can_activate_ = false;
- EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
root->ScrollBy(impl_thread_scroll1_);
EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
- EXPECT_VECTOR_EQ(root->scroll_delta(), impl_thread_scroll1_);
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), 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->scroll_delta(),
+ EXPECT_VECTOR_EQ(root->ScrollDelta(),
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->scroll_delta(), impl_thread_scroll2_);
+ EXPECT_VECTOR_EQ(pending_root->ScrollDelta(), 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->scroll_delta(), impl_thread_scroll2_);
+ EXPECT_VECTOR_EQ(root->ScrollDelta(), 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 4b44a15..f02f01d 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -25,8 +25,9 @@ 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_(0),
- currently_scrolling_layer_(0),
+ root_scroll_layer_(NULL),
+ currently_scrolling_layer_(NULL),
+ root_layer_scroll_offset_delegate_(NULL),
background_color_(0),
has_transparent_background_(false),
pinch_zoom_scrollbar_horizontal_layer_id_(Layer::INVALID_ID),
@@ -66,9 +67,11 @@ static LayerImpl* FindRootScrollLayerRecursive(LayerImpl* layer) {
}
void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
+ if (root_scroll_layer_)
+ root_scroll_layer_->SetScrollOffsetDelegate(NULL);
root_layer_ = layer.Pass();
- root_scroll_layer_ = NULL;
currently_scrolling_layer_ = NULL;
+ root_scroll_layer_ = NULL;
layer_tree_host_impl_->OnCanDrawStateChangedForTree();
}
@@ -76,6 +79,11 @@ 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(),
@@ -89,6 +97,8 @@ 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;
@@ -561,6 +571,15 @@ 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 5ee9c46..4681fc1 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -197,6 +197,9 @@ 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();
@@ -222,6 +225,7 @@ 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_;
generated by cgit v1.1 at 2025-02-07 05:21:28 +0000