Don't PushProperties every commit for animating layers

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"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_value_observer.h"
 #include "cc/base/scoped_ptr_algorithm.h"
 #include "cc/output/filter_operations.h"
 #include "ui/gfx/box_f.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 LayerAnimationController::LayerAnimationController(int id)
-    : force_sync_(false),
-      registrar_(0),
+    : registrar_(0),
       id_(id),
       is_active_(false),
       last_tick_time_(0),
       layer_animation_delegate_(NULL) {}
 
 LayerAnimationController::~LayerAnimationController() {
   if (registrar_)
     registrar_->UnregisterAnimationController(this);
 }
 
@@ skipping 65 matching lines @@
         !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();
-    PushNewAnimationsToImplThread(controller_impl);
+  if (!has_any_animation() && !controller_impl->has_any_animation())
+    return;
+  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);
+  // 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);
 
-    PushPropertiesToImplThread(controller_impl);
-  }
+  PushPropertiesToImplThread(controller_impl);
   controller_impl->UpdateActivation(NormalActivation);
   UpdateActivation(NormalActivation);
 }
 
 void LayerAnimationController::Animate(double monotonic_time) {
   if (!HasValueObserver())
     return;
 
   StartAnimationsWaitingForNextTick(monotonic_time);
   StartAnimationsWaitingForStartTime(monotonic_time);
@@ skipping 461 matching lines @@
                                                monotonic_time);
           }
         }
       }
     }
   }
 }
 
 void LayerAnimationController::MarkAnimationsForDeletion(
     double monotonic_time, AnimationEventsVector* events) {
+  bool marked_animations_for_deletions = false;
+
   // 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);
+      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 || active_animations_[i]->received_finished_event();
@@ skipping 28 matching lines @@
                 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);
           }
           active_animations_[j]->SetRunState(Animation::WaitingForDeletion,
                                              monotonic_time);
         }
       }
+      marked_animations_for_deletions = true;
     }
   }
+  if (marked_animations_for_deletions)
+    NotifyObserversAnimationWaitingForDeletion();
 }
 
 static bool IsWaitingForDeletion(Animation* animation) {
   return animation->run_state() == Animation::WaitingForDeletion;
 }
 
 void LayerAnimationController::PurgeAnimationsMarkedForDeletion() {
   ScopedPtrVector<Animation>& animations = active_animations_;
   animations.erase(cc::remove_if(&animations,
                                  animations.begin(),
                                  animations.end(),
                                  IsWaitingForDeletion),
                    animations.end());
 }
 
-void LayerAnimationController::ReplaceImplThreadAnimations(
-    LayerAnimationController* controller_impl) const {
-  controller_impl->active_animations_.clear();
-  for (size_t i = 0; i < active_animations_.size(); ++i) {
-    scoped_ptr<Animation> to_add;
-    if (active_animations_[i]->needs_synchronized_start_time()) {
-      // We haven't received an animation started notification yet, so it
-      // is important that we add it in a 'waiting' and not 'running' state.
-      Animation::RunState initial_run_state =
-          Animation::WaitingForTargetAvailability;
-      double start_time = 0;
-      to_add = active_animations_[i]->CloneAndInitialize(
-          initial_run_state, start_time).Pass();
-    } else {
-      to_add = active_animations_[i]->Clone().Pass();
-    }
-
-    controller_impl->AddAnimation(to_add.Pass());
-  }
-}
-
 void LayerAnimationController::TickAnimations(double monotonic_time) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->run_state() == Animation::Starting ||
         active_animations_[i]->run_state() == Animation::Running ||
         active_animations_[i]->run_state() == Animation::Paused) {
       double trimmed =
           active_animations_[i]->TrimTimeToCurrentIteration(monotonic_time);
 
       switch (active_animations_[i]->target_property()) {
         case Animation::Transform: {
@@ skipping 67 matching lines @@
                     OnTransformAnimated(transform));
 }
 
 void LayerAnimationController::NotifyObserversFilterAnimated(
     const FilterOperations& filters) {
   FOR_EACH_OBSERVER(LayerAnimationValueObserver,
                     value_observers_,
                     OnFilterAnimated(filters));
 }
 
+void LayerAnimationController::NotifyObserversAnimationWaitingForDeletion() {
+  FOR_EACH_OBSERVER(LayerAnimationValueObserver,
+                    value_observers_,
+                    OnAnimationWaitingForDeletion());
+}
+
 bool LayerAnimationController::HasValueObserver() {
   if (value_observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(
         value_observers_);
     return it.GetNext() != NULL;
   }
   return false;
 }
 
 bool LayerAnimationController::HasActiveValueObserver() {
   if (value_observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc