Rename cc animation classes to be consistent with blink classes and spec

Currently the names of Animation related classes on cc side is very
confusing. e.g. cc::Animation is quite different from blink::Animation.
blink::Animation is corresponding to cc::AnimationPlayer which owns
multiple cc::AnimationTicker which owns multiple cc::Animation.

To be consistent with blink, it’s better to rename the relevant classes.
In addition, the cc::AnimationTicker behaves as the cc counterpart of
blink::KeyframeEffect therefore it should be renamed as well.

Corresponding changes are also made to the clients of cc::Animation
(vr, ui, blink) in this patch.

Summary:
This patch:
Animation       -> KeyframeModel
AnimationTicker -> KeyframeEffect

Follow up patch:
AnimationPlayer -> Animation

Bug: 807667
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_vr;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I24c240b514da38541e4dd8a5550a9092ebd11430
Reviewed-on: https://chromium-review.googlesource.com/906830
Commit-Queue: Yi Gu <yigu@chromium.org>
Reviewed-by: Ian Vollick <vollick@chromium.org>
Reviewed-by: Majid Valipour <majidvp@chromium.org>
Reviewed-by: Robert Flack <flackr@chromium.org>
Reviewed-by: Stephen McGruer <smcgruer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#537082}

Author: yi-gu

cc/animation/BUILD.gn

@@ -7,8 +7,6 @@ import("//cc/cc.gni")
 cc_component("animation") {
   output_name = "cc_animation"
   sources = [
-    "animation.cc",
-    "animation.h",
     "animation_curve.cc",
     "animation_curve.h",
     "animation_delegate.h",
@@ -22,12 +20,14 @@ cc_component("animation") {
     "animation_player.cc",
     "animation_player.h",
     "animation_target.h",
-    "animation_ticker.cc",
-    "animation_ticker.h",
     "animation_timeline.cc",
     "animation_timeline.h",
     "element_animations.cc",
     "element_animations.h",
+    "keyframe_effect.cc",
+    "keyframe_effect.h",
+    "keyframe_model.cc",
+    "keyframe_model.h",
     "keyframed_animation_curve.cc",
     "keyframed_animation_curve.h",
     "scroll_offset_animation_curve.cc",
@@ -38,8 +38,8 @@ cc_component("animation") {
     "scroll_offset_animations_impl.h",
     "scroll_timeline.cc",
     "scroll_timeline.h",
-    "single_ticker_animation_player.cc",
-    "single_ticker_animation_player.h",
+    "single_keyframe_effect_animation_player.cc",
+    "single_keyframe_effect_animation_player.h",
     "timing_function.cc",
     "timing_function.h",
     "transform_operation.cc",

cc/animation/README.md

@@ -19,7 +19,7 @@ of Chromium interact with cc/animation, most prominently Blink and ui/.
 ## How cc/animation works
 
 The root concept in cc/animation is an
-[animation](https://codesearch.chromium.org/chromium/src/cc/animation/animation.h).
+[keyframe model](https://codesearch.chromium.org/chromium/src/cc/animation/keyframe_model.h).
 Animations contain the state necessary to 'play' (interpolate values from) an
 [animation curve](https://codesearch.chromium.org/chromium/src/cc/animation/animation_curve.h),
 which is a function that returns a value given an input time. Aside from the
@@ -29,10 +29,10 @@ An animation does not know or care what property is being animated, and holds
 only an opaque identifier for the property to allow clients to map output values
 to the correct properties.
 
-Targeting only a single property means that cc animations are distinct from the
+Targeting only a single property means that cc KeyframeModels are distinct from the
 Blink concept of an animation, which wraps the animation of multiple properties.
 To coordinate the playback of multiple cc/animations (e.g. those that are
-animating multiple properties on the same target), animations have the concept
+animating multiple properties on the same target), KeyframeModels have the concept
 of a group identifier. Animations that have the same group identifier and the
 same target are started together, and animation-finished notifications are only
 sent when all animations in the group have finished.
@@ -42,7 +42,7 @@ Animations are grouped together based on their
 (the entity whose property is being animated) and each such group is owned by an
 [animation player](https://codesearch.chromium.org/chromium/src/cc/animation/animation_player.h).
 Note that there may be multiple animation players with the same target (each
-with a set of animations for that target); the
+with a set of KeyframeModels for that target); the
 [ElementAnimations](https://codesearch.chromium.org/chromium/src/cc/animation/element_animations.h)
 class wraps the multiple animation players and has a 1:1 relationship with
 target entities.

cc/animation/animation_delegate.h

@@ -6,13 +6,19 @@
 #define CC_ANIMATION_ANIMATION_DELEGATE_H_
 
 #include "base/time/time.h"
-#include "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
+#include "cc/animation/keyframe_model.h"
 
 namespace cc {
 
 class CC_ANIMATION_EXPORT AnimationDelegate {
  public:
+  // TODO(yigu): The Notify* methods will be called multiple times per
+  // animation (once for effect/property pairing).
+  // Ideally, we would only notify start once (e.g., wait on all effects to
+  // start before notifying delegate) this way effect becomes an internal
+  // details of the player. Perhaps we can do that at some point maybe as part
+  // of https://bugs.chromium.org/p/chromium/issues/detail?id=810003
   virtual void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                                       int target_property,
                                       int group) = 0;

cc/animation/animation_events.h

@@ -8,9 +8,9 @@
 #include <memory>
 #include <vector>
 
-#include "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_export.h"
+#include "cc/animation/keyframe_model.h"
 #include "cc/paint/filter_operations.h"
 #include "cc/trees/element_id.h"
 #include "cc/trees/mutator_host.h"

cc/animation/animation_host.cc

@@ -15,9 +15,9 @@
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
-#include "cc/animation/animation_ticker.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
+#include "cc/animation/keyframe_effect.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/scroll_offset_animations.h"
 #include "cc/animation/scroll_offset_animations_impl.h"
@@ -124,10 +124,11 @@ void AnimationHost::UnregisterElement(ElementId element_id,
     element_animations->ElementUnregistered(element_id, list_type);
 }
 
-void AnimationHost::RegisterTickerForElement(ElementId element_id,
-                                             AnimationTicker* ticker) {
+void AnimationHost::RegisterKeyframeEffectForElement(
+    ElementId element_id,
+    KeyframeEffect* keyframe_effect) {
   DCHECK(element_id);
-  DCHECK(ticker);
+  DCHECK(keyframe_effect);
 
   scoped_refptr<ElementAnimations> element_animations =
       GetElementAnimationsForElementId(element_id);
@@ -143,18 +144,19 @@ void AnimationHost::RegisterTickerForElement(ElementId element_id,
     element_animations->InitAffectedElementTypes();
   }
 
-  element_animations->AddTicker(ticker);
+  element_animations->AddKeyframeEffect(keyframe_effect);
 }
 
-void AnimationHost::UnregisterTickerForElement(ElementId element_id,
-                                               AnimationTicker* ticker) {
+void AnimationHost::UnregisterKeyframeEffectForElement(
+    ElementId element_id,
+    KeyframeEffect* keyframe_effect) {
   DCHECK(element_id);
-  DCHECK(ticker);
+  DCHECK(keyframe_effect);
 
   scoped_refptr<ElementAnimations> element_animations =
       GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
-  element_animations->RemoveTicker(ticker);
+  element_animations->RemoveKeyframeEffect(keyframe_effect);
 
   if (element_animations->IsEmpty()) {
     element_animations->ClearAffectedElementTypes();
@@ -287,7 +289,7 @@ bool AnimationHost::ActivateAnimations() {
   TRACE_EVENT0("cc", "AnimationHost::ActivateAnimations");
   PlayersList ticking_players_copy = ticking_players_;
   for (auto& it : ticking_players_copy)
-    it->ActivateAnimations();
+    it->ActivateKeyframeEffects();
 
   return true;
 }
@@ -522,14 +524,16 @@ bool AnimationHost::AnimationStartScale(ElementId element_id,
              : true;
 }
 
-bool AnimationHost::HasAnyAnimation(ElementId element_id) const {
+bool AnimationHost::IsElementAnimating(ElementId element_id) const {
   auto element_animations = GetElementAnimationsForElementId(element_id);
-  return element_animations ? element_animations->HasAnyAnimation() : false;
+  return element_animations ? element_animations->HasAnyKeyframeModel() : false;
 }
 
-bool AnimationHost::HasTickingAnimationForTesting(ElementId element_id) const {
+bool AnimationHost::HasTickingKeyframeModelForTesting(
+    ElementId element_id) const {
   auto element_animations = GetElementAnimationsForElementId(element_id);
-  return element_animations ? element_animations->HasTickingAnimation() : false;
+  return element_animations ? element_animations->HasTickingKeyframeEffect()
+                            : false;
 }
 
 void AnimationHost::ImplOnlyScrollAnimationCreate(
@@ -626,7 +630,7 @@ void AnimationHost::SetMutationUpdate(
 size_t AnimationHost::CompositedAnimationsCount() const {
   size_t composited_animations_count = 0;
   for (const auto& it : ticking_players_)
-    composited_animations_count += it->TickingAnimationsCount();
+    composited_animations_count += it->TickingKeyframeModelsCount();
   return composited_animations_count;
 }
 
@@ -635,11 +639,11 @@ void AnimationHost::SetAnimationCounts(
     size_t main_thread_compositable_animations_count) {
   // The |total_animations_count| is the total number of blink::Animations.
   // A blink::Animation holds a CompositorAnimationPlayerHolder, which holds
-  // a CompositorAnimationPlayer, which holds a cc::AnimationPlayer. In other
+  // a CompositorAnimationPlayer, which holds a AnimationPlayer. In other
   // words, if a blink::Animation can be accelerated on compositor, it would
-  // have a 1:1 mapping to a cc::AnimationPlayer.
+  // have a 1:1 mapping to a AnimationPlayer.
   // So to check how many main thread animations there are, we subtract the
-  // number of cc::AnimationPlayer from |total_animations_count|.
+  // number of AnimationPlayer from |total_animations_count|.
   size_t ticking_players_count = ticking_players_.size();
   if (main_thread_animations_count_ !=
       total_animations_count - ticking_players_count) {

cc/animation/animation_host.h

@@ -13,8 +13,8 @@
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
-#include "cc/animation/animation.h"
 #include "cc/animation/animation_export.h"
+#include "cc/animation/keyframe_model.h"
 #include "cc/trees/mutator_host.h"
 #include "cc/trees/mutator_host_client.h"
 #include "ui/gfx/geometry/box_f.h"
@@ -27,10 +27,10 @@ class ScrollOffset;
 namespace cc {
 
 class AnimationPlayer;
-class AnimationTicker;
 class AnimationTimeline;
 class ElementAnimations;
 class LayerTreeHost;
+class KeyframeEffect;
 class ScrollOffsetAnimations;
 class ScrollOffsetAnimationsImpl;
 
@@ -62,9 +62,10 @@ class CC_ANIMATION_EXPORT AnimationHost : public MutatorHost,
   void RemoveAnimationTimeline(scoped_refptr<AnimationTimeline> timeline);
   AnimationTimeline* GetTimelineById(int timeline_id) const;
 
-  void RegisterTickerForElement(ElementId element_id, AnimationTicker* ticker);
-  void UnregisterTickerForElement(ElementId element_id,
-                                  AnimationTicker* ticker);
+  void RegisterKeyframeEffectForElement(ElementId element_id,
+                                        KeyframeEffect* keyframe_effect);
+  void UnregisterKeyframeEffectForElement(ElementId element_id,
+                                          KeyframeEffect* keyframe_effect);
 
   scoped_refptr<ElementAnimations> GetElementAnimationsForElementId(
       ElementId element_id) const;
@@ -145,8 +146,8 @@ class CC_ANIMATION_EXPORT AnimationHost : public MutatorHost,
                            ElementListType list_type,
                            float* start_scale) const override;
 
-  bool HasAnyAnimation(ElementId element_id) const override;
-  bool HasTickingAnimationForTesting(ElementId element_id) const override;
+  bool IsElementAnimating(ElementId element_id) const override;
+  bool HasTickingKeyframeModelForTesting(ElementId element_id) const override;
 
   void ImplOnlyScrollAnimationCreate(
       ElementId element_id,

cc/animation/animation_host_perftest.cc

@@ -6,9 +6,9 @@
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_id_provider.h"
-#include "cc/animation/animation_ticker.h"
 #include "cc/animation/animation_timeline.h"
-#include "cc/animation/single_ticker_animation_player.h"
+#include "cc/animation/keyframe_effect.h"
+#include "cc/animation/single_keyframe_effect_animation_player.h"
 #include "cc/base/lap_timer.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host.h"
@@ -70,13 +70,13 @@ class AnimationHostPerfTest : public testing::Test {
       root_layer_->AddChild(layer);
       layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
 
-      scoped_refptr<SingleTickerAnimationPlayer> player =
-          SingleTickerAnimationPlayer::Create(last_player_id_);
+      scoped_refptr<SingleKeyframeEffectAnimationPlayer> player =
+          SingleKeyframeEffectAnimationPlayer::Create(last_player_id_);
       last_player_id_ = AnimationIdProvider::NextPlayerId();
 
       all_players_timeline_->AttachPlayer(player);
       player->AttachElement(layer->element_id());
-      EXPECT_TRUE(player->element_animations(player->animation_ticker()->id()));
+      EXPECT_TRUE(player->element_animations(player->keyframe_effect()->id()));
     }
 
     // Create impl players.

cc/animation/animation_id_provider.cc

@@ -7,14 +7,14 @@
 
 namespace cc {
 
-base::AtomicSequenceNumber g_next_animation_id;
+base::AtomicSequenceNumber g_next_keyframe_model_id;
 base::AtomicSequenceNumber g_next_group_id;
 base::AtomicSequenceNumber g_next_timeline_id;
 base::AtomicSequenceNumber g_next_player_id;
 
-int AnimationIdProvider::NextAnimationId() {
+int AnimationIdProvider::NextKeyframeModelId() {
   // Animation IDs start from 1.
-  return g_next_animation_id.GetNext() + 1;
+  return g_next_keyframe_model_id.GetNext() + 1;
 }
 
 int AnimationIdProvider::NextGroupId() {

cc/animation/animation_id_provider.h

@@ -13,7 +13,7 @@ namespace cc {
 class CC_ANIMATION_EXPORT AnimationIdProvider {
  public:
   // These functions each return monotonically increasing values.
-  static int NextAnimationId();
+  static int NextKeyframeModelId();
   static int NextGroupId();
   static int NextTimelineId();
   static int NextPlayerId();