cc: Chromify Layer and LayerImpl 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"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/layer_tree_test_common.h"
 #include "cc/timing_function.h"
 
 namespace cc {
 namespace {
 
 class LayerTreeHostAnimationTest : public ThreadedTest {
  public:
   virtual void setupTree() OVERRIDE {
     ThreadedTest::setupTree();
-    m_layerTreeHost->rootLayer()->setLayerAnimationDelegate(this);
+    m_layerTreeHost->rootLayer()->set_layer_animation_delegate(this);
   }
 };
 
 // Makes sure that setNeedsAnimate does not cause the commitRequested() state to
 // be set.
 class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested :
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested()
       : num_commits_(0) {
@@ skipping 211 matching lines @@
   LayerTreeHostAnimationTestAddAnimationWithTimingFunction() {}
 
   virtual void beginTest() OVERRIDE {
     postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
   }
 
   virtual void animateLayers(
       LayerTreeHostImpl* host_impl,
       base::TimeTicks monotonicTime) OVERRIDE {
     LayerAnimationController* controller =
-        m_layerTreeHost->rootLayer()->layerAnimationController();
+        m_layerTreeHost->rootLayer()->layer_animation_controller();
     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();
+        host_impl->rootLayer()->layer_animation_controller();
     Animation* animation_impl =
         controller_impl->GetAnimation(0, Animation::Opacity);
 
     controller->RemoveAnimation(animation->id());
     controller_impl->RemoveAnimation(animation_impl->id());
     endTest();
   }
 
   virtual void afterTest() OVERRIDE {}
 };
@@ skipping 10 matching lines @@
       : 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();
+        m_layerTreeHost->rootLayer()->layer_animation_controller();
     Animation* animation =
         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();
+        impl_host->rootLayer()->layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(0, Animation::Opacity);
     if (!animation)
       return;
 
     impl_start_time_ = animation->start_time();
     controller->RemoveAnimation(animation->id());
 
     if (main_start_time_ > 0)
       endTest();
@@ skipping 15 matching lines @@
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimationFinishedEvents() {}
 
   virtual void beginTest() OVERRIDE {
     postAddInstantAnimationToMainThread();
   }
 
   virtual void notifyAnimationFinished(double time) OVERRIDE {
     LayerAnimationController* controller =
-        m_layerTreeHost->rootLayer()->layerAnimationController();
+        m_layerTreeHost->rootLayer()->layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(0, Animation::Opacity);
     if (animation)
       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
 // subtree to be skipped.
 class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity :
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity()
       : update_check_layer_(FakeContentLayer::Create(&client_)) {
   }
 
   virtual void setupTree() OVERRIDE {
-    update_check_layer_->setOpacity(0);
+    update_check_layer_->SetOpacity(0);
     m_layerTreeHost->setRootLayer(update_check_layer_);
     LayerTreeHostAnimationTest::setupTree();
   }
 
   virtual void beginTest() OVERRIDE {
     postAddAnimationToMainThread(update_check_layer_.get());
   }
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE {
     endTest();
   }
 
   virtual void afterTest() OVERRIDE {
-    // update() should have been called once, proving that the layer was not
+    // Update() should have been called once, proving that the layer was not
     // skipped.
     EXPECT_EQ(1, update_check_layer_->update_count());
 
     // clear update_check_layer_ so LayerTreeHost dies.
     update_check_layer_ = NULL;
   }
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> update_check_layer_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity)
 
 // Layers added to tree with existing active animations should have the
 // animation correctly recognized.
 class LayerTreeHostAnimationTestLayerAddedWithAnimation :
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestLayerAddedWithAnimation() { }
 
   virtual void beginTest() OVERRIDE {
     postSetNeedsCommitToMainThread();
   }
 
   virtual void didCommit() OVERRIDE {
     if (m_layerTreeHost->commitNumber() == 1) {
-      scoped_refptr<Layer> layer = Layer::create();
-      layer->setLayerAnimationDelegate(this);
+      scoped_refptr<Layer> layer = Layer::Create();
+      layer->set_layer_animation_delegate(this);
 
       // Any valid AnimationCurve will do here.
       scoped_ptr<AnimationCurve> curve(EaseTimingFunction::create());
       scoped_ptr<Animation> animation(
           Animation::Create(curve.Pass(), 1, 1,
                                   Animation::Opacity));
-      layer->layerAnimationController()->AddAnimation(animation.Pass());
+      layer->layer_animation_controller()->AddAnimation(animation.Pass());
 
       // We add the animation *before* attaching the layer to the tree.
-      m_layerTreeHost->rootLayer()->addChild(layer);
+      m_layerTreeHost->rootLayer()->AddChild(layer);
     }
   }
 
   virtual void animateLayers(
       LayerTreeHostImpl* impl_host,
       base::TimeTicks monotonic_time) OVERRIDE {
     endTest();
   }
 
   virtual void afterTest() OVERRIDE {}
@@ skipping 64 matching lines @@
     postSetNeedsCommitToMainThread();
   }
 
   virtual void animate(base::TimeTicks) OVERRIDE {
     if (num_draw_layers_ == 2)
       return;
     m_layerTreeHost->setNeedsAnimate();
   }
 
   virtual void layout() OVERRIDE {
-    m_layerTreeHost->rootLayer()->setNeedsDisplay();
+    m_layerTreeHost->rootLayer()->SetNeedsDisplay();
   }
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE {
     if (num_draw_layers_ == 1)
       num_commit_complete_++;
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_draw_layers_++;
     if (num_draw_layers_ == 2)
       endTest();
   }
 
   virtual void afterTest() OVERRIDE {
     // Check that we didn't commit twice between first and second draw.
     EXPECT_EQ(1, num_commit_complete_);
   }
 
  private:
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestContinuousAnimate)
 
 }  // namespace
 }  // namespace cc