Added LayerAnimationObserver::OnLayerAnimationStarted() notification.

ui/compositor/layer_animator_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/compositor/layer_animator.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 36 matching lines @@
   first_sequence->AddElement(first);
   LayerAnimationSequence* second_sequence = new LayerAnimationSequence();
   second_sequence->AddElement(second);
 
   std::vector<ui::LayerAnimationSequence*> animations;
   animations.push_back(first_sequence);
   animations.push_back(second_sequence);
   return animations;
 }
 
+// Creates a default animator with timers disabled for test. |delegate| and
+// |observer| are attached if non-null.
+LayerAnimator* CreateDefaultTestAnimator(LayerAnimationDelegate* delegate,
+                                         LayerAnimationObserver* observer) {
+  LayerAnimator* animator(LayerAnimator::CreateDefaultAnimator());
+  animator->set_disable_timer_for_test(true);
+  if (delegate)
+    animator->SetDelegate(delegate);
+  if (observer)
+    animator->AddObserver(observer);
+  return animator;
+}
+
+// Creates a default animator with timers disabled for test. |delegate| is
+// attached if non-null.
+LayerAnimator* CreateDefaultTestAnimator(LayerAnimationDelegate* delegate) {
+  return CreateDefaultTestAnimator(delegate, nullptr);
+}
+
+// Creates a default animator with timers disabled for test.
+LayerAnimator* CreateDefaultTestAnimator() {
+  return CreateDefaultTestAnimator(nullptr, nullptr);
+}
+
+// Creates an implicit animator with timers disabled for test. |delegate| and
+// |observer| are attached if non-null.
+LayerAnimator* CreateImplicitTestAnimator(LayerAnimationDelegate* delegate,
+                                          LayerAnimationObserver* observer) {
+  LayerAnimator* animator(LayerAnimator::CreateImplicitAnimator());
+  animator->set_disable_timer_for_test(true);
+  if (delegate)
+    animator->SetDelegate(delegate);
+  if (observer)
+    animator->AddObserver(observer);
+  return animator;
+}
+
+// Creates an implicit animator with timers disabled for test. |delegate| is
+// attached if non-null.
+LayerAnimator* CreateImplicitTestAnimator(LayerAnimationDelegate* delegate) {
+  return CreateImplicitTestAnimator(delegate, nullptr);
+}
+
+// Creates an implicit animator with timers disabled for test.
+LayerAnimator* CreateImplicitTestAnimator() {
+  return CreateImplicitTestAnimator(nullptr, nullptr);
+}
+
 class TestImplicitAnimationObserver : public ImplicitAnimationObserver {
  public:
   explicit TestImplicitAnimationObserver(bool notify_when_animator_destructed)
     : animations_completed_(false),
       notify_when_animator_destructed_(notify_when_animator_destructed) {
   }
 
   bool animations_completed() const { return animations_completed_; }
   void set_animations_completed(bool completed) {
     animations_completed_ = completed;
@@ skipping 114 matching lines @@
   int* num_live_instances_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimationSequence);
 };
 
 } // namespace
 
 // Checks that setting a property on an implicit animator causes an animation to
 // happen.
 TEST(LayerAnimatorTest, ImplicitAnimation) {
-  scoped_refptr<LayerAnimator> animator(
-      LayerAnimator::CreateImplicitAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateImplicitTestAnimator(&delegate));
   base::TimeTicks now = base::TimeTicks::Now();
   animator->SetBrightness(0.5);
   EXPECT_TRUE(animator->is_animating());
   animator->Step(now + base::TimeDelta::FromSeconds(1));
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), 0.5);
 }
 
 // Checks that if the animator is a default animator, that implicit animations
 // are not started.
 TEST(LayerAnimatorTest, NoImplicitAnimation) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   animator->SetBrightness(0.5);
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), 0.5);
 }
 
 // Checks that StopAnimatingProperty stops animation for that property, and also
 // skips the stopped animation to the end.
 TEST(LayerAnimatorTest, StopAnimatingProperty) {
-  scoped_refptr<LayerAnimator> animator(
-      LayerAnimator::CreateImplicitAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateImplicitTestAnimator(&delegate));
   double target_opacity(0.5);
   gfx::Rect target_bounds(0, 0, 50, 50);
   animator->SetOpacity(target_opacity);
   animator->SetBounds(target_bounds);
   animator->StopAnimatingProperty(LayerAnimationElement::OPACITY);
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), 0.5);
   animator->StopAnimatingProperty(LayerAnimationElement::BOUNDS);
   EXPECT_FALSE(animator->is_animating());
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
-// Checks that multiple running animation for separate properties can be stopped
-// simultaneously and that all animations are advanced to their target values.
+// Checks that multiple running animations for separate properties can be
+// stopped simultaneously and that all animations are advanced to their target
+// values.
 TEST(LayerAnimatorTest, StopAnimating) {
-  scoped_refptr<LayerAnimator> animator(
-      LayerAnimator::CreateImplicitAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateImplicitTestAnimator(&delegate));
   double target_opacity(0.5);
   gfx::Rect target_bounds(0, 0, 50, 50);
   animator->SetOpacity(target_opacity);
   animator->SetBounds(target_bounds);
   EXPECT_TRUE(animator->is_animating());
   animator->StopAnimating();
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), 0.5);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
-// Checks that multiple running animation for separate properties can be stopped
-// simultaneously and that all animations are advanced to their target values.
+// Checks that multiple running animations for separate properties can be
+// stopped simultaneously and that aborted animations are NOT advanced to their
+// target values.
 TEST(LayerAnimatorTest, AbortAllAnimations) {
-  scoped_refptr<LayerAnimator> animator(
-      LayerAnimator::CreateImplicitAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   double initial_opacity(1.0);
   gfx::Rect initial_bounds(0, 0, 10, 10);
   delegate.SetOpacityFromAnimation(initial_opacity);
   delegate.SetBoundsFromAnimation(initial_bounds);
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateImplicitTestAnimator(&delegate));
   double target_opacity(0.5);
   gfx::Rect target_bounds(0, 0, 50, 50);
   animator->SetOpacity(target_opacity);
   animator->SetBounds(target_bounds);
   EXPECT_TRUE(animator->is_animating());
   animator->AbortAllAnimations();
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(initial_opacity, delegate.GetOpacityForAnimation());
   CheckApproximatelyEqual(initial_bounds, delegate.GetBoundsForAnimation());
 }
 
 // Schedule a non-threaded animation that can run immediately. This is the
 // trivial case and should result in the animation being started immediately.
 TEST(LayerAnimatorTest, ScheduleAnimationThatCanRunImmediately) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->ScheduleAnimation(
@@ skipping 13 matching lines @@
 
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 }
 
 // Schedule a threaded animation that can run immediately.
 TEST(LayerAnimatorTest, ScheduleThreadedAnimationThatCanRunImmediately) {
   double epsilon = 0.00001;
+  TestLayerAnimationDelegate delegate;
   LayerAnimatorTestController test_controller(
-      LayerAnimator::CreateDefaultAnimator());
+      CreateDefaultTestAnimator(&delegate));
   LayerAnimator* animator = test_controller.animator();
-  test_controller.animator()->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   test_controller.animator()->ScheduleAnimation(
       new LayerAnimationSequence(
@@ skipping 22 matching lines @@
 
   animator->Step(effective_start + delta);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 }
 
 // Schedule two non-threaded animations on separate properties. Both animations
 // should start immediately and should progress in lock step.
 TEST(LayerAnimatorTest, ScheduleTwoAnimationsThatCanRunImmediately) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
   target_bounds.set_x(90);
 
@@ skipping 27 matching lines @@
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Schedule a threaded and a non-threaded animation on separate properties. Both
 // animations should progress in lock step.
 TEST(LayerAnimatorTest, ScheduleThreadedAndNonThreadedAnimations) {
   double epsilon = 0.00001;
+  TestLayerAnimationDelegate delegate;
   LayerAnimatorTestController test_controller(
-      LayerAnimator::CreateDefaultAnimator());
+      CreateDefaultTestAnimator(&delegate));
   LayerAnimator* animator = test_controller.animator();
-  test_controller.animator()->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
   target_bounds.set_x(90);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
@@ skipping 38 matching lines @@
   animator->Step(effective_start + delta);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Schedule two animations on the same property. In this case, the two
 // animations should run one after another.
 TEST(LayerAnimatorTest, ScheduleTwoAnimationsOnSameProperty) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->ScheduleAnimation(
@@ skipping 29 matching lines @@
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Schedule [{g}, {g,b}, {b}] and ensure that {b} doesn't run right away. That
 // is, ensure that all animations targetting a particular property are run in
 // order.
 TEST(LayerAnimatorTest, ScheduleBlockedAnimation) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_grayscale(0.0);
   double middle_grayscale(0.5);
   double target_grayscale(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
   target_bounds.set_x(90);
 
@@ skipping 55 matching lines @@
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 }
 
 // Schedule {g} and then schedule {g} and {b} together. In this case, since
 // ScheduleTogether is being used, the bounds animation should not start until
 // the second grayscale animation starts.
 TEST(LayerAnimatorTest, ScheduleTogether) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_grayscale(0.0);
   double target_grayscale(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
   target_bounds.set_x(90);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
@@ skipping 29 matching lines @@
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Start non-threaded animation (that can run immediately). This is the trivial
 // case (see the trival case for ScheduleAnimation).
 TEST(LayerAnimatorTest, StartAnimationThatCanRunImmediately) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->StartAnimation(
@@ skipping 13 matching lines @@
 
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 }
 
 // Start threaded animation (that can run immediately).
 TEST(LayerAnimatorTest, StartThreadedAnimationThatCanRunImmediately) {
   double epsilon = 0.00001;
+  TestLayerAnimationDelegate delegate;
   LayerAnimatorTestController test_controller(
-      LayerAnimator::CreateDefaultAnimator());
+      CreateDefaultTestAnimator(&delegate));
   LayerAnimator* animator = test_controller.animator();
-  test_controller.animator()->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   test_controller.animator()->StartAnimation(
       new LayerAnimationSequence(
@@ skipping 20 matching lines @@
           last_progressed_fraction(),
       epsilon);
 
   animator->Step(effective_start + delta);
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 }
 
 // Preempt by immediately setting new target.
 TEST(LayerAnimatorTest, PreemptBySettingNewTarget) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   animator->set_preemption_strategy(LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // Preempt by animating to new target, with a non-threaded animation.
 TEST(LayerAnimatorTest, PreemptByImmediatelyAnimatingToNewTarget) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(
@@ skipping 31 matching lines @@
 
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt by animating to new target, with a threaded animation.
 TEST(LayerAnimatorTest, PreemptThreadedByImmediatelyAnimatingToNewTarget) {
   double epsilon = 0.00001;
+  TestLayerAnimationDelegate delegate;
   LayerAnimatorTestController test_controller(
-      LayerAnimator::CreateDefaultAnimator());
+      CreateDefaultTestAnimator(&delegate));
   LayerAnimator* animator = test_controller.animator();
-  test_controller.animator()->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double middle_opacity(0.5);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   test_controller.animator()->set_preemption_strategy(
@@ skipping 45 matching lines @@
       epsilon);
 
   animator->Step(second_effective_start + delta);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // Preempt by enqueuing the new animation.
 TEST(LayerAnimatorTest, PreemptEnqueueNewAnimation) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
@@ skipping 30 matching lines @@
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Start an animation when there are sequences waiting in the queue. In this
 // case, all pending and running animations should be finished, and the new
 // animation started.
 TEST(LayerAnimatorTest, PreemptyByReplacingQueuedAnimations) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
@@ skipping 32 matching lines @@
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 TEST(LayerAnimatorTest, StartTogetherSetsLastStepTime) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_grayscale(0.0);
   double target_grayscale(1.0);
   double start_brightness(0.1);
   double target_brightness(0.9);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBrightnessFromAnimation(start_brightness);
@@ skipping 15 matching lines @@
   // miniscule (fractions of a millisecond). If set correctly, then the delta
   // should be enormous. Arbitrarily choosing 1 minute as the threshold,
   // though a much smaller value would probably have sufficed.
   delta = base::TimeTicks::Now() - animator->last_step_time();
   EXPECT_GT(60.0, delta.InSecondsF());
 }
 
 //-------------------------------------------------------
 // Preempt by immediately setting new target.
 TEST(LayerAnimatorTest, MultiPreemptBySettingNewTarget) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_opacity(0.0);
   double target_opacity(1.0);
   double start_brightness(0.1);
   double target_brightness(0.9);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
   delegate.SetBrightnessFromAnimation(start_brightness);
@@ skipping 14 matching lines @@
                                                          delta)
       ));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt by animating to new target.
 TEST(LayerAnimatorTest, MultiPreemptByImmediatelyAnimatingToNewTarget) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_grayscale(0.0);
   double middle_grayscale(0.5);
   double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
@@ skipping 45 matching lines @@
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt a threaded animation by animating to new target.
 TEST(LayerAnimatorTest, MultiPreemptThreadedByImmediatelyAnimatingToNewTarget) {
   double epsilon = 0.00001;
+  TestLayerAnimationDelegate delegate;
   LayerAnimatorTestController test_controller(
-      LayerAnimator::CreateDefaultAnimator());
+      CreateDefaultTestAnimator(&delegate));
   LayerAnimator* animator = test_controller.animator();
-  test_controller.animator()->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double middle_opacity(0.5);
   double target_opacity(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
@@ skipping 62 matching lines @@
 
   animator->Step(second_effective_start + delta);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt by enqueuing the new animation.
 TEST(LayerAnimatorTest, MultiPreemptEnqueueNewAnimation) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_grayscale(0.0);
   double middle_grayscale(0.5);
   double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
@@ skipping 42 matching lines @@
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Start an animation when there are sequences waiting in the queue. In this
 // case, all pending and running animations should be finished, and the new
 // animation started.
 TEST(LayerAnimatorTest, MultiPreemptByReplacingQueuedAnimations) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_grayscale(0.0);
   double middle_grayscale(0.5);
   double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
@@ skipping 47 matching lines @@
 
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 //-------------------------------------------------------
 // Test that non-threaded cyclic sequences continue to animate.
 TEST(LayerAnimatorTest, CyclicSequences) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   scoped_ptr<LayerAnimationSequence> sequence(
       new LayerAnimationSequence(
@@ skipping 36 matching lines @@
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   animator->StopAnimatingProperty(LayerAnimationElement::BRIGHTNESS);
 
   EXPECT_FALSE(animator->is_animating());
 }
 
 // Test that threaded cyclic sequences continue to animate.
 TEST(LayerAnimatorTest, ThreadedCyclicSequences) {
+  TestLayerAnimationDelegate delegate;
   LayerAnimatorTestController test_controller(
-      LayerAnimator::CreateDefaultAnimator());
+      CreateDefaultTestAnimator(&delegate));
   LayerAnimator* animator = test_controller.animator();
-  test_controller.animator()->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   scoped_ptr<LayerAnimationSequence> sequence(
       new LayerAnimationSequence(
@@ skipping 68 matching lines @@
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
   test_controller.animator()->StopAnimatingProperty(
       LayerAnimationElement::OPACITY);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
 }
 
 TEST(LayerAnimatorTest, AddObserverExplicit) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationObserver observer;
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
-  animator->AddObserver(&observer);
+  scoped_refptr<LayerAnimator> animator(
+      CreateDefaultTestAnimator(&delegate, &observer));
   observer.set_requires_notification_when_animator_destroyed(true);
 
   EXPECT_TRUE(!observer.last_ended_sequence());
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(0.0f);
 
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
@@ skipping 15 matching lines @@
   animator->StartAnimation(sequence);
 
   animator = NULL;
 
   EXPECT_EQ(observer.last_aborted_sequence(), sequence);
 }
 
 // Tests that an observer added to a scoped settings object is still notified
 // when the object goes out of scope.
 TEST(LayerAnimatorTest, ImplicitAnimationObservers) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   TestImplicitAnimationObserver observer(false);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
   animator->SetBrightness(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer);
     animator->SetBrightness(0.0f);
   }
 
   EXPECT_FALSE(observer.animations_completed());
   base::TimeTicks start_time = animator->last_step_time();
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_TRUE(observer.WasAnimationCompletedForProperty(
       LayerAnimationElement::BRIGHTNESS));
   EXPECT_FLOAT_EQ(0.0f, delegate.GetBrightnessForAnimation());
 }
 
 // Tests that an observer added to a scoped settings object is still notified
 // when the object goes out of scope due to the animation being interrupted.
 TEST(LayerAnimatorTest, InterruptedImplicitAnimationObservers) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   TestImplicitAnimationObserver observer(false);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
   animator->SetBrightness(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer);
     animator->SetBrightness(0.0f);
   }
 
@@ skipping 26 matching lines @@
     animator->Step(now + base::TimeDelta::FromSeconds(1));
     EXPECT_FALSE(destruction_observer.IsAnimatorDeleted());
   }
   // ScopedLayerAnimationSettings was destroyed, so Animator should be deleted.
   EXPECT_TRUE(destruction_observer.IsAnimatorDeleted());
 }
 
 // Tests that an observer added to a scoped settings object is not notified
 // when the animator is destroyed unless explicitly requested.
 TEST(LayerAnimatorTest, ImplicitObserversAtAnimatorDestruction) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   TestImplicitAnimationObserver observer_notify(true);
   TestImplicitAnimationObserver observer_do_not_notify(false);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer_notify.animations_completed());
   EXPECT_FALSE(observer_do_not_notify.animations_completed());
 
   animator->SetBrightness(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer_notify);
     settings.AddObserver(&observer_do_not_notify);
     animator->SetBrightness(0.0f);
   }
 
   EXPECT_FALSE(observer_notify.animations_completed());
   EXPECT_FALSE(observer_do_not_notify.animations_completed());
   animator = NULL;
   EXPECT_TRUE(observer_notify.animations_completed());
   EXPECT_TRUE(observer_notify.WasAnimationAbortedForProperty(
       LayerAnimationElement::BRIGHTNESS));
   EXPECT_FALSE(observer_do_not_notify.animations_completed());
 }
 
 TEST(LayerAnimatorTest, AbortedAnimationStatusInImplicitObservers) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   TestImplicitAnimationObserver observer(false);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
   animator->SetBrightness(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer);
     animator->SetBrightness(0.0f);
   }
   EXPECT_FALSE(observer.animations_completed());
@@ skipping 15 matching lines @@
 
   animator->AbortAllAnimations();
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_TRUE(observer.WasAnimationAbortedForProperty(
       LayerAnimationElement::BRIGHTNESS));
   EXPECT_TRUE(observer.WasAnimationAbortedForProperty(
       LayerAnimationElement::OPACITY));
 }
 
 TEST(LayerAnimatorTest, RemoveObserverShouldRemoveFromSequences) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   TestLayerAnimationObserver observer;
   TestLayerAnimationObserver removed_observer;
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   sequence->AddObserver(&observer);
   sequence->AddObserver(&removed_observer);
 
   animator->StartAnimation(sequence);
 
   EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
   EXPECT_TRUE(!observer.last_ended_sequence());
   EXPECT_EQ(removed_observer.last_scheduled_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 
   // This should stop the observer from observing sequence.
   animator->RemoveObserver(&removed_observer);
 
   base::TimeTicks start_time = animator->last_step_time();
 
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 }
 
 TEST(LayerAnimatorTest, ObserverReleasedBeforeAnimationSequenceEnds) {
   TestLayerAnimationDelegate delegate;
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
-
   scoped_ptr<TestLayerAnimationObserver> observer(
       new TestLayerAnimationObserver);
-  animator->SetDelegate(&delegate);
-  animator->AddObserver(observer.get());
+  scoped_refptr<LayerAnimator> animator(
+      CreateDefaultTestAnimator(&delegate, observer.get()));
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
 
   // |observer| should be attached to |sequence|.
   EXPECT_TRUE(sequence->observers_.might_have_observers());
 
   // Now, release |observer|
   observer.reset();
 
   // And |sequence| should no longer be attached to |observer|.
   EXPECT_FALSE(sequence->observers_.might_have_observers());
 }
 
 TEST(LayerAnimatorTest, ObserverAttachedAfterAnimationStarted) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   TestImplicitAnimationObserver observer(false);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   delegate.SetBrightnessFromAnimation(0.0f);
 
   {
     ScopedLayerAnimationSettings setter(animator.get());
 
     base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
     LayerAnimationSequence* sequence = new LayerAnimationSequence(
         LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
     animator->StartAnimation(sequence);
     base::TimeTicks start_time = animator->last_step_time();
     animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
     setter.AddObserver(&observer);
 
     // Start observing an in-flight animation.
     sequence->AddObserver(&observer);
 
     animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   }
 
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_TRUE(observer.WasAnimationCompletedForProperty(
                   LayerAnimationElement::BRIGHTNESS));
 }
 
 TEST(LayerAnimatorTest, ObserverDetachedBeforeAnimationFinished) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   TestImplicitAnimationObserver observer(false);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   delegate.SetBrightnessFromAnimation(0.0f);
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   {
     ScopedLayerAnimationSettings setter(animator.get());
     setter.AddObserver(&observer);
 
@@ skipping 173 matching lines @@
   // brightness animation. |observer| should have stopped the bounds animation
   // as a result.
   ASSERT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
 
   animator->RemoveObserver(observer.get());
 }
 
 // Check that setting a property during an animation with a default animator
 // cancels the original animation.
 TEST(LayerAnimatorTest, SettingPropertyDuringAnAnimation) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   scoped_ptr<LayerAnimationSequence> sequence(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   animator->StartAnimation(sequence.release());
 
   animator->SetOpacity(0.5);
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_EQ(0.5, animator->GetTargetOpacity());
 }
 
 // Tests that the preemption mode IMMEDIATELY_SET_NEW_TARGET, doesn't cause the
 // second sequence to be leaked.
 TEST(LayerAnimatorTest, ImmediatelySettingNewTargetDoesNotLeak) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   animator->set_preemption_strategy(LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
-  animator->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect middle_bounds(10, 10, 100, 100);
   gfx::Rect target_bounds(5, 5, 5, 5);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
   {
     // start an implicit bounds animation.
     ScopedLayerAnimationSettings settings(animator.get());
@@ skipping 16 matching lines @@
   animator->StartAnimation(sequence.release());
 
   EXPECT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
   EXPECT_EQ(0, num_live_instances);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Verifies GetTargetOpacity() works when multiple sequences are scheduled.
 TEST(LayerAnimatorTest, GetTargetOpacity) {
   TestLayerAnimationDelegate delegate;
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
-  animator->set_disable_timer_for_test(true);
-  animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     animator->SetOpacity(0.5);
     EXPECT_EQ(0.5, animator->GetTargetOpacity());
 
     // Because the strategy is ENQUEUE_NEW_ANIMATION the target should now be 1.
     animator->SetOpacity(1.0);
     EXPECT_EQ(1.0, animator->GetTargetOpacity());
   }
 }
 
 // Verifies GetTargetBrightness() works when multiple sequences are scheduled.
 TEST(LayerAnimatorTest, GetTargetBrightness) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
-  animator->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   delegate.SetBrightnessFromAnimation(0.0);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     animator->SetBrightness(0.5);
     EXPECT_EQ(0.5, animator->GetTargetBrightness());
 
     // Because the strategy is ENQUEUE_NEW_ANIMATION the target should now be 1.
     animator->SetBrightness(1.0);
     EXPECT_EQ(1.0, animator->GetTargetBrightness());
   }
 }
 
 // Verifies GetTargetGrayscale() works when multiple sequences are scheduled.
 TEST(LayerAnimatorTest, GetTargetGrayscale) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
-  animator->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
 
   delegate.SetGrayscaleFromAnimation(0.0);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     animator->SetGrayscale(0.5);
     EXPECT_EQ(0.5, animator->GetTargetGrayscale());
 
     // Because the strategy is ENQUEUE_NEW_ANIMATION the target should now be 1.
     animator->SetGrayscale(1.0);
     EXPECT_EQ(1.0, animator->GetTargetGrayscale());
   }
 }
 
 // Verifies color property is modified appropriately.
 TEST(LayerAnimatorTest, Color) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   SkColor start_color  = SkColorSetARGB( 64, 20, 40,  60);
   SkColor middle_color = SkColorSetARGB(128, 35, 70, 120);
   SkColor target_color = SkColorSetARGB(192, 40, 80, 140);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetColorFromAnimation(start_color);
 
   animator->ScheduleAnimation(
@@ skipping 14 matching lines @@
 
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_EQ(ColorToString(target_color),
             ColorToString(delegate.GetColorForAnimation()));
 }
 
 // Verifies SchedulePauseForProperties().
 TEST(LayerAnimatorTest, SchedulePauseForProperties) {
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator());
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
   animator->SchedulePauseForProperties(
       base::TimeDelta::FromMilliseconds(100),
       LayerAnimationElement::TRANSFORM | LayerAnimationElement::BOUNDS);
   EXPECT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::TRANSFORM));
   EXPECT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
   EXPECT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::OPACITY));
 }
 
 
 class AnimatorOwner {
 public:
-  AnimatorOwner()
-      : animator_(LayerAnimator::CreateDefaultAnimator()) {
-  }
+ AnimatorOwner() : animator_(CreateDefaultTestAnimator()) {}
 
   LayerAnimator* animator() { return animator_.get(); }
 
 private:
   scoped_refptr<LayerAnimator> animator_;
 
   DISALLOW_COPY_AND_ASSIGN(AnimatorOwner);
 };
 
 class DeletingObserver : public LayerAnimationObserver {
@@ skipping 60 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DeletingObserver);
 };
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterFinishingAnimation) {
   bool observer_was_deleted = false;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   observer->set_delete_on_animation_ended(true);
   observer->set_delete_on_animation_aborted(true);
   LayerAnimator* animator = observer->animator();
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetBrightnessFromAnimation(0.0f);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(10, 10, 100, 100);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
@@ skipping 12 matching lines @@
 
   EXPECT_TRUE(observer_was_deleted);
 }
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterStoppingAnimating) {
   bool observer_was_deleted = false;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   observer->set_delete_on_animation_ended(true);
   observer->set_delete_on_animation_aborted(true);
   LayerAnimator* animator = observer->animator();
-  animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(10, 10, 100, 100);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
@@ skipping 11 matching lines @@
 
   EXPECT_TRUE(observer_was_deleted);
 }
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterScheduling) {
   bool observer_was_deleted = false;
   TestLayerAnimationDelegate delegate;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   observer->set_delete_on_animation_scheduled(true);
   LayerAnimator* animator = observer->animator();
-  animator->set_disable_timer_for_test(true);
   animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(10, 10, 100, 100);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
   std::vector<LayerAnimationSequence*> to_start;
@@ skipping 12 matching lines @@
 }
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterAborted) {
   bool observer_was_deleted = false;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   TestLayerAnimationDelegate delegate;
   observer->set_delete_on_animation_aborted(true);
   LayerAnimator* animator = observer->animator();
   animator->set_preemption_strategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  animator->set_disable_timer_for_test(true);
   animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(10, 10, 100, 100);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
   std::vector<LayerAnimationSequence*> to_start;
@@ skipping 12 matching lines @@
 
   animator->StartAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
 
   EXPECT_TRUE(observer_was_deleted);
 }
 
 
 TEST(LayerAnimatorTest, TestSetterRespectEnqueueStrategy) {
   TestLayerAnimationDelegate delegate;
-  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  animator->set_disable_timer_for_test(true);
-
-  animator->SetDelegate(&delegate);
+  scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   float start_opacity = 0.0f;
   float target_opacity = 1.0f;
   float magic_opacity = 0.123f;
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   ScopedLayerAnimationSettings settings(animator.get());
   settings.SetPreemptionStrategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
@@ skipping 182 matching lines @@
 
   void OnLayerAnimationScheduled(LayerAnimationSequence* sequence) override {}
 
  private:
   scoped_ptr<Layer> animator_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerOwnerAnimationObserver);
 };
 
 TEST(LayerAnimatorTest, ObserverDeletesLayerInStopAnimating) {
-  scoped_refptr<LayerAnimator> animator(
-      LayerAnimator::CreateImplicitAnimator());
-  animator->set_disable_timer_for_test(true);
+  scoped_refptr<LayerAnimator> animator(CreateImplicitTestAnimator());
   LayerOwnerAnimationObserver observer(animator.get());
   LayerAnimationDelegate* delegate = observer.animator_layer();
 
   const gfx::Rect start_bounds(0, 0, 50, 50);
   const gfx::Rect target_bounds(10, 10, 100, 100);
   const double target_opacity = 1.0;
 
   delegate->SetOpacityFromAnimation(0.0f);
   delegate->SetBoundsFromAnimation(start_bounds);
 
   base::TimeDelta time_delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* opacity = new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(target_opacity, time_delta));
   opacity->AddObserver(&observer);
   animator->ScheduleAnimation(opacity);
   time_delta = base::TimeDelta::FromSeconds(2);
   LayerAnimationSequence* move = new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(target_bounds, time_delta));
   animator->ScheduleAnimation(move);
   EXPECT_TRUE(animator->is_animating());
   animator->Step(animator->last_step_time() +
                  base::TimeDelta::FromMilliseconds(500));
   animator->StopAnimating();
 
   EXPECT_EQ(nullptr, observer.animator_layer());
   EXPECT_TRUE(animator->is_animating());
 }
 
+// Verifies the LayerAnimatorObserver notification order for an animation
+// sequence that completes successfully.
+TEST(LayerAnimatorObserverNotificationOrderTest,
+     SuccessfulCompletionOfSequence) {
+  TestLayerAnimationObserver observer;
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(
+      CreateDefaultTestAnimator(&delegate, &observer));
+  observer.set_requires_notification_when_animator_destroyed(true);
+
+  const base::TimeDelta animation_duration = base::TimeDelta::FromSeconds(100);
+
+  LayerAnimationSequence* sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBrightnessElement(1.0f, animation_duration));
+
+  EXPECT_TRUE(observer.NoEventsObserved());
+
+  animator->StartAnimation(sequence);
+
+  EXPECT_EQ(observer.last_attached_sequence(), sequence);
+  EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
+  EXPECT_EQ(observer.last_started_sequence(), sequence);
+  EXPECT_EQ(observer.last_aborted_sequence(), nullptr);
+  EXPECT_EQ(observer.last_ended_sequence(), nullptr);
+  EXPECT_EQ(observer.last_detached_sequence(), nullptr);
+
+  EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
+  EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
+
+  observer.ResetLayerAnimationObserverations();
+
+  const base::TimeTicks start_time = animator->last_step_time();
+
+  animator->Step(start_time + animation_duration);
+
+  EXPECT_EQ(observer.last_attached_sequence(), nullptr);
+  EXPECT_EQ(observer.last_scheduled_sequence(), nullptr);
+  EXPECT_EQ(observer.last_started_sequence(), nullptr);
+  EXPECT_EQ(observer.last_aborted_sequence(), nullptr);
+  EXPECT_EQ(observer.last_ended_sequence(), sequence);
+  EXPECT_EQ(observer.last_detached_sequence(), sequence);
+
+  EXPECT_TRUE(observer.EndedEpochIsBeforeDetachedEpoch());
+}
+
+// Verifies the LayerAnimatorObserver notification order for an animation
+// sequence that is aborted after being scheduled.
+TEST(LayerAnimatorObserverNotificationOrderTest, AbortingAScheduledSequence) {
+  TestLayerAnimationObserver observer;
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(
+      CreateDefaultTestAnimator(&delegate, &observer));
+  observer.set_requires_notification_when_animator_destroyed(true);
+
+  const base::TimeDelta animation_duration = base::TimeDelta::FromSeconds(100);
+
+  LayerAnimationSequence* sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBrightnessElement(1.0f, animation_duration));
+
+  EXPECT_TRUE(observer.NoEventsObserved());
+
+  animator->StartAnimation(sequence);
+
+  EXPECT_EQ(observer.last_attached_sequence(), sequence);
+  EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
+  EXPECT_EQ(observer.last_started_sequence(), sequence);
+  EXPECT_EQ(observer.last_aborted_sequence(), nullptr);
+  EXPECT_EQ(observer.last_ended_sequence(), nullptr);
+  EXPECT_EQ(observer.last_detached_sequence(), nullptr);
+
+  EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
+  EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
+
+  observer.ResetLayerAnimationObserverations();
+
+  animator->AbortAllAnimations();
+
+  EXPECT_EQ(observer.last_attached_sequence(), nullptr);
+  EXPECT_EQ(observer.last_scheduled_sequence(), nullptr);
+  EXPECT_EQ(observer.last_started_sequence(), nullptr);
+  EXPECT_EQ(observer.last_aborted_sequence(), sequence);
+  EXPECT_EQ(observer.last_ended_sequence(), nullptr);
+  EXPECT_EQ(observer.last_detached_sequence(), sequence);
+
+  EXPECT_TRUE(observer.AbortedEpochIsBeforeDetachedEpoch());
+}
+
+// Verifies the LayerAnimatorObserver notification order for an animation
+// sequence that is queued up after another sequence that
+// completes successfully.
+TEST(LayerAnimatorObserverNotificationOrderTest,
+     RunningASequenceThatIsQueuedForLaterStartTime) {
+  TestLayerAnimationObserver observer;
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(
+      CreateDefaultTestAnimator(&delegate, &observer));
+  observer.set_requires_notification_when_animator_destroyed(true);
+
+  const base::TimeDelta animation_duration = base::TimeDelta::FromSeconds(100);
+
+  LayerAnimationSequence* first_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBrightnessElement(1.0f, animation_duration));
+
+  LayerAnimationSequence* queued_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBrightnessElement(1.0f, animation_duration));
+
+  EXPECT_TRUE(observer.NoEventsObserved());
+
+  animator->StartAnimation(first_sequence);
+
+  EXPECT_EQ(observer.last_attached_sequence(), first_sequence);
+  EXPECT_EQ(observer.last_scheduled_sequence(), first_sequence);
+  EXPECT_EQ(observer.last_started_sequence(), first_sequence);
+  EXPECT_EQ(observer.last_aborted_sequence(), nullptr);
+  EXPECT_EQ(observer.last_ended_sequence(), nullptr);
+  EXPECT_EQ(observer.last_detached_sequence(), nullptr);
+
+  EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
+  EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
+
+  observer.ResetLayerAnimationObserverations();
+
+  animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
+  animator->StartAnimation(queued_sequence);
+
+  EXPECT_EQ(observer.last_attached_sequence(), queued_sequence);
+  EXPECT_EQ(observer.last_scheduled_sequence(), queued_sequence);
+  EXPECT_EQ(observer.last_started_sequence(), nullptr);
+  EXPECT_EQ(observer.last_aborted_sequence(), nullptr);
+  EXPECT_EQ(observer.last_ended_sequence(), nullptr);
+  EXPECT_EQ(observer.last_detached_sequence(), nullptr);
+
+  EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
+
+  observer.ResetLayerAnimationObserverations();
+
+  base::TimeTicks start_time = animator->last_step_time();
+
+  animator->Step(start_time + animation_duration);
+
+  EXPECT_EQ(observer.last_attached_sequence(), nullptr);
+  EXPECT_EQ(observer.last_scheduled_sequence(), nullptr);
+  EXPECT_EQ(observer.last_started_sequence(), queued_sequence);
+  EXPECT_EQ(observer.last_aborted_sequence(), nullptr);
+  EXPECT_EQ(observer.last_ended_sequence(), first_sequence);
+  EXPECT_EQ(observer.last_detached_sequence(), first_sequence);
+
+  EXPECT_TRUE(observer.EndedEpochIsBeforeDetachedEpoch());
+  EXPECT_TRUE(observer.EndedEpochIsBeforeStartedEpoch());
+}
+
+// Verifies the LayerAnimatorObserver notification order for an animation
+// sequence that pre-empts another sequence.
+TEST(LayerAnimatorObserverNotificationOrderTest,
+     RunningASequenceThatPreEmptsAnotherSequence) {
+  TestLayerAnimationObserver observer;
+  TestLayerAnimationDelegate delegate;
+  scoped_refptr<LayerAnimator> animator(
+      CreateDefaultTestAnimator(&delegate, &observer));
+  observer.set_requires_notification_when_animator_destroyed(true);
+
+  const base::TimeDelta animation_duration = base::TimeDelta::FromSeconds(100);
+
+  LayerAnimationSequence* first_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBrightnessElement(1.0f, animation_duration));
+
+  LayerAnimationSequence* queued_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBrightnessElement(1.0f, animation_duration));
+
+  EXPECT_TRUE(observer.NoEventsObserved());
+
+  animator->StartAnimation(first_sequence);
+
+  EXPECT_EQ(observer.last_attached_sequence(), first_sequence);
+  EXPECT_EQ(observer.last_scheduled_sequence(), first_sequence);
+  EXPECT_EQ(observer.last_started_sequence(), first_sequence);
+  EXPECT_EQ(observer.last_aborted_sequence(), nullptr);
+  EXPECT_EQ(observer.last_ended_sequence(), nullptr);
+  EXPECT_EQ(observer.last_detached_sequence(), nullptr);
+
+  EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
+  EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
+
+  observer.ResetLayerAnimationObserverations();
+
+  animator->set_preemption_strategy(
+      LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  animator->StartAnimation(queued_sequence);
+
+  EXPECT_EQ(observer.last_attached_sequence(), queued_sequence);
+  EXPECT_EQ(observer.last_scheduled_sequence(), queued_sequence);
+  EXPECT_EQ(observer.last_started_sequence(), queued_sequence);
+  EXPECT_EQ(observer.last_aborted_sequence(), first_sequence);
+  EXPECT_EQ(observer.last_ended_sequence(), nullptr);
+  EXPECT_EQ(observer.last_detached_sequence(), first_sequence);
+
+  EXPECT_TRUE(observer.AbortedEpochIsBeforeDetachedEpoch());
+  EXPECT_TRUE(observer.AbortedEpochIsBeforeStartedEpoch());
+  EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
+  EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
+}
+
 }  // namespace ui