Purge impl-only animations awaiting deletion in AnimationPlayer::UpdateState.

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 235 matching lines @@
     if (player_impl->element_id())
       player_impl->DetachElement();
     if (element_id_)
       player_impl->AttachElement(element_id_);
   }
 
   if (!has_any_animation() && !player_impl->has_any_animation())
     return;
 
   MarkAbortedAnimationsForDeletion(player_impl);
-  PurgeAnimationsMarkedForDeletion();
+  PurgeAnimationsMarkedForDeletion(/* impl_only */ false);
   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->UpdateTickingState(UpdateTickingType::NORMAL);
@@ skipping 24 matching lines @@
   // 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);
+  PurgeAnimationsMarkedForDeletion(/* impl_only */ true);
 
   if (start_ready_animations) {
     if (needs_to_start_animations()) {
       StartAnimations(last_tick_time_);
       PromoteStartedAnimations(last_tick_time_, events);
     }
   }
 
   UpdateTickingState(UpdateTickingType::NORMAL);
 }
@@ skipping 779 matching lines @@
                                last_tick_time_);
         animation_aborted = true;
       }
     }
   }
 
   if (element_animations_ && animation_aborted)
     element_animations_->SetNeedsUpdateImplClientState();
 }
 
-void AnimationPlayer::PurgeAnimationsMarkedForDeletion() {
-  base::EraseIf(animations_, [](const std::unique_ptr<Animation>& animation) {
-    return animation->run_state() == Animation::WAITING_FOR_DELETION;
-  });
+void AnimationPlayer::PurgeAnimationsMarkedForDeletion(bool impl_only) {
+  base::EraseIf(
+      animations_, [impl_only](const std::unique_ptr<Animation>& animation) {
+        return animation->run_state() == Animation::WAITING_FOR_DELETION &&
+               (!impl_only || animation->is_impl_only());
+      });
 }
 
 void AnimationPlayer::PushNewAnimationsToImplThread(
     AnimationPlayer* animation_player_impl) const {
   // Any new animations owned by the main thread's AnimationPlayer are cloned
   // and added to the impl thread's AnimationPlayer.
   for (size_t i = 0; i < animations_.size(); ++i) {
     // If the animation is already running on the impl thread, there is no
     // need to copy it over.
     if (animation_player_impl->GetAnimationById(animations_[i]->id()))
@@ skipping 71 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