Fix a leak in wm::AnimateOnChildWindowVisibilityChanged().

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 40 matching lines @@
 // 1) Notifies AnimationHost at the end of hiding animation.
 // 2) Detaches the window's layers for hiding animation and deletes
 // them upon completion of the animation. This is necessary to a)
 // ensure that the animation continues in the event of the window being
 // deleted, and b) to ensure that the animation is visible even if the
 // window gets restacked below other windows when focus or activation
 // changes.
 // The subclass will determine when the animation is completed.
 class HidingWindowAnimationObserverBase : public aura::WindowObserver {
  public:
-  HidingWindowAnimationObserverBase(aura::Window* window) : window_(window) {
+  explicit HidingWindowAnimationObserverBase(aura::Window* window)
+      : window_(window) {
     window_->AddObserver(this);
   }
   virtual ~HidingWindowAnimationObserverBase() {
     if (window_)
       window_->RemoveObserver(this);
   }
 
   // aura::WindowObserver:
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
     DCHECK_EQ(window, window_);
@@ skipping 317 matching lines @@
   sequence->AddElement(CreateGrowShrinkElement(window, false));
   window->layer()->GetAnimator()->StartAnimation(sequence.release());
 }
 
 // A HidingWindowAnimationObserver that deletes observer and detached
 // layers when the last_sequence has been completed or aborted.
 class RotateHidingWindowAnimationObserver
     : public HidingWindowAnimationObserverBase,
       public ui::LayerAnimationObserver {
  public:
-  RotateHidingWindowAnimationObserver(aura::Window* window)
-      : HidingWindowAnimationObserverBase(window), last_sequence_(NULL) {}
+  explicit RotateHidingWindowAnimationObserver(aura::Window* window)
+      : HidingWindowAnimationObserverBase(window) {}
   virtual ~RotateHidingWindowAnimationObserver() {}
 
-  void set_last_sequence(ui::LayerAnimationSequence* last_sequence) {
-    last_sequence_ = last_sequence;
+  // 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);
   }
 
   // ui::LayerAnimationObserver:
   virtual void OnLayerAnimationEnded(
       ui::LayerAnimationSequence* sequence) OVERRIDE {
-    if (last_sequence_ == sequence)
-      OnAnimationCompleted();
+    OnAnimationCompleted();
   }
   virtual void OnLayerAnimationAborted(
       ui::LayerAnimationSequence* sequence) OVERRIDE {
-    if (last_sequence_ == sequence)
-      OnAnimationCompleted();
+    OnAnimationCompleted();
   }
   virtual void OnLayerAnimationScheduled(
       ui::LayerAnimationSequence* sequence) OVERRIDE {}
 
  private:
-  ui::LayerAnimationSequence* last_sequence_;
-
   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);
 
@@ skipping 41 matching lines @@
   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 =
       new ui::LayerAnimationSequence(transition.release());
   window->layer()->GetAnimator()->ScheduleAnimation(last_sequence);
+
   if (observer) {
-    observer->set_last_sequence(last_sequence);
+    observer->SetLastSequence(last_sequence);
     observer->DetachAndRecreateLayers();
   }
 }
 
 void AnimateShowWindow_Rotate(aura::Window* window) {
   AddLayerAnimationsForRotate(window, true);
 }
 
 void AnimateHideWindow_Rotate(aura::Window* window) {
   AddLayerAnimationsForRotate(window, false);
@@ skipping 152 matching lines @@
 }
 
 bool WindowAnimationsDisabled(aura::Window* window) {
   return (!gfx::Animation::ShouldRenderRichAnimation() || (window &&
           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowAnimationsDisabled));
 }
 
 }  // namespace wm