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

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 10 matching lines @@
 
 namespace cc {
 
 scoped_refptr<ElementAnimations> ElementAnimations::Create() {
   return make_scoped_refptr(new ElementAnimations());
 }
 
 ElementAnimations::ElementAnimations()
     : animation_host_(),
       element_id_(),
-      is_active_(false),
       has_element_in_active_list_(false),
       has_element_in_pending_list_(false),
-      scroll_offset_animation_was_interrupted_(false),
       needs_push_properties_(false),
       needs_update_impl_client_state_(false) {}
 
 ElementAnimations::~ElementAnimations() {}
 
 void ElementAnimations::SetAnimationHost(AnimationHost* host) {
   animation_host_ = host;
 }
 
 void ElementAnimations::SetElementId(ElementId element_id) {
@@ skipping 40 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);
 
-  animation_host_->DidDeactivateElementAnimations(this);
-  UpdateActivation(ActivationType::FORCE);
+  Deactivate();
 }
 
 void ElementAnimations::ElementRegistered(ElementId element_id,
                                           ElementListType list_type) {
   DCHECK_EQ(element_id_, element_id);
 
   if (!has_element_in_any_list())
     UpdateActivation(ActivationType::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())
-    animation_host_->DidDeactivateElementAnimations(this);
+    Deactivate();
 }
 
 void ElementAnimations::AddPlayer(AnimationPlayer* player) {
   players_list_.AddObserver(player);
 }
 
 void ElementAnimations::RemovePlayer(AnimationPlayer* player) {
   players_list_.RemoveObserver(player);
 }
 
 bool ElementAnimations::IsEmpty() const {
   return !players_list_.might_have_observers();
 }
 
 void ElementAnimations::SetNeedsPushProperties() {
   needs_push_properties_ = true;
 }
 
 void ElementAnimations::PushPropertiesTo(
     scoped_refptr<ElementAnimations> element_animations_impl) const {
   DCHECK_NE(this, element_animations_impl);
 
   if (!needs_push_properties_)
     return;
   needs_push_properties_ = false;
 
-  element_animations_impl->scroll_offset_animation_was_interrupted_ =
-      scroll_offset_animation_was_interrupted_;
-  scroll_offset_animation_was_interrupted_ = false;
-
   // Update impl client state.
   if (needs_update_impl_client_state_)
     element_animations_impl->UpdateClientAnimationState();
   needs_update_impl_client_state_ = false;
-
-  element_animations_impl->UpdateActivation(ActivationType::NORMAL);
 }
 
-void ElementAnimations::Animate(base::TimeTicks monotonic_time) {
-  DCHECK(!monotonic_time.is_null());
-  if (!has_element_in_active_list() && !has_element_in_pending_list())
-    return;
-
-  for (auto& player : players_list_) {
-    if (player.needs_to_start_animations())
-      player.StartAnimations(monotonic_time);
-  }
-
+void ElementAnimations::UpdateActivation(ActivationType activation_type) const {
   for (auto& player : players_list_)
-    player.TickAnimations(monotonic_time);
-
-  last_tick_time_ = monotonic_time;
-  UpdateClientAnimationState();
+    player.UpdateActivation(activation_type);
 }
 
-void ElementAnimations::UpdateState(bool start_ready_animations,
-                                    AnimationEvents* events) {
-  if (!has_element_in_active_list())
-    return;
-
-  // Animate hasn't been called, this happens if an element has been added
-  // between the Commit and Draw phases.
-  if (last_tick_time_ == base::TimeTicks())
-    return;
-
-  if (start_ready_animations) {
-    for (auto& player : players_list_)
-      player.PromoteStartedAnimations(last_tick_time_, events);
-  }
-
+void ElementAnimations::Deactivate() const {
   for (auto& player : players_list_)
-    player.MarkFinishedAnimations(last_tick_time_);
-
-  for (auto& player : players_list_)
-    player.MarkAnimationsForDeletion(last_tick_time_, events);
-
-  if (start_ready_animations) {
-    for (auto& player : players_list_) {
-      if (player.needs_to_start_animations()) {
-        player.StartAnimations(last_tick_time_);
-        player.PromoteStartedAnimations(last_tick_time_, events);
-      }
-    }
-  }
-
-  UpdateActivation(ActivationType::NORMAL);
-}
-
-void ElementAnimations::ActivateAnimations() {
-  for (auto& player : players_list_)
-    player.ActivateAnimations();
-
-  scroll_offset_animation_was_interrupted_ = false;
-  UpdateActivation(ActivationType::NORMAL);
+    player.Deactivate();
 }
 
 void ElementAnimations::NotifyAnimationStarted(const AnimationEvent& event) {
   DCHECK(!event.is_impl_only);
   for (auto& player : players_list_) {
     if (player.NotifyAnimationStarted(event))
       break;
   }
 }
 
@@ skipping 122 matching lines @@
     bool success = player.MaximumTargetScale(list_type, &player_max_scale);
     if (!success)
       return false;
     // Union: a maximum.
     *max_scale = std::max(*max_scale, player_max_scale);
   }
 
   return true;
 }
 
+bool ElementAnimations::ScrollOffsetAnimationWasInterrupted() const {
+  for (auto& player : players_list_) {
+    if (player.scroll_offset_animation_was_interrupted())
+      return true;
+  }
+  return false;
+}
+
 void ElementAnimations::SetNeedsUpdateImplClientState() {
   needs_update_impl_client_state_ = true;
   SetNeedsPushProperties();
 }
 
-void ElementAnimations::UpdateActivation(ActivationType type) {
-  bool force = type == ActivationType::FORCE;
-  if (animation_host_) {
-    bool was_active = is_active_;
-    is_active_ = false;
-
-    for (auto& player : players_list_) {
-      if (player.HasNonDeletedAnimation()) {
-        is_active_ = true;
-        break;
-      }
-    }
-
-    if (is_active_ && ((!was_active && has_element_in_any_list()) || force)) {
-      animation_host_->DidActivateElementAnimations(this);
-    } else if (!is_active_ && (was_active || force)) {
-      // Resetting last_tick_time_ here ensures that calling ::UpdateState
-      // before ::Animate doesn't start an animation.
-      last_tick_time_ = base::TimeTicks();
-      animation_host_->DidDeactivateElementAnimations(this);
-    }
-  }
-}
-
-void ElementAnimations::UpdateActivationNormal() {
-  UpdateActivation(ActivationType::NORMAL);
-}
-
 void ElementAnimations::NotifyClientOpacityAnimated(
     float opacity,
     bool notify_active_elements,
     bool notify_pending_elements) {
   if (notify_active_elements && has_element_in_active_list())
     OnOpacityAnimated(ElementListType::ACTIVE, opacity);
   if (notify_pending_elements && has_element_in_pending_list())
     OnOpacityAnimated(ElementListType::PENDING, opacity);
 }
 
@@ skipping 113 matching lines @@
     TargetProperty::Type target_property,
     ElementListType list_type) const {
   for (auto& player : players_list_) {
     if (player.IsCurrentlyAnimatingProperty(target_property, list_type))
       return true;
   }
 
   return false;
 }
 
-void ElementAnimations::SetScrollOffsetAnimationWasInterrupted() {
-  scroll_offset_animation_was_interrupted_ = true;
-}
-
 void ElementAnimations::OnFilterAnimated(ElementListType list_type,
                                          const FilterOperations& filters) {
   DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
   animation_host()->mutator_host_client()->SetElementFilterMutated(
       element_id(), list_type, filters);
 }
 
 void ElementAnimations::OnOpacityAnimated(ElementListType list_type,
@@ skipping 28 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