CC Animation: Rename Active Players to Ticking Players.

cc/animation/animation_host.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_host.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 139 matching lines @@
       GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
   element_animations->RemovePlayer(player);
 
   if (element_animations->IsEmpty()) {
     element_animations->ClearAffectedElementTypes();
     element_to_animations_map_.erase(element_animations->element_id());
     element_animations->SetAnimationHost(nullptr);
   }
 
-  DeactivateAnimationPlayer(player);
+  RemoveFromTicking(player);
 }
 
 void AnimationHost::SetMutatorHostClient(MutatorHostClient* client) {
   if (mutator_host_client_ == client)
     return;
 
   mutator_host_client_ = client;
 
   if (needs_push_properties() && mutator_host_client())
     SetNeedsPushProperties();
@@ skipping 92 matching lines @@
 
 void AnimationHost::SetSupportsScrollAnimations(
     bool supports_scroll_animations) {
   supports_scroll_animations_ = supports_scroll_animations;
 }
 
 bool AnimationHost::SupportsScrollAnimations() const {
   return supports_scroll_animations_;
 }
 
-bool AnimationHost::NeedsAnimateLayers() const {
-  return !active_players_.empty();
+bool AnimationHost::NeedsTickAnimations() const {
+  return !ticking_players_.empty();
 }
 
 bool AnimationHost::ActivateAnimations() {
-  if (!NeedsAnimateLayers())
+  if (!NeedsTickAnimations())
     return false;
 
   TRACE_EVENT0("cc", "AnimationHost::ActivateAnimations");
-  PlayersList active_active_players_copy = active_players_;
-  for (auto& it : active_active_players_copy)
+  PlayersList ticking_players_copy = ticking_players_;
+  for (auto& it : ticking_players_copy)
     it->ActivateAnimations();
 
   return true;
 }
 
-bool AnimationHost::AnimateLayers(base::TimeTicks monotonic_time) {
-  if (!NeedsAnimateLayers())
+bool AnimationHost::TickAnimations(base::TimeTicks monotonic_time) {
+  if (!NeedsTickAnimations())
     return false;
 
-  TRACE_EVENT0("cc", "AnimationHost::AnimateLayers");
-  PlayersList active_active_players_copy = active_players_;
-  for (auto& it : active_active_players_copy)
-    it->Animate(monotonic_time);
+  TRACE_EVENT0("cc", "AnimationHost::TickAnimations");
+  PlayersList ticking_players_copy = ticking_players_;
+  for (auto& it : ticking_players_copy)
+    it->Tick(monotonic_time);
 
   return true;
 }
 
 bool AnimationHost::UpdateAnimationState(bool start_ready_animations,
                                          MutatorEvents* mutator_events) {
-  if (!NeedsAnimateLayers())
+  if (!NeedsTickAnimations())
     return false;
 
   auto animation_events = static_cast<AnimationEvents*>(mutator_events);
 
   TRACE_EVENT0("cc", "AnimationHost::UpdateAnimationState");
-  PlayersList active_active_players_copy = active_players_;
-  for (auto& it : active_active_players_copy)
+  PlayersList ticking_players_copy = ticking_players_;
+  for (auto& it : ticking_players_copy)
     it->UpdateState(start_ready_animations, animation_events);
 
   return true;
 }
 
 std::unique_ptr<MutatorEvents> AnimationHost::CreateEvents() {
   return base::MakeUnique<AnimationEvents>();
 }
 
 void AnimationHost::SetAnimationEvents(
     std::unique_ptr<MutatorEvents> mutator_events) {
   auto events =
       base::WrapUnique(static_cast<AnimationEvents*>(mutator_events.release()));
 
   for (size_t event_index = 0; event_index < events->events_.size();
        ++event_index) {
     ElementId element_id = events->events_[event_index].element_id;
 
-    // Use the map of all ElementAnimations, not just active ones, since
-    // non-active ElementAnimations may still receive events for impl-only
-    // animations.
+    // Use the map of all ElementAnimations, not just ticking players, since
+    // non-ticking Players may still receive events for impl-only animations.
     const ElementToAnimationsMap& all_element_animations =
         element_to_animations_map_;
     auto iter = all_element_animations.find(element_id);
     if (iter != all_element_animations.end()) {
       switch (events->events_[event_index].type) {
         case AnimationEvent::STARTED:
           (*iter).second->NotifyAnimationStarted(events->events_[event_index]);
           break;
 
         case AnimationEvent::FINISHED:
@@ skipping 171 matching lines @@
   return element_animations
              ? element_animations->AnimationStartScale(list_type, start_scale)
              : true;
 }
 
 bool AnimationHost::HasAnyAnimation(ElementId element_id) const {
   auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations ? element_animations->HasAnyAnimation() : false;
 }
 
-bool AnimationHost::HasActiveAnimationForTesting(ElementId element_id) const {
+bool AnimationHost::HasTickingAnimationForTesting(ElementId element_id) const {
   auto element_animations = GetElementAnimationsForElementId(element_id);
-  return element_animations ? element_animations->HasActiveAnimation() : false;
+  return element_animations ? element_animations->HasTickingAnimation() : false;
 }
 
 void AnimationHost::ImplOnlyScrollAnimationCreate(
     ElementId element_id,
     const gfx::ScrollOffset& target_offset,
     const gfx::ScrollOffset& current_offset,
     base::TimeDelta delayed_by) {
   DCHECK(scroll_offset_animations_impl_);
   scroll_offset_animations_impl_->ScrollAnimationCreate(
       element_id, target_offset, current_offset, delayed_by);
@@ skipping 14 matching lines @@
 ScrollOffsetAnimations& AnimationHost::scroll_offset_animations() const {
   DCHECK(scroll_offset_animations_);
   return *scroll_offset_animations_.get();
 }
 
 void AnimationHost::ScrollAnimationAbort(bool needs_completion) {
   DCHECK(scroll_offset_animations_impl_);
   return scroll_offset_animations_impl_->ScrollAnimationAbort(needs_completion);
 }
 
-void AnimationHost::ActivateAnimationPlayer(
-    scoped_refptr<AnimationPlayer> player) {
-  DCHECK(std::find(active_players_.begin(), active_players_.end(), player) ==
-         active_players_.end());
-  active_players_.push_back(player);
+void AnimationHost::AddToTicking(scoped_refptr<AnimationPlayer> player) {
+  DCHECK(std::find(ticking_players_.begin(), ticking_players_.end(), player) ==
+         ticking_players_.end());
+  ticking_players_.push_back(player);
 }
 
-void AnimationHost::DeactivateAnimationPlayer(
-    scoped_refptr<AnimationPlayer> player) {
+void AnimationHost::RemoveFromTicking(scoped_refptr<AnimationPlayer> player) {
   auto to_erase =
-      std::find(active_players_.begin(), active_players_.end(), player);
-  if (to_erase != active_players_.end())
-    active_players_.erase(to_erase);
+      std::find(ticking_players_.begin(), ticking_players_.end(), player);
+  if (to_erase != ticking_players_.end())
+    ticking_players_.erase(to_erase);
 }
 
-const AnimationHost::PlayersList& AnimationHost::active_players_for_testing()
+const AnimationHost::PlayersList& AnimationHost::ticking_players_for_testing()
     const {
-  return active_players_;
+  return ticking_players_;
 }
 
 const AnimationHost::ElementToAnimationsMap&
-AnimationHost::all_element_animations_for_testing() const {
+AnimationHost::element_animations_for_testing() const {
   return element_to_animations_map_;
 }
 
 }  // namespace cc