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

ui/compositor/layer_animation_sequence.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_animation_sequence.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/debug/trace_event.h"
@@ skipping 13 matching lines @@
       last_element_(0) {
   AddElement(element);
 }
 
 LayerAnimationSequence::~LayerAnimationSequence() {
   FOR_EACH_OBSERVER(LayerAnimationObserver,
                     observers_,
                     DetachedFromSequence(this, true));
 }
 
-bool LayerAnimationSequence::Progress(base::TimeDelta elapsed,
+void LayerAnimationSequence::Progress(base::TimeDelta elapsed,
                                       LayerAnimationDelegate* delegate) {
   bool redraw_required = false;
 
   if (elements_.empty())
-    return redraw_required;
+    return;
 
   if (is_cyclic_ && duration_ > base::TimeDelta()) {
     // If delta = elapsed - last_start_ is huge, we can skip ahead by complete
     // loops to save time.
     base::TimeDelta delta = elapsed - last_start_;
     int64 k = delta.ToInternalValue() / duration_.ToInternalValue() - 1;
 
     last_start_ += base::TimeDelta::FromInternalValue(
       k * duration_.ToInternalValue());
   }
@@ skipping 12 matching lines @@
   if (is_cyclic_ || last_element_ < elements_.size()) {
     double t = 1.0;
     if (elements_[current_index]->duration() > base::TimeDelta()) {
       t = (elapsed - last_start_).InMillisecondsF() /
           elements_[current_index]->duration().InMillisecondsF();
     }
     if (elements_[current_index]->Progress(t, delegate))
       redraw_required = true;
   }
 
+  // Since the delegate may be deleted due to the notifications below, it is
+  // important that we schedule a draw before sending them.
+  if (redraw_required)
+    delegate->ScheduleDrawForAnimation();
+
   if (!is_cyclic_ && elapsed == duration_) {
     last_element_ = 0;
     last_start_ = base::TimeDelta::FromMilliseconds(0);
     NotifyEnded();
   }
-
-  return redraw_required;
 }
 
 void LayerAnimationSequence::GetTargetValue(
     LayerAnimationElement::TargetValue* target) const {
   if (is_cyclic_)
     return;
 
   for (size_t i = last_element_; i < elements_.size(); ++i)
     elements_[i]->GetTargetValue(target);
 }
@@ skipping 70 matching lines @@
                     OnLayerAnimationEnded(this));
 }
 
 void LayerAnimationSequence::NotifyAborted() {
   FOR_EACH_OBSERVER(LayerAnimationObserver,
                     observers_,
                     OnLayerAnimationAborted(this));
 }
 
 }  // namespace ui