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

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) {
+      needs_to_start_animations_(false),
+      is_active_(false),
+      scroll_offset_animation_was_interrupted_(false) {
   DCHECK(id_);
 }
 
 AnimationPlayer::~AnimationPlayer() {
   DCHECK(!animation_timeline_);
   DCHECK(!element_animations_);
 }
 
 scoped_refptr<AnimationPlayer> AnimationPlayer::CreateImplInstance() const {
   scoped_refptr<AnimationPlayer> player = AnimationPlayer::Create(id());
@@ skipping 90 matching lines @@
     SetNeedsPushProperties();
   }
 }
 
 void AnimationPlayer::AnimationAdded() {
   DCHECK(element_animations_);
 
   SetNeedsCommit();
   needs_to_start_animations_ = true;
 
-  element_animations_->UpdateActivationNormal();
+  UpdateActivation(ActivationType::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 14 matching lines @@
   // use a stable_parition here instead of remove_if. Remove_if leaves the
   // removed items in an unspecified state.
   auto animations_to_remove = std::stable_partition(
       animations_.begin(), animations_.end(),
       [animation_id](const std::unique_ptr<Animation>& animation) {
         return animation->id() != animation_id;
       });
   for (auto it = animations_to_remove; it != animations_.end(); ++it) {
     if ((*it)->target_property() == TargetProperty::SCROLL_OFFSET) {
       if (element_animations_)
-        element_animations_->SetScrollOffsetAnimationWasInterrupted();
+        scroll_offset_animation_was_interrupted_ = true;
     } else if (!(*it)->is_finished()) {
       animation_removed = true;
     }
   }
 
   animations_.erase(animations_to_remove, animations_.end());
 
   if (element_animations_) {
-    element_animations_->UpdateActivationNormal();
+    UpdateActivation(ActivationType::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 57 matching lines @@
   MarkAbortedAnimationsForDeletion(player_impl);
   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);
+}
+
+void AnimationPlayer::Animate(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);
+
+  last_tick_time_ = monotonic_time;
+  element_animations_->UpdateClientAnimationState();
+}
+
+void AnimationPlayer::UpdateState(bool start_ready_animations,
+                                  AnimationEvents* events) {
+  DCHECK(element_animations_);
+  if (!element_animations_->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)
+    PromoteStartedAnimations(last_tick_time_, events);
+
+  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);
+}
+
+void AnimationPlayer::UpdateActivation(ActivationType type) {
+  bool force = type == ActivationType::FORCE;
+  if (animation_host_) {
+    bool was_active = is_active_;
+    is_active_ = 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();
+    }
+  }
+}
+
+void AnimationPlayer::Deactivate() {
+  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);
 }
 
 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 470 matching lines @@
   auto affects_no_elements = [](const std::unique_ptr<Animation>& animation) {
     return !animation->affects_active_elements() &&
            !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);
 }
 
 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 349 matching lines @@
 }
 
 void AnimationPlayer::PushPropertiesToImplThread(
     AnimationPlayer* animation_player_impl) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     Animation* current_impl =
         animation_player_impl->GetAnimationById(animations_[i]->id());
     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