cc: Support animating scroll offset

cc/layers/layer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #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"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/rect_conversions.h"
 
@@ skipping 40 matching lines @@
       replica_layer_(NULL),
       raster_scale_(0.f),
       client_(NULL) {
   if (layer_id_ < 0) {
     s_next_layer_id = 1;
     layer_id_ = s_next_layer_id++;
   }
 
   layer_animation_controller_ = LayerAnimationController::Create(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
+  layer_animation_controller_->set_value_provider(this);
 }
 
 Layer::~Layer() {
   // Our parent should be holding a reference to us so there should be no
   // way for us to be destroyed while we still have a parent.
   DCHECK(!parent());
   // Similarly we shouldn't have a layer tree host since it also keeps a
   // reference to us.
   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();
   if (mask_layer_.get()) {
     DCHECK_EQ(this, mask_layer_->parent());
     mask_layer_->RemoveFromParent();
   }
   if (replica_layer_.get()) {
     DCHECK_EQ(this, replica_layer_->parent());
     replica_layer_->RemoveFromParent();
@@ skipping 945 matching lines @@
 void Layer::CreateRenderSurface() {
   DCHECK(!draw_properties_.render_surface);
   draw_properties_.render_surface = make_scoped_ptr(new RenderSurface(this));
   draw_properties_.render_target = this;
 }
 
 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
 // set directly rather than by calling Set<Property>.
 void Layer::OnFilterAnimated(const FilterOperations& filters) {
   filters_ = filters;
 }
 
 void Layer::OnOpacityAnimated(float opacity) {
   opacity_ = opacity;
 }
 
 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();
 }
 
 bool Layer::IsActive() const {
   return true;
 }
 
 bool Layer::AddAnimation(scoped_ptr <Animation> animation) {
@@ skipping 81 matching lines @@
     clip_parent_->RemoveClipChild(this);
 
   clip_parent_ = NULL;
 }
 
 void Layer::RunMicroBenchmark(MicroBenchmark* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 }  // namespace cc