cc: Support animating scroll offset

cc/layers/layer.cc

Index: cc/layers/layer.cc
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 77907193b59a9c2ddd23ce2f3cf1c54c0b381acd..b15cdc88c0dee3fd692c18e9616b2bef9dfe6907 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -12,6 +12,7 @@
 #include "base/single_thread_task_runner.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_events.h"
+#include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/layer_impl.h"
@@ -72,6 +73,7 @@ Layer::Layer()
 
   layer_animation_controller_ = LayerAnimationController::Create(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
+  layer_animation_controller_->set_value_provider(this);
 }
 
 Layer::~Layer() {
@@ -83,6 +85,7 @@ Layer::~Layer() {
   DCHECK(!layer_tree_host());
 
   layer_animation_controller_->RemoveValueObserver(this);
+  layer_animation_controller_->remove_value_provider(this);
 
   // Remove the parent reference from all children and dependents.
   RemoveAllChildren();
@@ -1048,6 +1051,10 @@ void Layer::ClearRenderSurface() {
   draw_properties_.render_surface.reset();
 }
 
+gfx::Vector2dF Layer::ScrollOffsetForAnimation() const {
+  return TotalScrollOffset();
+}
+
 // On<Property>Animated is called due to an ongoing accelerated animation.
 // Since this animation is also being run on the compositor thread, there
 // is no need to request a commit to push this value over, so the value is
@@ -1064,6 +1071,12 @@ void Layer::OnTransformAnimated(const gfx::Transform& transform) {
   transform_ = transform;
 }
 
+void Layer::OnScrollOffsetAnimated(gfx::Vector2dF scroll_offset) {
+  // Do nothing. Scroll deltas will be sent from the compositor thread back
+  // to the main thread in the same manner as during non-animated
+  // compositor-driven scrolling.

[ajuma, 2013/11/28 22:33:36]

SingleThreadProxy doesn't send back scroll deltas. We have a few options here:
1) Just make SingleThreadProxy support this.
2) Rely on the fact that the flags that trigger
ScrollableArea::usesCompositedScrolling won't be true in places where we still
ship SingleThreadProxy (and Blink will check usesCompositedScrolling before
sending scroll animations over to cc).
3) Add a flag for accelerated smooth scroll animations (which would only affect
whether these animations get sent to cc, not whether the smooth scroll API is
enabled), and make this default to false when threaded compositing is disabled.

The main downside to (1) is that it requires doing an additional tree walk (for
LayerTreeHostImpl::ProcessScrollDeltas) on each commit, to gather scroll deltas
that will virtually always be 0 in practice for SingleThreadProxy.

[Ian Vollick, 2013/11/29 15:29:29]

Re 2), we could use scroll to on the main frame, too, and that will never have
usesCompositedScrolling, even if its on the fast path.

As we chatted about offline, I think my favorite option is to detect when we're
in single threaded mode, and never invoke the cc scroll animation machinery in
that case (and instead fall back to the main thread machinery that we'll need to
create anyhow). And if we go with this approach, this method can stay as-is,
doing nothing.

[ajuma, 2013/11/29 21:18:41]

Ah, I missed that usesCompositedScrolling doesn't get set in this case.
 
Agreed. Note that this is effectively option (3), since (as far as I can tell,
looking through Source/core/page/Settings.in) Blink doesn't "know" when we're in
single-threaded mode (which is something I didn't realize when we discussed this
offline).

+}
+
 void Layer::OnAnimationWaitingForDeletion() {
   // Animations are only deleted during PushProperties.
   SetNeedsPushProperties();