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

ui/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/compositor/layer_animator.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 2593 matching lines @@
   EXPECT_FALSE(compositor_2->layer_animator_collection()->HasActiveAnimators());
 
   root_2.Add(&layer);
   EXPECT_FALSE(compositor_1->layer_animator_collection()->HasActiveAnimators());
   EXPECT_TRUE(compositor_2->layer_animator_collection()->HasActiveAnimators());
   host_2.reset();
   host_1.reset();
   TerminateContextFactoryForTests();
 }
 
+class DelegateOwnerAnimationObserver : public LayerAnimationObserver {
+ public:
+  DelegateOwnerAnimationObserver(LayerAnimator* animator)
+      : animator_delegate_(new TestLayerAnimationDelegate()),
+        animator_(animator) {
+    animator_->SetDelegate(animator_delegate_.get());
+  }
+
+  ~DelegateOwnerAnimationObserver() { animator_->SetDelegate(nullptr); }

[sky, 2014/12/18 20:31:40]

override

+
+  void OnLayerAnimationEnded(LayerAnimationSequence* sequence) override {
+    ASSERT_TRUE(sequence);
+    reset_delegate();
+  }
+
+  void OnLayerAnimationAborted(LayerAnimationSequence* sequence) override {
+    ASSERT_TRUE(sequence);
+    reset_delegate();
+  }
+
+  TestLayerAnimationDelegate* get_animator_delegate() {
+    return animator_delegate_.get();
+  }
+
+  void OnLayerAnimationScheduled(LayerAnimationSequence* sequence) override {}
+
+ private:
+  void reset_delegate() {
+    animator_->SetDelegate(nullptr);
+    animator_delegate_.reset();
+  }
+
+  scoped_ptr<TestLayerAnimationDelegate> animator_delegate_;
+  scoped_refptr<LayerAnimator> animator_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelegateOwnerAnimationObserver);
+};
+
+TEST(LayerAnimatorTest, ObserverRemovesDelegateInStopAnimating) {
+  scoped_refptr<LayerAnimator> animator(

[sky, 2014/12/18 20:31:40]

Can you write this test using the layer and deleting the layer as the window
unit test is doing? That way the test better matches usage.

+      LayerAnimator::CreateImplicitAnimator());
+  animator->set_disable_timer_for_test(true);
+  DelegateOwnerAnimationObserver observer(animator.get());
+  TestLayerAnimationDelegate* delegate = observer.get_animator_delegate();
+
+  const gfx::Rect start_bounds(0, 0, 50, 50);
+  const gfx::Rect target_bounds(10, 10, 100, 100);
+  const double target_opacity = 1.0;
+
+  delegate->SetOpacityFromAnimation(0.0f);
+  delegate->SetBoundsFromAnimation(start_bounds);
+
+  base::TimeDelta time_delta = base::TimeDelta::FromSeconds(1);
+  LayerAnimationSequence* opacity = new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(target_opacity, time_delta));
+  opacity->AddObserver(&observer);
+  animator->ScheduleAnimation(opacity);
+  time_delta = base::TimeDelta::FromSeconds(2);
+  LayerAnimationSequence* move = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBoundsElement(target_bounds, time_delta));
+  animator->ScheduleAnimation(move);
+  EXPECT_TRUE(animator->is_animating());
+  animator->Step(animator->last_step_time() +
+                 base::TimeDelta::FromMilliseconds(500));
+  animator->StopAnimating();
+
+  EXPECT_EQ(observer.get_animator_delegate(), nullptr);
+  EXPECT_TRUE(animator->is_animating());
+}
+
 }  // namespace ui