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;
+  void SetLastSequence(ui::LayerAnimationSequence* sequence) {
+    DCHECK(sequence);
+    sequence->AddObserver(this);
+    DetachAndRecreateLayers();
   }
 
   // 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 40 matching lines @@
   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 =
       new ui::LayerAnimationSequence(transition.release());
+
+  if (observer)
+    observer->SetLastSequence(last_sequence);

[sky, 2014/07/09 20:32:12]

If you do this here, doesn't that mean the animation that is started on the next
line applies to the new layer and not the old?

[please use gerrit instead, 2014/07/09 20:53:55]

Hm, I think you're right. The problem I'm encountering is that 
DetachAndRecreateLayers() should be ran while the window still exists, but
before the animation sequence is finished. Unit tests finish animations
immediately, so DetachAndRecreateLayers() cannot be run after the next line. Do
you have any pointers on how to make unit tests finish animations only after 
AddLayerAnimationsForRotate exits?

+
   window->layer()->GetAnimator()->ScheduleAnimation(last_sequence);
-  if (observer) {
-    observer->set_last_sequence(last_sequence);
-    observer->DetachAndRecreateLayers();
-  }
 }
 
 void AnimateShowWindow_Rotate(aura::Window* window) {
   AddLayerAnimationsForRotate(window, true);
 }
 
 void AnimateHideWindow_Rotate(aura::Window* window) {
   AddLayerAnimationsForRotate(window, false);
 }
 
@@ skipping 150 matching lines @@
 }
 
 bool WindowAnimationsDisabled(aura::Window* window) {
   return (!gfx::Animation::ShouldRenderRichAnimation() || (window &&
           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowAnimationsDisabled));
 }
 
 }  // namespace wm