Rename ActiveAnimation -> Animation

cc/layer_tree_host_unittest_animation.cc

 // Copyright 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 "cc/layer_tree_host.h"
 
 #include "cc/animation_curve.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
@@ skipping 230 matching lines @@
   virtual void beginTest() OVERRIDE {
     postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
   }
 
   virtual void animateLayers(
       LayerTreeHostImpl* host_impl,
       base::TimeTicks monotonicTime,
       bool hasUnfinishedAnimation) OVERRIDE {
     LayerAnimationController* controller =
         m_layerTreeHost->rootLayer()->layerAnimationController();
-    ActiveAnimation* animation =
-        controller->getActiveAnimation(0, ActiveAnimation::Opacity);
+    Animation* animation =
+        controller->getAnimation(0, Animation::Opacity);
     if (!animation)
       return;
 
     const FloatAnimationCurve* curve =
         animation->curve()->toFloatAnimationCurve();
     float startOpacity = curve->getValue(0);
     float endOpacity = curve->getValue(curve->duration());
     float linearly_interpolated_opacity =
         0.25 * endOpacity + 0.75 * startOpacity;
     double time = curve->duration() * 0.25;
     // If the linear timing function associated with this animation was not
     // picked up, then the linearly interpolated opacity would be different
     // because of the default ease timing function.
     EXPECT_FLOAT_EQ(linearly_interpolated_opacity, curve->getValue(time));
 
     LayerAnimationController* controller_impl =
         host_impl->rootLayer()->layerAnimationController();
-    ActiveAnimation* animation_impl =
-        controller_impl->getActiveAnimation(0, ActiveAnimation::Opacity);
+    Animation* animation_impl =
+        controller_impl->getAnimation(0, Animation::Opacity);
 
     controller->removeAnimation(animation->id());
     controller_impl->removeAnimation(animation_impl->id());
     endTest();
   }
 
   virtual void afterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationWithTimingFunction)
 
 // Ensures that main thread animations have their start times synchronized with
 // impl thread animations.
 class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes :
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSynchronizeAnimationStartTimes()
       : main_start_time_(-1),
         impl_start_time_(-1) {
   }
 
   virtual void beginTest() OVERRIDE {
     postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
   }
 
   virtual void notifyAnimationStarted(double time) OVERRIDE {
     LayerAnimationController* controller =
         m_layerTreeHost->rootLayer()->layerAnimationController();
-    ActiveAnimation* animation =
-        controller->getActiveAnimation(0, ActiveAnimation::Opacity);
+    Animation* animation =
+        controller->getAnimation(0, Animation::Opacity);
     main_start_time_ = animation->startTime();
     controller->removeAnimation(animation->id());
 
     if (impl_start_time_ > 0)
       endTest();
   }
 
   virtual void animateLayers(
       LayerTreeHostImpl* impl_host,
       base::TimeTicks monotonicTime,
       bool hasUnfinishedAnimation) OVERRIDE {
     LayerAnimationController* controller =
         impl_host->rootLayer()->layerAnimationController();
-    ActiveAnimation* animation =
-        controller->getActiveAnimation(0, ActiveAnimation::Opacity);
+    Animation* animation =
+        controller->getAnimation(0, Animation::Opacity);
     if (!animation)
       return;
 
     impl_start_time_ = animation->startTime();
     controller->removeAnimation(animation->id());
 
     if (main_start_time_ > 0)
       endTest();
   }
 
@@ skipping 14 matching lines @@
  public:
   LayerTreeHostAnimationTestAnimationFinishedEvents() {}
 
   virtual void beginTest() OVERRIDE {
     postAddInstantAnimationToMainThread();
   }
 
   virtual void notifyAnimationFinished(double time) OVERRIDE {
     LayerAnimationController* controller =
         m_layerTreeHost->rootLayer()->layerAnimationController();
-    ActiveAnimation* animation =
-        controller->getActiveAnimation(0, ActiveAnimation::Opacity);
+    Animation* animation =
+        controller->getAnimation(0, Animation::Opacity);
     controller->removeAnimation(animation->id());
     endTest();
   }
 
   virtual void afterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimationFinishedEvents)
 
@@ skipping 48 matching lines @@
     postSetNeedsCommitToMainThread();
   }
 
   virtual void didCommit() OVERRIDE {
     if (m_layerTreeHost->commitNumber() == 1) {
       scoped_refptr<Layer> layer = Layer::create();
       layer->setLayerAnimationDelegate(this);
 
       // Any valid AnimationCurve will do here.
       scoped_ptr<AnimationCurve> curve(EaseTimingFunction::create());
-      scoped_ptr<ActiveAnimation> animation(
-          ActiveAnimation::create(curve.Pass(), 1, 1,
-                                  ActiveAnimation::Opacity));
+      scoped_ptr<Animation> animation(
+          Animation::create(curve.Pass(), 1, 1,
+                                  Animation::Opacity));
       layer->layerAnimationController()->addAnimation(animation.Pass());
 
       // We add the animation *before* attaching the layer to the tree.
       m_layerTreeHost->rootLayer()->addChild(layer);
     }
   }
 
   virtual void animateLayers(
       LayerTreeHostImpl* impl_host,
       base::TimeTicks monotonic_time,
@@ skipping 97 matching lines @@
 
  private:
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestContinuousAnimate)
 
 }  // namespace
 }  // namespace cc