diff options
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; |