cc: Fix capitalization style in chromified files.

cc/test/animation_test_common.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/test/animation_test_common.h"
 
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 
 using cc::Animation;
 using cc::AnimationCurve;
 using cc::EaseTimingFunction;
 using cc::FloatKeyframe;
 using cc::KeyframedFloatAnimationCurve;
 using cc::KeyframedTransformAnimationCurve;
 using cc::TimingFunction;
 using cc::TransformKeyframe;
 
 namespace cc {
 
-static int nextAnimationId = 0;
+static int s_next_animation_id = 0;
 
 template <class Target>
 int AddOpacityTransition(Target* target,
                          double duration,
-                         float startOpacity,
-                         float endOpacity,
-                         bool useTimingFunction) {
+                         float start_opacity,
+                         float end_opacity,
+                         bool use_timing_function) {
   scoped_ptr<KeyframedFloatAnimationCurve>
       curve(KeyframedFloatAnimationCurve::Create());
 
   scoped_ptr<TimingFunction> func;
-  if (!useTimingFunction)
+  if (!use_timing_function)
     func = EaseTimingFunction::Create();
   if (duration > 0.0)
-    curve->AddKeyframe(FloatKeyframe::Create(0.0, startOpacity, func.Pass()));
+    curve->AddKeyframe(FloatKeyframe::Create(0.0, start_opacity, func.Pass()));
   curve->AddKeyframe(FloatKeyframe::Create(duration,
-                                           endOpacity,
+                                           end_opacity,
                                            scoped_ptr<cc::TimingFunction>()));
 
-  int id = nextAnimationId++;
+  int id = s_next_animation_id++;
 
   scoped_ptr<Animation> animation(Animation::Create(
       curve.PassAs<AnimationCurve>(),
       id,
       0,
       Animation::Opacity));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(animation.Pass());
   return id;
 }
 
 template <class Target>
 int AddAnimatedTransform(Target* target,
                          double duration,
-                         int deltaX,
-                         int deltaY) {
+                         int delta_x,
+                         int delta_y) {
   scoped_ptr<KeyframedTransformAnimationCurve>
       curve(KeyframedTransformAnimationCurve::Create());
 
   if (duration > 0.0) {
-    TransformOperations startOperations;
-    startOperations.AppendTranslate(deltaX, deltaY, 0.0);
+    TransformOperations start_operations;
+    start_operations.AppendTranslate(delta_x, delta_y, 0.0);
     curve->AddKeyframe(TransformKeyframe::Create(
         0.0,
-        startOperations,
+        start_operations,
         scoped_ptr<cc::TimingFunction>()));
   }
 
   TransformOperations operations;
-  operations.AppendTranslate(deltaX, deltaY, 0.0);
+  operations.AppendTranslate(delta_x, delta_y, 0.0);
   curve->AddKeyframe(TransformKeyframe::Create(
       duration,
       operations,
       scoped_ptr<cc::TimingFunction>()));
 
-  int id = nextAnimationId++;
+  int id = s_next_animation_id++;
 
   scoped_ptr<Animation> animation(Animation::Create(
       curve.PassAs<AnimationCurve>(),
       id, 0, Animation::Transform));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(animation.Pass());
   return id;
 }
 
@@ skipping 149 matching lines @@
                                 double duration,
                                 int delta_x,
                                 int delta_y) {
   return AddAnimatedTransform(layer->layer_animation_controller(),
                               duration,
                               delta_x,
                               delta_y);
 }
 
 }  // namespace cc