ui/gfx/animation/animation_container_unittest.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/animation/animation_container.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "ui/gfx/animation/animation_container_observer.h"
  10 #include "ui/gfx/animation/linear_animation.h"
  11 #include "ui/gfx/animation/test_animation_delegate.h"
  12
  13 namespace gfx {
  14
  15 namespace {
  16
  17 class FakeAnimationContainerObserver : public AnimationContainerObserver {
  18  public:
  19   FakeAnimationContainerObserver()
  20       : progressed_count_(0),
  21         empty_(false) {
  22   }
  23
  24   int progressed_count() const { return progressed_count_; }
  25   bool empty() const { return empty_; }
  26
  27  private:
  28   void AnimationContainerProgressed(AnimationContainer* container) override {
  29     progressed_count_++;
  30   }
  31
  32   // Invoked when no more animations are being managed by this container.
  33   void AnimationContainerEmpty(AnimationContainer* container) override {
  34     empty_ = true;
  35   }
  36
  37   int progressed_count_;
  38   bool empty_;
  39
  40   DISALLOW_COPY_AND_ASSIGN(FakeAnimationContainerObserver);
  41 };
  42
  43 class TestAnimation : public LinearAnimation {
  44  public:
  45   explicit TestAnimation(AnimationDelegate* delegate)
  46       : LinearAnimation(20, 20, delegate) {
  47   }
  48
  49   void AnimateToState(double state) override {}
  50
  51  private:
  52   DISALLOW_COPY_AND_ASSIGN(TestAnimation);
  53 };
  54
  55 }  // namespace
  56
  57 class AnimationContainerTest: public testing::Test {
  58  private:
  59   base::MessageLoopForUI message_loop_;
  60 };
  61
  62 // Makes sure the animation ups the ref count of the container and releases it
  63 // appropriately.
  64 TEST_F(AnimationContainerTest, Ownership) {
  65   TestAnimationDelegate delegate;
  66   scoped_refptr<AnimationContainer> container(new AnimationContainer());
  67   scoped_ptr<Animation> animation(new TestAnimation(&delegate));
  68   animation->SetContainer(container.get());
  69   // Setting the container should up the ref count.
  70   EXPECT_FALSE(container->HasOneRef());
  71
  72   animation.reset();
  73
  74   // Releasing the animation should decrement the ref count.
  75   EXPECT_TRUE(container->HasOneRef());
  76 }
  77
  78 // Makes sure multiple animations are managed correctly.
  79 TEST_F(AnimationContainerTest, Multi) {
  80   TestAnimationDelegate delegate1;
  81   TestAnimationDelegate delegate2;
  82
  83   scoped_refptr<AnimationContainer> container(new AnimationContainer());
  84   TestAnimation animation1(&delegate1);
  85   TestAnimation animation2(&delegate2);
  86   animation1.SetContainer(container.get());
  87   animation2.SetContainer(container.get());
  88
  89   // Start both animations.
  90   animation1.Start();
  91   EXPECT_TRUE(container->is_running());
  92   animation2.Start();
  93   EXPECT_TRUE(container->is_running());
  94
  95   // Run the message loop the delegate quits the message loop when notified.
  96   base::MessageLoop::current()->Run();
  97
  98   // Both timers should have finished.
  99   EXPECT_TRUE(delegate1.finished());
 100   EXPECT_TRUE(delegate2.finished());
 101
 102   // And the container should no longer be runnings.
 103   EXPECT_FALSE(container->is_running());
 104 }
 105
 106 // Makes sure observer is notified appropriately.
 107 TEST_F(AnimationContainerTest, Observer) {
 108   FakeAnimationContainerObserver observer;
 109   TestAnimationDelegate delegate1;
 110
 111   scoped_refptr<AnimationContainer> container(new AnimationContainer());
 112   container->set_observer(&observer);
 113   TestAnimation animation1(&delegate1);
 114   animation1.SetContainer(container.get());
 115
 116   // Start the animation.
 117   animation1.Start();
 118   EXPECT_TRUE(container->is_running());
 119
 120   // Run the message loop. The delegate quits the message loop when notified.
 121   base::MessageLoop::current()->Run();
 122
 123   EXPECT_EQ(1, observer.progressed_count());
 124
 125   // The timer should have finished.
 126   EXPECT_TRUE(delegate1.finished());
 127
 128   EXPECT_TRUE(observer.empty());
 129
 130   // And the container should no longer be running.
 131   EXPECT_FALSE(container->is_running());
 132
 133   container->set_observer(NULL);
 134 }
 135
 136 }  // namespace gfx