compositor/layer_animator: handle delegate removal in LayerAnimation::StopAnimating

ui/wm/core/window_animations.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/wm/core/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 386 matching lines @@
 class RotateHidingWindowAnimationObserver
     : public HidingWindowAnimationObserverBase,
       public ui::LayerAnimationObserver {
  public:
   explicit RotateHidingWindowAnimationObserver(aura::Window* window)
       : HidingWindowAnimationObserverBase(window) {}
   ~RotateHidingWindowAnimationObserver() override {}
 
   // Destroys itself after |last_sequence| ends or is aborted. Does not take
   // ownership of |last_sequence|, which should not be NULL.
-  void SetLastSequence(ui::LayerAnimationSequence* last_sequence) {
-    last_sequence->AddObserver(this);
+  void AddSequence(ui::LayerAnimationSequence* sequence) {
+    sequences_.push_back(sequence);

[sky, 2014/12/15 17:48:54]

I think you're working around the bug. OnLayerAnimationEnded is being called
correctly and 'this' attempts to delete itself. The problem is the deletion is
triggered from a call in LayerAnimator. LayerAnimator is ref counted and isn't
destroyed. When the stack unravels LayerAnimator attempts to use its delegate(),
which is the Layer that was destroyed and we crash. The fix should be in
LayerAnimator.

+    sequence->AddObserver(this);
   }
 
   // ui::LayerAnimationObserver:
   void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override {
-    OnAnimationCompleted();
+    RemoveAnimation(sequence);
   }
   void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override {
-    OnAnimationCompleted();
+    RemoveAnimation(sequence);
   }
   void OnLayerAnimationScheduled(
       ui::LayerAnimationSequence* sequence) override {}
 
  private:
+  // Destroys itself after last sequence ends or is aborted.
+  void RemoveAnimation(ui::LayerAnimationSequence *sequence) {
+    auto it = std::remove(sequences_.begin(), sequences_.end(), sequence);
+    if (it != sequences_.end()) {
+      sequences_.erase(it);
+      if (sequences_.empty())
+        OnAnimationCompleted();
+    }
+  }
+
+  std::vector<ui::LayerAnimationSequence *> sequences_;
+
   DISALLOW_COPY_AND_ASSIGN(RotateHidingWindowAnimationObserver);
 };
 
 void AddLayerAnimationsForRotate(aura::Window* window, bool show) {
   if (show)
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
       kWindowAnimation_Rotate_DurationMS);
 
   RotateHidingWindowAnimationObserver* observer = NULL;
 
   if (!show) {
     observer = new RotateHidingWindowAnimationObserver(window);
     window->layer()->GetAnimator()->SchedulePauseForProperties(
         duration * (100 - kWindowAnimation_Rotate_OpacityDurationPercent) / 100,
         ui::LayerAnimationElement::OPACITY);
   }
   scoped_ptr<ui::LayerAnimationElement> opacity(
       ui::LayerAnimationElement::CreateOpacityElement(
           show ? kWindowAnimation_ShowOpacity : kWindowAnimation_HideOpacity,
           duration * kWindowAnimation_Rotate_OpacityDurationPercent / 100));
   opacity->set_tween_type(gfx::Tween::EASE_IN_OUT);
-  window->layer()->GetAnimator()->ScheduleAnimation(
-      new ui::LayerAnimationSequence(opacity.release()));
+  ui::LayerAnimationSequence *opacity_sequence =

[sky, 2014/12/15 17:48:54]

nit: "ui::LayerAnimationSequence *" -> "ui::LayerAnimationSequence* "

+      new ui::LayerAnimationSequence(opacity.release());
+  window->layer()->GetAnimator()->ScheduleAnimation(opacity_sequence);
+  if (observer)
+    observer->AddSequence(opacity_sequence);
 
   float xcenter = window->bounds().width() * 0.5;
 
   gfx::Transform transform;
   transform.Translate(xcenter, 0);
   transform.ApplyPerspectiveDepth(kWindowAnimation_Rotate_PerspectiveDepth);
   transform.Translate(-xcenter, 0);
   scoped_ptr<ui::InterpolatedTransform> perspective(
       new ui::InterpolatedConstantTransform(transform));
 
@@ skipping 13 matching lines @@
           gfx::Vector3dF(1, 0, 0), 0, kWindowAnimation_Rotate_DegreesX));
 
   scale_about_pivot->SetChild(perspective.release());
   translation->SetChild(scale_about_pivot.release());
   rotation->SetChild(translation.release());
   rotation->SetReversed(show);
 
   scoped_ptr<ui::LayerAnimationElement> transition(
       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
           rotation.release(), duration));
-  ui::LayerAnimationSequence* last_sequence =
+  ui::LayerAnimationSequence* transition_sequence =
       new ui::LayerAnimationSequence(transition.release());
-  window->layer()->GetAnimator()->ScheduleAnimation(last_sequence);
+  window->layer()->GetAnimator()->ScheduleAnimation(transition_sequence);
 
   if (observer) {
-    observer->SetLastSequence(last_sequence);
+    observer->AddSequence(transition_sequence);
     observer->DetachAndRecreateLayers();
   }
 }
 
 void AnimateShowWindow_Rotate(aura::Window* window) {
   AddLayerAnimationsForRotate(window, true);
 }
 
 void AnimateHideWindow_Rotate(aura::Window* window) {
   AddLayerAnimationsForRotate(window, false);
@@ skipping 165 matching lines @@
   // being accessed via Remote Desktop.
   if (ui::ScopedAnimationDurationScaleMode::duration_scale_mode() ==
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION)
     return false;
 
   // Let the user decide whether or not to play the animation.
   return !gfx::Animation::ShouldRenderRichAnimation();
 }
 
 }  // namespace wm