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

ui/compositor/layer_animator.h

 // 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.
 
 #ifndef UI_COMPOSITOR_LAYER_ANIMATOR_H_
 #define UI_COMPOSITOR_LAYER_ANIMATOR_H_
 
 #include <deque>
 #include <vector>
 
@@ skipping 16 matching lines @@
 class Layer;
 class LayerAnimationSequence;
 class LayerAnimationDelegate;
 class LayerAnimationObserver;
 class ScopedLayerAnimationSettings;
 class Transform;
 
 // When a property of layer needs to be changed it is set by way of
 // LayerAnimator. This enables LayerAnimator to animate property changes.
 // NB: during many tests, set_disable_animations_for_test is used and causes
-// all animations to complete immediately.
-class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
+// all animations to complete immediately. The layer animation is ref counted
+// so that if its owning layer is deleted (and the owning layer is only other
+// class that should ever hold a ref ptr to a LayerAnimator), the animator can
+// ensure that it is not disposed of until it finishes executing. It does this
+// by holding a reference to itself for the duration of methods for which it
+// must guarantee that |this| is valid.
+class COMPOSITOR_EXPORT LayerAnimator
+    : public AnimationContainerElement, public base::RefCounted<LayerAnimator> {
  public:
   enum PreemptionStrategy {
     IMMEDIATELY_SET_NEW_TARGET,
     IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
     ENQUEUE_NEW_ANIMATION,
     REPLACE_QUEUED_ANIMATIONS,
     BLEND_WITH_CURRENT_ANIMATION
   };
 
   explicit LayerAnimator(base::TimeDelta transition_duration);
-  virtual ~LayerAnimator();
 
   // No implicit animations when properties are set.
   static LayerAnimator* CreateDefaultAnimator();
 
   // Implicitly animates when properties are set.
   static LayerAnimator* CreateImplicitAnimator();
 
   // Sets the transform on the delegate. May cause an implicit animation.
   virtual void SetTransform(const Transform& transform);
   Transform GetTargetTransform() const;
@@ skipping 12 matching lines @@
 
   // Sets the brightness on the delegate. May cause an implicit animation.
   virtual void SetBrightness(float brightness);
   float GetTargetBrightness() const;
 
   // Sets the grayscale on the delegate. May cause an implicit animation.
   virtual void SetGrayscale(float grayscale);
   float GetTargetGrayscale() const;
 
   // Sets the layer animation delegate the animator is associated with. The
-  // animator does not own the delegate.
+  // animator does not own the delegate. The layer animator expects a non-NULL
+  // delegate for most of its operations, so do not call any methods without
+  // a valid delegate installed.
   void SetDelegate(LayerAnimationDelegate* delegate);
 
   // Sets the animation preemption strategy. This determines the behaviour if
   // a property is set during an animation. The default is
   // IMMEDIATELY_SET_NEW_TARGET (see ImmediatelySetNewTarget below).
   void set_preemption_strategy(PreemptionStrategy strategy) {
     preemption_strategy_ = strategy;
   }
 
   PreemptionStrategy preemption_strategy() const {
@@ skipping 74 matching lines @@
   // When set to true, all animations complete immediately.
   static void set_disable_animations_for_test(bool disable_animations) {
     disable_animations_for_test_ = disable_animations;
   }
 
   static bool disable_animations_for_test() {
     return disable_animations_for_test_;
   }
 
  protected:
+  virtual ~LayerAnimator();
+
   LayerAnimationDelegate* delegate() { return delegate_; }
   const LayerAnimationDelegate* delegate() const { return delegate_; }
 
   // Virtual for testing.
-  virtual bool ProgressAnimation(LayerAnimationSequence* sequence,
+  virtual void ProgressAnimation(LayerAnimationSequence* sequence,
                                  base::TimeDelta delta);
 
   // Returns true if the sequence is owned by this animator.
   bool HasAnimation(LayerAnimationSequence* sequence) const;
 
  private:
+  friend class base::RefCounted<LayerAnimator>;
   friend class ScopedLayerAnimationSettings;
 
-  class DestroyedTracker;
-
-  // Used by FinishAnimation() to indicate if this has been destroyed.
-  enum DestroyedType {
-    DESTROYED,
-    NOT_DESTROYED,
-  };
-
   // We need to keep track of the start time of every running animation.
   struct RunningAnimation {
     RunningAnimation(LayerAnimationSequence* sequence,
                      base::TimeTicks start_time)
         : sequence(sequence),
           start_time(start_time) {
     }
     LayerAnimationSequence* sequence;
     base::TimeTicks start_time;
   };
 
   typedef std::vector<RunningAnimation> RunningAnimations;
   typedef std::deque<linked_ptr<LayerAnimationSequence> > AnimationQueue;
 
   // Implementation of AnimationContainerElement
   virtual void SetStartTime(base::TimeTicks start_time) OVERRIDE;
   virtual void Step(base::TimeTicks time_now) OVERRIDE;
   virtual base::TimeDelta GetTimerInterval() const OVERRIDE;
 
   // Starts or stops stepping depending on whether thare are running animations.
   void UpdateAnimationState();
 
   // Removes the sequences from both the running animations and the queue.
   // Returns a pointer to the removed animation, if any. NOTE: the caller is
   // responsible for deleting the returned pointer.
   LayerAnimationSequence* RemoveAnimation(
       LayerAnimationSequence* sequence) WARN_UNUSED_RESULT;
 
   // Progresses to the end of the sequence before removing it.
-  DestroyedType FinishAnimation(
-      LayerAnimationSequence* sequence) WARN_UNUSED_RESULT;
+  void FinishAnimation(LayerAnimationSequence* sequence);
 
   // Finishes any running animation with zero duration.
   void FinishAnyAnimationWithZeroDuration();
 
   // Clears the running animations and the queue. No sequences are progressed.
   void ClearAnimations();
 
   // Returns the running animation animating the given property, if any.
   RunningAnimation* GetRunningAnimation(
       LayerAnimationElement::AnimatableProperty property);
@@ skipping 36 matching lines @@
   void GetTargetValue(LayerAnimationElement::TargetValue* target) const;
 
   // Called whenever an animation is added to the animation queue. Either by
   // starting the animation or adding to the queue.
   void OnScheduled(LayerAnimationSequence* sequence);
 
   // Returns the default length of animations, including adjustment for slow
   // animation mode if set.
   base::TimeDelta GetTransitionDuration() const;
 
+  // Clears the animation queues and notifies any running animations that they
+  // have been aborted.
+  void ClearAnimationsInternal();
+
   // This is the queue of animations to run.
   AnimationQueue animation_queue_;
 
   // The target of all layer animations.
   LayerAnimationDelegate* delegate_;
 
   // The currently running animations.
   RunningAnimations running_animations_;
 
   // Determines how animations are replaced.
@@ skipping 21 matching lines @@
   // Slows down all animations for visual debugging.
   static bool slow_animation_mode_;
 
   // Amount to slow animations for debugging.
   static int slow_animation_scale_factor_;
 
   // Observers are notified when layer animations end, are scheduled or are
   // aborted.
   ObserverList<LayerAnimationObserver> observers_;
 
-  scoped_refptr<DestroyedTracker> destroyed_tracker_;
-
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATOR_H_