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