cc: Fix capitalization style in chromified files.

cc/trees/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/trees/layer_tree_host.h"
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/layer_tree_test.h"
 
 namespace cc {
 namespace {
 
 class LayerTreeHostAnimationTest : public LayerTreeTest {
  public:
   virtual void SetupTree() OVERRIDE {
     LayerTreeTest::SetupTree();
     layer_tree_host()->root_layer()->set_layer_animation_delegate(this);
   }
 };
 
-// Makes sure that setNeedsAnimate does not cause the commitRequested() state to
+// Makes sure that SetNeedsAnimate does not cause the CommitRequested() state to
 // be set.
 class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested :
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested()
       : num_commits_(0) {
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void Animate(base::TimeTicks monotonicTime) OVERRIDE {
+  virtual void Animate(base::TimeTicks monotonic_time) OVERRIDE {
     // We skip the first commit becasue its the commit that populates the
     // impl thread with a tree. After the second commit, the test is done.
     if (num_commits_ != 1)
       return;
 
     layer_tree_host()->SetNeedsAnimate();
-    // Right now, commitRequested is going to be true, because during
-    // beginFrame, we force commitRequested to true to prevent requests from
-    // hitting the impl thread. But, when the next didCommit happens, we should
-    // verify that commitRequested has gone back to false.
+    // Right now, CommitRequested is going to be true, because during
+    // BeginFrame, we force CommitRequested to true to prevent requests from
+    // hitting the impl thread. But, when the next DidCommit happens, we should
+    // verify that CommitRequested has gone back to false.
   }
 
   virtual void DidCommit() OVERRIDE {
     if (!num_commits_) {
       EXPECT_FALSE(layer_tree_host()->CommitRequested());
       layer_tree_host()->SetNeedsAnimate();
       EXPECT_FALSE(layer_tree_host()->CommitRequested());
     }
 
-    // Verifies that the setNeedsAnimate we made in ::animate did not
-    // trigger commitRequested.
+    // Verifies that the SetNeedsAnimate we made in ::animate did not
+    // trigger CommitRequested.
     EXPECT_FALSE(layer_tree_host()->CommitRequested());
     EndTest();
     num_commits_++;
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_commits_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested)
 
-// Trigger a frame with setNeedsCommit. Then, inside the resulting animate
-// callback, requet another frame using setNeedsAnimate. End the test when
+// Trigger a frame with SetNeedsCommit. Then, inside the resulting animate
+// callback, requet another frame using SetNeedsAnimate. End the test when
 // animate gets called yet-again, indicating that the proxy is correctly
-// handling the case where setNeedsAnimate() is called inside the begin frame
+// handling the case where SetNeedsAnimate() is called inside the begin frame
 // flow.
 class LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback :
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback()
       : num_animates_(0) {
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
@@ skipping 11 matching lines @@
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_animates_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback)
 
 // Add a layer animation and confirm that
-// LayerTreeHostImpl::updateAnimationState does get called and continues to
+// LayerTreeHostImpl::UpdateAnimationState does get called and continues to
 // get called.
 class LayerTreeHostAnimationTestAddAnimation :
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimation()
       : num_animates_(0)
       , received_animation_started_notification_(false)
       , start_time_(0) {
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddInstantAnimationToMainThread();
   }
 
   virtual void UpdateAnimationState(
       LayerTreeHostImpl* impl_host,
-      bool hasUnfinishedAnimation) OVERRIDE {
+      bool has_unfinished_animation) OVERRIDE {
     if (!num_animates_) {
-      // The animation had zero duration so layerTreeHostImpl should no
+      // The animation had zero duration so LayerTreeHostImpl should no
       // longer need to animate its layers.
-      EXPECT_FALSE(hasUnfinishedAnimation);
+      EXPECT_FALSE(has_unfinished_animation);
       num_animates_++;
       return;
     }
 
     if (received_animation_started_notification_) {
       EXPECT_LT(0, start_time_);
       EndTest();
     }
   }
 
@@ skipping 24 matching lines @@
   LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws()
       : started_animating_(false) {
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* host_impl,
-      base::TimeTicks monotonicTime) OVERRIDE {
+      base::TimeTicks monotonic_time) OVERRIDE {
     started_animating_ = true;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl*) OVERRIDE {
     if (started_animating_)
       EndTest();
   }
 
   virtual bool PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
@@ skipping 16 matching lines @@
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestTickAnimationWhileBackgrounded()
       : num_animates_(0) {
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
-  // Use willAnimateLayers to set visible false before the animation runs and
+  // Use WillAnimateLayers to set visible false before the animation runs and
   // causes a commit, so we block the second visible animate in single-thread
   // mode.
   virtual void WillAnimateLayers(
       LayerTreeHostImpl* host_impl,
-      base::TimeTicks monotonicTime) OVERRIDE {
+      base::TimeTicks monotonic_time) OVERRIDE {
     if (num_animates_ < 2) {
       if (!num_animates_) {
         // We have a long animation running. It should continue to tick even
         // if we are not visible.
         PostSetVisibleToMainThread(false);
       }
       num_animates_++;
       return;
     }
     EndTest();
@@ skipping 13 matching lines @@
     public LayerTreeHostAnimationTest {
 public:
   LayerTreeHostAnimationTestAddAnimationWithTimingFunction() {}
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* host_impl,
-      base::TimeTicks monotonicTime) OVERRIDE {
+      base::TimeTicks monotonic_time) OVERRIDE {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->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 start_opacity = curve->GetValue(0);
+    float end_opacity = curve->GetValue(curve->Duration());
     float linearly_interpolated_opacity =
-        0.25 * endOpacity + 0.75 * startOpacity;
+        0.25 * end_opacity + 0.75 * start_opacity;
     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()->layer_animation_controller();
     Animation* animation_impl =
         controller_impl->GetAnimation(0, Animation::Opacity);
@@ skipping 30 matching lines @@
         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 {
+      bool has_unfinished_animation) OVERRIDE {
     LayerAnimationController* controller =
         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());
 
@@ skipping 120 matching lines @@
     LayerTreeHostAnimationTestLayerAddedWithAnimation)
 
 class LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount :
     public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount()
       : animated_commit_(-1) {
   }
 
   virtual void Animate(base::TimeTicks) OVERRIDE {
-    // We shouldn't animate on the compositeAndReadback-forced commit, but we
-    // should for the setNeedsCommit-triggered commit.
+    // We shouldn't animate on the CompositeAndReadback-forced commit, but we
+    // should for the SetNeedsCommit-triggered commit.
     animated_commit_ = layer_tree_host()->commit_number();
     EXPECT_NE(2, animated_commit_);
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->commit_number()) {
@@ skipping 67 matching lines @@
 
  private:
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestContinuousAnimate)
 
 }  // namespace
 }  // namespace cc