CC Animations: Port Impl-only-scrolling to use compositor animation timelines.

cc/animation/animation_timeline.cc

 // Copyright 2015 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/animation/animation_timeline.h"
 
 #include <algorithm>
 
+#include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_registrar.h"
+#include "cc/animation/scroll_offset_animation_curve.h"
+#include "cc/animation/timing_function.h"
 #include "ui/gfx/geometry/box_f.h"
+#include "ui/gfx/geometry/scroll_offset.h"
 
 namespace cc {
 
 scoped_refptr<AnimationTimeline> AnimationTimeline::Create() {
   return make_scoped_refptr(new AnimationTimeline());
 }
 
 AnimationTimeline::AnimationTimeline()
     : animation_registrar_(AnimationRegistrar::Create()),
       layer_tree_mutators_client_() {
+  scroll_offset_animation_player_ =
+      AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
+  AttachPlayer(scroll_offset_animation_player_.get());
 }
 
 AnimationTimeline::~AnimationTimeline() {
   DCHECK(!layer_tree_mutators_client());
 
+  DetachPlayer(scroll_offset_animation_player_.get());
+
   for (auto& player : players_)
     player->SetAnimationTimeline(nullptr);
 }
 
 void AnimationTimeline::AttachPlayer(AnimationPlayer* player) {
   player->SetAnimationTimeline(this);
   players_.push_back(player);
 }
 
 void AnimationTimeline::DetachPlayer(AnimationPlayer* player) {
@@ skipping 282 matching lines @@
   return player ? player->layer_animation_controller()->has_any_animation()
                 : false;
 }
 
 bool AnimationTimeline::HasActiveAnimation(int layer_id) const {
   AnimationPlayer* player = GetPlayerForLayerId(layer_id);
   return player ? player->layer_animation_controller()->HasActiveAnimation()
                 : false;
 }
 
+void AnimationTimeline::ScrollAnimationCreate(
+    int layer_id,
+    const gfx::ScrollOffset& target_offset,
+    const gfx::ScrollOffset& current_offset) {
+  scoped_ptr<ScrollOffsetAnimationCurve> curve =
+      ScrollOffsetAnimationCurve::Create(target_offset,
+                                         EaseInOutTimingFunction::Create());
+  curve->SetInitialValue(current_offset);
+
+  scoped_ptr<Animation> animation = Animation::Create(
+      curve.Pass(), AnimationIdProvider::NextAnimationId(),
+      AnimationIdProvider::NextGroupId(), Animation::SCROLL_OFFSET);
+  animation->set_is_impl_only(true);

[ajuma, 2015/03/24 13:37:23]

Not all scroll animations are impl-only, so this method should be renamed to
something like ImplOnlyScrollAnimationCreate.

[loyso (OOO), 2015/04/13 07:38:24]

Done.

+
+  scroll_offset_animation_player_->AttachLayer(layer_id);
+  scroll_offset_animation_player_->AddAnimation(animation.Pass());
+}
+
+bool AnimationTimeline::ScrollAnimationUpdateTarget(
+    int layer_id,
+    const gfx::Vector2dF& scroll_delta,
+    const gfx::ScrollOffset& max_scroll_offset,
+    base::TimeTicks frame_monotonic_time) {
+  DCHECK(scroll_offset_animation_player_.get());
+  DCHECK_EQ(layer_id, scroll_offset_animation_player_->layer_id());
+
+  Animation* animation =
+      scroll_offset_animation_player_->layer_animation_controller()
+          ->GetAnimation(Animation::SCROLL_OFFSET);
+  if (!animation) {
+    scroll_offset_animation_player_->DetachLayer();
+    return false;
+  }
+
+  ScrollOffsetAnimationCurve* curve =
+      animation->curve()->ToScrollOffsetAnimationCurve();
+
+  gfx::ScrollOffset new_target =
+      gfx::ScrollOffsetWithDelta(curve->target_value(), scroll_delta);
+  new_target.SetToMax(gfx::ScrollOffset());
+  new_target.SetToMin(max_scroll_offset);
+
+  curve->UpdateTarget(
+      animation->TrimTimeToCurrentIteration(frame_monotonic_time).InSecondsF(),
+      new_target);
+
+  return true;
+}
+
 }  // namespace cc