Fix a memory leak in the layer animator

ui/gfx/compositor/layer_animator_unittest.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/gfx/compositor/layer_animator.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
@@ skipping 25 matching lines @@
   // ImplicitAnimationObserver implementation
   virtual void OnImplicitAnimationsCompleted() OVERRIDE {
     animations_completed_ = true;
   }
 
   bool animations_completed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestImplicitAnimationObserver);
 };
 
+class TestLayerAnimationSequence : public LayerAnimationSequence {
+ public:
+  TestLayerAnimationSequence(LayerAnimationElement* element,
+                             int* num_live_instances)
+      : LayerAnimationSequence(element),
+        num_live_instances_(num_live_instances) {
+    *num_live_instances_ += 1;

[oshima, 2012/02/09 07:46:02]

++ 

+  }
+
+  virtual ~TestLayerAnimationSequence() {
+    *num_live_instances_ -= 1;

[oshima, 2012/02/09 07:46:02]

--

+  }
+
+ private:
+  int* num_live_instances_;

[sky, 2012/02/09 03:48:56]

DISALLOW_COPY_AND_ASSIGN.
And add a description of what this class does.

+};
+
 } // namespace
 
 // Checks that setting a property on an implicit animator causes an animation to
 // happen.
 TEST(LayerAnimatorTest, ImplicitAnimation) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateImplicitAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
@@ skipping 847 matching lines @@
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   animator->StartAnimation(sequence.release());
 
   animator->SetOpacity(0.5);
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_EQ(0.5, animator->GetTargetOpacity());
 }
 
+// Schedule [{o}, {o,b}, {b}] and ensure that {b} doesn't run right away. That
+// is, ensure that all animations targetting a particular property are run in
+// order.
+TEST(LayerAnimatorTest, ImmediatelySettingNewTargetDoesNotLeak) {
+  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  animator->set_preemption_strategy(LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
+  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  animator->SetDelegate(&delegate);
+
+  gfx::Rect start_bounds, target_bounds, middle_bounds;

[oshima, 2012/02/09 07:46:02]

any good reason not doing start_bounds(0, 0, 50, 50) ... ?

+  start_bounds = gfx::Rect(0, 0, 50, 50);
+  middle_bounds = gfx::Rect(10, 10, 100, 100);
+  target_bounds = gfx::Rect(5, 5, 5, 5);
+
+  delegate.SetBoundsFromAnimation(start_bounds);
+
+  {
+    // start an implicit bounds animation.
+    ScopedLayerAnimationSettings settings(animator.get());
+    animator->SetBounds(middle_bounds);
+  }
+
+  EXPECT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
+
+  int num_live_instances = 0;
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+  scoped_ptr<TestLayerAnimationSequence> sequence(
+      new TestLayerAnimationSequence(
+          LayerAnimationElement::CreateBoundsElement(target_bounds, delta),
+          &num_live_instances));
+
+  EXPECT_EQ(1, num_live_instances);
+
+  // This should interrupt the running sequence causing us to immediately set
+  // the target value. The sequence should alse be destructed.
+  animator->StartAnimation(sequence.release());
+
+  EXPECT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
+  EXPECT_EQ(0, num_live_instances);
+  CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
+}
+
+

[oshima, 2012/02/09 07:46:02]

remove extra line

 } // namespace ui

[oshima, 2012/02/09 07:46:02]

two spaces before //