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