Allow animations with inactive observers to reach the Starting state

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/keyframed_animation_curve.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 1075 matching lines @@
   EXPECT_EQ(0.f, dummy.opacity());
 
   controller->Animate(3.0);
   controller->UpdateState(true, events.get());
 
   // The float tranisition should now be done.
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
+// Tests that an animation controller with only an inactive observer gets ticked
+// but doesn't progress animations past the Starting state.
+TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
+  scoped_ptr<AnimationEventsVector> events(
+      make_scoped_ptr(new AnimationEventsVector));
+  FakeLayerAnimationValueObserver dummy;
+  FakeInactiveLayerAnimationValueObserver inactive_dummy;
+  scoped_refptr<LayerAnimationController> controller(
+      LayerAnimationController::Create(0));
+
+  const int id = 1;
+  controller->AddAnimation(CreateAnimation(scoped_ptr<AnimationCurve>(
+      new FakeFloatTransition(1.0, 0.5f, 1.f)).Pass(),
+      id,
+      Animation::Opacity));
+
+  // Without an observer, the animation shouldn't progress to the Starting
+  // state.
+  controller->Animate(0.0);
+  controller->UpdateState(true, events.get());
+  EXPECT_EQ(0u, events->size());
+  EXPECT_EQ(Animation::WaitingForTargetAvailability,
+            controller->GetAnimation(id, Animation::Opacity)->run_state());
+
+  controller->AddValueObserver(&inactive_dummy);
+
+  // With only an inactive observer, the animation should progress to the
+  // Starting state and get ticked at its starting point, but should not
+  // progress to Running.
+  controller->Animate(1.0);
+  controller->UpdateState(true, events.get());
+  EXPECT_EQ(0u, events->size());
+  EXPECT_EQ(Animation::Starting,
+            controller->GetAnimation(id, Animation::Opacity)->run_state());
+  EXPECT_EQ(0.5f, inactive_dummy.opacity());
+
+  // Even when already in the Starting state, the animation should stay
+  // there, and shouldn't be ticked past its starting point.
+  controller->Animate(2.0);
+  controller->UpdateState(true, events.get());
+  EXPECT_EQ(0u, events->size());
+  EXPECT_EQ(Animation::Starting,
+            controller->GetAnimation(id, Animation::Opacity)->run_state());
+  EXPECT_EQ(0.5f, inactive_dummy.opacity());
+
+  controller->AddValueObserver(&dummy);
+
+  // Now that an active observer has been added, the animation should still
+  // initially tick at its starting point, but should now progress to Running.
+  controller->Animate(3.0);
+  controller->UpdateState(true, events.get());
+  EXPECT_EQ(1u, events->size());
+  EXPECT_EQ(Animation::Running,
+            controller->GetAnimation(id, Animation::Opacity)->run_state());
+  EXPECT_EQ(0.5f, inactive_dummy.opacity());
+  EXPECT_EQ(0.5f, dummy.opacity());
+
+  // The animation should now tick past its starting point.
+  controller->Animate(3.5);
+  EXPECT_NE(0.5f, inactive_dummy.opacity());
+  EXPECT_NE(0.5f, dummy.opacity());
+}
+
 }  // namespace
 }  // namespace cc