cc: Chromify the Animation and LayerAnimationController classes

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 236 matching lines @@
   virtual void beginTest() OVERRIDE {
     postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
   }
 
   virtual void animateLayers(
       LayerTreeHostImpl* host_impl,
       base::TimeTicks monotonicTime) OVERRIDE {
     LayerAnimationController* controller =
         m_layerTreeHost->rootLayer()->layerAnimationController();
     Animation* animation =
-        controller->getAnimation(0, Animation::Opacity);
+        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());
+        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;
+    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));
+    EXPECT_FLOAT_EQ(linearly_interpolated_opacity, curve->GetValue(time));
 
     LayerAnimationController* controller_impl =
         host_impl->rootLayer()->layerAnimationController();
     Animation* animation_impl =
-        controller_impl->getAnimation(0, Animation::Opacity);
+        controller_impl->GetAnimation(0, Animation::Opacity);
 
-    controller->removeAnimation(animation->id());
-    controller_impl->removeAnimation(animation_impl->id());
+    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();
     Animation* animation =
-        controller->getAnimation(0, Animation::Opacity);
-    main_start_time_ = animation->startTime();
-    controller->removeAnimation(animation->id());
+        controller->GetAnimation(0, Animation::Opacity);
+    main_start_time_ = animation->start_time();
+    controller->RemoveAnimation(animation->id());
 
     if (impl_start_time_ > 0)
       endTest();
   }
 
   virtual void updateAnimationState(
       LayerTreeHostImpl* impl_host,
       bool hasUnfinishedAnimation) OVERRIDE {
     LayerAnimationController* controller =
         impl_host->rootLayer()->layerAnimationController();
     Animation* animation =
-        controller->getAnimation(0, Animation::Opacity);
+        controller->GetAnimation(0, Animation::Opacity);
     if (!animation)
       return;
 
-    impl_start_time_ = animation->startTime();
-    controller->removeAnimation(animation->id());
+    impl_start_time_ = animation->start_time();
+    controller->RemoveAnimation(animation->id());
 
     if (main_start_time_ > 0)
       endTest();
   }
 
   virtual void afterTest() OVERRIDE {
     EXPECT_FLOAT_EQ(impl_start_time_, main_start_time_);
   }
 
  private:
@@ skipping 10 matching lines @@
   LayerTreeHostAnimationTestAnimationFinishedEvents() {}
 
   virtual void beginTest() OVERRIDE {
     postAddInstantAnimationToMainThread();
   }
 
   virtual void notifyAnimationFinished(double time) OVERRIDE {
     LayerAnimationController* controller =
         m_layerTreeHost->rootLayer()->layerAnimationController();
     Animation* animation =
-        controller->getAnimation(0, Animation::Opacity);
+        controller->GetAnimation(0, Animation::Opacity);
     if (animation)
-      controller->removeAnimation(animation->id());
+      controller->RemoveAnimation(animation->id());
     endTest();
   }
 
   virtual void afterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimationFinishedEvents)
 
 // Ensures that when opacity is being animated, this value does not cause the
@@ skipping 48 matching lines @@
   }
 
   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<Animation> animation(
-          Animation::create(curve.Pass(), 1, 1,
+          Animation::Create(curve.Pass(), 1, 1,
                                   Animation::Opacity));
-      layer->layerAnimationController()->addAnimation(animation.Pass());
+      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) OVERRIDE {
     endTest();
@@ skipping 95 matching lines @@
 
  private:
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestContinuousAnimate)
 
 }  // namespace
 }  // namespace cc