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

ui/compositor/layer_animator.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/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/animation/animation_container.h"
@@ skipping 25 matching lines @@
 int LayerAnimator::slow_animation_scale_factor_ = 4;
 
 // LayerAnimator public --------------------------------------------------------
 
 LayerAnimator::LayerAnimator(base::TimeDelta transition_duration)
     : delegate_(NULL),
       preemption_strategy_(IMMEDIATELY_SET_NEW_TARGET),
       transition_duration_(transition_duration),
       tween_type_(Tween::LINEAR),
       is_started_(false),
-      disable_timer_for_test_(false) {
+      disable_timer_for_test_(false),
+      destroyed_(NULL) {
 }
 
 LayerAnimator::~LayerAnimator() {
   for (size_t i = 0; i < running_animations_.size(); ++i)
     running_animations_[i].sequence->OnAnimatorDestroyed();
   ClearAnimations();
+  if (destroyed_)
+    *destroyed_ = true;
 }
 
 // static
 LayerAnimator* LayerAnimator::CreateDefaultAnimator() {
   return new LayerAnimator(base::TimeDelta::FromMilliseconds(0));
 }
 
 // static
 LayerAnimator* LayerAnimator::CreateImplicitAnimator() {
   return new LayerAnimator(kDefaultTransitionDuration);
@@ skipping 210 matching lines @@
       return true;
   }
   return false;
 }
 
 // LayerAnimator private -------------------------------------------------------
 
 void LayerAnimator::Step(base::TimeTicks now) {
   TRACE_EVENT0("ui", "LayerAnimator::Step");
 
+  bool destroyed = false;
+  destroyed_ = &destroyed;
   last_step_time_ = now;
   // We need to make a copy of the running animations because progressing them
   // and finishing them may indirectly affect the collection of running
   // animations.
   RunningAnimations running_animations_copy = running_animations_;
   bool needs_redraw = false;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!HasAnimation(running_animations_copy[i].sequence))
       continue;
 
     base::TimeDelta delta = now - running_animations_copy[i].start_time;
     if (delta >= running_animations_copy[i].sequence->duration() &&
         !running_animations_copy[i].sequence->is_cyclic()) {
       FinishAnimation(running_animations_copy[i].sequence);
+      if (destroyed)
+        return;
       needs_redraw = true;
-    } else if (ProgressAnimation(running_animations_copy[i].sequence, delta))
+    } else if (ProgressAnimation(running_animations_copy[i].sequence, delta)) {
       needs_redraw = true;
+    }
   }
 
+  destroyed_ = NULL;
   if (needs_redraw && delegate())
     delegate()->ScheduleDrawForAnimation();
 }
 
 void LayerAnimator::SetStartTime(base::TimeTicks start_time) {
   // Do nothing.
 }
 
 base::TimeDelta LayerAnimator::GetTimerInterval() const {
   return kTimerInterval;
@@ skipping 299 matching lines @@
     }
   }
   sequence->OnScheduled();
 }
 
 base::TimeDelta LayerAnimator::GetTransitionDuration() const {
   return transition_duration_;
 }
 
 }  // namespace ui