LayerAnimator must be prepared for its owning layer's deletion whenever it notifies observers.

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/time.h"
@@ skipping 60 matching lines @@
  private:
   LayerAnimator* animator_;
   LayerAnimationSequence* sequence_;
 
   DISALLOW_COPY_AND_ASSIGN(DeletingLayerAnimationObserver);
 };
 
 class TestLayerAnimator : public LayerAnimator {
  public:
   TestLayerAnimator() : LayerAnimator(base::TimeDelta::FromSeconds(0)) {}
+
+ protected:
   virtual ~TestLayerAnimator() {}
 
- protected:
-  virtual bool ProgressAnimation(LayerAnimationSequence* sequence,
+  virtual void ProgressAnimation(LayerAnimationSequence* sequence,
                                  base::TimeDelta delta) OVERRIDE {
     EXPECT_TRUE(HasAnimation(sequence));
-    return LayerAnimator::ProgressAnimation(sequence, delta);
+    LayerAnimator::ProgressAnimation(sequence, delta);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimator);
 };
 
 // The test layer animation sequence updates a live instances count when it is
 // created and destroyed.
 class TestLayerAnimationSequence : public LayerAnimationSequence {
  public:
@@ skipping 12 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_ptr<LayerAnimator> animator(LayerAnimator::CreateImplicitAnimator());
+  scoped_refptr<LayerAnimator> animator(
+      LayerAnimator::CreateImplicitAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   base::TimeTicks now = base::TimeTicks::Now();
   animator->SetOpacity(0.5);
   EXPECT_TRUE(animator->is_animating());
   element->Step(now + base::TimeDelta::FromSeconds(1));
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), 0.5);
 }
 
 // Checks that if the animator is a default animator, that implicit animations
 // are not started.
 TEST(LayerAnimatorTest, NoImplicitAnimation) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   animator->SetOpacity(0.5);
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), 0.5);
 }
 
 // Checks that StopAnimatingProperty stops animation for that property, and also
 // skips the stopped animation to the end.
 TEST(LayerAnimatorTest, StopAnimatingProperty) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateImplicitAnimator());
+  scoped_refptr<LayerAnimator> animator(
+      LayerAnimator::CreateImplicitAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&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.
 TEST(LayerAnimatorTest, StopAnimating) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateImplicitAnimator());
+  scoped_refptr<LayerAnimator> animator(
+      LayerAnimator::CreateImplicitAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&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);
 }
 
 // Schedule an animation that can run immediately. This is the trivial case and
 // should result in the animation being started immediately.
 TEST(LayerAnimatorTest, ScheduleAnimationThatCanRunImmediately) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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);
@@ skipping 16 matching lines @@
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 }
 
 // Schedule two animations on separate properties. Both animations should
 // start immediately and should progress in lock step.
 TEST(LayerAnimatorTest, ScheduleTwoAnimationsThatCanRunImmediately) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double middle_opacity(0.5);
   double target_opacity(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
@@ skipping 29 matching lines @@
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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);
@@ skipping 31 matching lines @@
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // Schedule [{o}, {o,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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double middle_opacity(0.5);
   double target_opacity(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
@@ skipping 57 matching lines @@
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 }
 
 // Schedule {o} and then schedule {o} and {b} together. In this case, since
 // ScheduleTogether is being used, the bounds animation should not start until
 // the second opacity animation starts.
 TEST(LayerAnimatorTest, ScheduleTogether) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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 = gfx::Rect(0, 0, 50, 50);
@@ skipping 32 matching lines @@
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Start animation (that can run immediately). This is the trivial case (see
 // the trival case for ScheduleAnimation).
 TEST(LayerAnimatorTest, StartAnimationThatCanRunImmediately) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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);
@@ skipping 15 matching lines @@
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 }
 
 // Preempt by immediately setting new target.
 TEST(LayerAnimatorTest, PreemptBySettingNewTarget) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&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.
 TEST(LayerAnimatorTest, PreemptByImmediatelyAnimatingToNewTarget) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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);
@@ skipping 31 matching lines @@
                   0.5 * (start_opacity + middle_opacity));
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // Preempt by enqueuing the new animation.
 TEST(LayerAnimatorTest, PreemptEnqueueNewAnimation) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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);
@@ skipping 32 matching lines @@
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // 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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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);
@@ skipping 34 matching lines @@
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // Test that cyclic sequences continue to animate.
 TEST(LayerAnimatorTest, CyclicSequences) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
@@ skipping 38 matching lines @@
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 
   animator->StopAnimatingProperty(LayerAnimationElement::OPACITY);
 
   EXPECT_FALSE(animator->is_animating());
 }
 
 TEST(LayerAnimatorTest, AddObserverExplicit) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationObserver observer;
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   animator->AddObserver(&observer);
   observer.set_requires_notification_when_animator_destroyed(true);
 
   EXPECT_TRUE(!observer.last_ended_sequence());
 
@@ skipping 13 matching lines @@
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
 
   // |sequence| has been destroyed. Recreate it to test abort.
   sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
 
-  animator.reset();
+  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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
   animator->SetOpacity(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer);
     animator->SetOpacity(0.0f);
   }
 
   EXPECT_FALSE(observer.animations_completed());
   base::TimeTicks start_time = animator->last_step_time();
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_FLOAT_EQ(0.0f, delegate.GetOpacityForAnimation());
 }
 
 // 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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
   animator->SetOpacity(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer);
     animator->SetOpacity(0.0f);
   }
 
   EXPECT_FALSE(observer.animations_completed());
   // This should interrupt the implicit animation causing the observer to be
   // notified immediately.
   animator->SetOpacity(1.0f);
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_FLOAT_EQ(1.0f, delegate.GetOpacityForAnimation());
 }
 
 // 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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   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->SetOpacity(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer_notify);
     settings.AddObserver(&observer_do_not_notify);
     animator->SetOpacity(0.0f);
   }
 
   EXPECT_FALSE(observer_notify.animations_completed());
   EXPECT_FALSE(observer_do_not_notify.animations_completed());
-  animator.reset(NULL);
+  animator = NULL;
   EXPECT_TRUE(observer_notify.animations_completed());
   EXPECT_FALSE(observer_do_not_notify.animations_completed());
 }
 
 
 TEST(LayerAnimatorTest, RemoveObserverShouldRemoveFromSequences) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationObserver observer;
   TestLayerAnimationObserver removed_observer;
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
@@ skipping 14 matching lines @@
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 }
 
 TEST(LayerAnimatorTest, ObserverReleasedBeforeAnimationSequenceEnds) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
 
   scoped_ptr<TestLayerAnimationObserver> observer(
       new TestLayerAnimationObserver);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   animator->AddObserver(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_EQ(static_cast<size_t>(1), sequence->observers_.size());
 
   // Now, release |observer|
   observer.reset();
 
   // And |sequence| should no longer be attached to |observer|.
   EXPECT_EQ(static_cast<size_t>(0), sequence->observers_.size());
 }
 
 TEST(LayerAnimatorTest, ObserverAttachedAfterAnimationStarted) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
 
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   {
@@ skipping 12 matching lines @@
     // Start observing an in-flight animation.
     sequence->AddObserver(&observer);
 
     element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   }
 
   EXPECT_TRUE(observer.animations_completed());
 }
 
 TEST(LayerAnimatorTest, ObserverDetachedBeforeAnimationFinished) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
 
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0f);
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
@@ skipping 16 matching lines @@
   EXPECT_TRUE(observer.animations_completed());
 }
 
 // This checks that if an animation is deleted due to a callback, that the
 // animator does not try to use the deleted animation. For example, if we have
 // two running animations, and the first finishes and the resulting callback
 // causes the second to be deleted, we should not attempt to animate the second
 // animation.
 TEST(LayerAnimatorTest, ObserverDeletesAnimations) {
   LayerAnimator::set_disable_animations_for_test(false);
-  scoped_ptr<LayerAnimator> animator(new TestLayerAnimator());
+  scoped_refptr<LayerAnimator> animator(new TestLayerAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(5, 5, 5, 5);
@@ skipping 22 matching lines @@
 
   base::TimeTicks start_time = animator->last_step_time();
   element->Step(start_time + halfway_delta);
 
   animator->RemoveObserver(observer.get());
 }
 
 // Check that setting a property during an animation with a default animator
 // cancels the original animation.
 TEST(LayerAnimatorTest, SettingPropertyDuringAnAnimation) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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(
           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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   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);
@@ skipping 19 matching lines @@
   // the target value. The sequence should alse be destructed.
   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) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   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 SchedulePauseForProperties().
 TEST(LayerAnimatorTest, SchedulePauseForProperties) {
-  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
   animator->SchedulePauseForProperties(base::TimeDelta::FromMilliseconds(100),
                                        LayerAnimationElement::TRANSFORM,
                                        LayerAnimationElement::BOUNDS, -1);
   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()) {
+  }
+
+  LayerAnimator* animator() { return animator_.get(); }
+
+private:
+  scoped_refptr<LayerAnimator> animator_;
+
+  DISALLOW_COPY_AND_ASSIGN(AnimatorOwner);
+};
+
+class DeletingObserver : public LayerAnimationObserver {
+public:
+  DeletingObserver(bool* was_deleted)
+      : animator_owner_(new AnimatorOwner),
+        delete_on_animation_ended_(false),
+        delete_on_animation_aborted_(false),
+        delete_on_animation_scheduled_(false),
+        was_deleted_(was_deleted) {
+    animator()->AddObserver(this);
+  }
+
+  ~DeletingObserver() {
+    animator()->RemoveObserver(this);
+    *was_deleted_ = true;
+  }
+
+  LayerAnimator* animator() { return animator_owner_->animator(); }
+
+  bool delete_on_animation_ended() const {
+    return delete_on_animation_ended_;
+  }
+  void set_delete_on_animation_ended(bool enabled) {
+    delete_on_animation_ended_ = enabled;
+  }
+
+  bool delete_on_animation_aborted() const {
+    return delete_on_animation_aborted_;
+  }
+  void set_delete_on_animation_aborted(bool enabled) {
+    delete_on_animation_aborted_ = enabled;
+  }
+
+  bool delete_on_animation_scheduled() const {
+    return delete_on_animation_scheduled_;
+  }
+  void set_delete_on_animation_scheduled(bool enabled) {
+    delete_on_animation_scheduled_ = enabled;
+  }
+
+  // LayerAnimationObserver implementation.
+  virtual void OnLayerAnimationEnded(
+      LayerAnimationSequence* sequence) OVERRIDE {
+    if (delete_on_animation_ended_)
+      delete this;
+  }
+
+  virtual void OnLayerAnimationAborted(
+      LayerAnimationSequence* sequence) OVERRIDE {
+    if (delete_on_animation_aborted_)
+      delete this;
+  }
+
+  virtual void OnLayerAnimationScheduled(
+      LayerAnimationSequence* sequence) {
+    if (delete_on_animation_scheduled_)
+      delete this;
+  }
+
+private:
+  scoped_ptr<AnimatorOwner> animator_owner_;
+  bool delete_on_animation_ended_;
+  bool delete_on_animation_aborted_;
+  bool delete_on_animation_scheduled_;
+  bool* was_deleted_;
+
+  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();
+  AnimationContainerElement* element = 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);
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+  LayerAnimationSequence* opacity_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+  animator->StartAnimation(opacity_sequence);
+
+  delta = base::TimeDelta::FromSeconds(2);
+  LayerAnimationSequence* bounds_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
+  animator->StartAnimation(bounds_sequence);
+
+  base::TimeTicks start_time = animator->last_step_time();
+  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+
+  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);
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+  LayerAnimationSequence* opacity_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+  animator->StartAnimation(opacity_sequence);
+
+  delta = base::TimeDelta::FromSeconds(2);
+  LayerAnimationSequence* bounds_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
+  animator->StartAnimation(bounds_sequence);
+
+  animator->StopAnimating();
+
+  EXPECT_TRUE(observer_was_deleted);
+}
+
+TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterScheduling) {
+  bool observer_was_deleted = false;
+  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);
+  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);
+
+  std::vector<LayerAnimationSequence*> to_start;
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+  to_start.push_back(new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
+
+  delta = base::TimeDelta::FromSeconds(2);
+  to_start.push_back(new LayerAnimationSequence(
+      LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
+
+  animator->ScheduleTogether(to_start);
+
+  EXPECT_TRUE(observer_was_deleted);
+}
+
+TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterAborted) {
+  bool observer_was_deleted = false;
+  DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
+  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);
+  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);
+
+  std::vector<LayerAnimationSequence*> to_start;
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+  to_start.push_back(new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
+
+  delta = base::TimeDelta::FromSeconds(2);
+  to_start.push_back(new LayerAnimationSequence(
+      LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
+
+  animator->ScheduleTogether(to_start);
+
+  EXPECT_FALSE(observer_was_deleted);
+
+  animator->StartAnimation(new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
+
+  EXPECT_TRUE(observer_was_deleted);
+}
+
 }  // namespace ui