CC Animation: Make AnimationPlayer to be a unit of activation.

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 136 matching lines @@
   DCHECK(player);
 
   scoped_refptr<ElementAnimations> element_animations =
       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());
-    DidDeactivateElementAnimations(element_animations.get());
     element_animations->SetAnimationHost(nullptr);
   }
+
+  DeactivateAnimationPlayer(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 93 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_element_to_animations_map_.empty();
+  return !active_players_.empty();
 }
 
 bool AnimationHost::ActivateAnimations() {
   if (!NeedsAnimateLayers())
     return false;
 
   TRACE_EVENT0("cc", "AnimationHost::ActivateAnimations");
-  ElementToAnimationsMap active_element_animations_map_copy =
-      active_element_to_animations_map_;
-  for (auto& it : active_element_animations_map_copy)
-    it.second->ActivateAnimations();
+  PlayersList active_active_players_copy = active_players_;
+  for (auto& it : active_active_players_copy)
+    it->ActivateAnimations();
 
   return true;
 }
 
 bool AnimationHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!NeedsAnimateLayers())
     return false;
 
   TRACE_EVENT0("cc", "AnimationHost::AnimateLayers");
-  ElementToAnimationsMap active_element_animations_map_copy =
-      active_element_to_animations_map_;
-  for (auto& it : active_element_animations_map_copy)
-    it.second->Animate(monotonic_time);
+  PlayersList active_active_players_copy = active_players_;
+  for (auto& it : active_active_players_copy)
+    it->Animate(monotonic_time);
 
   return true;
 }
 
 bool AnimationHost::UpdateAnimationState(bool start_ready_animations,
                                          MutatorEvents* mutator_events) {
   if (!NeedsAnimateLayers())
     return false;
 
   auto animation_events = static_cast<AnimationEvents*>(mutator_events);
 
   TRACE_EVENT0("cc", "AnimationHost::UpdateAnimationState");
-  ElementToAnimationsMap active_element_animations_map_copy =
-      active_element_to_animations_map_;
-  for (auto& it : active_element_animations_map_copy)
-    it.second->UpdateState(start_ready_animations, animation_events);
+  PlayersList active_active_players_copy = active_players_;
+  for (auto& it : active_active_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) {
@@ skipping 34 matching lines @@
           break;
       }
     }
   }
 }
 
 bool AnimationHost::ScrollOffsetAnimationWasInterrupted(
     ElementId element_id) const {
   auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
-             ? element_animations->scroll_offset_animation_was_interrupted()
+             ? element_animations->ScrollOffsetAnimationWasInterrupted()
              : false;
 }
 
 bool AnimationHost::IsAnimatingFilterProperty(ElementId element_id,
                                               ElementListType list_type) const {
   auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
                    TargetProperty::FILTER, list_type)
              : false;
@@ skipping 173 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::DidActivateElementAnimations(
-    ElementAnimations* element_animations) {
-  DCHECK(element_animations->element_id());
-  active_element_to_animations_map_[element_animations->element_id()] =
-      element_animations;
+void AnimationHost::ActivateAnimationPlayer(

[ajuma, 2016/11/30 15:34:53]

Not related to this CL but something to consider for a future cleanup: we have
two different notions of "Activate" in the animation code:
pending-tree-to-active-tree "activation", and "activation" in the sense of going
from not having any animations to having animations. This is pretty confusing so
it might be worth renaming the latter.

+    scoped_refptr<AnimationPlayer> player) {
+  DCHECK(std::find(active_players_.begin(), active_players_.end(), player) ==
+         active_players_.end());
+  active_players_.push_back(player);
 }
 
-void AnimationHost::DidDeactivateElementAnimations(
-    ElementAnimations* element_animations) {
-  DCHECK(element_animations->element_id());
-  active_element_to_animations_map_.erase(element_animations->element_id());
+void AnimationHost::DeactivateAnimationPlayer(
+    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);
+}
+
+const AnimationHost::PlayersList& AnimationHost::active_players_for_testing()
+    const {
+  return active_players_;
 }
 
 const AnimationHost::ElementToAnimationsMap&
-AnimationHost::active_element_animations_for_testing() const {
-  return active_element_to_animations_map_;
-}
-
-const AnimationHost::ElementToAnimationsMap&
 AnimationHost::all_element_animations_for_testing() const {
   return element_to_animations_map_;
 }
 
 }  // namespace cc