ui/compositor/layer_animator_unittest.cc

   1 // Copyright (c) 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 "ui/compositor/layer_animator.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/time/time.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "ui/compositor/layer.h"
  14 #include "ui/compositor/layer_animation_delegate.h"
  15 #include "ui/compositor/layer_animation_element.h"
  16 #include "ui/compositor/layer_animation_sequence.h"
  17 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  18 #include "ui/compositor/scoped_layer_animation_settings.h"
  19 #include "ui/compositor/test/layer_animator_test_controller.h"
  20 #include "ui/compositor/test/test_layer_animation_delegate.h"
  21 #include "ui/compositor/test/test_layer_animation_observer.h"
  22 #include "ui/compositor/test/test_utils.h"
  23 #include "ui/gfx/frame_time.h"
  24 #include "ui/gfx/rect.h"
  25 #include "ui/gfx/transform.h"
  26
  27 using gfx::AnimationContainerElement;
  28
  29 namespace ui {
  30
  31 namespace {
  32
  33 // Converts |color| to a string. Each component of the color is separated by a
  34 // space and the order if A R G B.
  35 std::string ColorToString(SkColor color) {
  36   return base::StringPrintf("%d %d %d %d", SkColorGetA(color),
  37                             SkColorGetR(color), SkColorGetG(color),
  38                             SkColorGetB(color));
  39 }
  40
  41 // Creates vector with two LayerAnimationSequences, based on |first| and
  42 // |second| layer animation elements.
  43 std::vector<LayerAnimationSequence*> CreateMultiSequence(
  44     LayerAnimationElement* first,
  45     LayerAnimationElement* second) {
  46   LayerAnimationSequence* first_sequence = new LayerAnimationSequence();
  47   first_sequence->AddElement(first);
  48   LayerAnimationSequence* second_sequence = new LayerAnimationSequence();
  49   second_sequence->AddElement(second);
  50
  51   std::vector<ui::LayerAnimationSequence*> animations;
  52   animations.push_back(first_sequence);
  53   animations.push_back(second_sequence);
  54   return animations;
  55 }
  56
  57 class TestImplicitAnimationObserver : public ImplicitAnimationObserver {
  58  public:
  59   explicit TestImplicitAnimationObserver(bool notify_when_animator_destructed)
  60     : animations_completed_(false),
  61       notify_when_animator_destructed_(notify_when_animator_destructed) {
  62   }
  63
  64   bool animations_completed() const { return animations_completed_; }
  65   void set_animations_completed(bool completed) {
  66     animations_completed_ = completed;
  67   }
  68
  69   bool WasAnimationAbortedForProperty(
  70       LayerAnimationElement::AnimatableProperty property) const {
  71     return ImplicitAnimationObserver::WasAnimationAbortedForProperty(property);
  72   }
  73
  74   bool WasAnimationCompletedForProperty(
  75       LayerAnimationElement::AnimatableProperty property) const {
  76     return ImplicitAnimationObserver::WasAnimationCompletedForProperty(
  77         property);
  78   }
  79
  80  private:
  81   // ImplicitAnimationObserver implementation
  82   virtual void OnImplicitAnimationsCompleted() OVERRIDE {
  83     animations_completed_ = true;
  84   }
  85
  86   virtual bool RequiresNotificationWhenAnimatorDestroyed() const OVERRIDE {
  87     return notify_when_animator_destructed_;
  88   }
  89
  90   bool animations_completed_;
  91   bool notify_when_animator_destructed_;
  92
  93   DISALLOW_COPY_AND_ASSIGN(TestImplicitAnimationObserver);
  94 };
  95
  96 // When notified that an animation has ended, stops all other animations.
  97 class DeletingLayerAnimationObserver : public LayerAnimationObserver {
  98  public:
  99   DeletingLayerAnimationObserver(LayerAnimator* animator)
 100     : animator_(animator) {
 101   }
 102
 103   virtual void OnLayerAnimationEnded(
 104       LayerAnimationSequence* sequence) OVERRIDE {
 105     animator_->StopAnimating();
 106   }
 107
 108   virtual void OnLayerAnimationAborted(
 109       LayerAnimationSequence* sequence) OVERRIDE {
 110     animator_->StopAnimating();
 111   }
 112
 113   virtual void OnLayerAnimationScheduled(
 114       LayerAnimationSequence* sequence) OVERRIDE {
 115   }
 116
 117  private:
 118   LayerAnimator* animator_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(DeletingLayerAnimationObserver);
 121 };
 122
 123 class TestLayerAnimator : public LayerAnimator {
 124  public:
 125   TestLayerAnimator() : LayerAnimator(base::TimeDelta::FromSeconds(0)) {}
 126
 127  protected:
 128   virtual ~TestLayerAnimator() {}
 129
 130   virtual void ProgressAnimation(LayerAnimationSequence* sequence,
 131                                  base::TimeTicks now) OVERRIDE {
 132     EXPECT_TRUE(HasAnimation(sequence));
 133     LayerAnimator::ProgressAnimation(sequence, now);
 134   }
 135
 136  private:
 137   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimator);
 138 };
 139
 140 // The test layer animation sequence updates a live instances count when it is
 141 // created and destroyed.
 142 class TestLayerAnimationSequence : public LayerAnimationSequence {
 143  public:
 144   TestLayerAnimationSequence(LayerAnimationElement* element,
 145                              int* num_live_instances)
 146       : LayerAnimationSequence(element),
 147         num_live_instances_(num_live_instances) {
 148     (*num_live_instances_)++;
 149   }
 150
 151   virtual ~TestLayerAnimationSequence() {
 152     (*num_live_instances_)--;
 153   }
 154
 155  private:
 156   int* num_live_instances_;
 157
 158   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimationSequence);
 159 };
 160
 161 } // namespace
 162
 163 // Checks that setting a property on an implicit animator causes an animation to
 164 // happen.
 165 TEST(LayerAnimatorTest, ImplicitAnimation) {
 166   scoped_refptr<LayerAnimator> animator(
 167       LayerAnimator::CreateImplicitAnimator());
 168   AnimationContainerElement* element = animator.get();
 169   animator->set_disable_timer_for_test(true);
 170   TestLayerAnimationDelegate delegate;
 171   animator->SetDelegate(&delegate);
 172   base::TimeTicks now = gfx::FrameTime::Now();
 173   animator->SetBrightness(0.5);
 174   EXPECT_TRUE(animator->is_animating());
 175   element->Step(now + base::TimeDelta::FromSeconds(1));
 176   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), 0.5);
 177 }
 178
 179 // Checks that if the animator is a default animator, that implicit animations
 180 // are not started.
 181 TEST(LayerAnimatorTest, NoImplicitAnimation) {
 182   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 183   animator->set_disable_timer_for_test(true);
 184   TestLayerAnimationDelegate delegate;
 185   animator->SetDelegate(&delegate);
 186   animator->SetBrightness(0.5);
 187   EXPECT_FALSE(animator->is_animating());
 188   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), 0.5);
 189 }
 190
 191 // Checks that StopAnimatingProperty stops animation for that property, and also
 192 // skips the stopped animation to the end.
 193 TEST(LayerAnimatorTest, StopAnimatingProperty) {
 194   scoped_refptr<LayerAnimator> animator(
 195       LayerAnimator::CreateImplicitAnimator());
 196   animator->set_disable_timer_for_test(true);
 197   TestLayerAnimationDelegate delegate;
 198   animator->SetDelegate(&delegate);
 199   double target_opacity(0.5);
 200   gfx::Rect target_bounds(0, 0, 50, 50);
 201   animator->SetOpacity(target_opacity);
 202   animator->SetBounds(target_bounds);
 203   animator->StopAnimatingProperty(LayerAnimationElement::OPACITY);
 204   EXPECT_TRUE(animator->is_animating());
 205   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), 0.5);
 206   animator->StopAnimatingProperty(LayerAnimationElement::BOUNDS);
 207   EXPECT_FALSE(animator->is_animating());
 208   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 209 }
 210
 211 // Checks that multiple running animation for separate properties can be stopped
 212 // simultaneously and that all animations are advanced to their target values.
 213 TEST(LayerAnimatorTest, StopAnimating) {
 214   scoped_refptr<LayerAnimator> animator(
 215       LayerAnimator::CreateImplicitAnimator());
 216   animator->set_disable_timer_for_test(true);
 217   TestLayerAnimationDelegate delegate;
 218   animator->SetDelegate(&delegate);
 219   double target_opacity(0.5);
 220   gfx::Rect target_bounds(0, 0, 50, 50);
 221   animator->SetOpacity(target_opacity);
 222   animator->SetBounds(target_bounds);
 223   EXPECT_TRUE(animator->is_animating());
 224   animator->StopAnimating();
 225   EXPECT_FALSE(animator->is_animating());
 226   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), 0.5);
 227   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 228 }
 229
 230 // Checks that multiple running animation for separate properties can be stopped
 231 // simultaneously and that all animations are advanced to their target values.
 232 TEST(LayerAnimatorTest, AbortAllAnimations) {
 233   scoped_refptr<LayerAnimator> animator(
 234       LayerAnimator::CreateImplicitAnimator());
 235   animator->set_disable_timer_for_test(true);
 236   TestLayerAnimationDelegate delegate;
 237   double initial_opacity(1.0);
 238   gfx::Rect initial_bounds(0, 0, 10, 10);
 239   delegate.SetOpacityFromAnimation(initial_opacity);
 240   delegate.SetBoundsFromAnimation(initial_bounds);
 241   animator->SetDelegate(&delegate);
 242   double target_opacity(0.5);
 243   gfx::Rect target_bounds(0, 0, 50, 50);
 244   animator->SetOpacity(target_opacity);
 245   animator->SetBounds(target_bounds);
 246   EXPECT_TRUE(animator->is_animating());
 247   animator->AbortAllAnimations();
 248   EXPECT_FALSE(animator->is_animating());
 249   EXPECT_FLOAT_EQ(initial_opacity, delegate.GetOpacityForAnimation());
 250   CheckApproximatelyEqual(initial_bounds, delegate.GetBoundsForAnimation());
 251 }
 252
 253 // Schedule a non-threaded animation that can run immediately. This is the
 254 // trivial case and should result in the animation being started immediately.
 255 TEST(LayerAnimatorTest, ScheduleAnimationThatCanRunImmediately) {
 256   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 257   AnimationContainerElement* element = animator.get();
 258   animator->set_disable_timer_for_test(true);
 259   TestLayerAnimationDelegate delegate;
 260   animator->SetDelegate(&delegate);
 261
 262   double start_brightness(0.0);
 263   double middle_brightness(0.5);
 264   double target_brightness(1.0);
 265
 266   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 267
 268   delegate.SetBrightnessFromAnimation(start_brightness);
 269
 270   animator->ScheduleAnimation(
 271       new LayerAnimationSequence(
 272           LayerAnimationElement::CreateBrightnessElement(target_brightness,
 273                                                          delta)));
 274
 275   EXPECT_TRUE(animator->is_animating());
 276   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 277
 278   base::TimeTicks start_time = animator->last_step_time();
 279
 280   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 281
 282   EXPECT_TRUE(animator->is_animating());
 283   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 284
 285   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 286
 287   EXPECT_FALSE(animator->is_animating());
 288   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 289 }
 290
 291 // Schedule a threaded animation that can run immediately.
 292 TEST(LayerAnimatorTest, ScheduleThreadedAnimationThatCanRunImmediately) {
 293   double epsilon = 0.00001;
 294   LayerAnimatorTestController test_controller(
 295       LayerAnimator::CreateDefaultAnimator());
 296   AnimationContainerElement* element = test_controller.animator();
 297   test_controller.animator()->set_disable_timer_for_test(true);
 298   TestLayerAnimationDelegate delegate;
 299   test_controller.animator()->SetDelegate(&delegate);
 300
 301   double start_opacity(0.0);
 302   double target_opacity(1.0);
 303
 304   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 305
 306   delegate.SetOpacityFromAnimation(start_opacity);
 307
 308   test_controller.animator()->ScheduleAnimation(
 309       new LayerAnimationSequence(
 310           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 311
 312   EXPECT_TRUE(test_controller.animator()->is_animating());
 313   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 314
 315   base::TimeTicks start_time = test_controller.animator()->last_step_time();
 316   base::TimeTicks effective_start = start_time + delta;
 317
 318   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
 319       cc::AnimationEvent::Started,
 320       0,
 321       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 322           animation_group_id(),
 323       cc::Animation::Opacity,
 324       (effective_start - base::TimeTicks()).InSecondsF()));
 325
 326   element->Step(effective_start + delta/2);
 327
 328   EXPECT_TRUE(test_controller.animator()->is_animating());
 329   EXPECT_NEAR(
 330       0.5,
 331       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 332           last_progressed_fraction(),
 333       epsilon);
 334
 335   element->Step(effective_start + delta);
 336
 337   EXPECT_FALSE(test_controller.animator()->is_animating());
 338   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 339 }
 340
 341 // Schedule two non-threaded animations on separate properties. Both animations
 342 // should start immediately and should progress in lock step.
 343 TEST(LayerAnimatorTest, ScheduleTwoAnimationsThatCanRunImmediately) {
 344   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 345   AnimationContainerElement* element = animator.get();
 346   animator->set_disable_timer_for_test(true);
 347   TestLayerAnimationDelegate delegate;
 348   animator->SetDelegate(&delegate);
 349
 350   double start_brightness(0.0);
 351   double middle_brightness(0.5);
 352   double target_brightness(1.0);
 353
 354   gfx::Rect start_bounds, target_bounds, middle_bounds;
 355   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
 356   start_bounds.set_x(-90);
 357   target_bounds.set_x(90);
 358
 359   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 360
 361   delegate.SetBrightnessFromAnimation(start_brightness);
 362   delegate.SetBoundsFromAnimation(start_bounds);
 363
 364   animator->ScheduleAnimation(
 365       new LayerAnimationSequence(
 366           LayerAnimationElement::CreateBrightnessElement(target_brightness,
 367                                                          delta)));
 368
 369   animator->ScheduleAnimation(
 370       new LayerAnimationSequence(
 371           LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 372
 373   EXPECT_TRUE(animator->is_animating());
 374   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 375   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 376
 377   base::TimeTicks start_time = animator->last_step_time();
 378
 379   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 380
 381   EXPECT_TRUE(animator->is_animating());
 382   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 383   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), middle_bounds);
 384
 385   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 386
 387   EXPECT_FALSE(animator->is_animating());
 388   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 389   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 390 }
 391
 392 // Schedule a threaded and a non-threaded animation on separate properties. Both
 393 // animations should progress in lock step.
 394 TEST(LayerAnimatorTest, ScheduleThreadedAndNonThreadedAnimations) {
 395   double epsilon = 0.00001;
 396   LayerAnimatorTestController test_controller(
 397       LayerAnimator::CreateDefaultAnimator());
 398   AnimationContainerElement* element = test_controller.animator();
 399   test_controller.animator()->set_disable_timer_for_test(true);
 400   TestLayerAnimationDelegate delegate;
 401   test_controller.animator()->SetDelegate(&delegate);
 402
 403   double start_opacity(0.0);
 404   double target_opacity(1.0);
 405
 406   gfx::Rect start_bounds, target_bounds, middle_bounds;
 407   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
 408   start_bounds.set_x(-90);
 409   target_bounds.set_x(90);
 410
 411   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 412
 413   delegate.SetOpacityFromAnimation(start_opacity);
 414   delegate.SetBoundsFromAnimation(start_bounds);
 415
 416   std::vector<LayerAnimationSequence*> animations;
 417   animations.push_back(
 418       new LayerAnimationSequence(
 419           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 420
 421   animations.push_back(
 422       new LayerAnimationSequence(
 423           LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 424
 425   test_controller.animator()->ScheduleTogether(animations);
 426
 427   EXPECT_TRUE(test_controller.animator()->is_animating());
 428   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 429   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 430
 431   base::TimeTicks start_time = test_controller.animator()->last_step_time();
 432   base::TimeTicks effective_start = start_time + delta;
 433
 434   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
 435       cc::AnimationEvent::Started,
 436       0,
 437       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 438           animation_group_id(),
 439       cc::Animation::Opacity,
 440       (effective_start - base::TimeTicks()).InSecondsF()));
 441
 442   element->Step(effective_start + delta/2);
 443
 444   EXPECT_TRUE(test_controller.animator()->is_animating());
 445   EXPECT_NEAR(
 446       0.5,
 447       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 448           last_progressed_fraction(),
 449       epsilon);
 450   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), middle_bounds);
 451
 452   element->Step(effective_start + delta);
 453
 454   EXPECT_FALSE(test_controller.animator()->is_animating());
 455   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 456   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 457 }
 458
 459 // Schedule two animations on the same property. In this case, the two
 460 // animations should run one after another.
 461 TEST(LayerAnimatorTest, ScheduleTwoAnimationsOnSameProperty) {
 462   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 463   AnimationContainerElement* element = animator.get();
 464   animator->set_disable_timer_for_test(true);
 465   TestLayerAnimationDelegate delegate;
 466   animator->SetDelegate(&delegate);
 467
 468   double start_brightness(0.0);
 469   double middle_brightness(0.5);
 470   double target_brightness(1.0);
 471
 472   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 473
 474   delegate.SetBrightnessFromAnimation(start_brightness);
 475
 476   animator->ScheduleAnimation(
 477       new LayerAnimationSequence(
 478           LayerAnimationElement::CreateBrightnessElement(target_brightness,
 479                                                          delta)));
 480
 481   animator->ScheduleAnimation(
 482       new LayerAnimationSequence(
 483           LayerAnimationElement::CreateBrightnessElement(start_brightness,
 484                                                          delta)));
 485
 486   EXPECT_TRUE(animator->is_animating());
 487   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 488
 489   base::TimeTicks start_time = animator->last_step_time();
 490
 491   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 492
 493   EXPECT_TRUE(animator->is_animating());
 494   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 495
 496   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 497
 498   EXPECT_TRUE(animator->is_animating());
 499   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 500
 501   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 502
 503   EXPECT_TRUE(animator->is_animating());
 504   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 505
 506   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 507
 508   EXPECT_FALSE(animator->is_animating());
 509   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 510 }
 511
 512 // Schedule [{g}, {g,b}, {b}] and ensure that {b} doesn't run right away. That
 513 // is, ensure that all animations targetting a particular property are run in
 514 // order.
 515 TEST(LayerAnimatorTest, ScheduleBlockedAnimation) {
 516   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 517   AnimationContainerElement* element = animator.get();
 518   animator->set_disable_timer_for_test(true);
 519   TestLayerAnimationDelegate delegate;
 520   animator->SetDelegate(&delegate);
 521
 522   double start_grayscale(0.0);
 523   double middle_grayscale(0.5);
 524   double target_grayscale(1.0);
 525
 526   gfx::Rect start_bounds, target_bounds, middle_bounds;
 527   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
 528   start_bounds.set_x(-90);
 529   target_bounds.set_x(90);
 530
 531   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 532
 533   delegate.SetGrayscaleFromAnimation(start_grayscale);
 534   delegate.SetBoundsFromAnimation(start_bounds);
 535
 536   animator->ScheduleAnimation(
 537       new LayerAnimationSequence(
 538           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
 539                                                         delta)));
 540
 541   scoped_ptr<LayerAnimationSequence> bounds_and_grayscale(
 542       new LayerAnimationSequence(
 543           LayerAnimationElement::CreateGrayscaleElement(start_grayscale,
 544                                                         delta)));
 545
 546   bounds_and_grayscale->AddElement(
 547       LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
 548
 549   animator->ScheduleAnimation(bounds_and_grayscale.release());
 550
 551   animator->ScheduleAnimation(
 552       new LayerAnimationSequence(
 553           LayerAnimationElement::CreateBoundsElement(start_bounds, delta)));
 554
 555   EXPECT_TRUE(animator->is_animating());
 556   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
 557   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 558
 559   base::TimeTicks start_time = animator->last_step_time();
 560
 561   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 562
 563   EXPECT_TRUE(animator->is_animating());
 564   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
 565   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 566
 567   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 568
 569   EXPECT_TRUE(animator->is_animating());
 570   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
 571   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 572
 573   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 574
 575   EXPECT_TRUE(animator->is_animating());
 576   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
 577   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 578
 579   element->Step(start_time + base::TimeDelta::FromMilliseconds(3000));
 580
 581   EXPECT_TRUE(animator->is_animating());
 582   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
 583   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 584
 585   element->Step(start_time + base::TimeDelta::FromMilliseconds(4000));
 586
 587   EXPECT_FALSE(animator->is_animating());
 588   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
 589   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 590 }
 591
 592 // Schedule {g} and then schedule {g} and {b} together. In this case, since
 593 // ScheduleTogether is being used, the bounds animation should not start until
 594 // the second grayscale animation starts.
 595 TEST(LayerAnimatorTest, ScheduleTogether) {
 596   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 597   AnimationContainerElement* element = animator.get();
 598   animator->set_disable_timer_for_test(true);
 599   TestLayerAnimationDelegate delegate;
 600   animator->SetDelegate(&delegate);
 601
 602   double start_grayscale(0.0);
 603   double target_grayscale(1.0);
 604
 605   gfx::Rect start_bounds, target_bounds, middle_bounds;
 606   start_bounds = target_bounds = gfx::Rect(0, 0, 50, 50);
 607   start_bounds.set_x(-90);
 608   target_bounds.set_x(90);
 609
 610   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 611
 612   delegate.SetGrayscaleFromAnimation(start_grayscale);
 613   delegate.SetBoundsFromAnimation(start_bounds);
 614
 615   animator->ScheduleAnimation(
 616       new LayerAnimationSequence(
 617           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
 618                                                         delta)));
 619
 620   std::vector<LayerAnimationSequence*> sequences;
 621   sequences.push_back(new LayerAnimationSequence(
 622       LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta)));
 623   sequences.push_back(new LayerAnimationSequence(
 624       LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 625
 626   animator->ScheduleTogether(sequences);
 627
 628   EXPECT_TRUE(animator->is_animating());
 629   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
 630   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 631
 632   base::TimeTicks start_time = animator->last_step_time();
 633
 634   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 635
 636   EXPECT_TRUE(animator->is_animating());
 637   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
 638   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 639
 640   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 641
 642   EXPECT_FALSE(animator->is_animating());
 643   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
 644   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 645 }
 646
 647 // Start non-threaded animation (that can run immediately). This is the trivial
 648 // case (see the trival case for ScheduleAnimation).
 649 TEST(LayerAnimatorTest, StartAnimationThatCanRunImmediately) {
 650   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 651   AnimationContainerElement* element = animator.get();
 652   animator->set_disable_timer_for_test(true);
 653   TestLayerAnimationDelegate delegate;
 654   animator->SetDelegate(&delegate);
 655
 656   double start_brightness(0.0);
 657   double middle_brightness(0.5);
 658   double target_brightness(1.0);
 659
 660   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 661
 662   delegate.SetBrightnessFromAnimation(start_brightness);
 663
 664   animator->StartAnimation(
 665       new LayerAnimationSequence(
 666           LayerAnimationElement::CreateBrightnessElement(target_brightness,
 667                                                          delta)));
 668
 669   EXPECT_TRUE(animator->is_animating());
 670   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 671
 672   base::TimeTicks start_time = animator->last_step_time();
 673
 674   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 675
 676   EXPECT_TRUE(animator->is_animating());
 677   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 678
 679   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 680
 681   EXPECT_FALSE(animator->is_animating());
 682   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 683 }
 684
 685 // Start threaded animation (that can run immediately).
 686 TEST(LayerAnimatorTest, StartThreadedAnimationThatCanRunImmediately) {
 687   double epsilon = 0.00001;
 688   LayerAnimatorTestController test_controller(
 689       LayerAnimator::CreateDefaultAnimator());
 690   AnimationContainerElement* element = test_controller.animator();
 691   test_controller.animator()->set_disable_timer_for_test(true);
 692   TestLayerAnimationDelegate delegate;
 693   test_controller.animator()->SetDelegate(&delegate);
 694
 695   double start_opacity(0.0);
 696   double target_opacity(1.0);
 697
 698   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 699
 700   delegate.SetOpacityFromAnimation(start_opacity);
 701
 702   test_controller.animator()->StartAnimation(
 703       new LayerAnimationSequence(
 704           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 705
 706   EXPECT_TRUE(test_controller.animator()->is_animating());
 707   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 708
 709   base::TimeTicks start_time = test_controller.animator()->last_step_time();
 710   base::TimeTicks effective_start = start_time + delta;
 711
 712   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
 713       cc::AnimationEvent::Started,
 714       0,
 715       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 716           animation_group_id(),
 717       cc::Animation::Opacity,
 718       (effective_start - base::TimeTicks()).InSecondsF()));
 719
 720   element->Step(effective_start + delta/2);
 721
 722   EXPECT_TRUE(test_controller.animator()->is_animating());
 723   EXPECT_NEAR(
 724       0.5,
 725       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 726           last_progressed_fraction(),
 727       epsilon);
 728
 729   element->Step(effective_start + delta);
 730   EXPECT_FALSE(test_controller.animator()->is_animating());
 731   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 732 }
 733
 734 // Preempt by immediately setting new target.
 735 TEST(LayerAnimatorTest, PreemptBySettingNewTarget) {
 736   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 737   animator->set_disable_timer_for_test(true);
 738   TestLayerAnimationDelegate delegate;
 739   animator->SetDelegate(&delegate);
 740
 741   double start_opacity(0.0);
 742   double target_opacity(1.0);
 743
 744   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 745
 746   delegate.SetOpacityFromAnimation(start_opacity);
 747
 748   animator->set_preemption_strategy(LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
 749
 750   animator->StartAnimation(
 751       new LayerAnimationSequence(
 752           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 753
 754   animator->StartAnimation(
 755       new LayerAnimationSequence(
 756           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 757
 758   EXPECT_FALSE(animator->is_animating());
 759   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 760 }
 761
 762 // Preempt by animating to new target, with a non-threaded animation.
 763 TEST(LayerAnimatorTest, PreemptByImmediatelyAnimatingToNewTarget) {
 764   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 765   AnimationContainerElement* element = animator.get();
 766   animator->set_disable_timer_for_test(true);
 767   TestLayerAnimationDelegate delegate;
 768   animator->SetDelegate(&delegate);
 769
 770   double start_brightness(0.0);
 771   double middle_brightness(0.5);
 772   double target_brightness(1.0);
 773
 774   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 775
 776   delegate.SetBrightnessFromAnimation(start_brightness);
 777
 778   animator->set_preemption_strategy(
 779       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 780
 781   animator->StartAnimation(
 782       new LayerAnimationSequence(
 783           LayerAnimationElement::CreateBrightnessElement(target_brightness,
 784                                                          delta)));
 785
 786   base::TimeTicks start_time = animator->last_step_time();
 787
 788   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 789
 790   animator->StartAnimation(
 791       new LayerAnimationSequence(
 792           LayerAnimationElement::CreateBrightnessElement(start_brightness,
 793                                                          delta)));
 794
 795   EXPECT_TRUE(animator->is_animating());
 796   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 797
 798   animator->StartAnimation(
 799       new LayerAnimationSequence(
 800           LayerAnimationElement::CreateBrightnessElement(start_brightness,
 801                                                          delta)));
 802
 803   EXPECT_TRUE(animator->is_animating());
 804
 805   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 806
 807   EXPECT_TRUE(animator->is_animating());
 808   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
 809                   0.5 * (start_brightness + middle_brightness));
 810
 811   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 812
 813   EXPECT_FALSE(animator->is_animating());
 814   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 815 }
 816
 817 // Preempt by animating to new target, with a threaded animation.
 818 TEST(LayerAnimatorTest, PreemptThreadedByImmediatelyAnimatingToNewTarget) {
 819   double epsilon = 0.00001;
 820   LayerAnimatorTestController test_controller(
 821       LayerAnimator::CreateDefaultAnimator());
 822   AnimationContainerElement* element = test_controller.animator();
 823   test_controller.animator()->set_disable_timer_for_test(true);
 824   TestLayerAnimationDelegate delegate;
 825   test_controller.animator()->SetDelegate(&delegate);
 826
 827   double start_opacity(0.0);
 828   double middle_opacity(0.5);
 829   double target_opacity(1.0);
 830
 831   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 832
 833   delegate.SetOpacityFromAnimation(start_opacity);
 834
 835   test_controller.animator()->set_preemption_strategy(
 836       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 837
 838   test_controller.animator()->StartAnimation(
 839       new LayerAnimationSequence(
 840           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 841
 842   base::TimeTicks start_time = test_controller.animator()->last_step_time();
 843   base::TimeTicks effective_start = start_time + delta;
 844
 845   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
 846       cc::AnimationEvent::Started,
 847       0,
 848       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 849           animation_group_id(),
 850       cc::Animation::Opacity,
 851       (effective_start - base::TimeTicks()).InSecondsF()));
 852
 853   element->Step(effective_start + delta/2);
 854
 855   test_controller.animator()->StartAnimation(
 856       new LayerAnimationSequence(
 857           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 858
 859   EXPECT_TRUE(test_controller.animator()->is_animating());
 860   EXPECT_NEAR(delegate.GetOpacityForAnimation(), middle_opacity, epsilon);
 861
 862   test_controller.animator()->StartAnimation(
 863       new LayerAnimationSequence(
 864           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 865
 866   EXPECT_TRUE(test_controller.animator()->is_animating());
 867
 868   base::TimeTicks second_effective_start = effective_start + delta;
 869
 870   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
 871       cc::AnimationEvent::Started,
 872       0,
 873       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 874           animation_group_id(),
 875       cc::Animation::Opacity,
 876       (second_effective_start - base::TimeTicks()).InSecondsF()));
 877
 878   element->Step(second_effective_start + delta/2);
 879
 880   EXPECT_TRUE(test_controller.animator()->is_animating());
 881   EXPECT_NEAR(
 882       0.5,
 883       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
 884           last_progressed_fraction(),
 885       epsilon);
 886
 887   element->Step(second_effective_start + delta);
 888
 889   EXPECT_FALSE(test_controller.animator()->is_animating());
 890   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 891 }
 892
 893 // Preempt by enqueuing the new animation.
 894 TEST(LayerAnimatorTest, PreemptEnqueueNewAnimation) {
 895   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 896   AnimationContainerElement* element = animator.get();
 897   animator->set_disable_timer_for_test(true);
 898   TestLayerAnimationDelegate delegate;
 899   animator->SetDelegate(&delegate);
 900
 901   double start_brightness(0.0);
 902   double middle_brightness(0.5);
 903   double target_brightness(1.0);
 904
 905   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 906
 907   delegate.SetBrightnessFromAnimation(start_brightness);
 908
 909   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
 910
 911   animator->StartAnimation(
 912       new LayerAnimationSequence(
 913           LayerAnimationElement::CreateBrightnessElement(target_brightness,
 914                                                           delta)));
 915
 916   base::TimeTicks start_time = animator->last_step_time();
 917
 918   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 919
 920   animator->StartAnimation(
 921       new LayerAnimationSequence(
 922           LayerAnimationElement::CreateBrightnessElement(start_brightness,
 923                                                          delta)));
 924
 925   EXPECT_TRUE(animator->is_animating());
 926   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 927
 928   EXPECT_TRUE(animator->is_animating());
 929
 930   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 931
 932   EXPECT_TRUE(animator->is_animating());
 933   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 934
 935   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 936
 937   EXPECT_TRUE(animator->is_animating());
 938   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 939
 940   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 941
 942   EXPECT_FALSE(animator->is_animating());
 943   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 944 }
 945
 946 // Start an animation when there are sequences waiting in the queue. In this
 947 // case, all pending and running animations should be finished, and the new
 948 // animation started.
 949 TEST(LayerAnimatorTest, PreemptyByReplacingQueuedAnimations) {
 950   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
 951   AnimationContainerElement* element = animator.get();
 952   animator->set_disable_timer_for_test(true);
 953   TestLayerAnimationDelegate delegate;
 954   animator->SetDelegate(&delegate);
 955
 956   double start_brightness(0.0);
 957   double middle_brightness(0.5);
 958   double target_brightness(1.0);
 959
 960   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 961
 962   delegate.SetBrightnessFromAnimation(start_brightness);
 963
 964   animator->set_preemption_strategy(LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 965
 966   animator->StartAnimation(
 967       new LayerAnimationSequence(
 968           LayerAnimationElement::CreateBrightnessElement(target_brightness,
 969                                                          delta)));
 970
 971   base::TimeTicks start_time = animator->last_step_time();
 972
 973   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 974
 975   animator->StartAnimation(
 976       new LayerAnimationSequence(
 977           LayerAnimationElement::CreateBrightnessElement(middle_brightness,
 978                                                          delta)));
 979
 980   // Queue should now have two animations. Starting a third should replace the
 981   // second.
 982   animator->StartAnimation(
 983       new LayerAnimationSequence(
 984           LayerAnimationElement::CreateBrightnessElement(start_brightness,
 985                                                          delta)));
 986
 987   EXPECT_TRUE(animator->is_animating());
 988   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 989
 990   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 991
 992   EXPECT_TRUE(animator->is_animating());
 993   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 994
 995   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 996
 997   EXPECT_TRUE(animator->is_animating());
 998   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 999
1000   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
1001
1002   EXPECT_FALSE(animator->is_animating());
1003   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
1004 }
1005
1006 TEST(LayerAnimatorTest, StartTogetherSetsLastStepTime) {
1007   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1008   animator->set_disable_timer_for_test(true);
1009   TestLayerAnimationDelegate delegate;
1010   animator->SetDelegate(&delegate);
1011
1012   double start_grayscale(0.0);
1013   double target_grayscale(1.0);
1014   double start_brightness(0.1);
1015   double target_brightness(0.9);
1016
1017   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1018
1019   delegate.SetGrayscaleFromAnimation(start_grayscale);
1020   delegate.SetBrightnessFromAnimation(start_brightness);
1021
1022   animator->set_preemption_strategy(
1023       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
1024
1025   animator->set_last_step_time(base::TimeTicks());
1026
1027   animator->StartTogether(
1028       CreateMultiSequence(
1029           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
1030                                                         delta),
1031           LayerAnimationElement::CreateBrightnessElement(target_brightness,
1032                                                          delta)
1033       ));
1034
1035   // If last step time was not set correctly, the resulting delta should be
1036   // miniscule (fractions of a millisecond). If set correctly, then the delta
1037   // should be enormous. Arbitrarily choosing 1 minute as the threshold,
1038   // though a much smaller value would probably have sufficed.
1039   delta = gfx::FrameTime::Now() - animator->last_step_time();
1040   EXPECT_GT(60.0, delta.InSecondsF());
1041 }
1042
1043 //-------------------------------------------------------
1044 // Preempt by immediately setting new target.
1045 TEST(LayerAnimatorTest, MultiPreemptBySettingNewTarget) {
1046   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1047   animator->set_disable_timer_for_test(true);
1048   TestLayerAnimationDelegate delegate;
1049   animator->SetDelegate(&delegate);
1050
1051   double start_opacity(0.0);
1052   double target_opacity(1.0);
1053   double start_brightness(0.1);
1054   double target_brightness(0.9);
1055
1056   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1057
1058   delegate.SetOpacityFromAnimation(start_opacity);
1059   delegate.SetBrightnessFromAnimation(start_brightness);
1060
1061   animator->set_preemption_strategy(LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
1062
1063   animator->StartTogether(
1064       CreateMultiSequence(
1065           LayerAnimationElement::CreateOpacityElement(target_opacity, delta),
1066           LayerAnimationElement::CreateBrightnessElement(target_brightness,
1067                                                          delta)
1068       ));
1069
1070   animator->StartTogether(
1071       CreateMultiSequence(
1072           LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
1073           LayerAnimationElement::CreateBrightnessElement(start_brightness,
1074                                                          delta)
1075       ));
1076
1077   EXPECT_FALSE(animator->is_animating());
1078   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
1079   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
1080 }
1081
1082 // Preempt by animating to new target.
1083 TEST(LayerAnimatorTest, MultiPreemptByImmediatelyAnimatingToNewTarget) {
1084   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1085   AnimationContainerElement* element = animator.get();
1086   animator->set_disable_timer_for_test(true);
1087   TestLayerAnimationDelegate delegate;
1088   animator->SetDelegate(&delegate);
1089
1090   double start_grayscale(0.0);
1091   double middle_grayscale(0.5);
1092   double target_grayscale(1.0);
1093
1094   double start_brightness(0.1);
1095   double middle_brightness(0.2);
1096   double target_brightness(0.3);
1097
1098   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1099
1100   delegate.SetGrayscaleFromAnimation(start_grayscale);
1101   delegate.SetBrightnessFromAnimation(start_brightness);
1102
1103   animator->set_preemption_strategy(
1104       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
1105
1106   animator->StartTogether(
1107       CreateMultiSequence(
1108           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
1109                                                         delta),
1110           LayerAnimationElement::CreateBrightnessElement(target_brightness,
1111                                                          delta)
1112       ));
1113
1114   base::TimeTicks start_time = animator->last_step_time();
1115
1116   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
1117
1118   animator->StartTogether(
1119       CreateMultiSequence(
1120           LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
1121           LayerAnimationElement::CreateBrightnessElement(start_brightness,
1122                                                          delta)));
1123
1124   EXPECT_TRUE(animator->is_animating());
1125   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
1126   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
1127
1128   animator->StartTogether(
1129       CreateMultiSequence(
1130           LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
1131           LayerAnimationElement::CreateBrightnessElement(start_brightness,
1132                                                          delta)));
1133
1134   EXPECT_TRUE(animator->is_animating());
1135
1136   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
1137
1138   EXPECT_TRUE(animator->is_animating());
1139   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(),
1140                   0.5 * (start_grayscale + middle_grayscale));
1141   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
1142                   0.5 * (start_brightness + middle_brightness));
1143
1144   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
1145
1146   EXPECT_FALSE(animator->is_animating());
1147   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
1148   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
1149 }
1150
1151 // Preempt a threaded animation by animating to new target.
1152 TEST(LayerAnimatorTest, MultiPreemptThreadedByImmediatelyAnimatingToNewTarget) {
1153   double epsilon = 0.00001;
1154   LayerAnimatorTestController test_controller(
1155       LayerAnimator::CreateDefaultAnimator());
1156   AnimationContainerElement* element = test_controller.animator();
1157   test_controller.animator()->set_disable_timer_for_test(true);
1158   TestLayerAnimationDelegate delegate;
1159   test_controller.animator()->SetDelegate(&delegate);
1160
1161   double start_opacity(0.0);
1162   double middle_opacity(0.5);
1163   double target_opacity(1.0);
1164
1165   double start_brightness(0.1);
1166   double middle_brightness(0.2);
1167   double target_brightness(0.3);
1168
1169   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1170
1171   delegate.SetOpacityFromAnimation(start_opacity);
1172   delegate.SetBrightnessFromAnimation(start_brightness);
1173
1174   test_controller.animator()->set_preemption_strategy(
1175       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
1176
1177   test_controller.animator()->StartTogether(
1178       CreateMultiSequence(
1179           LayerAnimationElement::CreateOpacityElement(target_opacity, delta),
1180           LayerAnimationElement::CreateBrightnessElement(target_brightness,
1181                                                          delta)
1182       ));
1183
1184   base::TimeTicks start_time = test_controller.animator()->last_step_time();
1185   base::TimeTicks effective_start = start_time + delta;
1186
1187   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
1188       cc::AnimationEvent::Started,
1189       0,
1190       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
1191           animation_group_id(),
1192       cc::Animation::Opacity,
1193       (effective_start - base::TimeTicks()).InSecondsF()));
1194
1195   element->Step(effective_start + delta/2);
1196
1197   test_controller.animator()->StartTogether(
1198       CreateMultiSequence(
1199           LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
1200           LayerAnimationElement::CreateBrightnessElement(start_brightness,
1201                                                          delta)));
1202
1203   EXPECT_TRUE(test_controller.animator()->is_animating());
1204   EXPECT_NEAR(delegate.GetOpacityForAnimation(), middle_opacity, epsilon);
1205   EXPECT_NEAR(delegate.GetBrightnessForAnimation(), middle_brightness, epsilon);
1206
1207   test_controller.animator()->StartTogether(
1208       CreateMultiSequence(
1209           LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
1210           LayerAnimationElement::CreateBrightnessElement(start_brightness,
1211                                                          delta)));
1212
1213   EXPECT_TRUE(test_controller.animator()->is_animating());
1214
1215   base::TimeTicks second_effective_start = effective_start + delta;
1216
1217   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
1218       cc::AnimationEvent::Started,
1219       0,
1220       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
1221           animation_group_id(),
1222       cc::Animation::Opacity,
1223       (second_effective_start - base::TimeTicks()).InSecondsF()));
1224
1225   element->Step(second_effective_start + delta/2);
1226
1227   EXPECT_TRUE(test_controller.animator()->is_animating());
1228   EXPECT_NEAR(
1229       0.5,
1230       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
1231           last_progressed_fraction(),
1232       epsilon);
1233   EXPECT_NEAR(delegate.GetBrightnessForAnimation(),
1234               0.5 * (start_brightness + middle_brightness),
1235               epsilon);
1236
1237   element->Step(second_effective_start + delta);
1238
1239   EXPECT_FALSE(test_controller.animator()->is_animating());
1240   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
1241   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
1242 }
1243
1244 // Preempt by enqueuing the new animation.
1245 TEST(LayerAnimatorTest, MultiPreemptEnqueueNewAnimation) {
1246   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1247   AnimationContainerElement* element = animator.get();
1248   animator->set_disable_timer_for_test(true);
1249   TestLayerAnimationDelegate delegate;
1250   animator->SetDelegate(&delegate);
1251
1252   double start_grayscale(0.0);
1253   double middle_grayscale(0.5);
1254   double target_grayscale(1.0);
1255
1256   double start_brightness(0.1);
1257   double middle_brightness(0.2);
1258   double target_brightness(0.3);
1259
1260   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1261
1262   delegate.SetGrayscaleFromAnimation(start_grayscale);
1263   delegate.SetBrightnessFromAnimation(start_brightness);
1264
1265   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
1266
1267   animator->StartTogether(
1268       CreateMultiSequence(
1269           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
1270                                                         delta),
1271           LayerAnimationElement::CreateBrightnessElement(target_brightness,
1272                                                          delta)));
1273
1274   base::TimeTicks start_time = animator->last_step_time();
1275
1276   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
1277
1278   animator->StartTogether(
1279       CreateMultiSequence(
1280           LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
1281           LayerAnimationElement::CreateBrightnessElement(start_brightness,
1282                                                          delta)));
1283
1284   EXPECT_TRUE(animator->is_animating());
1285   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
1286   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
1287
1288   EXPECT_TRUE(animator->is_animating());
1289
1290   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
1291
1292   EXPECT_TRUE(animator->is_animating());
1293   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
1294   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
1295
1296   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
1297
1298   EXPECT_TRUE(animator->is_animating());
1299   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
1300   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
1301
1302   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
1303
1304   EXPECT_FALSE(animator->is_animating());
1305   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
1306   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
1307 }
1308
1309 // Start an animation when there are sequences waiting in the queue. In this
1310 // case, all pending and running animations should be finished, and the new
1311 // animation started.
1312 TEST(LayerAnimatorTest, MultiPreemptByReplacingQueuedAnimations) {
1313   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1314   AnimationContainerElement* element = animator.get();
1315   animator->set_disable_timer_for_test(true);
1316   TestLayerAnimationDelegate delegate;
1317   animator->SetDelegate(&delegate);
1318
1319   double start_grayscale(0.0);
1320   double middle_grayscale(0.5);
1321   double target_grayscale(1.0);
1322
1323   double start_brightness(0.1);
1324   double middle_brightness(0.2);
1325   double target_brightness(0.3);
1326
1327   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1328
1329   delegate.SetGrayscaleFromAnimation(start_grayscale);
1330   delegate.SetBrightnessFromAnimation(start_brightness);
1331
1332   animator->set_preemption_strategy(LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
1333
1334   animator->StartTogether(
1335       CreateMultiSequence(
1336           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
1337                                                         delta),
1338           LayerAnimationElement::CreateBrightnessElement(target_brightness,
1339                                                          delta)));
1340
1341   base::TimeTicks start_time = animator->last_step_time();
1342
1343   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
1344
1345   animator->StartTogether(
1346       CreateMultiSequence(
1347           LayerAnimationElement::CreateGrayscaleElement(middle_grayscale,
1348                                                         delta),
1349           LayerAnimationElement::CreateBrightnessElement(middle_brightness,
1350                                                          delta)));
1351
1352   // Queue should now have two animations. Starting a third should replace the
1353   // second.
1354   animator->StartTogether(
1355       CreateMultiSequence(
1356           LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
1357           LayerAnimationElement::CreateBrightnessElement(start_brightness,
1358                                                          delta)));
1359
1360   EXPECT_TRUE(animator->is_animating());
1361   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
1362   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
1363
1364   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
1365
1366   EXPECT_TRUE(animator->is_animating());
1367   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
1368   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
1369
1370   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
1371
1372   EXPECT_TRUE(animator->is_animating());
1373   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
1374   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
1375
1376   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
1377
1378   EXPECT_FALSE(animator->is_animating());
1379   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
1380   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
1381 }
1382 //-------------------------------------------------------
1383 // Test that non-threaded cyclic sequences continue to animate.
1384 TEST(LayerAnimatorTest, CyclicSequences) {
1385   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1386   AnimationContainerElement* element = animator.get();
1387   animator->set_disable_timer_for_test(true);
1388   TestLayerAnimationDelegate delegate;
1389   animator->SetDelegate(&delegate);
1390
1391   double start_brightness(0.0);
1392   double target_brightness(1.0);
1393
1394   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1395
1396   delegate.SetBrightnessFromAnimation(start_brightness);
1397
1398   scoped_ptr<LayerAnimationSequence> sequence(
1399       new LayerAnimationSequence(
1400           LayerAnimationElement::CreateBrightnessElement(target_brightness,
1401                                                          delta)));
1402
1403   sequence->AddElement(
1404       LayerAnimationElement::CreateBrightnessElement(start_brightness, delta));
1405
1406   sequence->set_is_cyclic(true);
1407
1408   animator->StartAnimation(sequence.release());
1409
1410   base::TimeTicks start_time = animator->last_step_time();
1411
1412   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
1413
1414   EXPECT_TRUE(animator->is_animating());
1415   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
1416
1417   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
1418
1419   EXPECT_TRUE(animator->is_animating());
1420   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
1421
1422   element->Step(start_time + base::TimeDelta::FromMilliseconds(3000));
1423
1424   EXPECT_TRUE(animator->is_animating());
1425   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
1426
1427   // Skip ahead by a lot.
1428   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000000000));
1429
1430   EXPECT_TRUE(animator->is_animating());
1431   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
1432
1433   // Skip ahead by a lot.
1434   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000001000));
1435
1436   EXPECT_TRUE(animator->is_animating());
1437   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
1438
1439   animator->StopAnimatingProperty(LayerAnimationElement::BRIGHTNESS);
1440
1441   EXPECT_FALSE(animator->is_animating());
1442 }
1443
1444 // Test that threaded cyclic sequences continue to animate.
1445 TEST(LayerAnimatorTest, ThreadedCyclicSequences) {
1446   LayerAnimatorTestController test_controller(
1447       LayerAnimator::CreateDefaultAnimator());
1448   AnimationContainerElement* element = test_controller.animator();
1449   test_controller.animator()->set_disable_timer_for_test(true);
1450   TestLayerAnimationDelegate delegate;
1451   test_controller.animator()->SetDelegate(&delegate);
1452
1453   double start_opacity(0.0);
1454   double target_opacity(1.0);
1455
1456   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1457
1458   delegate.SetOpacityFromAnimation(start_opacity);
1459
1460   scoped_ptr<LayerAnimationSequence> sequence(
1461       new LayerAnimationSequence(
1462           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
1463
1464   sequence->AddElement(
1465       LayerAnimationElement::CreateOpacityElement(start_opacity, delta));
1466
1467   sequence->set_is_cyclic(true);
1468
1469   test_controller.animator()->StartAnimation(sequence.release());
1470
1471   base::TimeTicks start_time = test_controller.animator()->last_step_time();
1472   base::TimeTicks effective_start = start_time + delta;
1473
1474   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
1475       cc::AnimationEvent::Started,
1476       0,
1477       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
1478           animation_group_id(),
1479       cc::Animation::Opacity,
1480       (effective_start - base::TimeTicks()).InSecondsF()));
1481
1482   element->Step(effective_start + delta);
1483   EXPECT_TRUE(test_controller.animator()->is_animating());
1484   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
1485
1486   base::TimeTicks second_effective_start = effective_start + 2 * delta;
1487   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
1488       cc::AnimationEvent::Started,
1489       0,
1490       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
1491           animation_group_id(),
1492       cc::Animation::Opacity,
1493       (second_effective_start - base::TimeTicks()).InSecondsF()));
1494
1495   element->Step(second_effective_start + delta);
1496
1497   EXPECT_TRUE(test_controller.animator()->is_animating());
1498   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
1499
1500   base::TimeTicks third_effective_start = second_effective_start + 2 * delta;
1501   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
1502       cc::AnimationEvent::Started,
1503       0,
1504       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
1505           animation_group_id(),
1506       cc::Animation::Opacity,
1507       (third_effective_start - base::TimeTicks()).InSecondsF()));
1508
1509   element->Step(third_effective_start + delta);
1510   EXPECT_TRUE(test_controller.animator()->is_animating());
1511   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
1512
1513   base::TimeTicks fourth_effective_start = third_effective_start + 2 * delta;
1514   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
1515       cc::AnimationEvent::Started,
1516       0,
1517       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
1518           animation_group_id(),
1519       cc::Animation::Opacity,
1520       (fourth_effective_start - base::TimeTicks()).InSecondsF()));
1521
1522   // Skip ahead by a lot.
1523   element->Step(fourth_effective_start + 1000 * delta);
1524
1525   EXPECT_TRUE(test_controller.animator()->is_animating());
1526   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
1527
1528   base::TimeTicks fifth_effective_start = fourth_effective_start + 1001 * delta;
1529   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
1530       cc::AnimationEvent::Started,
1531       0,
1532       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
1533           animation_group_id(),
1534       cc::Animation::Opacity,
1535       (fifth_effective_start - base::TimeTicks()).InSecondsF()));
1536
1537   // Skip ahead by a lot.
1538   element->Step(fifth_effective_start + 999 * delta);
1539
1540   EXPECT_TRUE(test_controller.animator()->is_animating());
1541   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
1542
1543   test_controller.animator()->StopAnimatingProperty(
1544       LayerAnimationElement::OPACITY);
1545
1546   EXPECT_FALSE(test_controller.animator()->is_animating());
1547 }
1548
1549 TEST(LayerAnimatorTest, AddObserverExplicit) {
1550   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1551   AnimationContainerElement* element = animator.get();
1552   animator->set_disable_timer_for_test(true);
1553   TestLayerAnimationObserver observer;
1554   TestLayerAnimationDelegate delegate;
1555   animator->SetDelegate(&delegate);
1556   animator->AddObserver(&observer);
1557   observer.set_requires_notification_when_animator_destroyed(true);
1558
1559   EXPECT_TRUE(!observer.last_ended_sequence());
1560
1561   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1562
1563   delegate.SetBrightnessFromAnimation(0.0f);
1564
1565   LayerAnimationSequence* sequence = new LayerAnimationSequence(
1566       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
1567
1568   animator->StartAnimation(sequence);
1569
1570   EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
1571
1572   base::TimeTicks start_time = animator->last_step_time();
1573
1574   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
1575
1576   EXPECT_EQ(observer.last_ended_sequence(), sequence);
1577
1578   // |sequence| has been destroyed. Recreate it to test abort.
1579   sequence = new LayerAnimationSequence(
1580       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
1581
1582   animator->StartAnimation(sequence);
1583
1584   animator = NULL;
1585
1586   EXPECT_EQ(observer.last_aborted_sequence(), sequence);
1587 }
1588
1589 // Tests that an observer added to a scoped settings object is still notified
1590 // when the object goes out of scope.
1591 TEST(LayerAnimatorTest, ImplicitAnimationObservers) {
1592   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1593   AnimationContainerElement* element = animator.get();
1594   animator->set_disable_timer_for_test(true);
1595   TestImplicitAnimationObserver observer(false);
1596   TestLayerAnimationDelegate delegate;
1597   animator->SetDelegate(&delegate);
1598
1599   EXPECT_FALSE(observer.animations_completed());
1600   animator->SetBrightness(1.0f);
1601
1602   {
1603     ScopedLayerAnimationSettings settings(animator.get());
1604     settings.AddObserver(&observer);
1605     animator->SetBrightness(0.0f);
1606   }
1607
1608   EXPECT_FALSE(observer.animations_completed());
1609   base::TimeTicks start_time = animator->last_step_time();
1610   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
1611   EXPECT_TRUE(observer.animations_completed());
1612   EXPECT_TRUE(observer.WasAnimationCompletedForProperty(
1613       LayerAnimationElement::BRIGHTNESS));
1614   EXPECT_FLOAT_EQ(0.0f, delegate.GetBrightnessForAnimation());
1615 }
1616
1617 // Tests that an observer added to a scoped settings object is still notified
1618 // when the object goes out of scope due to the animation being interrupted.
1619 TEST(LayerAnimatorTest, InterruptedImplicitAnimationObservers) {
1620   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1621   animator->set_disable_timer_for_test(true);
1622   TestImplicitAnimationObserver observer(false);
1623   TestLayerAnimationDelegate delegate;
1624   animator->SetDelegate(&delegate);
1625
1626   EXPECT_FALSE(observer.animations_completed());
1627   animator->SetBrightness(1.0f);
1628
1629   {
1630     ScopedLayerAnimationSettings settings(animator.get());
1631     settings.AddObserver(&observer);
1632     animator->SetBrightness(0.0f);
1633   }
1634
1635   EXPECT_FALSE(observer.animations_completed());
1636   // This should interrupt the implicit animation causing the observer to be
1637   // notified immediately.
1638   animator->SetBrightness(1.0f);
1639   EXPECT_TRUE(observer.animations_completed());
1640   EXPECT_TRUE(observer.WasAnimationCompletedForProperty(
1641       LayerAnimationElement::BRIGHTNESS));
1642   EXPECT_FLOAT_EQ(1.0f, delegate.GetBrightnessForAnimation());
1643 }
1644
1645 // Tests that an observer added to a scoped settings object is not notified
1646 // when the animator is destroyed unless explicitly requested.
1647 TEST(LayerAnimatorTest, ImplicitObserversAtAnimatorDestruction) {
1648   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1649   animator->set_disable_timer_for_test(true);
1650   TestImplicitAnimationObserver observer_notify(true);
1651   TestImplicitAnimationObserver observer_do_not_notify(false);
1652   TestLayerAnimationDelegate delegate;
1653   animator->SetDelegate(&delegate);
1654
1655   EXPECT_FALSE(observer_notify.animations_completed());
1656   EXPECT_FALSE(observer_do_not_notify.animations_completed());
1657
1658   animator->SetBrightness(1.0f);
1659
1660   {
1661     ScopedLayerAnimationSettings settings(animator.get());
1662     settings.AddObserver(&observer_notify);
1663     settings.AddObserver(&observer_do_not_notify);
1664     animator->SetBrightness(0.0f);
1665   }
1666
1667   EXPECT_FALSE(observer_notify.animations_completed());
1668   EXPECT_FALSE(observer_do_not_notify.animations_completed());
1669   animator = NULL;
1670   EXPECT_TRUE(observer_notify.animations_completed());
1671   EXPECT_TRUE(observer_notify.WasAnimationAbortedForProperty(
1672       LayerAnimationElement::BRIGHTNESS));
1673   EXPECT_FALSE(observer_do_not_notify.animations_completed());
1674 }
1675
1676 TEST(LayerAnimatorTest, AbortedAnimationStatusInImplicitObservers) {
1677   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1678   animator->set_disable_timer_for_test(true);
1679   TestImplicitAnimationObserver observer(false);
1680   TestLayerAnimationDelegate delegate;
1681   animator->SetDelegate(&delegate);
1682
1683   EXPECT_FALSE(observer.animations_completed());
1684   animator->SetBrightness(1.0f);
1685
1686   {
1687     ScopedLayerAnimationSettings settings(animator.get());
1688     settings.AddObserver(&observer);
1689     animator->SetBrightness(0.0f);
1690   }
1691   EXPECT_FALSE(observer.animations_completed());
1692
1693   animator->AbortAllAnimations();
1694   EXPECT_TRUE(observer.animations_completed());
1695   EXPECT_TRUE(observer.WasAnimationAbortedForProperty(
1696       LayerAnimationElement::BRIGHTNESS));
1697   EXPECT_FALSE(observer.WasAnimationAbortedForProperty(
1698       LayerAnimationElement::OPACITY));
1699
1700   observer.set_animations_completed(false);
1701   {
1702     ScopedLayerAnimationSettings settings(animator.get());
1703     settings.AddObserver(&observer);
1704     animator->SetOpacity(0.0f);
1705   }
1706   EXPECT_FALSE(observer.animations_completed());
1707
1708   animator->AbortAllAnimations();
1709   EXPECT_TRUE(observer.animations_completed());
1710   EXPECT_TRUE(observer.WasAnimationAbortedForProperty(
1711       LayerAnimationElement::BRIGHTNESS));
1712   EXPECT_TRUE(observer.WasAnimationAbortedForProperty(
1713       LayerAnimationElement::OPACITY));
1714 }
1715
1716 TEST(LayerAnimatorTest, RemoveObserverShouldRemoveFromSequences) {
1717   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1718   AnimationContainerElement* element = animator.get();
1719   animator->set_disable_timer_for_test(true);
1720   TestLayerAnimationObserver observer;
1721   TestLayerAnimationObserver removed_observer;
1722   TestLayerAnimationDelegate delegate;
1723   animator->SetDelegate(&delegate);
1724
1725   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1726
1727   LayerAnimationSequence* sequence = new LayerAnimationSequence(
1728       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
1729
1730   sequence->AddObserver(&observer);
1731   sequence->AddObserver(&removed_observer);
1732
1733   animator->StartAnimation(sequence);
1734
1735   EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
1736   EXPECT_TRUE(!observer.last_ended_sequence());
1737   EXPECT_EQ(removed_observer.last_scheduled_sequence(), sequence);
1738   EXPECT_TRUE(!removed_observer.last_ended_sequence());
1739
1740   // This should stop the observer from observing sequence.
1741   animator->RemoveObserver(&removed_observer);
1742
1743   base::TimeTicks start_time = animator->last_step_time();
1744
1745   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
1746
1747   EXPECT_EQ(observer.last_ended_sequence(), sequence);
1748   EXPECT_TRUE(!removed_observer.last_ended_sequence());
1749 }
1750
1751 TEST(LayerAnimatorTest, ObserverReleasedBeforeAnimationSequenceEnds) {
1752   TestLayerAnimationDelegate delegate;
1753   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1754   animator->set_disable_timer_for_test(true);
1755
1756   scoped_ptr<TestLayerAnimationObserver> observer(
1757       new TestLayerAnimationObserver);
1758   animator->SetDelegate(&delegate);
1759   animator->AddObserver(observer.get());
1760
1761   delegate.SetOpacityFromAnimation(0.0f);
1762
1763   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1764   LayerAnimationSequence* sequence = new LayerAnimationSequence(
1765       LayerAnimationElement::CreateOpacityElement(1.0f, delta));
1766
1767   animator->StartAnimation(sequence);
1768
1769   // |observer| should be attached to |sequence|.
1770   EXPECT_TRUE(sequence->observers_.might_have_observers());
1771
1772   // Now, release |observer|
1773   observer.reset();
1774
1775   // And |sequence| should no longer be attached to |observer|.
1776   EXPECT_FALSE(sequence->observers_.might_have_observers());
1777 }
1778
1779 TEST(LayerAnimatorTest, ObserverAttachedAfterAnimationStarted) {
1780   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1781   AnimationContainerElement* element = animator.get();
1782   animator->set_disable_timer_for_test(true);
1783
1784   TestImplicitAnimationObserver observer(false);
1785   TestLayerAnimationDelegate delegate;
1786   animator->SetDelegate(&delegate);
1787
1788   delegate.SetBrightnessFromAnimation(0.0f);
1789
1790   {
1791     ScopedLayerAnimationSettings setter(animator.get());
1792
1793     base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1794     LayerAnimationSequence* sequence = new LayerAnimationSequence(
1795         LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
1796
1797     animator->StartAnimation(sequence);
1798     base::TimeTicks start_time = animator->last_step_time();
1799     element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
1800
1801     setter.AddObserver(&observer);
1802
1803     // Start observing an in-flight animation.
1804     sequence->AddObserver(&observer);
1805
1806     element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
1807   }
1808
1809   EXPECT_TRUE(observer.animations_completed());
1810   EXPECT_TRUE(observer.WasAnimationCompletedForProperty(
1811                   LayerAnimationElement::BRIGHTNESS));
1812 }
1813
1814 TEST(LayerAnimatorTest, ObserverDetachedBeforeAnimationFinished) {
1815   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
1816   AnimationContainerElement* element = animator.get();
1817   animator->set_disable_timer_for_test(true);
1818
1819   TestImplicitAnimationObserver observer(false);
1820   TestLayerAnimationDelegate delegate;
1821   animator->SetDelegate(&delegate);
1822
1823   delegate.SetBrightnessFromAnimation(0.0f);
1824   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
1825   LayerAnimationSequence* sequence = new LayerAnimationSequence(
1826       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
1827
1828   {
1829     ScopedLayerAnimationSettings setter(animator.get());
1830     setter.AddObserver(&observer);
1831
1832     animator->StartAnimation(sequence);
1833     base::TimeTicks start_time = animator->last_step_time();
1834     element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
1835   }
1836
1837   EXPECT_FALSE(observer.animations_completed());
1838
1839   // Stop observing an in-flight animation.
1840   sequence->RemoveObserver(&observer);
1841
1842   EXPECT_TRUE(observer.animations_completed());
1843
1844   // The animation didn't complete, and neither was it aborted.
1845   EXPECT_FALSE(observer.WasAnimationCompletedForProperty(
1846                   LayerAnimationElement::BRIGHTNESS));
1847   EXPECT_FALSE(observer.WasAnimationAbortedForProperty(
1848                   LayerAnimationElement::BRIGHTNESS));
1849 }
1850
1851 // This checks that if an animation is deleted due to a callback, that the
1852 // animator does not try to use the deleted animation. For example, if we have
1853 // two running animations, and the first finishes and the resulting callback
1854 // causes the second to be deleted, we should not attempt to animate the second
1855 // animation.
1856 TEST(LayerAnimatorTest, ObserverDeletesAnimationsOnEnd) {
1857   ScopedAnimationDurationScaleMode normal_duration_mode(
1858       ScopedAnimationDurationScaleMode::NORMAL_DURATION);
1859   scoped_refptr<LayerAnimator> animator(new TestLayerAnimator());
1860   AnimationContainerElement* element = animator.get();
1861   animator->set_disable_timer_for_test(true);
1862   TestLayerAnimationDelegate delegate;
1863   animator->SetDelegate(&delegate);
1864
1865   double start_brightness(0.0);
1866   double target_brightness(1.0);
1867
1868   gfx::Rect start_bounds(0, 0, 50, 50);
1869   gfx::Rect target_bounds(5, 5, 5, 5);
1870
1871   delegate.SetBrightnessFromAnimation(start_brightness);
1872   delegate.SetBoundsFromAnimation(start_bounds);
1873
1874   base::TimeDelta brightness_delta = base::TimeDelta::FromSeconds(1);
1875   base::TimeDelta halfway_delta = base::TimeDelta::FromSeconds(2);
1876   base::TimeDelta bounds_delta = base::TimeDelta::FromSeconds(3);
1877
1878   scoped_ptr<DeletingLayerAnimationObserver> observer(
1879       new DeletingLayerAnimationObserver(animator.get()));
1880
1881   animator->AddObserver(observer.get());
1882
1883   animator->StartAnimation(
1884       new LayerAnimationSequence(
1885           LayerAnimationElement::CreateBrightnessElement(
1886               target_brightness, brightness_delta)));
1887
1888   animator->StartAnimation(new LayerAnimationSequence(
1889       LayerAnimationElement::CreateBoundsElement(
1890           target_bounds, bounds_delta)));
1891   ASSERT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
1892
1893   base::TimeTicks start_time = animator->last_step_time();
1894   element->Step(start_time + halfway_delta);
1895
1896   // Completing the brightness animation should have stopped the bounds
1897   // animation.
1898   ASSERT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
1899
1900   animator->RemoveObserver(observer.get());
1901 }
1902
1903 // Ensure that stopping animation in a bounds change does not crash and that
1904 // animation gets stopped correctly.
1905 // This scenario is possible when animation is restarted from inside a
1906 // callback triggered by the animation progress.
1907 TEST(LayerAnimatorTest, CallbackDeletesAnimationInProgress) {
1908
1909   class TestLayerAnimationDeletingDelegate : public TestLayerAnimationDelegate {
1910    public:
1911     TestLayerAnimationDeletingDelegate(LayerAnimator* animator, int max_width)
1912       : animator_(animator),
1913         max_width_(max_width) {
1914     }
1915
1916     virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) OVERRIDE {
1917       TestLayerAnimationDelegate::SetBoundsFromAnimation(bounds);
1918       if (bounds.width() > max_width_)
1919         animator_->StopAnimating();
1920     }
1921    private:
1922     LayerAnimator* animator_;
1923     int max_width_;
1924     // Allow copy and assign.
1925   };
1926
1927   ScopedAnimationDurationScaleMode normal_duration_mode(
1928       ScopedAnimationDurationScaleMode::NORMAL_DURATION);
1929   scoped_refptr<LayerAnimator> animator(new TestLayerAnimator());
1930   AnimationContainerElement* element = animator.get();
1931   animator->set_disable_timer_for_test(true);
1932   TestLayerAnimationDeletingDelegate delegate(animator.get(), 30);
1933   animator->SetDelegate(&delegate);
1934
1935   gfx::Rect start_bounds(0, 0, 0, 0);
1936   gfx::Rect target_bounds(5, 5, 50, 50);
1937
1938   delegate.SetBoundsFromAnimation(start_bounds);
1939
1940   base::TimeDelta bounds_delta1 = base::TimeDelta::FromMilliseconds(333);
1941   base::TimeDelta bounds_delta2 = base::TimeDelta::FromMilliseconds(666);
1942   base::TimeDelta bounds_delta = base::TimeDelta::FromMilliseconds(1000);
1943   base::TimeDelta final_delta = base::TimeDelta::FromMilliseconds(1500);
1944
1945   animator->StartAnimation(new LayerAnimationSequence(
1946       LayerAnimationElement::CreateBoundsElement(
1947           target_bounds, bounds_delta)));
1948   ASSERT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
1949
1950   base::TimeTicks start_time = animator->last_step_time();
1951   ASSERT_NO_FATAL_FAILURE(element->Step(start_time + bounds_delta1));
1952   ASSERT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
1953
1954   // The next step should change the animated bounds past the threshold and
1955   // cause the animaton to stop.
1956   ASSERT_NO_FATAL_FAILURE(element->Step(start_time + bounds_delta2));
1957   ASSERT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
1958   ASSERT_NO_FATAL_FAILURE(element->Step(start_time + final_delta));
1959
1960   // Completing the animation should have stopped the bounds
1961   // animation.
1962   ASSERT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
1963 }
1964
1965 // Similar to the ObserverDeletesAnimationsOnEnd test above except that it
1966 // tests the behavior when the OnLayerAnimationAborted() callback causes
1967 // all of the animator's other animations to be deleted.
1968 TEST(LayerAnimatorTest, ObserverDeletesAnimationsOnAbort) {
1969   ScopedAnimationDurationScaleMode normal_duration_mode(
1970       ScopedAnimationDurationScaleMode::NORMAL_DURATION);
1971   scoped_refptr<LayerAnimator> animator(new TestLayerAnimator());
1972   animator->set_disable_timer_for_test(true);
1973   TestLayerAnimationDelegate delegate;
1974   animator->SetDelegate(&delegate);
1975
1976   double start_brightness(0.0);
1977   double target_brightness(1.0);
1978   gfx::Rect start_bounds(0, 0, 50, 50);
1979   gfx::Rect target_bounds(5, 5, 5, 5);
1980   base::TimeDelta brightness_delta = base::TimeDelta::FromSeconds(1);
1981   base::TimeDelta bounds_delta = base::TimeDelta::FromSeconds(2);
1982
1983   delegate.SetBrightnessFromAnimation(start_brightness);
1984   delegate.SetBoundsFromAnimation(start_bounds);
1985
1986   scoped_ptr<DeletingLayerAnimationObserver> observer(
1987       new DeletingLayerAnimationObserver(animator.get()));
1988   animator->AddObserver(observer.get());
1989
1990   animator->StartAnimation(
1991       new LayerAnimationSequence(
1992           LayerAnimationElement::CreateBrightnessElement(
1993               target_brightness, brightness_delta)));
1994   animator->StartAnimation(new LayerAnimationSequence(
1995       LayerAnimationElement::CreateBoundsElement(
1996           target_bounds, bounds_delta)));
1997   ASSERT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
1998
1999   animator->set_preemption_strategy(
2000       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
2001   animator->StartAnimation(
2002       new LayerAnimationSequence(
2003           LayerAnimationElement::CreateBrightnessElement(
2004               target_brightness, brightness_delta)));
2005
2006   // Starting the second brightness animation should have aborted the initial
2007   // brightness animation. |observer| should have stopped the bounds animation
2008   // as a result.
2009   ASSERT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
2010
2011   animator->RemoveObserver(observer.get());
2012 }
2013
2014 // Check that setting a property during an animation with a default animator
2015 // cancels the original animation.
2016 TEST(LayerAnimatorTest, SettingPropertyDuringAnAnimation) {
2017   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
2018   animator->set_disable_timer_for_test(true);
2019   TestLayerAnimationDelegate delegate;
2020   animator->SetDelegate(&delegate);
2021
2022   double start_opacity(0.0);
2023   double target_opacity(1.0);
2024
2025   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
2026
2027   delegate.SetOpacityFromAnimation(start_opacity);
2028
2029   scoped_ptr<LayerAnimationSequence> sequence(
2030       new LayerAnimationSequence(
2031           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
2032
2033   animator->StartAnimation(sequence.release());
2034
2035   animator->SetOpacity(0.5);
2036
2037   EXPECT_FALSE(animator->is_animating());
2038   EXPECT_EQ(0.5, animator->GetTargetOpacity());
2039 }
2040
2041 // Tests that the preemption mode IMMEDIATELY_SET_NEW_TARGET, doesn't cause the
2042 // second sequence to be leaked.
2043 TEST(LayerAnimatorTest, ImmediatelySettingNewTargetDoesNotLeak) {
2044   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
2045   animator->set_preemption_strategy(LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
2046   animator->set_disable_timer_for_test(true);
2047   TestLayerAnimationDelegate delegate;
2048   animator->SetDelegate(&delegate);
2049
2050   gfx::Rect start_bounds(0, 0, 50, 50);
2051   gfx::Rect middle_bounds(10, 10, 100, 100);
2052   gfx::Rect target_bounds(5, 5, 5, 5);
2053
2054   delegate.SetBoundsFromAnimation(start_bounds);
2055
2056   {
2057     // start an implicit bounds animation.
2058     ScopedLayerAnimationSettings settings(animator.get());
2059     animator->SetBounds(middle_bounds);
2060   }
2061
2062   EXPECT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
2063
2064   int num_live_instances = 0;
2065   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
2066   scoped_ptr<TestLayerAnimationSequence> sequence(
2067       new TestLayerAnimationSequence(
2068           LayerAnimationElement::CreateBoundsElement(target_bounds, delta),
2069           &num_live_instances));
2070
2071   EXPECT_EQ(1, num_live_instances);
2072
2073   // This should interrupt the running sequence causing us to immediately set
2074   // the target value. The sequence should alse be destructed.
2075   animator->StartAnimation(sequence.release());
2076
2077   EXPECT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
2078   EXPECT_EQ(0, num_live_instances);
2079   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
2080 }
2081
2082 // Verifies GetTargetOpacity() works when multiple sequences are scheduled.
2083 TEST(LayerAnimatorTest, GetTargetOpacity) {
2084   TestLayerAnimationDelegate delegate;
2085   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
2086   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
2087   animator->set_disable_timer_for_test(true);
2088   animator->SetDelegate(&delegate);
2089
2090   delegate.SetOpacityFromAnimation(0.0);
2091
2092   {
2093     ScopedLayerAnimationSettings settings(animator.get());
2094     animator->SetOpacity(0.5);
2095     EXPECT_EQ(0.5, animator->GetTargetOpacity());
2096
2097     // Because the strategy is ENQUEUE_NEW_ANIMATION the target should now be 1.
2098     animator->SetOpacity(1.0);
2099     EXPECT_EQ(1.0, animator->GetTargetOpacity());
2100   }
2101 }
2102
2103 // Verifies GetTargetBrightness() works when multiple sequences are scheduled.
2104 TEST(LayerAnimatorTest, GetTargetBrightness) {
2105   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
2106   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
2107   animator->set_disable_timer_for_test(true);
2108   TestLayerAnimationDelegate delegate;
2109   animator->SetDelegate(&delegate);
2110
2111   delegate.SetBrightnessFromAnimation(0.0);
2112
2113   {
2114     ScopedLayerAnimationSettings settings(animator.get());
2115     animator->SetBrightness(0.5);
2116     EXPECT_EQ(0.5, animator->GetTargetBrightness());
2117
2118     // Because the strategy is ENQUEUE_NEW_ANIMATION the target should now be 1.
2119     animator->SetBrightness(1.0);
2120     EXPECT_EQ(1.0, animator->GetTargetBrightness());
2121   }
2122 }
2123
2124 // Verifies GetTargetGrayscale() works when multiple sequences are scheduled.
2125 TEST(LayerAnimatorTest, GetTargetGrayscale) {
2126   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
2127   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
2128   animator->set_disable_timer_for_test(true);
2129   TestLayerAnimationDelegate delegate;
2130   animator->SetDelegate(&delegate);
2131
2132   delegate.SetGrayscaleFromAnimation(0.0);
2133
2134   {
2135     ScopedLayerAnimationSettings settings(animator.get());
2136     animator->SetGrayscale(0.5);
2137     EXPECT_EQ(0.5, animator->GetTargetGrayscale());
2138
2139     // Because the strategy is ENQUEUE_NEW_ANIMATION the target should now be 1.
2140     animator->SetGrayscale(1.0);
2141     EXPECT_EQ(1.0, animator->GetTargetGrayscale());
2142   }
2143 }
2144
2145 // Verifies color property is modified appropriately.
2146 TEST(LayerAnimatorTest, Color) {
2147   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
2148   AnimationContainerElement* element = animator.get();
2149   animator->set_disable_timer_for_test(true);
2150   TestLayerAnimationDelegate delegate;
2151   animator->SetDelegate(&delegate);
2152
2153   SkColor start_color  = SkColorSetARGB( 64, 20, 40,  60);
2154   SkColor middle_color = SkColorSetARGB(128, 35, 70, 120);
2155   SkColor target_color = SkColorSetARGB(192, 40, 80, 140);
2156
2157   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
2158
2159   delegate.SetColorFromAnimation(start_color);
2160
2161   animator->ScheduleAnimation(
2162       new LayerAnimationSequence(
2163           LayerAnimationElement::CreateColorElement(target_color, delta)));
2164
2165   EXPECT_TRUE(animator->is_animating());
2166   EXPECT_EQ(ColorToString(start_color),
2167             ColorToString(delegate.GetColorForAnimation()));
2168
2169   base::TimeTicks start_time = animator->last_step_time();
2170
2171   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
2172
2173   EXPECT_TRUE(animator->is_animating());
2174   EXPECT_EQ(ColorToString(middle_color),
2175             ColorToString(delegate.GetColorForAnimation()));
2176
2177   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
2178
2179   EXPECT_FALSE(animator->is_animating());
2180   EXPECT_EQ(ColorToString(target_color),
2181             ColorToString(delegate.GetColorForAnimation()));
2182 }
2183
2184 // Verifies SchedulePauseForProperties().
2185 TEST(LayerAnimatorTest, SchedulePauseForProperties) {
2186   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
2187   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
2188   animator->SchedulePauseForProperties(
2189       base::TimeDelta::FromMilliseconds(100),
2190       LayerAnimationElement::TRANSFORM | LayerAnimationElement::BOUNDS);
2191   EXPECT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::TRANSFORM));
2192   EXPECT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
2193   EXPECT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::OPACITY));
2194 }
2195
2196
2197 class AnimatorOwner {
2198 public:
2199   AnimatorOwner()
2200       : animator_(LayerAnimator::CreateDefaultAnimator()) {
2201   }
2202
2203   LayerAnimator* animator() { return animator_.get(); }
2204
2205 private:
2206   scoped_refptr<LayerAnimator> animator_;
2207
2208   DISALLOW_COPY_AND_ASSIGN(AnimatorOwner);
2209 };
2210
2211 class DeletingObserver : public LayerAnimationObserver {
2212 public:
2213   DeletingObserver(bool* was_deleted)
2214       : animator_owner_(new AnimatorOwner),
2215         delete_on_animation_ended_(false),
2216         delete_on_animation_aborted_(false),
2217         delete_on_animation_scheduled_(false),
2218         was_deleted_(was_deleted) {
2219     animator()->AddObserver(this);
2220   }
2221
2222   virtual ~DeletingObserver() {
2223     animator()->RemoveObserver(this);
2224     *was_deleted_ = true;
2225   }
2226
2227   LayerAnimator* animator() { return animator_owner_->animator(); }
2228
2229   bool delete_on_animation_ended() const {
2230     return delete_on_animation_ended_;
2231   }
2232   void set_delete_on_animation_ended(bool enabled) {
2233     delete_on_animation_ended_ = enabled;
2234   }
2235
2236   bool delete_on_animation_aborted() const {
2237     return delete_on_animation_aborted_;
2238   }
2239   void set_delete_on_animation_aborted(bool enabled) {
2240     delete_on_animation_aborted_ = enabled;
2241   }
2242
2243   bool delete_on_animation_scheduled() const {
2244     return delete_on_animation_scheduled_;
2245   }
2246   void set_delete_on_animation_scheduled(bool enabled) {
2247     delete_on_animation_scheduled_ = enabled;
2248   }
2249
2250   // LayerAnimationObserver implementation.
2251   virtual void OnLayerAnimationEnded(
2252       LayerAnimationSequence* sequence) OVERRIDE {
2253     if (delete_on_animation_ended_)
2254       delete this;
2255   }
2256
2257   virtual void OnLayerAnimationAborted(
2258       LayerAnimationSequence* sequence) OVERRIDE {
2259     if (delete_on_animation_aborted_)
2260       delete this;
2261   }
2262
2263   virtual void OnLayerAnimationScheduled(
2264       LayerAnimationSequence* sequence) OVERRIDE {
2265     if (delete_on_animation_scheduled_)
2266       delete this;
2267   }
2268
2269 private:
2270   scoped_ptr<AnimatorOwner> animator_owner_;
2271   bool delete_on_animation_ended_;
2272   bool delete_on_animation_aborted_;
2273   bool delete_on_animation_scheduled_;
2274   bool* was_deleted_;
2275
2276   DISALLOW_COPY_AND_ASSIGN(DeletingObserver);
2277 };
2278
2279 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterFinishingAnimation) {
2280   bool observer_was_deleted = false;
2281   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
2282   observer->set_delete_on_animation_ended(true);
2283   observer->set_delete_on_animation_aborted(true);
2284   LayerAnimator* animator = observer->animator();
2285   AnimationContainerElement* element = observer->animator();
2286   animator->set_disable_timer_for_test(true);
2287   TestLayerAnimationDelegate delegate;
2288   animator->SetDelegate(&delegate);
2289
2290   delegate.SetBrightnessFromAnimation(0.0f);
2291
2292   gfx::Rect start_bounds(0, 0, 50, 50);
2293   gfx::Rect target_bounds(10, 10, 100, 100);
2294
2295   delegate.SetBoundsFromAnimation(start_bounds);
2296
2297   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
2298   LayerAnimationSequence* brightness_sequence = new LayerAnimationSequence(
2299       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
2300   animator->StartAnimation(brightness_sequence);
2301
2302   delta = base::TimeDelta::FromSeconds(2);
2303   LayerAnimationSequence* bounds_sequence = new LayerAnimationSequence(
2304       LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
2305   animator->StartAnimation(bounds_sequence);
2306
2307   base::TimeTicks start_time = animator->last_step_time();
2308   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
2309
2310   EXPECT_TRUE(observer_was_deleted);
2311 }
2312
2313 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterStoppingAnimating) {
2314   bool observer_was_deleted = false;
2315   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
2316   observer->set_delete_on_animation_ended(true);
2317   observer->set_delete_on_animation_aborted(true);
2318   LayerAnimator* animator = observer->animator();
2319   animator->set_disable_timer_for_test(true);
2320   TestLayerAnimationDelegate delegate;
2321   animator->SetDelegate(&delegate);
2322
2323   delegate.SetOpacityFromAnimation(0.0f);
2324
2325   gfx::Rect start_bounds(0, 0, 50, 50);
2326   gfx::Rect target_bounds(10, 10, 100, 100);
2327
2328   delegate.SetBoundsFromAnimation(start_bounds);
2329
2330   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
2331   LayerAnimationSequence* opacity_sequence = new LayerAnimationSequence(
2332       LayerAnimationElement::CreateOpacityElement(1.0f, delta));
2333   animator->StartAnimation(opacity_sequence);
2334
2335   delta = base::TimeDelta::FromSeconds(2);
2336   LayerAnimationSequence* bounds_sequence = new LayerAnimationSequence(
2337       LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
2338   animator->StartAnimation(bounds_sequence);
2339
2340   animator->StopAnimating();
2341
2342   EXPECT_TRUE(observer_was_deleted);
2343 }
2344
2345 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterScheduling) {
2346   bool observer_was_deleted = false;
2347   TestLayerAnimationDelegate delegate;
2348   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
2349   observer->set_delete_on_animation_scheduled(true);
2350   LayerAnimator* animator = observer->animator();
2351   animator->set_disable_timer_for_test(true);
2352   animator->SetDelegate(&delegate);
2353
2354   delegate.SetOpacityFromAnimation(0.0f);
2355
2356   gfx::Rect start_bounds(0, 0, 50, 50);
2357   gfx::Rect target_bounds(10, 10, 100, 100);
2358
2359   delegate.SetBoundsFromAnimation(start_bounds);
2360
2361   std::vector<LayerAnimationSequence*> to_start;
2362
2363   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
2364   to_start.push_back(new LayerAnimationSequence(
2365       LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
2366
2367   delta = base::TimeDelta::FromSeconds(2);
2368   to_start.push_back(new LayerAnimationSequence(
2369       LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
2370
2371   animator->ScheduleTogether(to_start);
2372
2373   EXPECT_TRUE(observer_was_deleted);
2374 }
2375
2376 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterAborted) {
2377   bool observer_was_deleted = false;
2378   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
2379   TestLayerAnimationDelegate delegate;
2380   observer->set_delete_on_animation_aborted(true);
2381   LayerAnimator* animator = observer->animator();
2382   animator->set_preemption_strategy(
2383       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
2384   animator->set_disable_timer_for_test(true);
2385   animator->SetDelegate(&delegate);
2386
2387   delegate.SetOpacityFromAnimation(0.0f);
2388
2389   gfx::Rect start_bounds(0, 0, 50, 50);
2390   gfx::Rect target_bounds(10, 10, 100, 100);
2391
2392   delegate.SetBoundsFromAnimation(start_bounds);
2393
2394   std::vector<LayerAnimationSequence*> to_start;
2395
2396   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
2397   to_start.push_back(new LayerAnimationSequence(
2398       LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
2399
2400   delta = base::TimeDelta::FromSeconds(2);
2401   to_start.push_back(new LayerAnimationSequence(
2402       LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
2403
2404   animator->ScheduleTogether(to_start);
2405
2406   EXPECT_FALSE(observer_was_deleted);
2407
2408   animator->StartAnimation(new LayerAnimationSequence(
2409       LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
2410
2411   EXPECT_TRUE(observer_was_deleted);
2412 }
2413
2414
2415 TEST(LayerAnimatorTest, TestSetterRespectEnqueueStrategy) {
2416   TestLayerAnimationDelegate delegate;
2417   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
2418   animator->set_disable_timer_for_test(true);
2419
2420   animator->SetDelegate(&delegate);
2421
2422   float start_opacity = 0.0f;
2423   float target_opacity = 1.0f;
2424   float magic_opacity = 0.123f;
2425
2426   delegate.SetOpacityFromAnimation(start_opacity);
2427
2428   ScopedLayerAnimationSettings settings(animator.get());
2429   settings.SetPreemptionStrategy(
2430       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
2431   settings.SetTransitionDuration(base::TimeDelta::FromSeconds(1));
2432   animator->SetOpacity(target_opacity);
2433
2434   EXPECT_EQ(start_opacity, delegate.GetOpacityForAnimation());
2435
2436   settings.SetPreemptionStrategy(
2437       LayerAnimator::ENQUEUE_NEW_ANIMATION);
2438   settings.SetTransitionDuration(base::TimeDelta());
2439   animator->SetOpacity(magic_opacity);
2440
2441   EXPECT_EQ(start_opacity, delegate.GetOpacityForAnimation());
2442 }
2443
2444 TEST(LayerAnimatorTest, TestScopedCounterAnimation) {
2445   Layer parent, child;
2446   parent.Add(&child);
2447
2448   gfx::Transform parent_begin, parent_end;
2449
2450   parent_end.Scale3d(2.0, 0.5, 1.0);
2451
2452   // Parent animates from identity to the end value. The counter animation will
2453   // start at the end value and animate back to identity.
2454   gfx::Transform child_begin(parent_end);
2455
2456   child.SetTransform(child_begin);
2457   parent.SetTransform(parent_begin);
2458
2459   EXPECT_FALSE(child.GetAnimator()->is_animating());
2460
2461   ScopedLayerAnimationSettings settings(parent.GetAnimator());
2462   settings.SetInverselyAnimatedBaseLayer(&parent);
2463   settings.AddInverselyAnimatedLayer(&child);
2464
2465   parent.SetTransform(parent_end);
2466
2467   EXPECT_TRUE(child.GetAnimator()->is_animating());
2468   EXPECT_TRUE(child.GetTargetTransform().IsIdentity())
2469     << child.GetTargetTransform().ToString();
2470
2471 }
2472
2473 }  // namespace ui