cc: Make animations tick regardless of drawing.

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_registrar.h"
@@ skipping 98 matching lines @@
 // thread are kept in sync.
 void LayerAnimationController::PushAnimationUpdatesTo(
     LayerAnimationController* controller_impl) {
   if (force_sync_) {
     ReplaceImplThreadAnimations(controller_impl);
     force_sync_ = false;
   } else {
     PurgeAnimationsMarkedForDeletion();
     PushNewAnimationsToImplThread(controller_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(controller_impl);
+    FinishAnimationsCompletedOnMainThread(controller_impl);

[ajuma, 2013/04/04 15:28:47]

This will also change the way animations that are aborted or removed on the main
thread are handled by the impl thread -- instead of removing them, we'll mark
them as Finished and later send a Finished event. Sending a Finished event for
an aborted animation seems ok (since aborting an animation is a decision made by
LayerAnimationController), but sending a Finished event for an animation that
was explicitly removed by a call to RemoveAnimation seems wrong, particularly
since the animation might not even have started yet.

Also, note that there's an in-progress CL
(https://chromiumcodereview.appspot.com/13465014) to fix the issue with Finished
events using a different approach: not deleting finished animations on the main
thread side until the Finished event is received.

 
     PushPropertiesToImplThread(controller_impl);
   }
   controller_impl->UpdateActivation(NormalActivation);
   UpdateActivation(NormalActivation);
 }
 
 void LayerAnimationController::Animate(double monotonic_time) {
   if (!HasActiveObserver())
     return;
@@ skipping 46 matching lines @@
     return;
 
   PromoteStartedAnimations(last_tick_time_, events);
   MarkFinishedAnimations(last_tick_time_);
   MarkAnimationsForDeletion(last_tick_time_, events);
   StartAnimationsWaitingForTargetAvailability(last_tick_time_);
   PromoteStartedAnimations(last_tick_time_, events);
 
   AccumulatePropertyUpdates(last_tick_time_, events);
 
+  if (events) {
+    // If we have an |events|, then we have sent a finished event to the main
+    // thread in the |events| list. Then the animation serves no purpose to the
+    // compositor anymore, and should be removed.
+    PurgeAnimationsMarkedForDeletion();

[ajuma, 2013/04/04 15:28:47]

This creates a risk of pushing an animation from the main thread to the impl
thread more than once:
1) We push the animation to the impl thread.
2) The animation starts and finishes on the impl thread, sending events back to
the main thread.
3) Before the main thread has a chance to process these events, a commit occurs.
In this case, PushNewAnimationsToImplThread will push the animation to the impl
thread again, and it will run again.

+  }
+
   UpdateActivation(NormalActivation);
 }
 
 void LayerAnimationController::AddAnimation(scoped_ptr<Animation> animation) {
   active_animations_.push_back(animation.Pass());
   UpdateActivation(NormalActivation);
 }
 
 Animation* LayerAnimationController::GetAnimation(
     int group_id,
@@ skipping 109 matching lines @@
       : main_thread_controller_(main_thread_controller) {}
   bool operator()(Animation* animation) const {
     if (animation->is_impl_only())
       return false;
     return !main_thread_controller_.GetAnimation(animation->group(),
                                                  animation->target_property());
   }
 
  private:
   const LayerAnimationController& main_thread_controller_;
 };

[ajuma, 2013/04/04 15:28:47]

With the change below, this struct is now unused. Please remove.

 
-void LayerAnimationController::RemoveAnimationsCompletedOnMainThread(
+void LayerAnimationController::FinishAnimationsCompletedOnMainThread(
     LayerAnimationController* controller_impl) const {
-  // Delete all impl thread animations for which there is no corresponding
-  // main thread animation. Each iteration,
-  // controller->active_animations_.size() is decremented or i is incremented
-  // guaranteeing progress towards loop termination.
-  ScopedPtrVector<Animation>& animations =
-      controller_impl->active_animations_;
-  animations.erase(cc::remove_if(&animations,
-                                 animations.begin(),
-                                 animations.end(),
-                                 IsCompleted(*this)),
-                   animations.end());
+  for (size_t i = 0; i < active_animations_.size(); ++i) {
+    if (active_animations_[i]->is_impl_only())
+      continue;
+    if (!GetAnimation(active_animations_[i]->group(),
+                      active_animations_[i]->target_property()))
+      active_animations_[i]->SetRunState(Animation::Finished, 0);
+  }
 }
 
 void LayerAnimationController::PushPropertiesToImplThread(
     LayerAnimationController* controller_impl) const {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     Animation* current_impl =
         controller_impl->GetAnimation(
             active_animations_[i]->group(),
             active_animations_[i]->target_property());
     if (current_impl)
@@ skipping 274 matching lines @@
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc