Fix assumptions made in LAC::MarkAnimationsForDeletion

cc/animation/layer_animation_controller.cc

 // Copyright 2012 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/layer_animation_controller.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/animation/animation.h"
@@ skipping 792 matching lines @@
       marked_animations_for_deletions = true;
       continue;
     }
 
     bool all_anims_with_same_id_are_finished = false;
 
     // Since deleting an animation on the main thread leads to its deletion
     // on the impl thread, we only mark a FINISHED main thread animation for
     // deletion once it has received a FINISHED event from the impl thread.
     bool animation_i_will_send_or_has_received_finish_event =
-        events || animations_[i]->received_finished_event();
+        animations_[i]->is_controlling_instance() ||
+        animations_[i]->is_impl_only() ||
+        animations_[i]->received_finished_event();
     // If an animation is finished, and not already marked for deletion,
     // find out if all other animations in the same group are also finished.
     if (animations_[i]->run_state() == Animation::FINISHED &&
         animation_i_will_send_or_has_received_finish_event) {
       // Clear the animations_with_same_group_id if it was added for
       // the previous animation's iteration.
       if (animations_with_same_group_id.size() > 0)
         animations_with_same_group_id.clear();
       all_anims_with_same_id_are_finished = true;
       for (size_t j = 0; j < animations_.size(); ++j) {
         bool animation_j_will_send_or_has_received_finish_event =
-            events || animations_[j]->received_finished_event();
+            animations_[j]->is_controlling_instance() ||
+            animations_[j]->is_impl_only() ||
+            animations_[j]->received_finished_event();
         if (group_id == animations_[j]->group()) {
           if (!animations_[j]->is_finished() ||
               (animations_[j]->run_state() == Animation::FINISHED &&
                !animation_j_will_send_or_has_received_finish_event)) {
             all_anims_with_same_id_are_finished = false;
             break;
           } else if (j >= i &&
                      animations_[j]->run_state() != Animation::ABORTED) {
             // Mark down the animations which belong to the same group
             // and is not yet aborted. If this current iteration finds that all
             // animations with same ID are finished, then the marked
             // animations below will be set to WAITING_FOR_DELETION in next
             // iteration.
             animations_with_same_group_id.push_back(j);
           }
         }
       }
     }
     if (all_anims_with_same_id_are_finished) {
       // We now need to remove all animations with the same group id as
       // group_id (and send along animation finished notifications, if
       // necessary).
       for (size_t j = 0; j < animations_with_same_group_id.size(); j++) {
         size_t animation_index = animations_with_same_group_id[j];
-          if (events) {
-            AnimationEvent finished_event(
-                AnimationEvent::FINISHED, id_,
-                animations_[animation_index]->group(),
-                animations_[animation_index]->target_property(),
-                monotonic_time);
-            finished_event.is_impl_only =
-                animations_[animation_index]->is_impl_only();
-            if (finished_event.is_impl_only)
-              NotifyAnimationFinished(finished_event);
-            else
-              events->push_back(finished_event);
-          }
-          animations_[animation_index]->SetRunState(
-              Animation::WAITING_FOR_DELETION, monotonic_time);
+        bool impl_animation =
+            animations_[animation_index]->is_controlling_instance() ||
+            animations_[animation_index]->is_impl_only();
+        if (events && impl_animation) {
+          AnimationEvent finished_event(
+              AnimationEvent::FINISHED, id_,
+              animations_[animation_index]->group(),
+              animations_[animation_index]->target_property(), monotonic_time);
+          finished_event.is_impl_only =
+              animations_[animation_index]->is_impl_only();
+          if (finished_event.is_impl_only)
+            NotifyAnimationFinished(finished_event);
+          else
+            events->push_back(finished_event);
+        }
+        animations_[animation_index]->SetRunState(
+            Animation::WAITING_FOR_DELETION, monotonic_time);
       }
       marked_animations_for_deletions = true;
     }
   }
   if (marked_animations_for_deletions)
     NotifyObserversAnimationWaitingForDeletion();
 }
 
 static bool IsWaitingForDeletion(Animation* animation) {
   return animation->run_state() == Animation::WAITING_FOR_DELETION;
@@ skipping 184 matching lines @@
         &value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != nullptr)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc