Attempt 2 at Fixes crash introduced @ 153047 (you can hit crash by maximizing a

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>
 
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
+#include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "base/time.h"
 #include "ui/base/animation/animation_container_element.h"
 #include "ui/base/animation/tween.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/compositor/layer_animation_element.h"
 
 namespace gfx {
 class Rect;
 }
@@ skipping 156 matching lines @@
   // Virtual for testing.
   virtual bool ProgressAnimation(LayerAnimationSequence* sequence,
                                  base::TimeDelta delta);
 
   // Returns true if the sequence is owned by this animator.
   bool HasAnimation(LayerAnimationSequence* sequence) const;
 
  private:
   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.
-  void FinishAnimation(LayerAnimationSequence* sequence);
+  DestroyedType FinishAnimation(
+      LayerAnimationSequence* sequence) WARN_UNUSED_RESULT;
 
   // 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 77 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_