CC Animation: Rename Active Players to Ticking Players.

cc/animation/element_animations.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/element_animations.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 29 matching lines @@
 }
 
 void ElementAnimations::SetElementId(ElementId element_id) {
   element_id_ = element_id;
 }
 
 void ElementAnimations::InitAffectedElementTypes() {
   DCHECK(element_id_);
   DCHECK(animation_host_);
 
-  UpdateActivation(ActivationType::FORCE);
+  UpdatePlayersTickingState(UpdateTickingType::FORCE);
 
   DCHECK(animation_host_->mutator_host_client());
   if (animation_host_->mutator_host_client()->IsElementInList(
           element_id_, ElementListType::ACTIVE)) {
     set_has_element_in_active_list(true);
   }
   if (animation_host_->mutator_host_client()->IsElementInList(
           element_id_, ElementListType::PENDING)) {
     set_has_element_in_pending_list(true);
   }
@@ skipping 22 matching lines @@
   }
   set_has_element_in_active_list(false);
 
   if (has_element_in_pending_list()) {
     animation_host()->mutator_host_client()->ElementIsAnimatingChanged(
         element_id(), ElementListType::PENDING, disabled_state_mask,
         disabled_state);
   }
   set_has_element_in_pending_list(false);
 
-  Deactivate();
+  RemovePlayersFromTicking();
 }
 
 void ElementAnimations::ElementRegistered(ElementId element_id,
                                           ElementListType list_type) {
   DCHECK_EQ(element_id_, element_id);
 
   if (!has_element_in_any_list())
-    UpdateActivation(ActivationType::FORCE);
+    UpdatePlayersTickingState(UpdateTickingType::FORCE);
 
   if (list_type == ElementListType::ACTIVE)
     set_has_element_in_active_list(true);
   else
     set_has_element_in_pending_list(true);
 }
 
 void ElementAnimations::ElementUnregistered(ElementId element_id,
                                             ElementListType list_type) {
   DCHECK_EQ(this->element_id(), element_id);
   if (list_type == ElementListType::ACTIVE)
     set_has_element_in_active_list(false);
   else
     set_has_element_in_pending_list(false);
 
   if (!has_element_in_any_list())
-    Deactivate();
+    RemovePlayersFromTicking();
 }
 
 void ElementAnimations::AddPlayer(AnimationPlayer* player) {
   players_list_.AddObserver(player);
 }
 
 void ElementAnimations::RemovePlayer(AnimationPlayer* player) {
   players_list_.RemoveObserver(player);
 }
 
@@ skipping 12 matching lines @@
   if (!needs_push_properties_)
     return;
   needs_push_properties_ = false;
 
   // Update impl client state.
   if (needs_update_impl_client_state_)
     element_animations_impl->UpdateClientAnimationState();
   needs_update_impl_client_state_ = false;
 }
 
-void ElementAnimations::UpdateActivation(ActivationType activation_type) const {
+void ElementAnimations::UpdatePlayersTickingState(
+    UpdateTickingType update_ticking_type) const {
   for (auto& player : players_list_)
-    player.UpdateActivation(activation_type);
+    player.UpdateTickingState(update_ticking_type);
 }
 
-void ElementAnimations::Deactivate() const {
+void ElementAnimations::RemovePlayersFromTicking() const {
   for (auto& player : players_list_)
-    player.Deactivate();
+    player.RemoveFromTicking();
 }
 
 void ElementAnimations::NotifyAnimationStarted(const AnimationEvent& event) {
   DCHECK(!event.is_impl_only);
   for (auto& player : players_list_) {
     if (player.NotifyAnimationStarted(event))
       break;
   }
 }
 
@@ skipping 219 matching lines @@
     animation_host()->mutator_host_client()->ElementIsAnimatingChanged(
         element_id(), ElementListType::ACTIVE, diff_active, active_state_);
   }
   if (has_element_in_pending_list() && prev_pending != pending_state_) {
     PropertyAnimationState diff_pending = prev_pending ^ pending_state_;
     animation_host()->mutator_host_client()->ElementIsAnimatingChanged(
         element_id(), ElementListType::PENDING, diff_pending, pending_state_);
   }
 }
 
-bool ElementAnimations::HasActiveAnimation() const {
+bool ElementAnimations::HasTickingAnimation() const {
   for (auto& player : players_list_) {
-    if (player.HasActiveAnimation())
+    if (player.HasTickingAnimation())
       return true;
   }
 
   return false;
 }
 
 bool ElementAnimations::HasAnyAnimation() const {
   for (auto& player : players_list_) {
     if (player.has_any_animation())
       return true;
@@ skipping 74 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc