cc/animation/layer_animation_controller_unittest.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/animation/layer_animation_controller.h"
   6
   7 #include "cc/animation/animation.h"
   8 #include "cc/animation/animation_curve.h"
   9 #include "cc/animation/keyframed_animation_curve.h"
  10 #include "cc/animation/transform_operations.h"
  11 #include "cc/test/animation_test_common.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/WebKit/public/platform/WebAnimationDelegate.h"
  15 #include "ui/gfx/transform.h"
  16
  17 namespace cc {
  18 namespace {
  19
  20 void ExpectTranslateX(double translate_x, const gfx::Transform& matrix) {
  21   EXPECT_FLOAT_EQ(translate_x, matrix.matrix().getDouble(0, 3)); }
  22
  23 scoped_ptr<Animation> CreateAnimation(scoped_ptr<AnimationCurve> curve,
  24                                       int id,
  25                                       Animation::TargetProperty property) {
  26   return Animation::Create(curve.Pass(), 0, id, property);
  27 }
  28
  29 TEST(LayerAnimationControllerTest, SyncNewAnimation) {
  30   FakeLayerAnimationValueObserver dummy_impl;
  31   scoped_refptr<LayerAnimationController> controller_impl(
  32       LayerAnimationController::Create(0));
  33   controller_impl->AddValueObserver(&dummy_impl);
  34   FakeLayerAnimationValueObserver dummy;
  35   scoped_refptr<LayerAnimationController> controller(
  36       LayerAnimationController::Create(0));
  37   controller->AddValueObserver(&dummy);
  38
  39   EXPECT_FALSE(controller_impl->GetAnimation(Animation::Opacity));
  40
  41   AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
  42   int group_id = controller->GetAnimation(Animation::Opacity)->group();
  43
  44   controller->PushAnimationUpdatesTo(controller_impl.get());
  45
  46   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity));
  47   EXPECT_EQ(Animation::WaitingForTargetAvailability,
  48             controller_impl->GetAnimation(group_id,
  49                                           Animation::Opacity)->run_state());
  50 }
  51
  52 // If an animation is started on the impl thread before it is ticked on the main
  53 // thread, we must be sure to respect the synchronized start time.
  54 TEST(LayerAnimationControllerTest, DoNotClobberStartTimes) {
  55   FakeLayerAnimationValueObserver dummy_impl;
  56   scoped_refptr<LayerAnimationController> controller_impl(
  57       LayerAnimationController::Create(0));
  58   controller_impl->AddValueObserver(&dummy_impl);
  59   FakeLayerAnimationValueObserver dummy;
  60   scoped_refptr<LayerAnimationController> controller(
  61       LayerAnimationController::Create(0));
  62   controller->AddValueObserver(&dummy);
  63
  64   EXPECT_FALSE(controller_impl->GetAnimation(Animation::Opacity));
  65
  66   AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
  67   int group_id = controller->GetAnimation(Animation::Opacity)->group();
  68
  69   controller->PushAnimationUpdatesTo(controller_impl.get());
  70
  71   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity));
  72   EXPECT_EQ(Animation::WaitingForTargetAvailability,
  73             controller_impl->GetAnimation(group_id,
  74                                           Animation::Opacity)->run_state());
  75
  76   AnimationEventsVector events;
  77   controller_impl->Animate(1.0);
  78   controller_impl->UpdateState(true, &events);
  79
  80   // Synchronize the start times.
  81   EXPECT_EQ(1u, events.size());
  82   controller->NotifyAnimationStarted(events[0], 0.0);
  83   EXPECT_EQ(controller->GetAnimation(group_id,
  84                                      Animation::Opacity)->start_time(),
  85             controller_impl->GetAnimation(group_id,
  86                                           Animation::Opacity)->start_time());
  87
  88   // Start the animation on the main thread. Should not affect the start time.
  89   controller->Animate(1.5);
  90   controller->UpdateState(true, NULL);
  91   EXPECT_EQ(controller->GetAnimation(group_id,
  92                                      Animation::Opacity)->start_time(),
  93             controller_impl->GetAnimation(group_id,
  94                                           Animation::Opacity)->start_time());
  95 }
  96
  97 TEST(LayerAnimationControllerTest, SyncPauseAndResume) {
  98   FakeLayerAnimationValueObserver dummy_impl;
  99   scoped_refptr<LayerAnimationController> controller_impl(
 100       LayerAnimationController::Create(0));
 101   controller_impl->AddValueObserver(&dummy_impl);
 102   FakeLayerAnimationValueObserver dummy;
 103   scoped_refptr<LayerAnimationController> controller(
 104       LayerAnimationController::Create(0));
 105   controller->AddValueObserver(&dummy);
 106
 107   EXPECT_FALSE(controller_impl->GetAnimation(Animation::Opacity));
 108
 109   AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
 110   int group_id = controller->GetAnimation(Animation::Opacity)->group();
 111
 112   controller->PushAnimationUpdatesTo(controller_impl.get());
 113
 114   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 115   EXPECT_EQ(Animation::WaitingForTargetAvailability,
 116             controller_impl->GetAnimation(group_id,
 117                                           Animation::Opacity)->run_state());
 118
 119   // Start the animations on each controller.
 120   AnimationEventsVector events;
 121   controller_impl->Animate(0.0);
 122   controller_impl->UpdateState(true, &events);
 123   controller->Animate(0.0);
 124   controller->UpdateState(true, NULL);
 125   EXPECT_EQ(Animation::Running,
 126             controller_impl->GetAnimation(group_id,
 127                                           Animation::Opacity)->run_state());
 128   EXPECT_EQ(Animation::Running,
 129             controller->GetAnimation(group_id,
 130                                      Animation::Opacity)->run_state());
 131
 132   // Pause the main-thread animation.
 133   controller->SuspendAnimations(1.0);
 134   EXPECT_EQ(Animation::Paused,
 135             controller->GetAnimation(group_id,
 136                                      Animation::Opacity)->run_state());
 137
 138   // The pause run state change should make it to the impl thread controller.
 139   controller->PushAnimationUpdatesTo(controller_impl.get());
 140   EXPECT_EQ(Animation::Paused,
 141             controller_impl->GetAnimation(group_id,
 142                                           Animation::Opacity)->run_state());
 143
 144   // Resume the main-thread animation.
 145   controller->ResumeAnimations(2.0);
 146   EXPECT_EQ(Animation::Running,
 147             controller->GetAnimation(group_id,
 148                                      Animation::Opacity)->run_state());
 149
 150   // The pause run state change should make it to the impl thread controller.
 151   controller->PushAnimationUpdatesTo(controller_impl.get());
 152   EXPECT_EQ(Animation::Running,
 153             controller_impl->GetAnimation(group_id,
 154                                           Animation::Opacity)->run_state());
 155 }
 156
 157 TEST(LayerAnimationControllerTest, DoNotSyncFinishedAnimation) {
 158   FakeLayerAnimationValueObserver dummy_impl;
 159   scoped_refptr<LayerAnimationController> controller_impl(
 160       LayerAnimationController::Create(0));
 161   controller_impl->AddValueObserver(&dummy_impl);
 162   FakeLayerAnimationValueObserver dummy;
 163   scoped_refptr<LayerAnimationController> controller(
 164       LayerAnimationController::Create(0));
 165   controller->AddValueObserver(&dummy);
 166
 167   EXPECT_FALSE(controller_impl->GetAnimation(Animation::Opacity));
 168
 169   int animation_id =
 170       AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
 171   int group_id = controller->GetAnimation(Animation::Opacity)->group();
 172
 173   controller->PushAnimationUpdatesTo(controller_impl.get());
 174
 175   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 176   EXPECT_EQ(Animation::WaitingForTargetAvailability,
 177             controller_impl->GetAnimation(group_id,
 178                                           Animation::Opacity)->run_state());
 179
 180   // Notify main thread controller that the animation has started.
 181   AnimationEvent animation_started_event(
 182       AnimationEvent::Started, 0, group_id, Animation::Opacity, 0);
 183   controller->NotifyAnimationStarted(animation_started_event, 0.0);
 184
 185   // Force animation to complete on impl thread.
 186   controller_impl->RemoveAnimation(animation_id);
 187
 188   EXPECT_FALSE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 189
 190   controller->PushAnimationUpdatesTo(controller_impl.get());
 191
 192   // Even though the main thread has a 'new' animation, it should not be pushed
 193   // because the animation has already completed on the impl thread.
 194   EXPECT_FALSE(controller_impl->GetAnimation(group_id, Animation::Opacity));
 195 }
 196
 197 // Ensure that a finished animation is eventually deleted by both the
 198 // main-thread and the impl-thread controllers.
 199 TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
 200   FakeLayerAnimationValueObserver dummy;
 201   FakeLayerAnimationValueObserver dummy_impl;
 202   scoped_ptr<AnimationEventsVector> events(
 203       make_scoped_ptr(new AnimationEventsVector));
 204   scoped_refptr<LayerAnimationController> controller(
 205       LayerAnimationController::Create(0));
 206   scoped_refptr<LayerAnimationController> controller_impl(
 207       LayerAnimationController::Create(0));
 208   controller->AddValueObserver(&dummy);
 209   controller_impl->AddValueObserver(&dummy_impl);
 210
 211   AddOpacityTransitionToController(controller.get(), 1.0, 0.0f, 1.0f, false);
 212   controller->Animate(0.0);
 213   controller->UpdateState(true, NULL);
 214   controller->PushAnimationUpdatesTo(controller_impl.get());
 215
 216   controller_impl->Animate(0.5);
 217   controller_impl->UpdateState(true, events.get());
 218
 219   // There should be a Started event for the animation.
 220   EXPECT_EQ(1u, events->size());
 221   EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);
 222   controller->NotifyAnimationStarted((*events)[0], 0.0);
 223
 224   controller->Animate(1.0);
 225   controller->UpdateState(true, NULL);
 226
 227   events.reset(new AnimationEventsVector);
 228   controller_impl->Animate(2.0);
 229   controller_impl->UpdateState(true, events.get());
 230
 231   // There should be a Finished event for the animation.
 232   EXPECT_EQ(1u, events->size());
 233   EXPECT_EQ(AnimationEvent::Finished, (*events)[0].type);
 234
 235   // Neither controller should have deleted the animation yet.
 236   EXPECT_TRUE(controller->GetAnimation(Animation::Opacity));
 237   EXPECT_TRUE(controller_impl->GetAnimation(Animation::Opacity));
 238
 239   controller->NotifyAnimationFinished((*events)[0], 0.0);
 240
 241   controller->Animate(3.0);
 242   controller->UpdateState(true, NULL);
 243
 244   controller->PushAnimationUpdatesTo(controller_impl.get());
 245
 246   // Both controllers should now have deleted the animation.
 247   EXPECT_FALSE(controller->has_any_animation());
 248   EXPECT_FALSE(controller_impl->has_any_animation());
 249 }
 250
 251 // Tests that transitioning opacity from 0 to 1 works as expected.
 252
 253 static const AnimationEvent* GetMostRecentPropertyUpdateEvent(
 254     const AnimationEventsVector* events) {
 255   const AnimationEvent* event = 0;
 256   for (size_t i = 0; i < events->size(); ++i)
 257     if ((*events)[i].type == AnimationEvent::PropertyUpdate)
 258       event = &(*events)[i];
 259
 260   return event;
 261 }
 262
 263 TEST(LayerAnimationControllerTest, TrivialTransition) {
 264   scoped_ptr<AnimationEventsVector> events(
 265       make_scoped_ptr(new AnimationEventsVector));
 266   FakeLayerAnimationValueObserver dummy;
 267   scoped_refptr<LayerAnimationController> controller(
 268       LayerAnimationController::Create(0));
 269   controller->AddValueObserver(&dummy);
 270
 271   scoped_ptr<Animation> to_add(CreateAnimation(
 272       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 273       1,
 274       Animation::Opacity));
 275
 276   controller->AddAnimation(to_add.Pass());
 277   controller->Animate(0.0);
 278   controller->UpdateState(true, events.get());
 279   EXPECT_TRUE(controller->HasActiveAnimation());
 280   EXPECT_EQ(0.f, dummy.opacity());
 281   // A non-impl-only animation should not generate property updates.
 282   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
 283   EXPECT_FALSE(event);
 284   controller->Animate(1.0);
 285   controller->UpdateState(true, events.get());
 286   EXPECT_EQ(1.f, dummy.opacity());
 287   EXPECT_FALSE(controller->HasActiveAnimation());
 288   event = GetMostRecentPropertyUpdateEvent(events.get());
 289   EXPECT_FALSE(event);
 290 }
 291
 292 TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {
 293   scoped_ptr<AnimationEventsVector> events(
 294       make_scoped_ptr(new AnimationEventsVector));
 295   FakeLayerAnimationValueObserver dummy_impl;
 296   scoped_refptr<LayerAnimationController> controller_impl(
 297       LayerAnimationController::Create(0));
 298   controller_impl->AddValueObserver(&dummy_impl);
 299
 300   scoped_ptr<Animation> to_add(CreateAnimation(
 301       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 302       1,
 303       Animation::Opacity));
 304   to_add->set_is_impl_only(true);
 305
 306   controller_impl->AddAnimation(to_add.Pass());
 307   controller_impl->Animate(0.0);
 308   controller_impl->UpdateState(true, events.get());
 309   EXPECT_TRUE(controller_impl->HasActiveAnimation());
 310   EXPECT_EQ(0.f, dummy_impl.opacity());
 311   EXPECT_EQ(2u, events->size());
 312   const AnimationEvent* start_opacity_event =
 313       GetMostRecentPropertyUpdateEvent(events.get());
 314   EXPECT_EQ(0.f, start_opacity_event->opacity);
 315
 316   controller_impl->Animate(1.0);
 317   controller_impl->UpdateState(true, events.get());
 318   EXPECT_EQ(1.f, dummy_impl.opacity());
 319   EXPECT_FALSE(controller_impl->HasActiveAnimation());
 320   EXPECT_EQ(4u, events->size());
 321   const AnimationEvent* end_opacity_event =
 322       GetMostRecentPropertyUpdateEvent(events.get());
 323   EXPECT_EQ(1.f, end_opacity_event->opacity);
 324 }
 325
 326 TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
 327   scoped_ptr<AnimationEventsVector> events(
 328       make_scoped_ptr(new AnimationEventsVector));
 329   FakeLayerAnimationValueObserver dummy_impl;
 330   scoped_refptr<LayerAnimationController> controller_impl(
 331       LayerAnimationController::Create(0));
 332   controller_impl->AddValueObserver(&dummy_impl);
 333
 334   // Choose different values for x and y to avoid coincidental values in the
 335   // observed transforms.
 336   const float delta_x = 3;
 337   const float delta_y = 4;
 338
 339   scoped_ptr<KeyframedTransformAnimationCurve> curve(
 340       KeyframedTransformAnimationCurve::Create());
 341
 342   // Create simple Transform animation.
 343   TransformOperations operations;
 344   curve->AddKeyframe(TransformKeyframe::Create(
 345       0, operations, scoped_ptr<cc::TimingFunction>()));
 346   operations.AppendTranslate(delta_x, delta_y, 0);
 347   curve->AddKeyframe(TransformKeyframe::Create(
 348       1, operations, scoped_ptr<cc::TimingFunction>()));
 349
 350   scoped_ptr<Animation> animation(Animation::Create(
 351       curve.PassAs<AnimationCurve>(), 1, 0, Animation::Transform));
 352   animation->set_is_impl_only(true);
 353   controller_impl->AddAnimation(animation.Pass());
 354
 355   // Run animation.
 356   controller_impl->Animate(0.0);
 357   controller_impl->UpdateState(true, events.get());
 358   EXPECT_TRUE(controller_impl->HasActiveAnimation());
 359   EXPECT_EQ(gfx::Transform(), dummy_impl.transform());
 360   EXPECT_EQ(2u, events->size());
 361   const AnimationEvent* start_transform_event =
 362       GetMostRecentPropertyUpdateEvent(events.get());
 363   ASSERT_TRUE(start_transform_event);
 364   EXPECT_EQ(gfx::Transform(), start_transform_event->transform);
 365   EXPECT_TRUE(start_transform_event->is_impl_only);
 366
 367   gfx::Transform expected_transform;
 368   expected_transform.Translate(delta_x, delta_y);
 369
 370   controller_impl->Animate(1.0);
 371   controller_impl->UpdateState(true, events.get());
 372   EXPECT_EQ(expected_transform, dummy_impl.transform());
 373   EXPECT_FALSE(controller_impl->HasActiveAnimation());
 374   EXPECT_EQ(4u, events->size());
 375   const AnimationEvent* end_transform_event =
 376       GetMostRecentPropertyUpdateEvent(events.get());
 377   EXPECT_EQ(expected_transform, end_transform_event->transform);
 378   EXPECT_TRUE(end_transform_event->is_impl_only);
 379 }
 380
 381 class FakeWebAnimationDelegate : public WebKit::WebAnimationDelegate {
 382  public:
 383   FakeWebAnimationDelegate()
 384       : started_(false),
 385         finished_(false) {}
 386
 387   virtual void notifyAnimationStarted(double time) OVERRIDE {
 388     started_ = true;
 389   }
 390
 391   virtual void notifyAnimationFinished(double time) OVERRIDE {
 392     finished_ = true;
 393   }
 394
 395   bool started() { return started_; }
 396
 397   bool finished() { return finished_; }
 398
 399  private:
 400   bool started_;
 401   bool finished_;
 402 };
 403
 404 // Tests that impl-only animations lead to start and finished notifications
 405 // being sent to the main thread controller's animation delegate.
 406 TEST(LayerAnimationControllerTest,
 407      NotificationsForImplOnlyAnimationsAreSentToMainThreadDelegate) {
 408   FakeLayerAnimationValueObserver dummy_impl;
 409   scoped_refptr<LayerAnimationController> controller_impl(
 410       LayerAnimationController::Create(0));
 411   controller_impl->AddValueObserver(&dummy_impl);
 412   scoped_ptr<AnimationEventsVector> events(
 413       make_scoped_ptr(new AnimationEventsVector));
 414   FakeLayerAnimationValueObserver dummy;
 415   scoped_refptr<LayerAnimationController> controller(
 416       LayerAnimationController::Create(0));
 417   controller->AddValueObserver(&dummy);
 418   FakeWebAnimationDelegate delegate;
 419   controller->set_layer_animation_delegate(&delegate);
 420
 421   scoped_ptr<Animation> to_add(CreateAnimation(
 422       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 423       1,
 424       Animation::Opacity));
 425   to_add->set_is_impl_only(true);
 426   controller_impl->AddAnimation(to_add.Pass());
 427
 428   controller_impl->Animate(0.0);
 429   controller_impl->UpdateState(true, events.get());
 430
 431   // We should receive 2 events (a started notification and a property update).
 432   EXPECT_EQ(2u, events->size());
 433   EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);
 434   EXPECT_TRUE((*events)[0].is_impl_only);
 435   EXPECT_EQ(AnimationEvent::PropertyUpdate, (*events)[1].type);
 436   EXPECT_TRUE((*events)[1].is_impl_only);
 437
 438   // Passing on the start event to the main thread controller should cause the
 439   // delegate to get notified.
 440   EXPECT_FALSE(delegate.started());
 441   controller->NotifyAnimationStarted((*events)[0], 0.0);
 442   EXPECT_TRUE(delegate.started());
 443
 444   events.reset(new AnimationEventsVector);
 445   controller_impl->Animate(1.0);
 446   controller_impl->UpdateState(true, events.get());
 447
 448   // We should receive 2 events (a finished notification and a property update).
 449   EXPECT_EQ(2u, events->size());
 450   EXPECT_EQ(AnimationEvent::Finished, (*events)[0].type);
 451   EXPECT_TRUE((*events)[0].is_impl_only);
 452   EXPECT_EQ(AnimationEvent::PropertyUpdate, (*events)[1].type);
 453   EXPECT_TRUE((*events)[1].is_impl_only);
 454
 455   // Passing on the finished event to the main thread controller should cause
 456   // the delegate to get notified.
 457   EXPECT_FALSE(delegate.finished());
 458   controller->NotifyAnimationFinished((*events)[0], 0.0);
 459   EXPECT_TRUE(delegate.finished());
 460 }
 461
 462 // Tests animations that are waiting for a synchronized start time do not
 463 // finish.
 464 TEST(LayerAnimationControllerTest,
 465      AnimationsWaitingForStartTimeDoNotFinishIfTheyOutwaitTheirFinish) {
 466   scoped_ptr<AnimationEventsVector> events(
 467       make_scoped_ptr(new AnimationEventsVector));
 468   FakeLayerAnimationValueObserver dummy;
 469   scoped_refptr<LayerAnimationController> controller(
 470       LayerAnimationController::Create(0));
 471   controller->AddValueObserver(&dummy);
 472
 473   scoped_ptr<Animation> to_add(CreateAnimation(
 474       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 475       1,
 476       Animation::Opacity));
 477   to_add->set_needs_synchronized_start_time(true);
 478
 479   // We should pause at the first keyframe indefinitely waiting for that
 480   // animation to start.
 481   controller->AddAnimation(to_add.Pass());
 482   controller->Animate(0.0);
 483   controller->UpdateState(true, events.get());
 484   EXPECT_TRUE(controller->HasActiveAnimation());
 485   EXPECT_EQ(0.f, dummy.opacity());
 486   controller->Animate(1.0);
 487   controller->UpdateState(true, events.get());
 488   EXPECT_TRUE(controller->HasActiveAnimation());
 489   EXPECT_EQ(0.f, dummy.opacity());
 490   controller->Animate(2.0);
 491   controller->UpdateState(true, events.get());
 492   EXPECT_TRUE(controller->HasActiveAnimation());
 493   EXPECT_EQ(0.f, dummy.opacity());
 494
 495   // Send the synchronized start time.
 496   controller->NotifyAnimationStarted(
 497       AnimationEvent(AnimationEvent::Started, 0, 1, Animation::Opacity, 2),
 498       0.0);
 499   controller->Animate(5.0);
 500   controller->UpdateState(true, events.get());
 501   EXPECT_EQ(1.f, dummy.opacity());
 502   EXPECT_FALSE(controller->HasActiveAnimation());
 503 }
 504
 505 // Tests that two queued animations affecting the same property run in sequence.
 506 TEST(LayerAnimationControllerTest, TrivialQueuing) {
 507   scoped_ptr<AnimationEventsVector> events(
 508       make_scoped_ptr(new AnimationEventsVector));
 509   FakeLayerAnimationValueObserver dummy;
 510   scoped_refptr<LayerAnimationController> controller(
 511       LayerAnimationController::Create(0));
 512   controller->AddValueObserver(&dummy);
 513
 514   controller->AddAnimation(CreateAnimation(
 515       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 516       1,
 517       Animation::Opacity));
 518   controller->AddAnimation(CreateAnimation(
 519       scoped_ptr<AnimationCurve>(
 520           new FakeFloatTransition(1.0, 1.f, 0.5f)).Pass(),
 521       2,
 522       Animation::Opacity));
 523
 524   controller->Animate(0.0);
 525   controller->UpdateState(true, events.get());
 526   EXPECT_TRUE(controller->HasActiveAnimation());
 527   EXPECT_EQ(0.f, dummy.opacity());
 528   controller->Animate(1.0);
 529   controller->UpdateState(true, events.get());
 530   EXPECT_TRUE(controller->HasActiveAnimation());
 531   EXPECT_EQ(1.f, dummy.opacity());
 532   controller->Animate(2.0);
 533   controller->UpdateState(true, events.get());
 534   EXPECT_EQ(0.5f, dummy.opacity());
 535   EXPECT_FALSE(controller->HasActiveAnimation());
 536 }
 537
 538 // Tests interrupting a transition with another transition.
 539 TEST(LayerAnimationControllerTest, Interrupt) {
 540   scoped_ptr<AnimationEventsVector> events(
 541       make_scoped_ptr(new AnimationEventsVector));
 542   FakeLayerAnimationValueObserver dummy;
 543   scoped_refptr<LayerAnimationController> controller(
 544       LayerAnimationController::Create(0));
 545   controller->AddValueObserver(&dummy);
 546   controller->AddAnimation(CreateAnimation(
 547       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 548       1,
 549       Animation::Opacity));
 550   controller->Animate(0.0);
 551   controller->UpdateState(true, events.get());
 552   EXPECT_TRUE(controller->HasActiveAnimation());
 553   EXPECT_EQ(0.f, dummy.opacity());
 554
 555   scoped_ptr<Animation> to_add(CreateAnimation(
 556       scoped_ptr<AnimationCurve>(
 557           new FakeFloatTransition(1.0, 1.f, 0.5f)).Pass(),
 558       2,
 559       Animation::Opacity));
 560   to_add->SetRunState(Animation::WaitingForNextTick, 0);
 561   controller->AddAnimation(to_add.Pass());
 562
 563   // Since the animation was in the WaitingForNextTick state, it should start
 564   // right in this call to animate.
 565   controller->Animate(0.5);
 566   controller->UpdateState(true, events.get());
 567   EXPECT_TRUE(controller->HasActiveAnimation());
 568   EXPECT_EQ(1.f, dummy.opacity());
 569   controller->Animate(1.5);
 570   controller->UpdateState(true, events.get());
 571   EXPECT_EQ(0.5f, dummy.opacity());
 572   EXPECT_FALSE(controller->HasActiveAnimation());
 573 }
 574
 575 // Tests scheduling two animations to run together when only one property is
 576 // free.
 577 TEST(LayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) {
 578   scoped_ptr<AnimationEventsVector> events(
 579       make_scoped_ptr(new AnimationEventsVector));
 580   FakeLayerAnimationValueObserver dummy;
 581   scoped_refptr<LayerAnimationController> controller(
 582       LayerAnimationController::Create(0));
 583   controller->AddValueObserver(&dummy);
 584
 585   controller->AddAnimation(CreateAnimation(
 586       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)).Pass(),
 587       1,
 588       Animation::Transform));
 589   controller->AddAnimation(CreateAnimation(
 590       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)).Pass(),
 591       2,
 592       Animation::Transform));
 593   controller->AddAnimation(CreateAnimation(
 594       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 595       2,
 596       Animation::Opacity));
 597
 598   controller->Animate(0.0);
 599   controller->UpdateState(true, events.get());
 600   EXPECT_EQ(0.f, dummy.opacity());
 601   EXPECT_TRUE(controller->HasActiveAnimation());
 602   controller->Animate(1.0);
 603   controller->UpdateState(true, events.get());
 604   // Should not have started the float transition yet.
 605   EXPECT_TRUE(controller->HasActiveAnimation());
 606   EXPECT_EQ(0.f, dummy.opacity());
 607   // The float animation should have started at time 1 and should be done.
 608   controller->Animate(2.0);
 609   controller->UpdateState(true, events.get());
 610   EXPECT_EQ(1.f, dummy.opacity());
 611   EXPECT_FALSE(controller->HasActiveAnimation());
 612 }
 613
 614 // Tests scheduling two animations to run together with different lengths and
 615 // another animation queued to start when the shorter animation finishes (should
 616 // wait for both to finish).
 617 TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {
 618   scoped_ptr<AnimationEventsVector> events(
 619       make_scoped_ptr(new AnimationEventsVector));
 620   FakeLayerAnimationValueObserver dummy;
 621   scoped_refptr<LayerAnimationController> controller(
 622       LayerAnimationController::Create(0));
 623   controller->AddValueObserver(&dummy);
 624
 625   controller->AddAnimation(CreateAnimation(
 626       scoped_ptr<AnimationCurve>(new FakeTransformTransition(2)).Pass(),
 627       1,
 628       Animation::Transform));
 629   controller->AddAnimation(CreateAnimation(
 630       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 631       1,
 632       Animation::Opacity));
 633   controller->AddAnimation(CreateAnimation(
 634       scoped_ptr<AnimationCurve>(
 635           new FakeFloatTransition(1.0, 1.f, 0.5f)).Pass(),
 636       2,
 637       Animation::Opacity));
 638
 639   // Animations with id 1 should both start now.
 640   controller->Animate(0.0);
 641   controller->UpdateState(true, events.get());
 642   EXPECT_TRUE(controller->HasActiveAnimation());
 643   EXPECT_EQ(0.f, dummy.opacity());
 644   // The opacity animation should have finished at time 1, but the group
 645   // of animations with id 1 don't finish until time 2 because of the length
 646   // of the transform animation.
 647   controller->Animate(2.0);
 648   controller->UpdateState(true, events.get());
 649   // Should not have started the float transition yet.
 650   EXPECT_TRUE(controller->HasActiveAnimation());
 651   EXPECT_EQ(1.f, dummy.opacity());
 652
 653   // The second opacity animation should start at time 2 and should be done by
 654   // time 3.
 655   controller->Animate(3.0);
 656   controller->UpdateState(true, events.get());
 657   EXPECT_EQ(0.5f, dummy.opacity());
 658   EXPECT_FALSE(controller->HasActiveAnimation());
 659 }
 660
 661 // Tests scheduling an animation to start in the future.
 662 TEST(LayerAnimationControllerTest, ScheduleAnimation) {
 663   scoped_ptr<AnimationEventsVector> events(
 664       make_scoped_ptr(new AnimationEventsVector));
 665   FakeLayerAnimationValueObserver dummy;
 666   scoped_refptr<LayerAnimationController> controller(
 667       LayerAnimationController::Create(0));
 668   controller->AddValueObserver(&dummy);
 669
 670   scoped_ptr<Animation> to_add(CreateAnimation(
 671       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 672       1,
 673       Animation::Opacity));
 674   to_add->SetRunState(Animation::WaitingForStartTime, 0);
 675   to_add->set_start_time(1.f);
 676   controller->AddAnimation(to_add.Pass());
 677
 678   controller->Animate(0.0);
 679   controller->UpdateState(true, events.get());
 680   EXPECT_TRUE(controller->HasActiveAnimation());
 681   EXPECT_EQ(0.f, dummy.opacity());
 682   controller->Animate(1.0);
 683   controller->UpdateState(true, events.get());
 684   EXPECT_TRUE(controller->HasActiveAnimation());
 685   EXPECT_EQ(0.f, dummy.opacity());
 686   controller->Animate(2.0);
 687   controller->UpdateState(true, events.get());
 688   EXPECT_EQ(1.f, dummy.opacity());
 689   EXPECT_FALSE(controller->HasActiveAnimation());
 690 }
 691
 692 // Tests scheduling an animation to start in the future that's interrupting a
 693 // running animation.
 694 TEST(LayerAnimationControllerTest,
 695      ScheduledAnimationInterruptsRunningAnimation) {
 696   scoped_ptr<AnimationEventsVector> events(
 697       make_scoped_ptr(new AnimationEventsVector));
 698   FakeLayerAnimationValueObserver dummy;
 699   scoped_refptr<LayerAnimationController> controller(
 700       LayerAnimationController::Create(0));
 701   controller->AddValueObserver(&dummy);
 702
 703   controller->AddAnimation(CreateAnimation(
 704       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
 705       1,
 706       Animation::Opacity));
 707
 708   scoped_ptr<Animation> to_add(CreateAnimation(
 709       scoped_ptr<AnimationCurve>(
 710           new FakeFloatTransition(1.0, 0.5f, 0.f)).Pass(),
 711       2,
 712       Animation::Opacity));
 713   to_add->SetRunState(Animation::WaitingForStartTime, 0);
 714   to_add->set_start_time(1.f);
 715   controller->AddAnimation(to_add.Pass());
 716
 717   // First 2s opacity transition should start immediately.
 718   controller->Animate(0.0);
 719   controller->UpdateState(true, events.get());
 720   EXPECT_TRUE(controller->HasActiveAnimation());
 721   EXPECT_EQ(0.f, dummy.opacity());
 722   controller->Animate(0.5);
 723   controller->UpdateState(true, events.get());
 724   EXPECT_TRUE(controller->HasActiveAnimation());
 725   EXPECT_EQ(0.25f, dummy.opacity());
 726   controller->Animate(1.0);
 727   controller->UpdateState(true, events.get());
 728   EXPECT_TRUE(controller->HasActiveAnimation());
 729   EXPECT_EQ(0.5f, dummy.opacity());
 730   controller->Animate(2.0);
 731   controller->UpdateState(true, events.get());
 732   EXPECT_EQ(0.f, dummy.opacity());
 733   EXPECT_FALSE(controller->HasActiveAnimation());
 734 }
 735
 736 // Tests scheduling an animation to start in the future that interrupts a
 737 // running animation and there is yet another animation queued to start later.
 738 TEST(LayerAnimationControllerTest,
 739      ScheduledAnimationInterruptsRunningAnimationWithAnimInQueue) {
 740   scoped_ptr<AnimationEventsVector> events(
 741       make_scoped_ptr(new AnimationEventsVector));
 742   FakeLayerAnimationValueObserver dummy;
 743   scoped_refptr<LayerAnimationController> controller(
 744       LayerAnimationController::Create(0));
 745   controller->AddValueObserver(&dummy);
 746
 747   controller->AddAnimation(CreateAnimation(
 748       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
 749       1,
 750       Animation::Opacity));
 751
 752   scoped_ptr<Animation> to_add(CreateAnimation(
 753       scoped_ptr<AnimationCurve>(
 754           new FakeFloatTransition(2.0, 0.5f, 0.f)).Pass(),
 755       2,
 756       Animation::Opacity));
 757   to_add->SetRunState(Animation::WaitingForStartTime, 0);
 758   to_add->set_start_time(1.f);
 759   controller->AddAnimation(to_add.Pass());
 760
 761   controller->AddAnimation(CreateAnimation(
 762       scoped_ptr<AnimationCurve>(
 763           new FakeFloatTransition(1.0, 0.f, 0.75f)).Pass(),
 764       3,
 765       Animation::Opacity));
 766
 767   // First 2s opacity transition should start immediately.
 768   controller->Animate(0.0);
 769   controller->UpdateState(true, events.get());
 770   EXPECT_TRUE(controller->HasActiveAnimation());
 771   EXPECT_EQ(0.f, dummy.opacity());
 772   controller->Animate(0.5);
 773   controller->UpdateState(true, events.get());
 774   EXPECT_TRUE(controller->HasActiveAnimation());
 775   EXPECT_EQ(0.25f, dummy.opacity());
 776   EXPECT_TRUE(controller->HasActiveAnimation());
 777   controller->Animate(1.0);
 778   controller->UpdateState(true, events.get());
 779   EXPECT_TRUE(controller->HasActiveAnimation());
 780   EXPECT_EQ(0.5f, dummy.opacity());
 781   controller->Animate(3.0);
 782   controller->UpdateState(true, events.get());
 783   EXPECT_TRUE(controller->HasActiveAnimation());
 784   EXPECT_EQ(0.f, dummy.opacity());
 785   controller->Animate(4.0);
 786   controller->UpdateState(true, events.get());
 787   EXPECT_EQ(0.75f, dummy.opacity());
 788   EXPECT_FALSE(controller->HasActiveAnimation());
 789 }
 790
 791 // Test that a looping animation loops and for the correct number of iterations.
 792 TEST(LayerAnimationControllerTest, TrivialLooping) {
 793   scoped_ptr<AnimationEventsVector> events(
 794       make_scoped_ptr(new AnimationEventsVector));
 795   FakeLayerAnimationValueObserver dummy;
 796   scoped_refptr<LayerAnimationController> controller(
 797       LayerAnimationController::Create(0));
 798   controller->AddValueObserver(&dummy);
 799
 800   scoped_ptr<Animation> to_add(CreateAnimation(
 801       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 802       1,
 803       Animation::Opacity));
 804   to_add->set_iterations(3);
 805   controller->AddAnimation(to_add.Pass());
 806
 807   controller->Animate(0.0);
 808   controller->UpdateState(true, events.get());
 809   EXPECT_TRUE(controller->HasActiveAnimation());
 810   EXPECT_EQ(0.f, dummy.opacity());
 811   controller->Animate(1.25);
 812   controller->UpdateState(true, events.get());
 813   EXPECT_TRUE(controller->HasActiveAnimation());
 814   EXPECT_EQ(0.25f, dummy.opacity());
 815   controller->Animate(1.75);
 816   controller->UpdateState(true, events.get());
 817   EXPECT_TRUE(controller->HasActiveAnimation());
 818   EXPECT_EQ(0.75f, dummy.opacity());
 819   controller->Animate(2.25);
 820   controller->UpdateState(true, events.get());
 821   EXPECT_TRUE(controller->HasActiveAnimation());
 822   EXPECT_EQ(0.25f, dummy.opacity());
 823   controller->Animate(2.75);
 824   controller->UpdateState(true, events.get());
 825   EXPECT_TRUE(controller->HasActiveAnimation());
 826   EXPECT_EQ(0.75f, dummy.opacity());
 827   controller->Animate(3.0);
 828   controller->UpdateState(true, events.get());
 829   EXPECT_FALSE(controller->HasActiveAnimation());
 830   EXPECT_EQ(1.f, dummy.opacity());
 831
 832   // Just be extra sure.
 833   controller->Animate(4.0);
 834   controller->UpdateState(true, events.get());
 835   EXPECT_EQ(1.f, dummy.opacity());
 836 }
 837
 838 // Test that an infinitely looping animation does indeed go until aborted.
 839 TEST(LayerAnimationControllerTest, InfiniteLooping) {
 840   scoped_ptr<AnimationEventsVector> events(
 841       make_scoped_ptr(new AnimationEventsVector));
 842   FakeLayerAnimationValueObserver dummy;
 843   scoped_refptr<LayerAnimationController> controller(
 844       LayerAnimationController::Create(0));
 845   controller->AddValueObserver(&dummy);
 846
 847   const int id = 1;
 848   scoped_ptr<Animation> to_add(CreateAnimation(
 849       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 850       id,
 851       Animation::Opacity));
 852   to_add->set_iterations(-1);
 853   controller->AddAnimation(to_add.Pass());
 854
 855   controller->Animate(0.0);
 856   controller->UpdateState(true, events.get());
 857   EXPECT_TRUE(controller->HasActiveAnimation());
 858   EXPECT_EQ(0.f, dummy.opacity());
 859   controller->Animate(1.25);
 860   controller->UpdateState(true, events.get());
 861   EXPECT_TRUE(controller->HasActiveAnimation());
 862   EXPECT_EQ(0.25f, dummy.opacity());
 863   controller->Animate(1.75);
 864   controller->UpdateState(true, events.get());
 865   EXPECT_TRUE(controller->HasActiveAnimation());
 866   EXPECT_EQ(0.75f, dummy.opacity());
 867
 868   controller->Animate(1073741824.25);
 869   controller->UpdateState(true, events.get());
 870   EXPECT_TRUE(controller->HasActiveAnimation());
 871   EXPECT_EQ(0.25f, dummy.opacity());
 872   controller->Animate(1073741824.75);
 873   controller->UpdateState(true, events.get());
 874   EXPECT_TRUE(controller->HasActiveAnimation());
 875   EXPECT_EQ(0.75f, dummy.opacity());
 876
 877   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
 878   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
 879       Animation::Aborted, 0.75);
 880   EXPECT_FALSE(controller->HasActiveAnimation());
 881   EXPECT_EQ(0.75f, dummy.opacity());
 882 }
 883
 884 // Test that pausing and resuming work as expected.
 885 TEST(LayerAnimationControllerTest, PauseResume) {
 886   scoped_ptr<AnimationEventsVector> events(
 887       make_scoped_ptr(new AnimationEventsVector));
 888   FakeLayerAnimationValueObserver dummy;
 889   scoped_refptr<LayerAnimationController> controller(
 890       LayerAnimationController::Create(0));
 891   controller->AddValueObserver(&dummy);
 892
 893   const int id = 1;
 894   controller->AddAnimation(CreateAnimation(
 895       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
 896       id,
 897       Animation::Opacity));
 898
 899   controller->Animate(0.0);
 900   controller->UpdateState(true, events.get());
 901   EXPECT_TRUE(controller->HasActiveAnimation());
 902   EXPECT_EQ(0.f, dummy.opacity());
 903   controller->Animate(0.5);
 904   controller->UpdateState(true, events.get());
 905   EXPECT_TRUE(controller->HasActiveAnimation());
 906   EXPECT_EQ(0.5f, dummy.opacity());
 907
 908   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
 909   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
 910       Animation::Paused, 0.5);
 911
 912   controller->Animate(1024);
 913   controller->UpdateState(true, events.get());
 914   EXPECT_TRUE(controller->HasActiveAnimation());
 915   EXPECT_EQ(0.5f, dummy.opacity());
 916
 917   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
 918   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
 919       Animation::Running, 1024);
 920
 921   controller->Animate(1024.25);
 922   controller->UpdateState(true, events.get());
 923   EXPECT_TRUE(controller->HasActiveAnimation());
 924   EXPECT_EQ(0.75f, dummy.opacity());
 925   controller->Animate(1024.5);
 926   controller->UpdateState(true, events.get());
 927   EXPECT_FALSE(controller->HasActiveAnimation());
 928   EXPECT_EQ(1.f, dummy.opacity());
 929 }
 930
 931 TEST(LayerAnimationControllerTest, AbortAGroupedAnimation) {
 932   scoped_ptr<AnimationEventsVector> events(
 933       make_scoped_ptr(new AnimationEventsVector));
 934   FakeLayerAnimationValueObserver dummy;
 935   scoped_refptr<LayerAnimationController> controller(
 936       LayerAnimationController::Create(0));
 937   controller->AddValueObserver(&dummy);
 938
 939   const int id = 1;
 940   controller->AddAnimation(CreateAnimation(
 941       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)).Pass(),
 942       id,
 943       Animation::Transform));
 944   controller->AddAnimation(CreateAnimation(
 945       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
 946       id,
 947       Animation::Opacity));
 948   controller->AddAnimation(CreateAnimation(
 949       scoped_ptr<AnimationCurve>(
 950           new FakeFloatTransition(1.0, 1.f, 0.75f)).Pass(),
 951       2,
 952       Animation::Opacity));
 953
 954   controller->Animate(0.0);
 955   controller->UpdateState(true, events.get());
 956   EXPECT_TRUE(controller->HasActiveAnimation());
 957   EXPECT_EQ(0.f, dummy.opacity());
 958   controller->Animate(1.0);
 959   controller->UpdateState(true, events.get());
 960   EXPECT_TRUE(controller->HasActiveAnimation());
 961   EXPECT_EQ(0.5f, dummy.opacity());
 962
 963   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
 964   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
 965       Animation::Aborted, 1);
 966   controller->Animate(1.0);
 967   controller->UpdateState(true, events.get());
 968   EXPECT_TRUE(controller->HasActiveAnimation());
 969   EXPECT_EQ(1.f, dummy.opacity());
 970   controller->Animate(2.0);
 971   controller->UpdateState(true, events.get());
 972   EXPECT_TRUE(!controller->HasActiveAnimation());
 973   EXPECT_EQ(0.75f, dummy.opacity());
 974 }
 975
 976 TEST(LayerAnimationControllerTest, ForceSyncWhenSynchronizedStartTimeNeeded) {
 977   FakeLayerAnimationValueObserver dummy_impl;
 978   scoped_refptr<LayerAnimationController> controller_impl(
 979       LayerAnimationController::Create(0));
 980   controller_impl->AddValueObserver(&dummy_impl);
 981   scoped_ptr<AnimationEventsVector> events(
 982       make_scoped_ptr(new AnimationEventsVector));
 983   FakeLayerAnimationValueObserver dummy;
 984   scoped_refptr<LayerAnimationController> controller(
 985       LayerAnimationController::Create(0));
 986   controller->AddValueObserver(&dummy);
 987
 988   scoped_ptr<Animation> to_add(CreateAnimation(
 989       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
 990       0,
 991       Animation::Opacity));
 992   to_add->set_needs_synchronized_start_time(true);
 993   controller->AddAnimation(to_add.Pass());
 994
 995   controller->Animate(0.0);
 996   controller->UpdateState(true, events.get());
 997   EXPECT_TRUE(controller->HasActiveAnimation());
 998   Animation* active_animation = controller->GetAnimation(0, Animation::Opacity);
 999   EXPECT_TRUE(active_animation);
1000   EXPECT_TRUE(active_animation->needs_synchronized_start_time());
1001
1002   controller->set_force_sync();
1003
1004   controller->PushAnimationUpdatesTo(controller_impl.get());
1005
1006   active_animation = controller_impl->GetAnimation(0, Animation::Opacity);
1007   EXPECT_TRUE(active_animation);
1008   EXPECT_EQ(Animation::WaitingForTargetAvailability,
1009             active_animation->run_state());
1010 }
1011
1012 // Tests that skipping a call to UpdateState works as expected.
1013 TEST(LayerAnimationControllerTest, SkipUpdateState) {
1014   scoped_ptr<AnimationEventsVector> events(
1015       make_scoped_ptr(new AnimationEventsVector));
1016   FakeLayerAnimationValueObserver dummy;
1017   scoped_refptr<LayerAnimationController> controller(
1018       LayerAnimationController::Create(0));
1019   controller->AddValueObserver(&dummy);
1020
1021   controller->AddAnimation(CreateAnimation(
1022       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)).Pass(),
1023       1,
1024       Animation::Transform));
1025
1026   controller->Animate(0.0);
1027   controller->UpdateState(true, events.get());
1028
1029   controller->AddAnimation(CreateAnimation(
1030       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
1031       2,
1032       Animation::Opacity));
1033
1034   // Animate but don't UpdateState.
1035   controller->Animate(1.0);
1036
1037   controller->Animate(2.0);
1038   events.reset(new AnimationEventsVector);
1039   controller->UpdateState(true, events.get());
1040
1041   // Should have one Started event and one Finished event.
1042   EXPECT_EQ(2u, events->size());
1043   EXPECT_NE((*events)[0].type, (*events)[1].type);
1044
1045   // The float transition should still be at its starting point.
1046   EXPECT_TRUE(controller->HasActiveAnimation());
1047   EXPECT_EQ(0.f, dummy.opacity());
1048
1049   controller->Animate(3.0);
1050   controller->UpdateState(true, events.get());
1051
1052   // The float tranisition should now be done.
1053   EXPECT_EQ(1.f, dummy.opacity());
1054   EXPECT_FALSE(controller->HasActiveAnimation());
1055 }
1056
1057 // Tests that an animation controller with only an inactive observer gets ticked
1058 // but doesn't progress animations past the Starting state.
1059 TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
1060   scoped_ptr<AnimationEventsVector> events(
1061       make_scoped_ptr(new AnimationEventsVector));
1062   FakeLayerAnimationValueObserver dummy;
1063   FakeInactiveLayerAnimationValueObserver inactive_dummy;
1064   scoped_refptr<LayerAnimationController> controller(
1065       LayerAnimationController::Create(0));
1066
1067   const int id = 1;
1068   controller->AddAnimation(CreateAnimation(scoped_ptr<AnimationCurve>(
1069       new FakeFloatTransition(1.0, 0.5f, 1.f)).Pass(),
1070       id,
1071       Animation::Opacity));
1072
1073   // Without an observer, the animation shouldn't progress to the Starting
1074   // state.
1075   controller->Animate(0.0);
1076   controller->UpdateState(true, events.get());
1077   EXPECT_EQ(0u, events->size());
1078   EXPECT_EQ(Animation::WaitingForTargetAvailability,
1079             controller->GetAnimation(id, Animation::Opacity)->run_state());
1080
1081   controller->AddValueObserver(&inactive_dummy);
1082
1083   // With only an inactive observer, the animation should progress to the
1084   // Starting state and get ticked at its starting point, but should not
1085   // progress to Running.
1086   controller->Animate(1.0);
1087   controller->UpdateState(true, events.get());
1088   EXPECT_EQ(0u, events->size());
1089   EXPECT_EQ(Animation::Starting,
1090             controller->GetAnimation(id, Animation::Opacity)->run_state());
1091   EXPECT_EQ(0.5f, inactive_dummy.opacity());
1092
1093   // Even when already in the Starting state, the animation should stay
1094   // there, and shouldn't be ticked past its starting point.
1095   controller->Animate(2.0);
1096   controller->UpdateState(true, events.get());
1097   EXPECT_EQ(0u, events->size());
1098   EXPECT_EQ(Animation::Starting,
1099             controller->GetAnimation(id, Animation::Opacity)->run_state());
1100   EXPECT_EQ(0.5f, inactive_dummy.opacity());
1101
1102   controller->AddValueObserver(&dummy);
1103
1104   // Now that an active observer has been added, the animation should still
1105   // initially tick at its starting point, but should now progress to Running.
1106   controller->Animate(3.0);
1107   controller->UpdateState(true, events.get());
1108   EXPECT_EQ(1u, events->size());
1109   EXPECT_EQ(Animation::Running,
1110             controller->GetAnimation(id, Animation::Opacity)->run_state());
1111   EXPECT_EQ(0.5f, inactive_dummy.opacity());
1112   EXPECT_EQ(0.5f, dummy.opacity());
1113
1114   // The animation should now tick past its starting point.
1115   controller->Animate(3.5);
1116   EXPECT_NE(0.5f, inactive_dummy.opacity());
1117   EXPECT_NE(0.5f, dummy.opacity());
1118 }
1119
1120 }  // namespace
1121 }  // namespace cc