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) {

[ajuma, 2015/06/16 13:51:53]

This will prevent Finished events from being produced on the main thread, but
Start events will still get produced (and need to be, since the property tree
rebuild logic from the other CL depends on this). This seems asymmetric. Would
it make sense to continue to produce Finished events on the main thread?

+          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