cc/trees/layer_tree_host_unittest_animation.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/trees/layer_tree_host.h"
   6
   7 #include "cc/animation/animation_curve.h"
   8 #include "cc/animation/layer_animation_controller.h"
   9 #include "cc/animation/timing_function.h"
  10 #include "cc/layers/layer.h"
  11 #include "cc/layers/layer_impl.h"
  12 #include "cc/test/animation_test_common.h"
  13 #include "cc/test/fake_content_layer.h"
  14 #include "cc/test/fake_content_layer_client.h"
  15 #include "cc/test/layer_tree_test.h"
  16 #include "cc/trees/layer_tree_impl.h"
  17
  18 namespace cc {
  19 namespace {
  20
  21 class LayerTreeHostAnimationTest : public LayerTreeTest {
  22  public:
  23   virtual void SetupTree() OVERRIDE {
  24     LayerTreeTest::SetupTree();
  25     layer_tree_host()->root_layer()->set_layer_animation_delegate(this);
  26   }
  27 };
  28
  29 // Makes sure that SetNeedsAnimate does not cause the CommitRequested() state to
  30 // be set.
  31 class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested
  32     : public LayerTreeHostAnimationTest {
  33  public:
  34   LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested()
  35       : num_commits_(0) {}
  36
  37   virtual void BeginTest() OVERRIDE {
  38     PostSetNeedsCommitToMainThread();
  39   }
  40
  41   virtual void Animate(base::TimeTicks monotonic_time) OVERRIDE {
  42     // We skip the first commit becasue its the commit that populates the
  43     // impl thread with a tree. After the second commit, the test is done.
  44     if (num_commits_ != 1)
  45       return;
  46
  47     layer_tree_host()->SetNeedsAnimate();
  48     // Right now, CommitRequested is going to be true, because during
  49     // BeginFrame, we force CommitRequested to true to prevent requests from
  50     // hitting the impl thread. But, when the next DidCommit happens, we should
  51     // verify that CommitRequested has gone back to false.
  52   }
  53
  54   virtual void DidCommit() OVERRIDE {
  55     if (!num_commits_) {
  56       EXPECT_FALSE(layer_tree_host()->CommitRequested());
  57       layer_tree_host()->SetNeedsAnimate();
  58       EXPECT_FALSE(layer_tree_host()->CommitRequested());
  59     }
  60
  61     // Verifies that the SetNeedsAnimate we made in ::Animate did not
  62     // trigger CommitRequested.
  63     EXPECT_FALSE(layer_tree_host()->CommitRequested());
  64     EndTest();
  65     num_commits_++;
  66   }
  67
  68   virtual void AfterTest() OVERRIDE {}
  69
  70  private:
  71   int num_commits_;
  72 };
  73
  74 MULTI_THREAD_TEST_F(
  75     LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested);
  76
  77 // Trigger a frame with SetNeedsCommit. Then, inside the resulting animate
  78 // callback, request another frame using SetNeedsAnimate. End the test when
  79 // animate gets called yet-again, indicating that the proxy is correctly
  80 // handling the case where SetNeedsAnimate() is called inside the BeginFrame
  81 // flow.
  82 class LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback
  83     : public LayerTreeHostAnimationTest {
  84  public:
  85   LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback()
  86       : num_animates_(0) {}
  87
  88   virtual void BeginTest() OVERRIDE {
  89     PostSetNeedsCommitToMainThread();
  90   }
  91
  92   virtual void Animate(base::TimeTicks) OVERRIDE {
  93     if (!num_animates_) {
  94       layer_tree_host()->SetNeedsAnimate();
  95       num_animates_++;
  96       return;
  97     }
  98     EndTest();
  99   }
 100
 101   virtual void AfterTest() OVERRIDE {}
 102
 103  private:
 104   int num_animates_;
 105 };
 106
 107 MULTI_THREAD_TEST_F(
 108     LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback);
 109
 110 // Add a layer animation and confirm that
 111 // LayerTreeHostImpl::updateAnimationState does get called and continues to
 112 // get called.
 113 class LayerTreeHostAnimationTestAddAnimation
 114     : public LayerTreeHostAnimationTest {
 115  public:
 116   LayerTreeHostAnimationTestAddAnimation()
 117       : num_animates_(0),
 118         received_animation_started_notification_(false),
 119         start_time_(0.0) {
 120   }
 121
 122   virtual void BeginTest() OVERRIDE {
 123     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
 124   }
 125
 126   virtual void UpdateAnimationState(
 127       LayerTreeHostImpl* host_impl,
 128       bool has_unfinished_animation) OVERRIDE {
 129     if (!num_animates_) {
 130       // The animation had zero duration so LayerTreeHostImpl should no
 131       // longer need to animate its layers.
 132       EXPECT_FALSE(has_unfinished_animation);
 133       num_animates_++;
 134       return;
 135     }
 136
 137     if (received_animation_started_notification_) {
 138       EXPECT_LT(0.0, start_time_);
 139
 140       LayerAnimationController* controller_impl =
 141           host_impl->active_tree()->root_layer()->layer_animation_controller();
 142       Animation* animation_impl =
 143           controller_impl->GetAnimation(Animation::Opacity);
 144       if (animation_impl)
 145         controller_impl->RemoveAnimation(animation_impl->id());
 146
 147       EndTest();
 148     }
 149   }
 150
 151   virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
 152     received_animation_started_notification_ = true;
 153     start_time_ = wall_clock_time;
 154     if (num_animates_) {
 155       EXPECT_LT(0.0, start_time_);
 156
 157       LayerAnimationController* controller =
 158           layer_tree_host()->root_layer()->layer_animation_controller();
 159       Animation* animation =
 160           controller->GetAnimation(Animation::Opacity);
 161       if (animation)
 162         controller->RemoveAnimation(animation->id());
 163
 164       EndTest();
 165     }
 166   }
 167
 168   virtual void AfterTest() OVERRIDE {}
 169
 170  private:
 171   int num_animates_;
 172   bool received_animation_started_notification_;
 173   double start_time_;
 174 };
 175
 176 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAddAnimation);
 177
 178 // Add a layer animation to a layer, but continually fail to draw. Confirm that
 179 // after a while, we do eventually force a draw.
 180 class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
 181     : public LayerTreeHostAnimationTest {
 182  public:
 183   LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws()
 184       : started_animating_(false) {}
 185
 186   virtual void BeginTest() OVERRIDE {
 187     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
 188   }
 189
 190   virtual void AnimateLayers(
 191       LayerTreeHostImpl* host_impl,
 192       base::TimeTicks monotonic_time) OVERRIDE {
 193     started_animating_ = true;
 194   }
 195
 196   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
 197     if (started_animating_)
 198       EndTest();
 199   }
 200
 201   virtual bool PrepareToDrawOnThread(
 202       LayerTreeHostImpl* host_impl,
 203       LayerTreeHostImpl::FrameData* frame,
 204       bool result) OVERRIDE {
 205     return false;
 206   }
 207
 208   virtual void AfterTest() OVERRIDE { }
 209
 210  private:
 211   bool started_animating_;
 212 };
 213
 214 // Starvation can only be an issue with the MT compositor.
 215 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws);
 216
 217 // Ensures that animations eventually get deleted.
 218 class LayerTreeHostAnimationTestAnimationsGetDeleted
 219     : public LayerTreeHostAnimationTest {
 220  public:
 221   LayerTreeHostAnimationTestAnimationsGetDeleted()
 222       : started_animating_(false) {}
 223
 224   virtual void BeginTest() OVERRIDE {
 225     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
 226   }
 227
 228   virtual void AnimateLayers(
 229       LayerTreeHostImpl* host_impl,
 230       base::TimeTicks monotonic_time) OVERRIDE {
 231     bool have_animations = !host_impl->animation_registrar()->
 232         active_animation_controllers().empty();
 233     if (!started_animating_ && have_animations) {
 234       started_animating_ = true;
 235       return;
 236     }
 237
 238     if (started_animating_ && !have_animations)
 239       EndTest();
 240   }
 241
 242   virtual void NotifyAnimationFinished(double time) OVERRIDE {
 243     // Animations on the impl-side controller only get deleted during a commit,
 244     // so we need to schedule a commit.
 245     layer_tree_host()->SetNeedsCommit();
 246   }
 247
 248   virtual void AfterTest() OVERRIDE {}
 249
 250  private:
 251   bool started_animating_;
 252 };
 253
 254 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimationsGetDeleted);
 255
 256 // Ensures that animations continue to be ticked when we are backgrounded.
 257 class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded
 258     : public LayerTreeHostAnimationTest {
 259  public:
 260   LayerTreeHostAnimationTestTickAnimationWhileBackgrounded()
 261       : num_animates_(0) {}
 262
 263   virtual void BeginTest() OVERRIDE {
 264     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
 265   }
 266
 267   // Use WillAnimateLayers to set visible false before the animation runs and
 268   // causes a commit, so we block the second visible animate in single-thread
 269   // mode.
 270   virtual void WillAnimateLayers(
 271       LayerTreeHostImpl* host_impl,
 272       base::TimeTicks monotonic_time) OVERRIDE {
 273     // Verify that the host can draw, it's just not visible.
 274     EXPECT_TRUE(host_impl->CanDraw());
 275     if (num_animates_ < 2) {
 276       if (!num_animates_) {
 277         // We have a long animation running. It should continue to tick even
 278         // if we are not visible.
 279         PostSetVisibleToMainThread(false);
 280       }
 281       num_animates_++;
 282       return;
 283     }
 284     EndTest();
 285   }
 286
 287   virtual void AfterTest() OVERRIDE {}
 288
 289  private:
 290   int num_animates_;
 291 };
 292
 293 SINGLE_AND_MULTI_THREAD_TEST_F(
 294     LayerTreeHostAnimationTestTickAnimationWhileBackgrounded);
 295
 296 // Ensures that animations do not tick when we are backgrounded and
 297 // and we have an empty active tree.
 298 class LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree
 299     : public LayerTreeHostAnimationTest {
 300  protected:
 301   LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree()
 302       : active_tree_was_animated_(false) {}
 303
 304   virtual base::TimeDelta LowFrequencyAnimationInterval() const OVERRIDE {
 305     return base::TimeDelta::FromMilliseconds(4);
 306   }
 307
 308   virtual void BeginTest() OVERRIDE {
 309     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
 310   }
 311
 312   virtual void NotifyAnimationFinished(double time) OVERRIDE {
 313     // Replace animated commits with an empty tree.
 314     layer_tree_host()->SetRootLayer(make_scoped_refptr<Layer>(NULL));
 315   }
 316
 317   virtual void DidCommit() OVERRIDE {
 318     // This alternates setting an empty tree and a non-empty tree with an
 319     // animation.
 320     switch (layer_tree_host()->source_frame_number()) {
 321       case 1:
 322         // Wait for NotifyAnimationFinished to commit an empty tree.
 323         break;
 324       case 2:
 325         SetupTree();
 326         AddOpacityTransitionToLayer(
 327             layer_tree_host()->root_layer(), 0.000001, 0, 0.5, true);
 328         break;
 329       case 3:
 330         // Wait for NotifyAnimationFinished to commit an empty tree.
 331         break;
 332       case 4:
 333         EndTest();
 334         break;
 335     }
 336   }
 337
 338   virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
 339     // At the start of every commit, block activations and make sure
 340     // we are backgrounded.
 341     host_impl->BlockNotifyReadyToActivateForTesting(true);
 342     PostSetVisibleToMainThread(false);
 343   }
 344
 345   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
 346     if (!host_impl->settings().impl_side_painting) {
 347       // There are no activations to block if we're not impl-side-painting,
 348       // so just advance the test immediately.
 349       if (host_impl->active_tree()->source_frame_number() < 3)
 350         UnblockActivations(host_impl);
 351       return;
 352     }
 353
 354     // We block activation for several ticks to make sure that, even though
 355     // there is a pending tree with animations, we still do not background
 356     // tick if the active tree is empty.
 357     if (host_impl->pending_tree()->source_frame_number() < 3) {
 358       base::MessageLoopProxy::current()->PostDelayedTask(
 359           FROM_HERE,
 360           base::Bind(
 361               &LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree::
 362                    UnblockActivations,
 363               base::Unretained(this),
 364               host_impl),
 365           4 * LowFrequencyAnimationInterval());
 366     }
 367   }
 368
 369   virtual void UnblockActivations(LayerTreeHostImpl* host_impl) {
 370     host_impl->BlockNotifyReadyToActivateForTesting(false);
 371   }
 372
 373   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
 374     active_tree_was_animated_ = false;
 375
 376     // Verify that commits are actually alternating with empty / non-empty
 377     // trees.
 378     switch (host_impl->active_tree()->source_frame_number()) {
 379       case 0:
 380       case 2:
 381         EXPECT_TRUE(host_impl->active_tree()->root_layer());
 382         break;
 383       case 1:
 384       case 3:
 385         EXPECT_FALSE(host_impl->active_tree()->root_layer());
 386         break;
 387     }
 388
 389     if (host_impl->active_tree()->source_frame_number() < 3) {
 390       // Initiate the next commit after a delay to give us a chance to
 391       // background tick if the active tree isn't empty.
 392       base::MessageLoopProxy::current()->PostDelayedTask(
 393           FROM_HERE,
 394           base::Bind(
 395               &LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree::
 396                    InitiateNextCommit,
 397               base::Unretained(this),
 398               host_impl),
 399           4 * LowFrequencyAnimationInterval());
 400     }
 401   }
 402
 403   virtual void WillAnimateLayers(LayerTreeHostImpl* host_impl,
 404                                  base::TimeTicks monotonic_time) OVERRIDE {
 405     EXPECT_TRUE(host_impl->active_tree()->root_layer());
 406     active_tree_was_animated_ = true;
 407   }
 408
 409   void InitiateNextCommit(LayerTreeHostImpl* host_impl) {
 410     // Verify that we actually animated when we should have.
 411     bool has_active_tree = host_impl->active_tree()->root_layer();
 412     EXPECT_EQ(has_active_tree, active_tree_was_animated_);
 413
 414     // The next commit is blocked until we become visible again.
 415     PostSetVisibleToMainThread(true);
 416   }
 417
 418   virtual void AfterTest() OVERRIDE {}
 419
 420   bool active_tree_was_animated_;
 421 };
 422
 423 SINGLE_AND_MULTI_THREAD_TEST_F(
 424     LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree);
 425
 426 // Ensure that an animation's timing function is respected.
 427 class LayerTreeHostAnimationTestAddAnimationWithTimingFunction
 428     : public LayerTreeHostAnimationTest {
 429  public:
 430   LayerTreeHostAnimationTestAddAnimationWithTimingFunction() {}
 431
 432   virtual void SetupTree() OVERRIDE {
 433     LayerTreeHostAnimationTest::SetupTree();
 434     content_ = FakeContentLayer::Create(&client_);
 435     content_->SetBounds(gfx::Size(4, 4));
 436     layer_tree_host()->root_layer()->AddChild(content_);
 437   }
 438
 439   virtual void BeginTest() OVERRIDE {
 440     PostAddAnimationToMainThread(content_.get());
 441   }
 442
 443   virtual void AnimateLayers(
 444       LayerTreeHostImpl* host_impl,
 445       base::TimeTicks monotonic_time) OVERRIDE {
 446     LayerAnimationController* controller_impl =
 447         host_impl->active_tree()->root_layer()->children()[0]->
 448         layer_animation_controller();
 449     Animation* animation =
 450         controller_impl->GetAnimation(Animation::Opacity);
 451     if (!animation)
 452       return;
 453
 454     const FloatAnimationCurve* curve =
 455         animation->curve()->ToFloatAnimationCurve();
 456     float start_opacity = curve->GetValue(0.0);
 457     float end_opacity = curve->GetValue(curve->Duration());
 458     float linearly_interpolated_opacity =
 459         0.25f * end_opacity + 0.75f * start_opacity;
 460     double time = curve->Duration() * 0.25;
 461     // If the linear timing function associated with this animation was not
 462     // picked up, then the linearly interpolated opacity would be different
 463     // because of the default ease timing function.
 464     EXPECT_FLOAT_EQ(linearly_interpolated_opacity, curve->GetValue(time));
 465
 466     EndTest();
 467   }
 468
 469   virtual void AfterTest() OVERRIDE {}
 470
 471   FakeContentLayerClient client_;
 472   scoped_refptr<FakeContentLayer> content_;
 473 };
 474
 475 SINGLE_AND_MULTI_THREAD_TEST_F(
 476     LayerTreeHostAnimationTestAddAnimationWithTimingFunction);
 477
 478 // Ensures that main thread animations have their start times synchronized with
 479 // impl thread animations.
 480 class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
 481     : public LayerTreeHostAnimationTest {
 482  public:
 483   LayerTreeHostAnimationTestSynchronizeAnimationStartTimes()
 484       : main_start_time_(-1.0),
 485         impl_start_time_(-1.0) {}
 486
 487   virtual void SetupTree() OVERRIDE {
 488     LayerTreeHostAnimationTest::SetupTree();
 489     content_ = FakeContentLayer::Create(&client_);
 490     content_->SetBounds(gfx::Size(4, 4));
 491     content_->set_layer_animation_delegate(this);
 492     layer_tree_host()->root_layer()->AddChild(content_);
 493   }
 494
 495   virtual void BeginTest() OVERRIDE {
 496     PostAddAnimationToMainThread(content_.get());
 497   }
 498
 499   virtual void NotifyAnimationStarted(double time) OVERRIDE {
 500     LayerAnimationController* controller =
 501         layer_tree_host()->root_layer()->children()[0]->
 502         layer_animation_controller();
 503     Animation* animation =
 504         controller->GetAnimation(Animation::Opacity);
 505     main_start_time_ = animation->start_time();
 506     controller->RemoveAnimation(animation->id());
 507
 508     if (impl_start_time_ > 0.0)
 509       EndTest();
 510   }
 511
 512   virtual void UpdateAnimationState(
 513       LayerTreeHostImpl* impl_host,
 514       bool has_unfinished_animation) OVERRIDE {
 515     LayerAnimationController* controller =
 516         impl_host->active_tree()->root_layer()->children()[0]->
 517         layer_animation_controller();
 518     Animation* animation =
 519         controller->GetAnimation(Animation::Opacity);
 520     if (!animation)
 521       return;
 522
 523     impl_start_time_ = animation->start_time();
 524     controller->RemoveAnimation(animation->id());
 525
 526     if (main_start_time_ > 0.0)
 527       EndTest();
 528   }
 529
 530   virtual void AfterTest() OVERRIDE {
 531     EXPECT_FLOAT_EQ(impl_start_time_, main_start_time_);
 532   }
 533
 534  private:
 535   double main_start_time_;
 536   double impl_start_time_;
 537   FakeContentLayerClient client_;
 538   scoped_refptr<FakeContentLayer> content_;
 539 };
 540
 541 SINGLE_AND_MULTI_THREAD_TEST_F(
 542     LayerTreeHostAnimationTestSynchronizeAnimationStartTimes);
 543
 544 // Ensures that notify animation finished is called.
 545 class LayerTreeHostAnimationTestAnimationFinishedEvents
 546     : public LayerTreeHostAnimationTest {
 547  public:
 548   LayerTreeHostAnimationTestAnimationFinishedEvents() {}
 549
 550   virtual void BeginTest() OVERRIDE {
 551     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
 552   }
 553
 554   virtual void NotifyAnimationFinished(double time) OVERRIDE {
 555     LayerAnimationController* controller =
 556         layer_tree_host()->root_layer()->layer_animation_controller();
 557     Animation* animation =
 558         controller->GetAnimation(Animation::Opacity);
 559     if (animation)
 560       controller->RemoveAnimation(animation->id());
 561     EndTest();
 562   }
 563
 564   virtual void AfterTest() OVERRIDE {}
 565 };
 566
 567 SINGLE_AND_MULTI_THREAD_TEST_F(
 568     LayerTreeHostAnimationTestAnimationFinishedEvents);
 569
 570 // Ensures that when opacity is being animated, this value does not cause the
 571 // subtree to be skipped.
 572 class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity
 573     : public LayerTreeHostAnimationTest {
 574  public:
 575   LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity()
 576       : update_check_layer_(FakeContentLayer::Create(&client_)) {
 577   }
 578
 579   virtual void SetupTree() OVERRIDE {
 580     update_check_layer_->SetOpacity(0.f);
 581     layer_tree_host()->SetRootLayer(update_check_layer_);
 582     LayerTreeHostAnimationTest::SetupTree();
 583   }
 584
 585   virtual void BeginTest() OVERRIDE {
 586     PostAddAnimationToMainThread(update_check_layer_.get());
 587   }
 588
 589   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
 590     LayerAnimationController* controller_impl =
 591         host_impl->active_tree()->root_layer()->layer_animation_controller();
 592     Animation* animation_impl =
 593         controller_impl->GetAnimation(Animation::Opacity);
 594     controller_impl->RemoveAnimation(animation_impl->id());
 595     EndTest();
 596   }
 597
 598   virtual void AfterTest() OVERRIDE {
 599     // Update() should have been called once, proving that the layer was not
 600     // skipped.
 601     EXPECT_EQ(1u, update_check_layer_->update_count());
 602
 603     // clear update_check_layer_ so LayerTreeHost dies.
 604     update_check_layer_ = NULL;
 605   }
 606
 607  private:
 608   FakeContentLayerClient client_;
 609   scoped_refptr<FakeContentLayer> update_check_layer_;
 610 };
 611
 612 SINGLE_AND_MULTI_THREAD_TEST_F(
 613     LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity);
 614
 615 // Layers added to tree with existing active animations should have the
 616 // animation correctly recognized.
 617 class LayerTreeHostAnimationTestLayerAddedWithAnimation
 618     : public LayerTreeHostAnimationTest {
 619  public:
 620   LayerTreeHostAnimationTestLayerAddedWithAnimation() {}
 621
 622   virtual void BeginTest() OVERRIDE {
 623     PostSetNeedsCommitToMainThread();
 624   }
 625
 626   virtual void DidCommit() OVERRIDE {
 627     if (layer_tree_host()->source_frame_number() == 1) {
 628       scoped_refptr<Layer> layer = Layer::Create();
 629       layer->set_layer_animation_delegate(this);
 630
 631       // Any valid AnimationCurve will do here.
 632       scoped_ptr<AnimationCurve> curve(EaseTimingFunction::Create());
 633       scoped_ptr<Animation> animation(
 634           Animation::Create(curve.Pass(), 1, 1,
 635                                   Animation::Opacity));
 636       layer->layer_animation_controller()->AddAnimation(animation.Pass());
 637
 638       // We add the animation *before* attaching the layer to the tree.
 639       layer_tree_host()->root_layer()->AddChild(layer);
 640     }
 641   }
 642
 643   virtual void AnimateLayers(
 644       LayerTreeHostImpl* impl_host,
 645       base::TimeTicks monotonic_time) OVERRIDE {
 646     EndTest();
 647   }
 648
 649   virtual void AfterTest() OVERRIDE {}
 650 };
 651
 652 SINGLE_AND_MULTI_THREAD_TEST_F(
 653     LayerTreeHostAnimationTestLayerAddedWithAnimation);
 654
 655 class LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount
 656     : public LayerTreeHostAnimationTest {
 657  public:
 658   LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount()
 659       : animated_commit_(-1) {
 660   }
 661
 662   virtual void Animate(base::TimeTicks) OVERRIDE {
 663     // We shouldn't animate on the CompositeAndReadback-forced commit, but we
 664     // should for the SetNeedsCommit-triggered commit.
 665     animated_commit_ = layer_tree_host()->source_frame_number();
 666     EXPECT_NE(2, animated_commit_);
 667   }
 668
 669   virtual void BeginTest() OVERRIDE {
 670     PostSetNeedsCommitToMainThread();
 671   }
 672
 673   virtual void DidCommit() OVERRIDE {
 674     switch (layer_tree_host()->source_frame_number()) {
 675       case 1:
 676         layer_tree_host()->SetNeedsCommit();
 677         break;
 678       case 2: {
 679         char pixels[4];
 680         layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
 681         break;
 682       }
 683       case 3:
 684         // This is finishing the readback's commit.
 685         break;
 686       case 4:
 687         // This is finishing the followup commit.
 688         EndTest();
 689         break;
 690       default:
 691         NOTREACHED();
 692     }
 693   }
 694
 695   virtual void AfterTest() OVERRIDE {
 696     EXPECT_EQ(3, animated_commit_);
 697   }
 698
 699  private:
 700   int animated_commit_;
 701 };
 702
 703 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount);
 704
 705 class LayerTreeHostAnimationTestContinuousAnimate
 706     : public LayerTreeHostAnimationTest {
 707  public:
 708   LayerTreeHostAnimationTestContinuousAnimate()
 709       : num_commit_complete_(0),
 710         num_draw_layers_(0) {
 711   }
 712
 713   virtual void BeginTest() OVERRIDE {
 714     PostSetNeedsCommitToMainThread();
 715   }
 716
 717   virtual void Animate(base::TimeTicks) OVERRIDE {
 718     if (num_draw_layers_ == 2)
 719       return;
 720     layer_tree_host()->SetNeedsAnimate();
 721   }
 722
 723   virtual void Layout() OVERRIDE {
 724     layer_tree_host()->root_layer()->SetNeedsDisplay();
 725   }
 726
 727   virtual void CommitCompleteOnThread(LayerTreeHostImpl* tree_impl) OVERRIDE {
 728     if (num_draw_layers_ == 1)
 729       num_commit_complete_++;
 730   }
 731
 732   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 733     num_draw_layers_++;
 734     if (num_draw_layers_ == 2)
 735       EndTest();
 736   }
 737
 738   virtual void AfterTest() OVERRIDE {
 739     // Check that we didn't commit twice between first and second draw.
 740     EXPECT_EQ(1, num_commit_complete_);
 741   }
 742
 743  private:
 744   int num_commit_complete_;
 745   int num_draw_layers_;
 746 };
 747
 748 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestContinuousAnimate);
 749
 750 // Make sure the main thread can still execute animations when CanDraw() is not
 751 // true.
 752 class LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw
 753     : public LayerTreeHostAnimationTest {
 754  public:
 755   LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw() : started_times_(0) {}
 756
 757   virtual void SetupTree() OVERRIDE {
 758     LayerTreeHostAnimationTest::SetupTree();
 759     content_ = FakeContentLayer::Create(&client_);
 760     content_->SetBounds(gfx::Size(4, 4));
 761     content_->set_layer_animation_delegate(this);
 762     layer_tree_host()->root_layer()->AddChild(content_);
 763   }
 764
 765   virtual void BeginTest() OVERRIDE {
 766     layer_tree_host()->SetViewportSize(gfx::Size());
 767     PostAddAnimationToMainThread(content_.get());
 768   }
 769
 770   virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
 771     started_times_++;
 772   }
 773
 774   virtual void NotifyAnimationFinished(double wall_clock_time) OVERRIDE {
 775     EndTest();
 776   }
 777
 778   virtual void AfterTest() OVERRIDE {
 779     EXPECT_EQ(1, started_times_);
 780   }
 781
 782  private:
 783   int started_times_;
 784   FakeContentLayerClient client_;
 785   scoped_refptr<FakeContentLayer> content_;
 786 };
 787
 788 SINGLE_AND_MULTI_THREAD_TEST_F(
 789     LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw);
 790
 791 // Make sure the main thread can still execute animations when the renderer is
 792 // backgrounded.
 793 class LayerTreeHostAnimationTestRunAnimationWhenNotVisible
 794     : public LayerTreeHostAnimationTest {
 795  public:
 796   LayerTreeHostAnimationTestRunAnimationWhenNotVisible() : started_times_(0) {}
 797
 798   virtual void SetupTree() OVERRIDE {
 799     LayerTreeHostAnimationTest::SetupTree();
 800     content_ = FakeContentLayer::Create(&client_);
 801     content_->SetBounds(gfx::Size(4, 4));
 802     content_->set_layer_animation_delegate(this);
 803     layer_tree_host()->root_layer()->AddChild(content_);
 804   }
 805
 806   virtual void BeginTest() OVERRIDE {
 807     visible_ = true;
 808     PostAddAnimationToMainThread(content_.get());
 809   }
 810
 811   virtual void DidCommit() OVERRIDE {
 812     visible_ = false;
 813     layer_tree_host()->SetVisible(false);
 814   }
 815
 816   virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
 817     EXPECT_FALSE(visible_);
 818     started_times_++;
 819   }
 820
 821   virtual void NotifyAnimationFinished(double wall_clock_time) OVERRIDE {
 822     EXPECT_FALSE(visible_);
 823     EXPECT_EQ(1, started_times_);
 824     EndTest();
 825   }
 826
 827   virtual void AfterTest() OVERRIDE {}
 828
 829  private:
 830   bool visible_;
 831   int started_times_;
 832   FakeContentLayerClient client_;
 833   scoped_refptr<FakeContentLayer> content_;
 834 };
 835
 836 SINGLE_AND_MULTI_THREAD_TEST_F(
 837     LayerTreeHostAnimationTestRunAnimationWhenNotVisible);
 838
 839 // Animations should not be started when frames are being skipped due to
 840 // checkerboard.
 841 class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
 842     : public LayerTreeHostAnimationTest {
 843   virtual void SetupTree() OVERRIDE {
 844     LayerTreeHostAnimationTest::SetupTree();
 845     content_ = FakeContentLayer::Create(&client_);
 846     content_->SetBounds(gfx::Size(4, 4));
 847     content_->set_layer_animation_delegate(this);
 848     layer_tree_host()->root_layer()->AddChild(content_);
 849   }
 850
 851   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
 852     // Make sure that drawing many times doesn't cause a checkerboarded
 853     // animation to start so we avoid flake in this test.
 854     settings->timeout_and_draw_when_animation_checkerboards = false;
 855   }
 856
 857   virtual void BeginTest() OVERRIDE {
 858     prevented_draw_ = 0;
 859     added_animations_ = 0;
 860     started_times_ = 0;
 861     finished_times_ = 0;
 862
 863     PostSetNeedsCommitToMainThread();
 864   }
 865
 866   virtual void DispatchAddInstantAnimation(Layer* layer_to_receive_animation)
 867       OVERRIDE {
 868     LayerTreeHostAnimationTest::DispatchAddInstantAnimation(
 869         layer_to_receive_animation);
 870     added_animations_++;
 871   }
 872
 873   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
 874                                      LayerTreeHostImpl::FrameData* frame_data,
 875                                      bool result) OVERRIDE {
 876     if (added_animations_ < 2)
 877       return result;
 878     if (TestEnded())
 879       return result;
 880     // Act like there is checkerboard when the second animation wants to draw.
 881     ++prevented_draw_;
 882     return false;
 883   }
 884
 885   virtual void DidCommitAndDrawFrame() OVERRIDE {
 886     switch (layer_tree_host()->source_frame_number()) {
 887       case 1:
 888         // The animation is longer than 1 BeginFrame interval.
 889         AddOpacityTransitionToLayer(content_.get(), 0.1, 0.2f, 0.8f, false);
 890         added_animations_++;
 891         break;
 892       case 2:
 893         // This second animation will not be drawn so it should not start.
 894         AddAnimatedTransformToLayer(content_.get(), 0.1, 5, 5);
 895         added_animations_++;
 896         break;
 897     }
 898   }
 899
 900   virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
 901     if (TestEnded())
 902       return;
 903     started_times_++;
 904   }
 905
 906   virtual void NotifyAnimationFinished(double wall_clock_time) OVERRIDE {
 907     // We should be checkerboarding already, but it should still finish the
 908     // first animation.
 909     EXPECT_EQ(2, added_animations_);
 910     finished_times_++;
 911     EndTest();
 912   }
 913
 914   virtual void AfterTest() OVERRIDE {
 915     // Make sure we tried to draw the second animation but failed.
 916     EXPECT_LT(0, prevented_draw_);
 917     // The first animation should be started, but the second should not because
 918     // of checkerboard.
 919     EXPECT_EQ(1, started_times_);
 920     // The first animation should still be finished.
 921     EXPECT_EQ(1, finished_times_);
 922   }
 923
 924   int prevented_draw_;
 925   int added_animations_;
 926   int started_times_;
 927   int finished_times_;
 928   FakeContentLayerClient client_;
 929   scoped_refptr<FakeContentLayer> content_;
 930 };
 931
 932 MULTI_THREAD_TEST_F(
 933     LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations);
 934
 935 }  // namespace
 936 }  // namespace cc