cc: Alow animations to be aborted from either thread

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 "cc/animation/animation.h"
 #include "cc/animation/animation_delegate.h"
@@ skipping 74 matching lines @@
   ScopedPtrVector<Animation>& animations = active_animations_;
   animations.erase(cc::remove_if(&animations,
                                  animations.begin(),
                                  animations.end(),
                                  HasAnimationIdAndProperty(animation_id,
                                                            target_property)),
                    animations.end());
   UpdateActivation(NormalActivation);
 }
 
+void LayerAnimationController::AbortAnimations(
+    Animation::TargetProperty target_property) {
+  for (size_t i = 0; i < active_animations_.size(); ++i) {
+    if (active_animations_[i]->target_property() == target_property &&
+        !active_animations_[i]->is_finished())
+      active_animations_[i]->SetRunState(Animation::Aborted, last_tick_time_);
+  }
+}
+
 // Ensures that the list of active animations on the main thread and the impl
 // thread are kept in sync.
 void LayerAnimationController::PushAnimationUpdatesTo(
     LayerAnimationController* controller_impl) {
   DCHECK(this != controller_impl);
   if (force_sync_) {
     ReplaceImplThreadAnimations(controller_impl);
     force_sync_ = false;
   } else {
     PurgeAnimationsMarkedForDeletion();
@@ skipping 204 matching lines @@
         active_animations_[i]->target_property() == event.target_property) {
       active_animations_[i]->set_received_finished_event(true);
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationFinished(wall_clock_time);
 
       return;
     }
   }
 }
 
+void LayerAnimationController::NotifyAnimationAborted(
+    const AnimationEvent& event) {
+  for (size_t i = 0; i < active_animations_.size(); ++i) {
+    if (active_animations_[i]->group() == event.group_id &&
+        active_animations_[i]->target_property() == event.target_property) {
+      active_animations_[i]->SetRunState(Animation::Aborted,
+                                         event.monotonic_time);
+    }
+  }
+}
+
 void LayerAnimationController::NotifyAnimationPropertyUpdate(
     const AnimationEvent& event) {
   switch (event.target_property) {
     case Animation::Opacity:
       NotifyObserversOpacityAnimated(event.opacity);
       break;
     case Animation::Transform:
       NotifyObserversTransformAnimated(event.transform);
       break;
     default:
@@ skipping 209 matching lines @@
         started_event.is_impl_only = active_animations_[i]->is_impl_only();
         events->push_back(started_event);
       }
     }
   }
 }
 
 void LayerAnimationController::MarkFinishedAnimations(double monotonic_time) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->IsFinishedAt(monotonic_time) &&
+        active_animations_[i]->run_state() != Animation::Aborted &&
         active_animations_[i]->run_state() != Animation::WaitingForDeletion)
       active_animations_[i]->SetRunState(Animation::Finished, monotonic_time);
   }
 }
 
 void LayerAnimationController::ResolveConflicts(double monotonic_time) {
   // Find any animations that are animating the same property and resolve the
   // confict. We could eventually blend, but for now we'll just abort the
   // previous animation (where 'previous' means: (1) has a prior start time or
   // (2) has an equal start time, but was added to the queue earlier, i.e.,
@@ skipping 21 matching lines @@
 }
 
 void LayerAnimationController::MarkAnimationsForDeletion(
     double monotonic_time, AnimationEventsVector* events) {
   // Non-aborted animations are marked for deletion after a corresponding
   // AnimationEvent::Finished event is sent or received. This means that if
   // we don't have an events vector, we must ensure that non-aborted animations
   // have received a finished event before marking them for deletion.
   for (size_t i = 0; i < active_animations_.size(); i++) {
     int group_id = active_animations_[i]->group();
+    if (active_animations_[i]->run_state() == Animation::Aborted) {
+      if (events && !active_animations_[i]->is_impl_only()) {
+        AnimationEvent aborted_event(
+            AnimationEvent::Aborted,
+            id_,
+            group_id,
+            active_animations_[i]->target_property(),
+            monotonic_time);
+        events->push_back(aborted_event);
+      }
+      active_animations_[i]->SetRunState(Animation::WaitingForDeletion,
+                                         monotonic_time);
+      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 || active_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 (active_animations_[i]->run_state() == Animation::Aborted ||
-        (active_animations_[i]->run_state() == Animation::Finished &&
-         animation_i_will_send_or_has_received_finish_event)) {
+    if (active_animations_[i]->run_state() == Animation::Finished &&
+        animation_i_will_send_or_has_received_finish_event) {
       all_anims_with_same_id_are_finished = true;
       for (size_t j = 0; j < active_animations_.size(); ++j) {
         bool animation_j_will_send_or_has_received_finish_event =
             events || active_animations_[j]->received_finished_event();
         if (group_id == active_animations_[j]->group() &&
             (!active_animations_[j]->is_finished() ||
              (active_animations_[j]->run_state() == Animation::Finished &&
               !animation_j_will_send_or_has_received_finish_event))) {
           all_anims_with_same_id_are_finished = false;
           break;
         }
       }
     }
     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 = i; j < active_animations_.size(); j++) {
-        if (group_id == active_animations_[j]->group()) {
+        if (active_animations_[j]->group() == group_id &&
+            active_animations_[j]->run_state() != Animation::Aborted) {
           if (events) {
             AnimationEvent finished_event(
                 AnimationEvent::Finished,
                 id_,
                 active_animations_[j]->group(),
                 active_animations_[j]->target_property(),
                 monotonic_time);
             finished_event.is_impl_only = active_animations_[j]->is_impl_only();
             events->push_back(finished_event);
           }
@@ skipping 133 matching lines @@
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc