cc: Chromify the Animation and LayerAnimationController classes

cc/keyframed_animation_curve.h

Index: cc/keyframed_animation_curve.h
diff --git a/cc/keyframed_animation_curve.h b/cc/keyframed_animation_curve.h
index 70fcd66c04fe847390ad3110ad1c0fd9f61aa553..6d835f351f805932e52fdab65b2c9be774ca5c85 100644
--- a/cc/keyframed_animation_curve.h
+++ b/cc/keyframed_animation_curve.h
@@ -14,101 +14,114 @@
 namespace cc {
 
 class CC_EXPORT Keyframe {
-public:
-    double time() const;
-    const TimingFunction* timingFunction() const;
+ public:
+  double Time() const;
+  const TimingFunction* timing_function() const {
+    return timing_function_.get();
+  }
 
-protected:
-    Keyframe(double time, scoped_ptr<TimingFunction>);
-    virtual ~Keyframe();
+ protected:
+  Keyframe(double time, scoped_ptr<TimingFunction> timing_function);
+  virtual ~Keyframe();
 
-private:
-    double m_time;
-    scoped_ptr<TimingFunction> m_timingFunction;
+ private:
+  double time_;
+  scoped_ptr<TimingFunction> timing_function_;
 
-    DISALLOW_COPY_AND_ASSIGN(Keyframe);
+  DISALLOW_COPY_AND_ASSIGN(Keyframe);
 };
 
 class CC_EXPORT FloatKeyframe : public Keyframe {
-public:
-    static scoped_ptr<FloatKeyframe> create(double time, float value, scoped_ptr<TimingFunction>);
-    virtual ~FloatKeyframe();
+ public:
+  static scoped_ptr<FloatKeyframe> Create(
+      double time,
+      float value,
+      scoped_ptr<TimingFunction> timing_function);
+  virtual ~FloatKeyframe();
 
-    float value() const;
+  float Value() const;
 
-    scoped_ptr<FloatKeyframe> clone() const;
+  scoped_ptr<FloatKeyframe> Clone() const;
 
-private:
-    FloatKeyframe(double time, float value, scoped_ptr<TimingFunction>);
+ private:
+  FloatKeyframe(double time,
+                float value,
+                scoped_ptr<TimingFunction> timing_function);
 
-    float m_value;
+  float value_;
 };
 
 class CC_EXPORT TransformKeyframe : public Keyframe {
-public:
-    static scoped_ptr<TransformKeyframe> create(double time, const TransformOperations& value, scoped_ptr<TimingFunction>);
-    virtual ~TransformKeyframe();
+ public:
+  static scoped_ptr<TransformKeyframe> Create(
+      double time,
+      const TransformOperations& value,
+      scoped_ptr<TimingFunction> timing_function);
+  virtual ~TransformKeyframe();
 
-    const TransformOperations& value() const;
+  const TransformOperations& Value() const;
 
-    scoped_ptr<TransformKeyframe> clone() const;
+  scoped_ptr<TransformKeyframe> Clone() const;
 
-private:
-    TransformKeyframe(double time, const TransformOperations& value, scoped_ptr<TimingFunction>);
+ private:
+  TransformKeyframe(
+      double time,
+      const TransformOperations& value,
+      scoped_ptr<TimingFunction> timing_function);
 
-    TransformOperations m_value;
+  TransformOperations value_;
 };
 
 class CC_EXPORT KeyframedFloatAnimationCurve : public FloatAnimationCurve {
-public:
-    // It is required that the keyframes be sorted by time.
-    static scoped_ptr<KeyframedFloatAnimationCurve> create();
+ public:
+  // It is required that the keyframes be sorted by time.
+  static scoped_ptr<KeyframedFloatAnimationCurve> Create();
 
-    virtual ~KeyframedFloatAnimationCurve();
+  virtual ~KeyframedFloatAnimationCurve();
 
-    void addKeyframe(scoped_ptr<FloatKeyframe>);
+  void AddKeyframe(scoped_ptr<FloatKeyframe> keyframe);
 
-    // AnimationCurve implementation
-    virtual double duration() const OVERRIDE;
-    virtual scoped_ptr<AnimationCurve> clone() const OVERRIDE;
+  // AnimationCurve implementation
+  virtual double Duration() const OVERRIDE;
+  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
 
-    // FloatAnimationCurve implementation
-    virtual float getValue(double t) const OVERRIDE;
+  // FloatAnimationCurve implementation
+  virtual float GetValue(double t) const OVERRIDE;
 
-private:
-    KeyframedFloatAnimationCurve();
+ private:
+  KeyframedFloatAnimationCurve();
 
-    // Always sorted in order of increasing time. No two keyframes have the
-    // same time.
-    ScopedPtrVector<FloatKeyframe> m_keyframes;
+  // Always sorted in order of increasing time. No two keyframes have the
+  // same time.
+  ScopedPtrVector<FloatKeyframe> keyframes_;
 
-    DISALLOW_COPY_AND_ASSIGN(KeyframedFloatAnimationCurve);
+  DISALLOW_COPY_AND_ASSIGN(KeyframedFloatAnimationCurve);
 };
 
 class CC_EXPORT KeyframedTransformAnimationCurve : public TransformAnimationCurve {
-public:
-    // It is required that the keyframes be sorted by time.
-    static scoped_ptr<KeyframedTransformAnimationCurve> create();
+ public:
+  // It is required that the keyframes be sorted by time.
+  static scoped_ptr<KeyframedTransformAnimationCurve> Create();
 
-    virtual ~KeyframedTransformAnimationCurve();
+  virtual ~KeyframedTransformAnimationCurve();
 
-    void addKeyframe(scoped_ptr<TransformKeyframe>);
+  void AddKeyframe(scoped_ptr<TransformKeyframe> keyframe);
 
-    // AnimationCurve implementation
-    virtual double duration() const OVERRIDE;
-    virtual scoped_ptr<AnimationCurve> clone() const OVERRIDE;
+  // AnimationCurve implementation
+  virtual double Duration() const OVERRIDE;
+  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
 
-    // TransformAnimationCurve implementation
-    virtual gfx::Transform getValue(double t) const OVERRIDE;
+  // TransformAnimationCurve implementation
+  virtual gfx::Transform GetValue(double t) const OVERRIDE;
 
-private:
-    KeyframedTransformAnimationCurve();
+ private:
+  KeyframedTransformAnimationCurve();
 
-    // Always sorted in order of increasing time. No two keyframes have the
-    // same time.
-    ScopedPtrVector<TransformKeyframe> m_keyframes;
+  // Always sorted in order of increasing time. No two keyframes have the
+  // same time.
+  ScopedPtrVector<TransformKeyframe> keyframes_;
 
-    DISALLOW_COPY_AND_ASSIGN(KeyframedTransformAnimationCurve);
+  DISALLOW_COPY_AND_ASSIGN(KeyframedTransformAnimationCurve);
 };
 
 }  // namespace cc