Don't PushProperties every commit for animating layers

cc/animation/layer_animation_controller_unittest.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 "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_registrar.h"
@@ skipping 275 matching lines @@
   controller_impl->UpdateState(true, events.get());
 
   // There should be a Started event for the animation.
   EXPECT_EQ(1u, events->size());
   EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);
   controller->NotifyAnimationStarted((*events)[0], 0.0);
 
   controller->Animate(1.0);
   controller->UpdateState(true, NULL);
 
+  EXPECT_FALSE(dummy.animation_waiting_for_deletion());
+  EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
+
   events.reset(new AnimationEventsVector);
   controller_impl->Animate(2.0);
   controller_impl->UpdateState(true, events.get());
 
+  EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
+
   // There should be a Finished event for the animation.
   EXPECT_EQ(1u, events->size());
   EXPECT_EQ(AnimationEvent::Finished, (*events)[0].type);
 
   // Neither controller should have deleted the animation yet.
   EXPECT_TRUE(controller->GetAnimation(Animation::Opacity));
   EXPECT_TRUE(controller_impl->GetAnimation(Animation::Opacity));
 
   controller->NotifyAnimationFinished((*events)[0], 0.0);
 
   controller->Animate(3.0);
   controller->UpdateState(true, NULL);
+  EXPECT_TRUE(dummy.animation_waiting_for_deletion());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   // Both controllers should now have deleted the animation.
   EXPECT_FALSE(controller->has_any_animation());
   EXPECT_FALSE(controller_impl->has_any_animation());
 }
 
 // Tests that transitioning opacity from 0 to 1 works as expected.
 
@@ skipping 811 matching lines @@
   controller->Animate(1.0);
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
   controller->Animate(2.0);
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(!controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 }
 
-TEST(LayerAnimationControllerTest, ForceSyncWhenSynchronizedStartTimeNeeded) {
+TEST(LayerAnimationControllerTest, PushUpdatesWhenSynchronizedStartTimeNeeded) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
       0,
       Animation::Opacity));
   to_add->set_needs_synchronized_start_time(true);
   controller->AddAnimation(to_add.Pass());
 
   controller->Animate(0.0);
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   Animation* active_animation = controller->GetAnimation(0, Animation::Opacity);
   EXPECT_TRUE(active_animation);
   EXPECT_TRUE(active_animation->needs_synchronized_start_time());
 
-  controller->set_force_sync();
-
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   active_animation = controller_impl->GetAnimation(0, Animation::Opacity);
   EXPECT_TRUE(active_animation);
   EXPECT_EQ(Animation::WaitingForTargetAvailability,
             active_animation->run_state());
 }
 
 // Tests that skipping a call to UpdateState works as expected.
 TEST(LayerAnimationControllerTest, SkipUpdateState) {
@@ skipping 249 matching lines @@
 
   AddOpacityTransitionToController(controller.get(), 1.0, 0.f, 1.f, false);
   int group_id = controller->GetAnimation(Animation::Opacity)->group();
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 
   controller->AbortAnimations(Animation::Opacity);
   EXPECT_EQ(Animation::Aborted,
             controller->GetAnimation(Animation::Opacity)->run_state());
+  EXPECT_FALSE(dummy.animation_waiting_for_deletion());
+  EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
   controller->Animate(1.0);
   controller->UpdateState(true, NULL);
+  EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   EXPECT_FALSE(controller->GetAnimation(group_id, Animation::Opacity));
   EXPECT_FALSE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 }
 
 // An animation aborted on the impl thread should get deleted on both threads.
 TEST(LayerAnimationControllerTest, ImplThreadAbortedAnimationGetsDeleted) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   AddOpacityTransitionToController(controller.get(), 1.0, 0.f, 1.f, false);
   int group_id = controller->GetAnimation(Animation::Opacity)->group();
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 
   controller_impl->AbortAnimations(Animation::Opacity);
   EXPECT_EQ(Animation::Aborted,
             controller_impl->GetAnimation(Animation::Opacity)->run_state());
+  EXPECT_FALSE(dummy.animation_waiting_for_deletion());
+  EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
   AnimationEventsVector events;
   controller_impl->Animate(1.0);
   controller_impl->UpdateState(true, &events);
+  EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
   EXPECT_EQ(1u, events.size());
   EXPECT_EQ(AnimationEvent::Aborted, events[0].type);
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller_impl->GetAnimation(Animation::Opacity)->run_state());
 
   controller->NotifyAnimationAborted(events[0]);
   EXPECT_EQ(Animation::Aborted,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
   controller->Animate(1.5);
   controller->UpdateState(true, NULL);
+  EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   EXPECT_FALSE(controller->GetAnimation(group_id, Animation::Opacity));
   EXPECT_FALSE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 }
 
 // Ensure that we only generate Finished events for animations in a group
 // once all animations in that group are finished.
@@ skipping 84 matching lines @@
   // animation, and an Aborted event for the opacity animation.
   EXPECT_EQ(2u, events->size());
   EXPECT_EQ(AnimationEvent::Finished, (*events)[0].type);
   EXPECT_EQ(Animation::Transform, (*events)[0].target_property);
   EXPECT_EQ(AnimationEvent::Aborted, (*events)[1].type);
   EXPECT_EQ(Animation::Opacity, (*events)[1].target_property);
 }
 
 }  // namespace
 }  // namespace cc