summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--cc/base/synced_property.h7
-rw-r--r--cc/layers/layer.cc24
-rw-r--r--cc/layers/layer.h4
-rw-r--r--cc/layers/layer_impl.cc302
-rw-r--r--cc/layers/layer_impl.h61
-rw-r--r--cc/layers/layer_impl_unittest.cc46
-rw-r--r--cc/layers/picture_image_layer_impl.cc5
-rw-r--r--cc/layers/picture_layer.cc3
-rw-r--r--cc/layers/picture_layer_impl.cc13
-rw-r--r--cc/layers/picture_layer_impl.h16
-rw-r--r--cc/layers/tiled_layer_impl.cc12
-rw-r--r--cc/layers/tiled_layer_impl.h14
-rw-r--r--cc/test/fake_content_layer_impl.cc10
-rw-r--r--cc/test/fake_content_layer_impl.h15
-rw-r--r--cc/test/fake_picture_layer_impl.cc26
-rw-r--r--cc/test/fake_picture_layer_impl.h5
-rw-r--r--cc/trees/layer_tree_host_common.cc6
-rw-r--r--cc/trees/layer_tree_host_common_unittest.cc3
-rw-r--r--cc/trees/layer_tree_host_impl.cc34
-rw-r--r--cc/trees/layer_tree_host_impl_unittest.cc14
-rw-r--r--cc/trees/layer_tree_host_unittest_animation.cc3
-rw-r--r--cc/trees/layer_tree_host_unittest_scroll.cc16
-rw-r--r--cc/trees/layer_tree_impl.cc39
-rw-r--r--cc/trees/layer_tree_impl.h2
-rw-r--r--cc/trees/property_tree_builder.cc4
25 files changed, 334 insertions, 350 deletions
diff --git a/cc/base/synced_property.h b/cc/base/synced_property.h
index 5c47932..8b554c6 100644
--- a/cc/base/synced_property.h
+++ b/cc/base/synced_property.h
@@ -97,12 +97,17 @@ class SyncedProperty : public base::RefCounted<SyncedProperty<T>> {
sent_delta_ = T::Identity();
}
- private:
+ // Values as last pushed to the pending or active tree respectively, with no
+ // impl-thread delta applied.
+ typename T::ValueType PendingBase() const { return pending_base_.get(); }
+ typename T::ValueType ActiveBase() const { return active_base_.get(); }
+
// The new delta we would use if we decide to activate now. This delta
// excludes the amount that we expect the main thread to reflect back at the
// impl thread during the commit.
T PendingDelta() const { return active_delta_.InverseCombine(sent_delta_); }
+ private:
// Value last committed to the pending tree.
T pending_base_;
// Value last committed to the active tree (on the last activation).
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 4aef7da..face433 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -978,21 +978,10 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
layer->SetClipChildren(nullptr);
}
- // Adjust the scroll delta to be just the scrolls that have happened since
- // the BeginMainFrame was sent. This happens for impl-side painting
- // in LayerImpl::ApplyScrollDeltasSinceBeginMainFrame in a separate tree walk.
- if (layer->layer_tree_impl()->settings().impl_side_painting) {
- layer->SetScrollOffset(scroll_offset_);
- } else {
- if (layer_animation_controller_
- ->scroll_offset_animation_was_interrupted()) {
- layer->SetScrollOffsetAndDelta(scroll_offset_, gfx::Vector2dF());
- } else {
- layer->SetScrollOffsetAndDelta(
- scroll_offset_, layer->ScrollDelta() - layer->sent_scroll_delta());
- }
- layer->SetSentScrollDelta(gfx::Vector2dF());
- }
+ layer->PushScrollOffsetFromMainThread(scroll_offset_);
+ if (layer_animation_controller_->scroll_offset_animation_was_interrupted() &&
+ layer->IsActive())
+ layer->SetScrollDelta(gfx::Vector2dF());
layer->SetScrollCompensationAdjustment(ScrollCompensationAdjustment());
// Wrap the copy_requests_ in a PostTask to the main thread.
@@ -1041,7 +1030,8 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
}
scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
- return LayerImpl::Create(tree_impl, layer_id_);
+ return LayerImpl::Create(tree_impl, layer_id_,
+ new LayerImpl::SyncedScrollOffset);
}
bool Layer::DrawsContent() const {
@@ -1135,7 +1125,7 @@ void Layer::ClearRenderSurfaceLayerList() {
}
gfx::ScrollOffset Layer::ScrollOffsetForAnimation() const {
- return TotalScrollOffset();
+ return CurrentScrollOffset();
}
// On<Property>Animated is called due to an ongoing accelerated animation.
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index 112d3f4..db472c6 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -318,9 +318,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
bool force_render_surface() const { return force_render_surface_; }
gfx::Vector2dF ScrollDelta() const { return gfx::Vector2dF(); }
- gfx::ScrollOffset TotalScrollOffset() const {
- return ScrollOffsetWithDelta(scroll_offset(), ScrollDelta());
- }
+ gfx::ScrollOffset CurrentScrollOffset() const { return scroll_offset_; }
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 561c0113..0e78ca8 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -34,7 +34,13 @@
#include "ui/gfx/geometry/vector2d_conversions.h"
namespace cc {
-LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
+LayerImpl::LayerImpl(LayerTreeImpl* layer_impl, int id)
+ : LayerImpl(layer_impl, id, new LayerImpl::SyncedScrollOffset) {
+}
+
+LayerImpl::LayerImpl(LayerTreeImpl* tree_impl,
+ int id,
+ scoped_refptr<SyncedScrollOffset> scroll_offset)
: parent_(nullptr),
scroll_parent_(nullptr),
clip_parent_(nullptr),
@@ -42,6 +48,7 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
replica_layer_id_(-1),
layer_id_(id),
layer_tree_impl_(tree_impl),
+ scroll_offset_(scroll_offset),
scroll_offset_delegate_(nullptr),
scroll_clip_layer_(nullptr),
should_scroll_on_main_thread_(false),
@@ -348,18 +355,10 @@ void LayerImpl::GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
*resource_id = 0;
}
-void LayerImpl::SetSentScrollDelta(const gfx::Vector2dF& sent_scroll_delta) {
- // Pending tree never has sent scroll deltas
- DCHECK(layer_tree_impl()->IsActiveTree());
-
- if (sent_scroll_delta_ == sent_scroll_delta)
- return;
-
- sent_scroll_delta_ = sent_scroll_delta;
-}
-
gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
- gfx::Vector2dF adjusted_scroll = scroll;
+ RefreshFromScrollDelegate();
+
+ gfx::ScrollOffset adjusted_scroll(scroll);
if (layer_tree_impl()->settings().use_pinch_virtual_viewport) {
if (!user_scrollable_horizontal_)
adjusted_scroll.set_x(0);
@@ -367,17 +366,14 @@ gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
adjusted_scroll.set_y(0);
}
DCHECK(scrollable());
- gfx::Vector2dF min_delta = -ScrollOffsetToVector2dF(scroll_offset_);
- gfx::Vector2dF max_delta = MaxScrollOffset().DeltaFrom(scroll_offset_);
- // Clamp new_delta so that position + delta stays within scroll bounds.
- gfx::Vector2dF new_delta = (ScrollDelta() + adjusted_scroll);
- new_delta.SetToMax(min_delta);
- new_delta.SetToMin(max_delta);
- gfx::Vector2dF unscrolled =
- ScrollDelta() + scroll - new_delta;
- SetScrollDelta(new_delta);
+ gfx::ScrollOffset old_offset = CurrentScrollOffset();
+ gfx::ScrollOffset new_offset =
+ ClampScrollOffsetToLimits(old_offset + adjusted_scroll);
+ SetCurrentScrollOffset(new_offset);
- return unscrolled;
+ gfx::ScrollOffset unscrolled =
+ old_offset + gfx::ScrollOffset(scroll) - new_offset;
+ return gfx::Vector2dF(unscrolled.x(), unscrolled.y());
}
void LayerImpl::SetScrollClipLayer(int scroll_clip_layer_id) {
@@ -390,41 +386,8 @@ bool LayerImpl::user_scrollable(ScrollbarOrientation orientation) const {
}
void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
- if (sent_scroll_delta_.IsZero())
- return;
-
- // Pending tree never has sent scroll deltas
DCHECK(layer_tree_impl()->IsActiveTree());
-
- // The combination of pending tree and aborted commits with impl scrolls
- // shouldn't happen; we don't know how to update its deltas correctly.
- DCHECK(!layer_tree_impl()->FindPendingTreeLayerById(id()));
-
- // Apply sent scroll deltas to scroll position / scroll delta as if the
- // main thread had applied them and then committed those values.
- SetScrollOffsetAndDelta(
- scroll_offset_ + gfx::ScrollOffset(sent_scroll_delta_),
- ScrollDelta() - sent_scroll_delta_);
- SetSentScrollDelta(gfx::Vector2dF());
-}
-
-void LayerImpl::ApplyScrollDeltasSinceBeginMainFrame() {
- // Only the pending tree can have missing scrolls.
- DCHECK(layer_tree_impl()->IsPendingTree());
- if (!scrollable())
- return;
-
- // Pending tree should never have sent scroll deltas.
- DCHECK(sent_scroll_delta().IsZero());
-
- LayerImpl* active_twin = layer_tree_impl()->FindActiveTreeLayerById(id());
- if (active_twin) {
- // Scrolls that happens after begin frame (where the sent scroll delta
- // comes from) and commit need to be applied to the pending tree
- // so that it is up to date with the total scroll.
- SetScrollDelta(active_twin->ScrollDelta() -
- active_twin->sent_scroll_delta());
- }
+ scroll_offset_->AbortCommit();
}
InputHandler::ScrollStatus LayerImpl::TryScroll(
@@ -503,7 +466,7 @@ skia::RefPtr<SkPicture> LayerImpl::GetPicture() {
}
scoped_ptr<LayerImpl> LayerImpl::CreateLayerImpl(LayerTreeImpl* tree_impl) {
- return LayerImpl::Create(tree_impl, layer_id_);
+ return LayerImpl::Create(tree_impl, layer_id_, scroll_offset_);
}
void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
@@ -543,17 +506,10 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
layer->set_user_scrollable_vertical(user_scrollable_vertical_);
- // Save the difference but clear the sent delta so that we don't subtract
- // it again in SetScrollOffsetAndDelta's pending twin mirroring logic.
- gfx::Vector2dF remaining_delta =
- layer_animation_controller_->scroll_offset_animation_was_interrupted()
- ? gfx::Vector2dF()
- : layer->ScrollDelta() - layer->sent_scroll_delta();
-
- layer->SetSentScrollDelta(gfx::Vector2dF());
- layer->SetScrollOffsetAndDelta(scroll_offset_, remaining_delta);
layer->SetScrollCompensationAdjustment(scroll_compensation_adjustment_);
+ layer->PushScrollOffset(nullptr);
+
layer->Set3dSortingContextId(sorting_context_id_);
layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
@@ -764,7 +720,7 @@ void LayerImpl::ResetAllChangeTrackingForSubtree() {
}
gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
- return TotalScrollOffset();
+ return CurrentScrollOffset();
}
void LayerImpl::OnFilterAnimated(const FilterOperations& filters) {
@@ -782,11 +738,11 @@ void LayerImpl::OnTransformAnimated(const gfx::Transform& transform) {
void LayerImpl::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {
// Only layers in the active tree should need to do anything here, since
// layers in the pending tree will find out about these changes as a
- // result of the call to SetScrollDelta.
+ // result of the shared SyncedProperty.
if (!IsActive())
return;
- SetScrollDelta(scroll_offset.DeltaFrom(scroll_offset_));
+ SetCurrentScrollOffset(scroll_offset);
layer_tree_impl_->DidAnimateScrollOffset();
}
@@ -1102,14 +1058,10 @@ void LayerImpl::SetScrollOffsetDelegate(
ScrollOffsetDelegate* scroll_offset_delegate) {
// Having both a scroll parent and a scroll offset delegate is unsupported.
DCHECK(!scroll_parent_);
- if (!scroll_offset_delegate && scroll_offset_delegate_) {
- scroll_delta_ = scroll_offset_delegate_->GetTotalScrollOffset().DeltaFrom(
- scroll_offset_);
- }
- gfx::ScrollOffset total_offset = TotalScrollOffset();
+ RefreshFromScrollDelegate();
scroll_offset_delegate_ = scroll_offset_delegate;
if (scroll_offset_delegate_)
- scroll_offset_delegate_->SetTotalScrollOffset(total_offset);
+ scroll_offset_delegate_->SetCurrentScrollOffset(CurrentScrollOffset());
}
bool LayerImpl::IsExternalFlingActive() const {
@@ -1117,74 +1069,89 @@ bool LayerImpl::IsExternalFlingActive() const {
scroll_offset_delegate_->IsExternalFlingActive();
}
-void LayerImpl::DidScroll() {
- NoteLayerPropertyChangedForSubtree();
- ScrollbarParametersDidChange(false);
+void LayerImpl::SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset) {
+ DCHECK(IsActive());
+ if (scroll_offset_->SetCurrent(scroll_offset))
+ DidUpdateScrollOffset();
}
-void LayerImpl::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
- SetScrollOffsetAndDelta(scroll_offset, ScrollDelta());
+void LayerImpl::PushScrollOffsetFromMainThread(
+ const gfx::ScrollOffset& scroll_offset) {
+ PushScrollOffset(&scroll_offset);
}
-void LayerImpl::SetScrollOffsetAndDelta(const gfx::ScrollOffset& scroll_offset,
- const gfx::Vector2dF& scroll_delta) {
- bool changed = false;
-
- last_scroll_offset_ = scroll_offset;
+gfx::ScrollOffset LayerImpl::PullDeltaForMainThread() {
+ RefreshFromScrollDelegate();
- if (scroll_offset_ != scroll_offset) {
- changed = true;
- scroll_offset_ = scroll_offset;
+ // TODO(aelias): Remove all this temporary flooring machinery when Blink
+ // fully supports fractional scrolls.
+ gfx::ScrollOffset current = CurrentScrollOffset();
+ gfx::ScrollOffset floored(floor(current.x()), floor(current.y()));
+ scroll_offset_->SetCurrent(floored);
+ gfx::ScrollOffset delta = scroll_offset_->PullDeltaForMainThread();
+ scroll_offset_->SetCurrent(current);
+ return delta;
+}
- if (scroll_offset_delegate_)
- scroll_offset_delegate_->SetTotalScrollOffset(TotalScrollOffset());
+void LayerImpl::RefreshFromScrollDelegate() {
+ if (scroll_offset_delegate_) {
+ SetCurrentScrollOffset(
+ gfx::ScrollOffset(scroll_offset_delegate_->GetCurrentScrollOffset()));
}
+}
- if (ScrollDelta() != scroll_delta) {
- changed = true;
- if (layer_tree_impl()->IsActiveTree()) {
- LayerImpl* pending_twin =
- layer_tree_impl()->FindPendingTreeLayerById(id());
- if (pending_twin) {
- // The pending twin can't mirror the scroll delta of the active
- // layer. Although the delta - sent scroll delta difference is
- // identical for both twins, the sent scroll delta for the pending
- // layer is zero, as anything that has been sent has been baked
- // into the layer's position/scroll offset as a part of commit.
- DCHECK(pending_twin->sent_scroll_delta().IsZero());
- pending_twin->SetScrollDelta(scroll_delta - sent_scroll_delta());
- }
- }
+gfx::ScrollOffset LayerImpl::CurrentScrollOffset() const {
+ return scroll_offset_->Current(IsActive());
+}
- if (scroll_offset_delegate_) {
- scroll_offset_delegate_->SetTotalScrollOffset(
- ScrollOffsetWithDelta(scroll_offset_, scroll_delta));
- } else {
- scroll_delta_ = scroll_delta;
- }
- }
+gfx::Vector2dF LayerImpl::ScrollDelta() const {
+ if (IsActive())
+ return gfx::Vector2dF(scroll_offset_->Delta().x(),
+ scroll_offset_->Delta().y());
+ else
+ return gfx::Vector2dF(scroll_offset_->PendingDelta().get().x(),
+ scroll_offset_->PendingDelta().get().y());
+}
- if (changed) {
- if (scroll_offset_delegate_)
- scroll_offset_delegate_->Update();
- DidScroll();
- }
+void LayerImpl::SetScrollDelta(const gfx::Vector2dF& delta) {
+ DCHECK(IsActive());
+ SetCurrentScrollOffset(scroll_offset_->ActiveBase() +
+ gfx::ScrollOffset(delta));
}
-gfx::Vector2dF LayerImpl::ScrollDelta() const {
- if (scroll_offset_delegate_) {
- return scroll_offset_delegate_->GetTotalScrollOffset().DeltaFrom(
- scroll_offset_);
- }
- return scroll_delta_;
+gfx::ScrollOffset LayerImpl::BaseScrollOffset() const {
+ if (IsActive())
+ return scroll_offset_->ActiveBase();
+ else
+ return scroll_offset_->PendingBase();
}
-void LayerImpl::SetScrollDelta(const gfx::Vector2dF& scroll_delta) {
- SetScrollOffsetAndDelta(scroll_offset_, scroll_delta);
+void LayerImpl::PushScrollOffset(const gfx::ScrollOffset* scroll_offset) {
+ DCHECK(scroll_offset || IsActive());
+ bool changed = false;
+ if (scroll_offset) {
+ DCHECK(!IsActive() || !layer_tree_impl_->FindPendingTreeLayerById(id()));
+ changed |= scroll_offset_->PushFromMainThread(*scroll_offset);
+ }
+ if (IsActive()) {
+ changed |= scroll_offset_->PushPendingToActive();
+ if (layer_animation_controller_->scroll_offset_animation_was_interrupted())
+ SetScrollDelta(gfx::Vector2dF());
+ }
+
+ if (changed)
+ DidUpdateScrollOffset();
}
-gfx::ScrollOffset LayerImpl::TotalScrollOffset() const {
- return ScrollOffsetWithDelta(scroll_offset_, ScrollDelta());
+void LayerImpl::DidUpdateScrollOffset() {
+ if (scroll_offset_delegate_) {
+ scroll_offset_delegate_->SetCurrentScrollOffset(CurrentScrollOffset());
+ scroll_offset_delegate_->Update();
+ RefreshFromScrollDelegate();
+ }
+
+ NoteLayerPropertyChangedForSubtree();
+ ScrollbarParametersDidChange(false);
}
void LayerImpl::SetDoubleSided(bool double_sided) {
@@ -1214,39 +1181,16 @@ gfx::ScrollOffset LayerImpl::MaxScrollOffset() const {
DCHECK(this != layer_tree_impl()->InnerViewportScrollLayer() ||
IsContainerForFixedPositionLayers());
- gfx::SizeF scaled_scroll_bounds(BoundsForScrolling());
-
float scale_factor = 1.f;
for (LayerImpl const* current_layer = this;
- current_layer != scroll_clip_layer_;
+ current_layer != scroll_clip_layer_->parent();
current_layer = current_layer->parent()) {
- DCHECK(current_layer);
- float current_layer_scale = 1.f;
-
- const gfx::Transform& layer_transform = current_layer->transform();
- if (current_layer == page_scale_layer) {
- DCHECK(layer_transform.IsIdentity());
- current_layer_scale = layer_tree_impl()->current_page_scale_factor();
- } else {
- // TODO(wjmaclean) Should we allow for translation too?
- DCHECK(layer_transform.IsScale2d());
- gfx::Vector2dF layer_scale = layer_transform.Scale2d();
- // TODO(wjmaclean) Allow for non-isotropic scales.
- DCHECK(layer_scale.x() == layer_scale.y());
- current_layer_scale = layer_scale.x();
- }
-
- scale_factor *= current_layer_scale;
+ if (current_layer == page_scale_layer)
+ scale_factor = layer_tree_impl()->current_page_scale_factor();
}
- // TODO(wjmaclean) Once we move to a model where the two-viewport model is
- // turned on in all builds, remove the next two lines. For now however, the
- // page scale layer may coincide with the clip layer, and so this is
- // necessary.
- if (page_scale_layer == scroll_clip_layer_)
- scale_factor *= layer_tree_impl()->current_page_scale_factor();
-
- scaled_scroll_bounds.SetSize(scale_factor * scaled_scroll_bounds.width(),
- scale_factor * scaled_scroll_bounds.height());
+
+ gfx::SizeF scaled_scroll_bounds =
+ gfx::ToFlooredSize(gfx::ScaleSize(BoundsForScrolling(), scale_factor));
scaled_scroll_bounds = gfx::ToFlooredSize(scaled_scroll_bounds);
gfx::ScrollOffset max_offset(
@@ -1258,17 +1202,19 @@ gfx::ScrollOffset LayerImpl::MaxScrollOffset() const {
return max_offset;
}
-gfx::Vector2dF LayerImpl::ClampScrollToMaxScrollOffset() {
- gfx::ScrollOffset max_offset = MaxScrollOffset();
- gfx::ScrollOffset old_offset = TotalScrollOffset();
- gfx::ScrollOffset clamped_offset = old_offset;
+gfx::ScrollOffset LayerImpl::ClampScrollOffsetToLimits(
+ gfx::ScrollOffset offset) const {
+ offset.SetToMin(MaxScrollOffset());
+ offset.SetToMax(gfx::ScrollOffset());
+ return offset;
+}
- clamped_offset.SetToMin(max_offset);
- clamped_offset.SetToMax(gfx::ScrollOffset());
+gfx::Vector2dF LayerImpl::ClampScrollToMaxScrollOffset() {
+ gfx::ScrollOffset old_offset = CurrentScrollOffset();
+ gfx::ScrollOffset clamped_offset = ClampScrollOffsetToLimits(old_offset);
gfx::Vector2dF delta = clamped_offset.DeltaFrom(old_offset);
if (!delta.IsZero())
ScrollBy(delta);
-
return delta;
}
@@ -1290,37 +1236,17 @@ void LayerImpl::SetScrollbarPosition(ScrollbarLayerImplBase* scrollbar_layer,
if (scroll_rect.size().IsEmpty())
return;
- // TODO(wjmaclean) This computation is nearly identical to the one in
- // MaxScrollOffset. Find some way to combine these.
gfx::ScrollOffset current_offset;
for (LayerImpl const* current_layer = this;
- current_layer != scrollbar_clip_layer;
+ current_layer != scrollbar_clip_layer->parent();
current_layer = current_layer->parent()) {
- DCHECK(current_layer);
- const gfx::Transform& layer_transform = current_layer->transform();
+ current_offset += current_layer->CurrentScrollOffset();
if (current_layer == page_scale_layer) {
- DCHECK(layer_transform.IsIdentity());
float scale_factor = layer_tree_impl()->current_page_scale_factor();
current_offset.Scale(scale_factor);
scroll_rect.Scale(scale_factor);
- } else {
- DCHECK(layer_transform.IsScale2d());
- gfx::Vector2dF layer_scale = layer_transform.Scale2d();
- DCHECK(layer_scale.x() == layer_scale.y());
- gfx::ScrollOffset new_offset = ScrollOffsetWithDelta(
- current_layer->scroll_offset(), current_layer->ScrollDelta());
- new_offset.Scale(layer_scale.x(), layer_scale.y());
- current_offset += new_offset;
}
}
- // TODO(wjmaclean) Once we move to a model where the two-viewport model is
- // turned on in all builds, remove the next two lines. For now however, the
- // page scale layer may coincide with the clip layer, and so this is
- // necessary.
- if (page_scale_layer == scrollbar_clip_layer) {
- scroll_rect.Scale(layer_tree_impl()->current_page_scale_factor());
- current_offset.Scale(layer_tree_impl()->current_page_scale_factor());
- }
bool scrollbar_needs_animation = false;
scrollbar_needs_animation |= scrollbar_layer->SetVerticalAdjust(
@@ -1472,7 +1398,11 @@ void LayerImpl::AsValueInto(base::debug::TracedValue* state) const {
state->SetInteger("draws_content", DrawsContent());
state->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
- MathUtil::AddToTracedValue("scroll_offset", scroll_offset_, state);
+ MathUtil::AddToTracedValue(
+ "scroll_offset", scroll_offset_ ? scroll_offset_->Current(IsActive())
+ : gfx::ScrollOffset(),
+ state);
+
MathUtil::AddToTracedValue("transform_origin", transform_origin_, state);
bool clipped;
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 883f824..1545bb9 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -19,6 +19,7 @@
#include "cc/base/cc_export.h"
#include "cc/base/region.h"
#include "cc/base/scoped_ptr_vector.h"
+#include "cc/base/synced_property.h"
#include "cc/debug/frame_timing_request.h"
#include "cc/input/input_handler.h"
#include "cc/input/scrollbar.h"
@@ -81,18 +82,26 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
// of the layer.
class ScrollOffsetDelegate {
public:
- virtual void SetTotalScrollOffset(const gfx::ScrollOffset& new_value) = 0;
- virtual gfx::ScrollOffset GetTotalScrollOffset() = 0;
+ virtual void SetCurrentScrollOffset(const gfx::ScrollOffset& new_value) = 0;
+ virtual gfx::ScrollOffset GetCurrentScrollOffset() = 0;
virtual bool IsExternalFlingActive() const = 0;
virtual void Update() const = 0;
};
+ typedef SyncedProperty<AdditionGroup<gfx::ScrollOffset>> SyncedScrollOffset;
typedef LayerImplList RenderSurfaceListType;
typedef LayerImplList LayerListType;
typedef RenderSurfaceImpl RenderSurfaceType;
enum RenderingContextConstants { NO_RENDERING_CONTEXT = 0 };
+ static scoped_ptr<LayerImpl> Create(
+ LayerTreeImpl* tree_impl,
+ int id,
+ scoped_refptr<SyncedScrollOffset> scroll_offset) {
+ return make_scoped_ptr(new LayerImpl(tree_impl, id, scroll_offset));
+ }
+
static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
return make_scoped_ptr(new LayerImpl(tree_impl, id));
}
@@ -385,22 +394,23 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
void SetContentsScale(float contents_scale_x, float contents_scale_y);
void SetScrollOffsetDelegate(ScrollOffsetDelegate* scroll_offset_delegate);
- void DidScroll();
+ void RefreshFromScrollDelegate();
bool IsExternalFlingActive() const;
- void SetScrollOffset(const gfx::ScrollOffset& scroll_offset);
- void SetScrollOffsetAndDelta(const gfx::ScrollOffset& scroll_offset,
- const gfx::Vector2dF& scroll_delta);
- gfx::ScrollOffset scroll_offset() const { return scroll_offset_; }
+ void SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset);
+ void PushScrollOffsetFromMainThread(const gfx::ScrollOffset& scroll_offset);
+ gfx::ScrollOffset PullDeltaForMainThread();
+ gfx::ScrollOffset CurrentScrollOffset() const;
+ gfx::ScrollOffset BaseScrollOffset() const;
+ gfx::Vector2dF ScrollDelta() const;
+ void SetScrollDelta(const gfx::Vector2dF& delta);
gfx::ScrollOffset MaxScrollOffset() const;
+ gfx::ScrollOffset ClampScrollOffsetToLimits(gfx::ScrollOffset offset) const;
gfx::Vector2dF ClampScrollToMaxScrollOffset();
void SetScrollbarPosition(ScrollbarLayerImplBase* scrollbar_layer,
LayerImpl* scrollbar_clip_layer,
bool on_resize) const;
- void SetScrollDelta(const gfx::Vector2dF& scroll_delta);
- gfx::Vector2dF ScrollDelta() const;
-
void SetScrollCompensationAdjustment(const gfx::Vector2dF& scroll_offset) {
scroll_compensation_adjustment_ = scroll_offset;
}
@@ -408,15 +418,18 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
return scroll_compensation_adjustment_;
}
- gfx::ScrollOffset TotalScrollOffset() const;
-
- void SetSentScrollDelta(const gfx::Vector2dF& sent_scroll_delta);
- gfx::Vector2dF sent_scroll_delta() const { return sent_scroll_delta_; }
-
// Returns the delta of the scroll that was outside of the bounds of the
// initial scroll
gfx::Vector2dF ScrollBy(const gfx::Vector2dF& scroll);
+ // TODO(aelias): Delete these three methods after doing a mass rename in
+ // tests.
+ gfx::ScrollOffset TotalScrollOffset() const { return CurrentScrollOffset(); }
+ void SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
+ PushScrollOffsetFromMainThread(scroll_offset);
+ }
+ gfx::ScrollOffset scroll_offset() const { return BaseScrollOffset(); }
+
void SetScrollClipLayer(int scroll_clip_layer_id);
LayerImpl* scroll_clip_layer() const { return scroll_clip_layer_; }
bool scrollable() const { return !!scroll_clip_layer_; }
@@ -435,7 +448,6 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
bool user_scrollable(ScrollbarOrientation orientation) const;
void ApplySentScrollDeltasFromAbortedCommit();
- void ApplyScrollDeltasSinceBeginMainFrame();
void SetShouldScrollOnMainThread(bool should_scroll_on_main_thread) {
should_scroll_on_main_thread_ = should_scroll_on_main_thread;
@@ -581,7 +593,12 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
return frame_timing_requests_;
}
+ SyncedScrollOffset* synced_scroll_offset() { return scroll_offset_.get(); }
+
protected:
+ LayerImpl(LayerTreeImpl* layer_impl,
+ int id,
+ scoped_refptr<SyncedScrollOffset> scroll_offset);
LayerImpl(LayerTreeImpl* layer_impl, int id);
// Get the color and size of the layer's debug border.
@@ -605,6 +622,8 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
void NoteLayerPropertyChangedForDescendants();
private:
+ void PushScrollOffset(const gfx::ScrollOffset* scroll_offset);
+ void DidUpdateScrollOffset();
void NoteLayerPropertyChangedForDescendantsInternal();
virtual const char* LayerTypeAsString() const;
@@ -633,11 +652,13 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
int layer_id_;
LayerTreeImpl* layer_tree_impl_;
+ // Properties dynamically changeable on active tree.
+ scoped_refptr<SyncedScrollOffset> scroll_offset_;
+ gfx::Vector2dF bounds_delta_;
+
// Properties synchronized from the associated Layer.
gfx::Point3F transform_origin_;
gfx::Size bounds_;
- gfx::Vector2dF bounds_delta_;
- gfx::ScrollOffset scroll_offset_;
ScrollOffsetDelegate* scroll_offset_delegate_;
LayerImpl* scroll_clip_layer_;
bool scrollable_ : 1;
@@ -678,10 +699,6 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
LayerPositionConstraint position_constraint_;
- gfx::Vector2dF scroll_delta_;
- gfx::Vector2dF sent_scroll_delta_;
- gfx::ScrollOffset last_scroll_offset_;
-
gfx::Vector2dF scroll_compensation_adjustment_;
int num_descendants_that_draw_content_;
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index 7b16710..c0b2aa7 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -511,14 +511,14 @@ TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) {
class ScrollDelegateIgnore : public LayerImpl::ScrollOffsetDelegate {
public:
- void SetTotalScrollOffset(const gfx::ScrollOffset& new_value) override {
+ void SetCurrentScrollOffset(const gfx::ScrollOffset& new_value) override {
last_attempted_set_offset_ = new_value;
}
gfx::ScrollOffset last_attempted_set_offset() const {
return last_attempted_set_offset_;
}
- gfx::ScrollOffset GetTotalScrollOffset() override {
+ gfx::ScrollOffset GetCurrentScrollOffset() override {
return gfx::ScrollOffset(fixed_offset_);
}
bool IsExternalFlingActive() const override { return false; }
@@ -545,6 +545,7 @@ TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) {
gfx::Vector2dF fixed_offset(32, 12);
delegate.set_fixed_offset(fixed_offset);
layer()->SetScrollOffsetDelegate(&delegate);
+ layer()->RefreshFromScrollDelegate();
EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
@@ -568,10 +569,12 @@ TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) {
class ScrollDelegateAccept : public LayerImpl::ScrollOffsetDelegate {
public:
- void SetTotalScrollOffset(const gfx::ScrollOffset& new_value) override {
+ void SetCurrentScrollOffset(const gfx::ScrollOffset& new_value) override {
current_offset_ = new_value;
}
- gfx::ScrollOffset GetTotalScrollOffset() override { return current_offset_; }
+ gfx::ScrollOffset GetCurrentScrollOffset() override {
+ return current_offset_;
+ }
bool IsExternalFlingActive() const override { return false; }
void Update() const override { }
@@ -616,15 +619,16 @@ TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) {
gfx::Vector2dF scroll_delta(20.5f, 8.5f);
gfx::Vector2d sent_scroll_delta(12, -3);
- layer()->SetScrollOffset(scroll_offset);
- layer()->ScrollBy(scroll_delta);
- layer()->SetSentScrollDelta(sent_scroll_delta);
+ layer()->PushScrollOffsetFromMainThread(scroll_offset);
+ layer()->ScrollBy(sent_scroll_delta);
+ layer()->PullDeltaForMainThread();
+ layer()->SetCurrentScrollOffset(scroll_offset +
+ gfx::ScrollOffset(scroll_delta));
EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
layer()->TotalScrollOffset());
EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta());
EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
- EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
layer()->ApplySentScrollDeltasFromAbortedCommit();
@@ -633,7 +637,6 @@ TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) {
EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta());
EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, sent_scroll_delta),
layer()->scroll_offset());
- EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
}
TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) {
@@ -641,15 +644,17 @@ TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) {
gfx::Vector2d sent_scroll_delta(12, -3);
gfx::Vector2dF fixed_offset(32, 12);
- layer()->SetScrollOffset(scroll_offset);
+ layer()->PushScrollOffsetFromMainThread(scroll_offset);
+ layer()->ScrollBy(sent_scroll_delta);
+ layer()->PullDeltaForMainThread();
+ layer()->SetCurrentScrollOffset(scroll_offset);
ScrollDelegateIgnore delegate;
delegate.set_fixed_offset(fixed_offset);
layer()->SetScrollOffsetDelegate(&delegate);
- layer()->SetSentScrollDelta(sent_scroll_delta);
+ layer()->RefreshFromScrollDelegate();
EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
- EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
layer()->ApplySentScrollDeltasFromAbortedCommit();
@@ -658,7 +663,6 @@ TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) {
EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, sent_scroll_delta),
layer()->scroll_offset());
- EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
}
TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) {
@@ -666,16 +670,17 @@ TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) {
gfx::Vector2d sent_scroll_delta(12, -3);
gfx::Vector2dF scroll_delta(20.5f, 8.5f);
- layer()->SetScrollOffset(scroll_offset);
+ layer()->PushScrollOffsetFromMainThread(scroll_offset);
+ layer()->ScrollBy(sent_scroll_delta);
+ layer()->PullDeltaForMainThread();
ScrollDelegateAccept delegate;
layer()->SetScrollOffsetDelegate(&delegate);
- layer()->ScrollBy(scroll_delta);
- layer()->SetSentScrollDelta(sent_scroll_delta);
+ layer()->SetCurrentScrollOffset(scroll_offset +
+ gfx::ScrollOffset(scroll_delta));
EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
layer()->TotalScrollOffset());
EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
- EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
layer()->ApplySentScrollDeltasFromAbortedCommit();
@@ -683,7 +688,6 @@ TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) {
layer()->TotalScrollOffset());
EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, sent_scroll_delta),
layer()->scroll_offset());
- EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
}
TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) {
@@ -710,10 +714,10 @@ TEST_F(LayerImplScrollTest, PushPropertiesToMirrorsTotalScrollOffset) {
EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), unscrolled);
EXPECT_VECTOR_EQ(gfx::Vector2dF(22, 23), layer()->TotalScrollOffset());
- layer()->SetSentScrollDelta(scroll_delta);
+ layer()->PullDeltaForMainThread();
- scoped_ptr<LayerImpl> pending_layer =
- LayerImpl::Create(host_impl().sync_tree(), layer()->id());
+ scoped_ptr<LayerImpl> pending_layer = LayerImpl::Create(
+ host_impl().sync_tree(), layer()->id(), layer()->synced_scroll_offset());
pending_layer->SetScrollOffset(layer()->TotalScrollOffset());
pending_layer->PushPropertiesTo(layer());
diff --git a/cc/layers/picture_image_layer_impl.cc b/cc/layers/picture_image_layer_impl.cc
index cf09654..03ef5ae 100644
--- a/cc/layers/picture_image_layer_impl.cc
+++ b/cc/layers/picture_image_layer_impl.cc
@@ -14,7 +14,10 @@ namespace cc {
PictureImageLayerImpl::PictureImageLayerImpl(LayerTreeImpl* tree_impl,
int id,
bool is_mask)
- : PictureLayerImpl(tree_impl, id, is_mask) {
+ : PictureLayerImpl(tree_impl,
+ id,
+ is_mask,
+ new LayerImpl::SyncedScrollOffset) {
}
PictureImageLayerImpl::~PictureImageLayerImpl() {
diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index a55318e..0b7d699 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -38,7 +38,8 @@ PictureLayer::~PictureLayer() {
}
scoped_ptr<LayerImpl> PictureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
- return PictureLayerImpl::Create(tree_impl, id(), is_mask_);
+ return PictureLayerImpl::Create(tree_impl, id(), is_mask_,
+ new LayerImpl::SyncedScrollOffset);
}
void PictureLayer::PushPropertiesTo(LayerImpl* base_layer) {
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 36c63c4..15059ba 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -65,10 +65,12 @@ PictureLayerImpl::Pair::Pair(PictureLayerImpl* active_layer,
PictureLayerImpl::Pair::~Pair() {
}
-PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl,
- int id,
- bool is_mask)
- : LayerImpl(tree_impl, id),
+PictureLayerImpl::PictureLayerImpl(
+ LayerTreeImpl* tree_impl,
+ int id,
+ bool is_mask,
+ scoped_refptr<SyncedScrollOffset> scroll_offset)
+ : LayerImpl(tree_impl, id, scroll_offset),
twin_layer_(nullptr),
tilings_(CreatePictureLayerTilingSet()),
ideal_page_scale_(0.f),
@@ -100,7 +102,8 @@ const char* PictureLayerImpl::LayerTypeAsString() const {
scoped_ptr<LayerImpl> PictureLayerImpl::CreateLayerImpl(
LayerTreeImpl* tree_impl) {
- return PictureLayerImpl::Create(tree_impl, id(), is_mask_);
+ return PictureLayerImpl::Create(tree_impl, id(), is_mask_,
+ synced_scroll_offset());
}
void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index 4b4816a..fa40683 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -38,10 +38,13 @@ class CC_EXPORT PictureLayerImpl
PictureLayerImpl* pending;
};
- static scoped_ptr<PictureLayerImpl> Create(LayerTreeImpl* tree_impl,
- int id,
- bool is_mask) {
- return make_scoped_ptr(new PictureLayerImpl(tree_impl, id, is_mask));
+ static scoped_ptr<PictureLayerImpl> Create(
+ LayerTreeImpl* tree_impl,
+ int id,
+ bool is_mask,
+ scoped_refptr<SyncedScrollOffset> scroll_offset) {
+ return make_scoped_ptr(
+ new PictureLayerImpl(tree_impl, id, is_mask, scroll_offset));
}
~PictureLayerImpl() override;
@@ -105,7 +108,10 @@ class CC_EXPORT PictureLayerImpl
friend class LayerRasterTileIterator;
using TileRequirementCheck = bool (PictureLayerTiling::*)(const Tile*) const;
- PictureLayerImpl(LayerTreeImpl* tree_impl, int id, bool is_mask);
+ PictureLayerImpl(LayerTreeImpl* tree_impl,
+ int id,
+ bool is_mask,
+ scoped_refptr<SyncedScrollOffset> scroll_offset);
PictureLayerTiling* AddTiling(float contents_scale);
void RemoveAllTilings();
void AddTilingsForRasterScale();
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index 31a8f39..535744d 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -48,7 +48,15 @@ class DrawableTile : public LayerTilingData::Tile {
};
TiledLayerImpl::TiledLayerImpl(LayerTreeImpl* tree_impl, int id)
- : LayerImpl(tree_impl, id), skips_draw_(true) {}
+ : TiledLayerImpl(tree_impl, id, new LayerImpl::SyncedScrollOffset) {
+}
+
+TiledLayerImpl::TiledLayerImpl(
+ LayerTreeImpl* tree_impl,
+ int id,
+ scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset)
+ : LayerImpl(tree_impl, id, synced_scroll_offset), skips_draw_(true) {
+}
TiledLayerImpl::~TiledLayerImpl() {
}
@@ -102,7 +110,7 @@ void TiledLayerImpl::GetDebugBorderProperties(SkColor* color,
scoped_ptr<LayerImpl> TiledLayerImpl::CreateLayerImpl(
LayerTreeImpl* tree_impl) {
- return TiledLayerImpl::Create(tree_impl, id());
+ return TiledLayerImpl::Create(tree_impl, id(), synced_scroll_offset());
}
void TiledLayerImpl::AsValueInto(base::debug::TracedValue* state) const {
diff --git a/cc/layers/tiled_layer_impl.h b/cc/layers/tiled_layer_impl.h
index e3ace34..039bf19 100644
--- a/cc/layers/tiled_layer_impl.h
+++ b/cc/layers/tiled_layer_impl.h
@@ -18,7 +18,15 @@ class DrawableTile;
class CC_EXPORT TiledLayerImpl : public LayerImpl {
public:
static scoped_ptr<TiledLayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
- return make_scoped_ptr(new TiledLayerImpl(tree_impl, id));
+ return make_scoped_ptr(
+ new TiledLayerImpl(tree_impl, id, new LayerImpl::SyncedScrollOffset));
+ }
+ static scoped_ptr<TiledLayerImpl> Create(
+ LayerTreeImpl* tree_impl,
+ int id,
+ scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset) {
+ return make_scoped_ptr(
+ new TiledLayerImpl(tree_impl, id, synced_scroll_offset));
}
~TiledLayerImpl() override;
@@ -51,6 +59,10 @@ class CC_EXPORT TiledLayerImpl : public LayerImpl {
protected:
TiledLayerImpl(LayerTreeImpl* tree_impl, int id);
+ TiledLayerImpl(
+ LayerTreeImpl* tree_impl,
+ int id,
+ scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset);
// Exposed for testing.
bool HasTileAt(int i, int j) const;
bool HasResourceIdForTileAt(int i, int j) const;
diff --git a/cc/test/fake_content_layer_impl.cc b/cc/test/fake_content_layer_impl.cc
index eb35bb6..54c62d0 100644
--- a/cc/test/fake_content_layer_impl.cc
+++ b/cc/test/fake_content_layer_impl.cc
@@ -6,15 +6,19 @@
namespace cc {
-FakeContentLayerImpl::FakeContentLayerImpl(LayerTreeImpl* tree_impl, int id)
- : TiledLayerImpl(tree_impl, id), lost_output_surface_count_(0) {
+FakeContentLayerImpl::FakeContentLayerImpl(
+ LayerTreeImpl* tree_impl,
+ int id,
+ scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset)
+ : TiledLayerImpl(tree_impl, id, synced_scroll_offset),
+ lost_output_surface_count_(0) {
}
FakeContentLayerImpl::~FakeContentLayerImpl() {}
scoped_ptr<LayerImpl> FakeContentLayerImpl::CreateLayerImpl(
LayerTreeImpl* tree_impl) {
- return FakeContentLayerImpl::Create(tree_impl, id());
+ return FakeContentLayerImpl::Create(tree_impl, id(), synced_scroll_offset());
}
bool FakeContentLayerImpl::HaveResourceForTileAt(int i, int j) {
diff --git a/cc/test/fake_content_layer_impl.h b/cc/test/fake_content_layer_impl.h
index 8a6c90b..d199fad 100644
--- a/cc/test/fake_content_layer_impl.h
+++ b/cc/test/fake_content_layer_impl.h
@@ -14,7 +14,15 @@ class FakeContentLayerImpl : public TiledLayerImpl {
public:
static scoped_ptr<FakeContentLayerImpl> Create(
LayerTreeImpl* tree_impl, int id) {
- return make_scoped_ptr(new FakeContentLayerImpl(tree_impl, id));
+ return make_scoped_ptr(new FakeContentLayerImpl(
+ tree_impl, id, new LayerImpl::SyncedScrollOffset));
+ }
+ static scoped_ptr<FakeContentLayerImpl> Create(
+ LayerTreeImpl* tree_impl,
+ int id,
+ scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset) {
+ return make_scoped_ptr(
+ new FakeContentLayerImpl(tree_impl, id, synced_scroll_offset));
}
~FakeContentLayerImpl() override;
@@ -30,7 +38,10 @@ class FakeContentLayerImpl : public TiledLayerImpl {
void ReleaseResources() override;
private:
- explicit FakeContentLayerImpl(LayerTreeImpl* tree_impl, int id);
+ explicit FakeContentLayerImpl(
+ LayerTreeImpl* tree_impl,
+ int id,
+ scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset);
size_t lost_output_surface_count_;
};
diff --git a/cc/test/fake_picture_layer_impl.cc b/cc/test/fake_picture_layer_impl.cc
index 132160f..43db7bc 100644
--- a/cc/test/fake_picture_layer_impl.cc
+++ b/cc/test/fake_picture_layer_impl.cc
@@ -15,7 +15,10 @@ FakePictureLayerImpl::FakePictureLayerImpl(
int id,
scoped_refptr<RasterSource> raster_source,
bool is_mask)
- : PictureLayerImpl(tree_impl, id, is_mask),
+ : PictureLayerImpl(tree_impl,
+ id,
+ is_mask,
+ new LayerImpl::SyncedScrollOffset),
append_quads_count_(0),
did_become_active_call_count_(0),
has_valid_tile_priorities_(false),
@@ -32,7 +35,10 @@ FakePictureLayerImpl::FakePictureLayerImpl(
scoped_refptr<RasterSource> raster_source,
bool is_mask,
const gfx::Size& layer_bounds)
- : PictureLayerImpl(tree_impl, id, is_mask),
+ : PictureLayerImpl(tree_impl,
+ id,
+ is_mask,
+ new LayerImpl::SyncedScrollOffset),
append_quads_count_(0),
did_become_active_call_count_(0),
has_valid_tile_priorities_(false),
@@ -46,7 +52,18 @@ FakePictureLayerImpl::FakePictureLayerImpl(
FakePictureLayerImpl::FakePictureLayerImpl(LayerTreeImpl* tree_impl,
int id,
bool is_mask)
- : PictureLayerImpl(tree_impl, id, is_mask),
+ : FakePictureLayerImpl(tree_impl,
+ id,
+ is_mask,
+ new LayerImpl::SyncedScrollOffset) {
+}
+
+FakePictureLayerImpl::FakePictureLayerImpl(
+ LayerTreeImpl* tree_impl,
+ int id,
+ bool is_mask,
+ scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset)
+ : PictureLayerImpl(tree_impl, id, is_mask, synced_scroll_offset),
append_quads_count_(0),
did_become_active_call_count_(0),
has_valid_tile_priorities_(false),
@@ -56,7 +73,8 @@ FakePictureLayerImpl::FakePictureLayerImpl(LayerTreeImpl* tree_impl,
scoped_ptr<LayerImpl> FakePictureLayerImpl::CreateLayerImpl(
LayerTreeImpl* tree_impl) {
- return make_scoped_ptr(new FakePictureLayerImpl(tree_impl, id(), is_mask_));
+ return make_scoped_ptr(new FakePictureLayerImpl(tree_impl, id(), is_mask_,
+ synced_scroll_offset()));
}
void FakePictureLayerImpl::PushPropertiesTo(LayerImpl* layer_impl) {
diff --git a/cc/test/fake_picture_layer_impl.h b/cc/test/fake_picture_layer_impl.h
index b34cd3e..caac373 100644
--- a/cc/test/fake_picture_layer_impl.h
+++ b/cc/test/fake_picture_layer_impl.h
@@ -149,6 +149,11 @@ class FakePictureLayerImpl : public PictureLayerImpl {
bool is_mask,
const gfx::Size& layer_bounds);
FakePictureLayerImpl(LayerTreeImpl* tree_impl, int id, bool is_mask);
+ FakePictureLayerImpl(
+ LayerTreeImpl* tree_impl,
+ int id,
+ bool is_mask,
+ scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset);
private:
gfx::Size fixed_tile_size_;
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 3edce30..f21ed3f 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -66,8 +66,8 @@ static gfx::Vector2dF GetEffectiveScrollDelta(LayerType* layer) {
}
template <typename LayerType>
-static gfx::ScrollOffset GetEffectiveTotalScrollOffset(LayerType* layer) {
- gfx::ScrollOffset offset = layer->TotalScrollOffset();
+static gfx::ScrollOffset GetEffectiveCurrentScrollOffset(LayerType* layer) {
+ gfx::ScrollOffset offset = layer->CurrentScrollOffset();
// The scroll parent's total scroll offset (scroll offset + scroll delta)
// can't be used because its scroll offset has already been applied to the
// scroll children's positions by the main thread layer positioning code.
@@ -1675,7 +1675,7 @@ static void CalculateDrawPropertiesInternal(
layer->parent()->screen_space_transform_is_animating();
}
gfx::Point3F transform_origin = layer->transform_origin();
- gfx::ScrollOffset scroll_offset = GetEffectiveTotalScrollOffset(layer);
+ gfx::ScrollOffset scroll_offset = GetEffectiveCurrentScrollOffset(layer);
gfx::PointF position =
layer->position() - ScrollOffsetToVector2dF(scroll_offset);
gfx::Transform combined_transform = data_from_ancestor.parent_matrix;
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index daf7d5b..74b5011 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -7819,7 +7819,8 @@ TEST_F(LayerTreeHostCommonTest,
SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
gfx::PointF(3.0f, 4.0f), gfx::Size(50, 50), true,
false, false);
- scroll_layer->SetScrollOffsetAndDelta(scroll_offset, scroll_delta);
+ scroll_layer->SetScrollOffset(scroll_offset);
+ scroll_layer->SetScrollDelta(scroll_delta);
scroll_layer->SetScrollCompensationAdjustment(main_scroll_fractional_part);
scroller->AddChild(fixed.Pass());
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 04d0c94..d89bad3 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -88,10 +88,10 @@ class ViewportAnchor {
ViewportAnchor(LayerImpl* inner_scroll, LayerImpl* outer_scroll)
: inner_(inner_scroll),
outer_(outer_scroll) {
- viewport_in_content_coordinates_ = inner_->TotalScrollOffset();
+ viewport_in_content_coordinates_ = inner_->CurrentScrollOffset();
if (outer_)
- viewport_in_content_coordinates_ += outer_->TotalScrollOffset();
+ viewport_in_content_coordinates_ += outer_->CurrentScrollOffset();
}
void ResetViewportToAnchoredPosition() {
@@ -100,8 +100,8 @@ class ViewportAnchor {
inner_->ClampScrollToMaxScrollOffset();
outer_->ClampScrollToMaxScrollOffset();
- gfx::ScrollOffset viewport_location = inner_->TotalScrollOffset() +
- outer_->TotalScrollOffset();
+ gfx::ScrollOffset viewport_location =
+ inner_->CurrentScrollOffset() + outer_->CurrentScrollOffset();
gfx::Vector2dF delta =
viewport_in_content_coordinates_.DeltaFrom(viewport_location);
@@ -305,8 +305,6 @@ void LayerTreeHostImpl::BeginCommit() {
void LayerTreeHostImpl::CommitComplete() {
TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
- if (pending_tree_)
- pending_tree_->ApplyScrollDeltasSinceBeginMainFrame();
sync_tree()->set_needs_update_draw_properties();
if (settings_.impl_side_painting) {
@@ -2406,7 +2404,7 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
if (!layer_impl->scrollable())
continue;
- gfx::ScrollOffset current_offset = layer_impl->TotalScrollOffset();
+ gfx::ScrollOffset current_offset = layer_impl->CurrentScrollOffset();
gfx::ScrollOffset target_offset =
ScrollOffsetWithDelta(current_offset, pending_delta);
target_offset.SetToMax(gfx::ScrollOffset());
@@ -2496,14 +2494,15 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
local_end_point.Scale(width_scale, height_scale);
// Apply the scroll delta.
- gfx::Vector2dF previous_delta = layer_impl->ScrollDelta();
+ gfx::ScrollOffset previous_offset = layer_impl->CurrentScrollOffset();
layer_impl->ScrollBy(local_end_point - local_start_point);
+ gfx::ScrollOffset scrolled =
+ layer_impl->CurrentScrollOffset() - previous_offset;
// 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->ScrollDelta() -
- previous_delta;
+ gfx::PointF actual_local_end_point =
+ local_start_point + gfx::Vector2dF(scrolled.x(), scrolled.y());
gfx::PointF actual_local_content_end_point =
gfx::ScalePoint(actual_local_end_point,
1.f / width_scale,
@@ -2527,11 +2526,13 @@ static gfx::Vector2dF ScrollLayerWithLocalDelta(
LayerImpl* layer_impl,
const gfx::Vector2dF& local_delta,
float page_scale_factor) {
- gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
+ gfx::ScrollOffset previous_offset = layer_impl->CurrentScrollOffset();
gfx::Vector2dF delta = local_delta;
delta.Scale(1.f / page_scale_factor);
layer_impl->ScrollBy(delta);
- return layer_impl->ScrollDelta() - previous_delta;
+ gfx::ScrollOffset scrolled =
+ layer_impl->CurrentScrollOffset() - previous_offset;
+ return gfx::Vector2dF(scrolled.x(), scrolled.y());
}
bool LayerTreeHostImpl::ShouldTopControlsConsumeScroll(
@@ -2981,14 +2982,13 @@ static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
if (!layer_impl)
return;
- gfx::Vector2d scroll_delta =
- gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
+ gfx::ScrollOffset scroll_delta = layer_impl->PullDeltaForMainThread();
+
if (!scroll_delta.IsZero()) {
LayerTreeHostCommon::ScrollUpdateInfo scroll;
scroll.layer_id = layer_impl->id();
- scroll.scroll_delta = scroll_delta;
+ scroll.scroll_delta = gfx::Vector2d(scroll_delta.x(), scroll_delta.y());
scroll_info->scrolls.push_back(scroll);
- layer_impl->SetSentScrollDelta(scroll_delta);
}
for (size_t i = 0; i < layer_impl->children().size(); ++i)
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 6ac2f8c..cc608fa 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -483,19 +483,17 @@ TEST_F(LayerTreeHostImplTest, ScrollDeltaRepeatedScrolls) {
scroll_info = host_impl_->ProcessScrollDeltas();
ASSERT_EQ(scroll_info->scrolls.size(), 1u);
- EXPECT_VECTOR_EQ(root->sent_scroll_delta(), scroll_delta);
ExpectContains(*scroll_info, root->id(), scroll_delta);
gfx::Vector2d scroll_delta2(-5, 27);
root->ScrollBy(scroll_delta2);
scroll_info = host_impl_->ProcessScrollDeltas();
ASSERT_EQ(scroll_info->scrolls.size(), 1u);
- EXPECT_VECTOR_EQ(root->sent_scroll_delta(), scroll_delta + scroll_delta2);
ExpectContains(*scroll_info, root->id(), scroll_delta + scroll_delta2);
root->ScrollBy(gfx::Vector2d());
scroll_info = host_impl_->ProcessScrollDeltas();
- EXPECT_EQ(root->sent_scroll_delta(), scroll_delta + scroll_delta2);
+ ExpectContains(*scroll_info, root->id(), scroll_delta + scroll_delta2);
}
TEST_F(LayerTreeHostImplTest, ScrollRootCallsCommitAndRedraw) {
@@ -1031,6 +1029,7 @@ TEST_F(LayerTreeHostImplTest, PinchGesture) {
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
max_page_scale);
scroll_layer->SetScrollDelta(gfx::Vector2d());
+ scroll_layer->PullDeltaForMainThread();
scroll_layer->SetScrollOffset(gfx::ScrollOffset(50, 50));
float page_scale_delta = 0.1f;
@@ -1052,6 +1051,7 @@ TEST_F(LayerTreeHostImplTest, PinchGesture) {
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
max_page_scale);
scroll_layer->SetScrollDelta(gfx::Vector2d());
+ scroll_layer->PullDeltaForMainThread();
scroll_layer->SetScrollOffset(gfx::ScrollOffset(20, 20));
float page_scale_delta = 1.f;
@@ -1073,6 +1073,7 @@ TEST_F(LayerTreeHostImplTest, PinchGesture) {
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
max_page_scale);
scroll_layer->SetScrollDelta(gfx::Vector2d());
+ scroll_layer->PullDeltaForMainThread();
scroll_layer->SetScrollOffset(gfx::ScrollOffset(20, 20));
float page_scale_delta = 1.f;
@@ -1094,6 +1095,7 @@ TEST_F(LayerTreeHostImplTest, PinchGesture) {
{
host_impl_->active_tree()->PushPageScaleFromMainThread(0.5f, 0.5f, 4.f);
scroll_layer->SetScrollDelta(gfx::Vector2d());
+ scroll_layer->PullDeltaForMainThread();
scroll_layer->SetScrollOffset(gfx::ScrollOffset(0, 0));
host_impl_->ScrollBegin(gfx::Point(0, 0), InputHandler::Gesture);
@@ -3741,6 +3743,8 @@ class TestScrollOffsetDelegate : public LayerScrollOffsetDelegate {
page_scale_factor_ = page_scale_factor;
min_page_scale_factor_ = min_page_scale_factor;
max_page_scale_factor_ = max_page_scale_factor;
+
+ set_getter_return_value(last_set_scroll_offset_);
}
gfx::ScrollOffset last_set_scroll_offset() {
@@ -7881,7 +7885,7 @@ TEST_F(LayerTreeHostImplTest, GetPictureLayerImplPairs) {
host_impl_->CreatePendingTree();
scoped_ptr<PictureLayerImpl> layer =
- PictureLayerImpl::Create(host_impl_->pending_tree(), 10, false);
+ FakePictureLayerImpl::Create(host_impl_->pending_tree(), 10);
layer->SetBounds(gfx::Size(10, 10));
scoped_refptr<RasterSource> pile(FakePicturePileImpl::CreateEmptyPile(
@@ -7931,7 +7935,7 @@ TEST_F(LayerTreeHostImplTest, GetPictureLayerImplPairs) {
// should get two pairs.
host_impl_->CreatePendingTree();
host_impl_->pending_tree()->root_layer()->AddChild(
- PictureLayerImpl::Create(host_impl_->pending_tree(), 11, false));
+ FakePictureLayerImpl::Create(host_impl_->pending_tree(), 11));
LayerImpl* new_pending_layer = pending_tree->root_layer()->children()[0];
diff --git a/cc/trees/layer_tree_host_unittest_animation.cc b/cc/trees/layer_tree_host_unittest_animation.cc
index 3868c87..7733f41 100644
--- a/cc/trees/layer_tree_host_unittest_animation.cc
+++ b/cc/trees/layer_tree_host_unittest_animation.cc
@@ -1089,8 +1089,7 @@ class LayerTreeHostAnimationTestScrollOffsetAnimationRemoval
// Block activation until the running animation has a chance to produce a
// scroll delta.
- gfx::Vector2dF scroll_delta = scroll_layer_impl->ScrollDelta() -
- scroll_layer_impl->sent_scroll_delta();
+ gfx::Vector2dF scroll_delta = scroll_layer_impl->ScrollDelta();
if (scroll_delta.x() < 1.f || scroll_delta.y() < 1.f)
return;
diff --git a/cc/trees/layer_tree_host_unittest_scroll.cc b/cc/trees/layer_tree_host_unittest_scroll.cc
index 4e561ed..e63d35f 100644
--- a/cc/trees/layer_tree_host_unittest_scroll.cc
+++ b/cc/trees/layer_tree_host_unittest_scroll.cc
@@ -830,7 +830,6 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll1_);
- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
PostSetNeedsCommitToMainThread();
// CommitCompleteOnThread will trigger this function again
@@ -844,8 +843,6 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
impl_thread_scroll1_ + impl_thread_scroll2_);
- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(),
- impl_thread_scroll1_);
LayerImpl* pending_scroll_layer = pending_root->children()[0];
EXPECT_VECTOR_EQ(
@@ -854,8 +851,6 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_));
EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
impl_thread_scroll2_);
- EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
- gfx::Vector2d());
}
break;
case 1:
@@ -865,7 +860,6 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
gfx::ScrollOffsetWithDelta(
initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_));
EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll2_);
- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
EndTest();
break;
}
@@ -963,8 +957,6 @@ class ImplSidePaintingScrollTestImplOnlyScroll
EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
initial_scroll_);
EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());
- EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
- gfx::Vector2d());
EXPECT_FALSE(active_root);
break;
case 1:
@@ -974,14 +966,10 @@ class ImplSidePaintingScrollTestImplOnlyScroll
initial_scroll_);
EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
impl_thread_scroll_);
- EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
- gfx::Vector2d());
ASSERT_TRUE(active_root);
EXPECT_VECTOR_EQ(active_scroll_layer->scroll_offset(), initial_scroll_);
EXPECT_VECTOR_EQ(active_scroll_layer->ScrollDelta(),
impl_thread_scroll_);
- EXPECT_VECTOR_EQ(active_scroll_layer->sent_scroll_delta(),
- gfx::Vector2d());
break;
case 2:
// On the next commit, this delta should have been sent and applied.
@@ -989,8 +977,6 @@ class ImplSidePaintingScrollTestImplOnlyScroll
gfx::ScrollOffsetWithDelta(initial_scroll_,
impl_thread_scroll_));
EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());
- EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
- gfx::Vector2d());
break;
}
}
@@ -1005,7 +991,6 @@ class ImplSidePaintingScrollTestImplOnlyScroll
case 0:
EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
PostSetNeedsCommitToMainThread();
@@ -1013,7 +998,6 @@ class ImplSidePaintingScrollTestImplOnlyScroll
case 1:
EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll_);
- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
EXPECT_EQ(impl_scale_,
impl->active_tree()->current_page_scale_factor());
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index a50b2ff..76f2750 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -50,11 +50,11 @@ class LayerScrollOffsetDelegateProxy : public LayerImpl::ScrollOffsetDelegate {
}
// LayerScrollOffsetDelegate implementation.
- void SetTotalScrollOffset(const gfx::ScrollOffset& new_offset) override {
+ void SetCurrentScrollOffset(const gfx::ScrollOffset& new_offset) override {
last_set_scroll_offset_ = new_offset;
}
- gfx::ScrollOffset GetTotalScrollOffset() override {
+ gfx::ScrollOffset GetCurrentScrollOffset() override {
return layer_tree_impl_->GetDelegatedScrollOffset(layer_);
}
@@ -154,10 +154,10 @@ gfx::ScrollOffset LayerTreeImpl::TotalScrollOffset() const {
gfx::ScrollOffset offset;
if (inner_viewport_scroll_layer_)
- offset += inner_viewport_scroll_layer_->TotalScrollOffset();
+ offset += inner_viewport_scroll_layer_->CurrentScrollOffset();
if (outer_viewport_scroll_layer_)
- offset += outer_viewport_scroll_layer_->TotalScrollOffset();
+ offset += outer_viewport_scroll_layer_->CurrentScrollOffset();
return offset;
}
@@ -173,15 +173,6 @@ gfx::ScrollOffset LayerTreeImpl::TotalMaxScrollOffset() const {
return offset;
}
-gfx::Vector2dF LayerTreeImpl::TotalScrollDelta() const {
- DCHECK(inner_viewport_scroll_layer_);
- gfx::Vector2dF delta = inner_viewport_scroll_layer_->ScrollDelta();
-
- if (outer_viewport_scroll_layer_)
- delta += outer_viewport_scroll_layer_->ScrollDelta();
-
- return delta;
-}
scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
// Clear all data structures that have direct references to the layer tree.
@@ -468,19 +459,6 @@ void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
root_layer(), base::Bind(&ApplySentScrollDeltasFromAbortedCommitTo));
}
-static void ApplyScrollDeltasSinceBeginMainFrameTo(LayerImpl* layer) {
- layer->ApplyScrollDeltasSinceBeginMainFrame();
-}
-
-void LayerTreeImpl::ApplyScrollDeltasSinceBeginMainFrame() {
- DCHECK(IsPendingTree());
- if (!root_layer())
- return;
-
- LayerTreeHostCommon::CallFunctionForSubtree(
- root_layer(), base::Bind(&ApplyScrollDeltasSinceBeginMainFrameTo));
-}
-
void LayerTreeImpl::SetViewportLayersFromIds(
int overscroll_elasticity_layer_id,
int page_scale_layer_id,
@@ -997,6 +975,11 @@ void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
}
if (inner_viewport_scroll_layer_)
+ inner_viewport_scroll_layer_->RefreshFromScrollDelegate();
+ if (outer_viewport_scroll_layer_)
+ outer_viewport_scroll_layer_->RefreshFromScrollDelegate();
+
+ if (inner_viewport_scroll_layer_)
UpdateScrollOffsetDelegate();
}
}
@@ -1004,10 +987,10 @@ void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
void LayerTreeImpl::OnRootLayerDelegatedScrollOffsetChanged() {
DCHECK(root_layer_scroll_offset_delegate_);
if (inner_viewport_scroll_layer_) {
- inner_viewport_scroll_layer_->DidScroll();
+ inner_viewport_scroll_layer_->RefreshFromScrollDelegate();
}
if (outer_viewport_scroll_layer_) {
- outer_viewport_scroll_layer_->DidScroll();
+ outer_viewport_scroll_layer_->RefreshFromScrollDelegate();
}
}
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 3ad278b..160a965 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -135,7 +135,6 @@ class CC_EXPORT LayerTreeImpl {
LayerImpl* OuterViewportScrollLayer() const;
gfx::ScrollOffset TotalScrollOffset() const;
gfx::ScrollOffset TotalMaxScrollOffset() const;
- gfx::Vector2dF TotalScrollDelta() const;
LayerImpl* InnerViewportContainerLayer() const;
LayerImpl* OuterViewportContainerLayer() const;
@@ -153,7 +152,6 @@ class CC_EXPORT LayerTreeImpl {
}
LayerImpl* page_scale_layer() { return page_scale_layer_; }
void ApplySentScrollAndScaleDeltasFromAbortedCommit();
- void ApplyScrollDeltasSinceBeginMainFrame();
SkColor background_color() const { return background_color_; }
void set_background_color(SkColor color) { background_color_ = color; }
diff --git a/cc/trees/property_tree_builder.cc b/cc/trees/property_tree_builder.cc
index 5573c32..1afd4bd 100644
--- a/cc/trees/property_tree_builder.cc
+++ b/cc/trees/property_tree_builder.cc
@@ -194,8 +194,8 @@ void AddTransformNodeIfNeeded(const DataForRecursion& data_from_ancestor,
// record, the slight difference should be inconsequential).
gfx::Vector2dF position = layer->position().OffsetFromOrigin();
if (!layer->scroll_parent()) {
- position -= gfx::Vector2dF(layer->TotalScrollOffset().x(),
- layer->TotalScrollOffset().y());
+ position -= gfx::Vector2dF(layer->CurrentScrollOffset().x(),
+ layer->CurrentScrollOffset().y());
}
position += parent_offset;