cc: Push Animation Finished State and Use Finished State for IsCompleted

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 "base/stl_util.h"
 #include "cc/animation/animation_delegate.h"
@@ skipping 356 matching lines @@
       animations_[i]->set_received_finished_event(true);
 
       if (animation_delegate_) {
         animation_delegate_->NotifyAnimationFinished(
             event.monotonic_time, event.target_property, event.group_id);
       }
       return true;
     }
   }
 
+  // This is for the case when an animation is already removed on main thread,
+  // but the impl version of it sent a finished event and is now waiting for
+  // deletion. We would need to delete that animation during push properties.
+  SetNeedsPushProperties();
   return false;
 }
 
 bool AnimationPlayer::NotifyAnimationFinishedForTesting(
     TargetProperty::Type target_property,
     int group_id) {
   AnimationEvent event(AnimationEvent::FINISHED, element_id_, group_id,
                        target_property, base::TimeTicks());
   return NotifyAnimationFinished(event);
 }
@@ skipping 401 matching lines @@
 }
 
 void AnimationPlayer::MarkFinishedAnimations(base::TimeTicks monotonic_time) {
   bool animation_finished = false;
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->IsFinishedAt(monotonic_time)) {
       animations_[i]->SetRunState(Animation::FINISHED, monotonic_time);
       animation_finished = true;
+      SetNeedsPushProperties();
+    }
+    if (!animations_[i]->affects_active_elements() &&
+        !animations_[i]->affects_pending_elements()) {
+      switch (animations_[i]->run_state()) {
+        case Animation::WAITING_FOR_TARGET_AVAILABILITY:
+        case Animation::STARTING:
+        case Animation::RUNNING:
+        case Animation::PAUSED:
+          animations_[i]->SetRunState(Animation::FINISHED, monotonic_time);
+          animation_finished = true;
+          break;
+        default:
+          break;
+      }
     }
   }
 
   DCHECK(element_animations_);
   if (animation_finished)
     element_animations_->UpdateClientAnimationState();
 }
 
 void AnimationPlayer::ActivateAnimations() {
   bool animation_activated = false;
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->affects_active_elements() !=
         animations_[i]->affects_pending_elements()) {
       animation_activated = true;
     }
     animations_[i]->set_affects_active_elements(
         animations_[i]->affects_pending_elements());
   }
-  auto affects_no_elements = [](const std::unique_ptr<Animation>& animation) {
-    return !animation->affects_active_elements() &&
-           !animation->affects_pending_elements();
-  };
-  base::EraseIf(animations_, affects_no_elements);
 
   if (animation_activated)
     element_animations_->UpdateClientAnimationState();
 
   scroll_offset_animation_was_interrupted_ = false;
   UpdateTickingState(UpdateTickingType::NORMAL);
 }
 
 bool AnimationPlayer::HasFilterAnimationThatInflatesBounds() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
@@ skipping 312 matching lines @@
     to_add->set_affects_active_elements(false);
     animation_player_impl->AddAnimation(std::move(to_add));
   }
 }
 
 static bool IsCompleted(Animation* animation,
                         const AnimationPlayer* main_thread_player) {
   if (animation->is_impl_only()) {
     return (animation->run_state() == Animation::WAITING_FOR_DELETION);
   } else {
-    return !main_thread_player->GetAnimationById(animation->id());
+    Animation* main_thread_animation =
+        main_thread_player->GetAnimationById(animation->id());
+    return !main_thread_animation || main_thread_animation->is_finished();
   }
 }
 
 void AnimationPlayer::RemoveAnimationsCompletedOnMainThread(
     AnimationPlayer* animation_player_impl) const {
   bool animation_completed = false;
 
   // Animations removed on the main thread should no longer affect pending
   // elements, and should stop affecting active elements after the next call
   // to ActivateAnimations. If already WAITING_FOR_DELETION, they can be removed
@@ skipping 24 matching lines @@
     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