CC Animation: Rename Active Players to Ticking Players.

cc/animation/animation_player.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_player.h"
 
 #include <algorithm>
 
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/trees/property_animation_state.h"
 
 namespace cc {
 
 scoped_refptr<AnimationPlayer> AnimationPlayer::Create(int id) {
   return make_scoped_refptr(new AnimationPlayer(id));
 }
 
 AnimationPlayer::AnimationPlayer(int id)
     : animation_host_(),
       animation_timeline_(),
       element_animations_(),
       animation_delegate_(),
       id_(id),
       needs_push_properties_(false),
       needs_to_start_animations_(false),
-      is_active_(false),
+      is_ticking_(false),
       scroll_offset_animation_was_interrupted_(false) {
   DCHECK(id_);
 }
 
 AnimationPlayer::~AnimationPlayer() {
   DCHECK(!animation_timeline_);
   DCHECK(!element_animations_);
 }
 
 scoped_refptr<AnimationPlayer> AnimationPlayer::CreateImplInstance() const {
@@ skipping 91 matching lines @@
     SetNeedsPushProperties();
   }
 }
 
 void AnimationPlayer::AnimationAdded() {
   DCHECK(element_animations_);
 
   SetNeedsCommit();
   needs_to_start_animations_ = true;
 
-  UpdateActivation(ActivationType::NORMAL);
+  UpdateTickingState(UpdateTickingType::NORMAL);
   element_animations_->UpdateClientAnimationState();
 }
 
 void AnimationPlayer::PauseAnimation(int animation_id, double time_offset) {
   const base::TimeDelta time_delta = base::TimeDelta::FromSecondsD(time_offset);
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->id() == animation_id) {
       animations_[i]->SetRunState(Animation::PAUSED,
                                   time_delta + animations_[i]->start_time() +
@@ skipping 23 matching lines @@
       if (element_animations_)
         scroll_offset_animation_was_interrupted_ = true;
     } else if (!(*it)->is_finished()) {
       animation_removed = true;
     }
   }
 
   animations_.erase(animations_to_remove, animations_.end());
 
   if (element_animations_) {
-    UpdateActivation(ActivationType::NORMAL);
+    UpdateTickingState(UpdateTickingType::NORMAL);
     if (animation_removed)
       element_animations_->UpdateClientAnimationState();
     SetNeedsCommit();
     SetNeedsPushProperties();
   }
 }
 
 void AnimationPlayer::AbortAnimation(int animation_id) {
   if (Animation* animation = GetAnimationById(animation_id)) {
     if (!animation->is_finished()) {
@@ skipping 58 matching lines @@
   PurgeAnimationsMarkedForDeletion();
   PushNewAnimationsToImplThread(player_impl);
 
   // Remove finished impl side animations only after pushing,
   // and only after the animations are deleted on the main thread
   // this insures we will never push an animation twice.
   RemoveAnimationsCompletedOnMainThread(player_impl);
 
   PushPropertiesToImplThread(player_impl);
 
-  player_impl->UpdateActivation(ActivationType::NORMAL);
+  player_impl->UpdateTickingState(UpdateTickingType::NORMAL);
 }
 
-void AnimationPlayer::Animate(base::TimeTicks monotonic_time) {
+void AnimationPlayer::Tick(base::TimeTicks monotonic_time) {
   DCHECK(!monotonic_time.is_null());
   DCHECK(element_animations_);
 
   if (!element_animations_->has_element_in_any_list())
     return;
 
   if (needs_to_start_animations())
     StartAnimations(monotonic_time);
 
   TickAnimations(monotonic_time);
@@ skipping 19 matching lines @@
   MarkFinishedAnimations(last_tick_time_);
   MarkAnimationsForDeletion(last_tick_time_, events);
 
   if (start_ready_animations) {
     if (needs_to_start_animations()) {
       StartAnimations(last_tick_time_);
       PromoteStartedAnimations(last_tick_time_, events);
     }
   }
 
-  UpdateActivation(ActivationType::NORMAL);
+  UpdateTickingState(UpdateTickingType::NORMAL);
 }
 
-void AnimationPlayer::UpdateActivation(ActivationType type) {
-  bool force = type == ActivationType::FORCE;
+void AnimationPlayer::UpdateTickingState(UpdateTickingType type) {
+  bool force = type == UpdateTickingType::FORCE;
   if (animation_host_) {
-    bool was_active = is_active_;
-    is_active_ = HasNonDeletedAnimation();
+    bool was_ticking = is_ticking_;
+    is_ticking_ = HasNonDeletedAnimation();
 
     bool has_element_in_any_list =
         element_animations_->has_element_in_any_list();
 
-    if (is_active_ && ((!was_active && has_element_in_any_list) || force)) {
-      animation_host_->ActivateAnimationPlayer(this);
-    } else if (!is_active_ && (was_active || force)) {
-      Deactivate();
+    if (is_ticking_ && ((!was_ticking && has_element_in_any_list) || force)) {
+      animation_host_->AddToTicking(this);
+    } else if (!is_ticking_ && (was_ticking || force)) {
+      RemoveFromTicking();
     }
   }
 }
 
-void AnimationPlayer::Deactivate() {
+void AnimationPlayer::RemoveFromTicking() {
   DCHECK(animation_host_);
   // Resetting last_tick_time_ here ensures that calling ::UpdateState
   // before ::Animate doesn't start an animation.
   last_tick_time_ = base::TimeTicks();
-  animation_host_->DeactivateAnimationPlayer(this);
+  animation_host_->RemoveFromTicking(this);
 }
 
 bool AnimationPlayer::NotifyAnimationStarted(const AnimationEvent& event) {
   DCHECK(!event.is_impl_only);
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
         animations_[i]->target_property() == event.target_property &&
         animations_[i]->needs_synchronized_start_time()) {
       animations_[i]->set_needs_synchronized_start_time(false);
@@ skipping 81 matching lines @@
 void AnimationPlayer::SetNeedsPushProperties() {
   needs_push_properties_ = true;
 
   DCHECK(animation_timeline_);
   animation_timeline_->SetNeedsPushProperties();
 
   DCHECK(element_animations_);
   element_animations_->SetNeedsPushProperties();
 }
 
-bool AnimationPlayer::HasActiveAnimation() const {
+bool AnimationPlayer::HasTickingAnimation() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished())
       return true;
   }
   return false;
 }
 
 bool AnimationPlayer::HasNonDeletedAnimation() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() != Animation::WAITING_FOR_DELETION)
@@ skipping 370 matching lines @@
            !animation->affects_pending_elements();
   };
   animations_.erase(std::remove_if(animations_.begin(), animations_.end(),
                                    affects_no_elements),
                     animations_.end());
 
   if (animation_activated)
     element_animations_->UpdateClientAnimationState();
 
   scroll_offset_animation_was_interrupted_ = false;
-  UpdateActivation(ActivationType::NORMAL);
+  UpdateTickingState(UpdateTickingType::NORMAL);
 }
 
 bool AnimationPlayer::HasFilterAnimationThatInflatesBounds() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->target_property() == TargetProperty::FILTER &&
         animations_[i]
             ->curve()
             ->ToFilterAnimationCurve()
             ->HasFilterThatMovesPixels())
@@ skipping 356 matching lines @@
     if (current_impl)
       animations_[i]->PushPropertiesTo(current_impl);
   }
 
   animation_player_impl->scroll_offset_animation_was_interrupted_ =
       scroll_offset_animation_was_interrupted_;
   scroll_offset_animation_was_interrupted_ = false;
 }
 
 }  // namespace cc