cc: Switch time_source.h and timing_function* to Chrome coding style.

cc/timing_function.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/timing_function.h"
+
 #include "third_party/skia/include/core/SkMath.h"
 
 // TODO(danakj) These methods come from SkInterpolator.cpp. When such a method
 // is available in the public Skia API, we should switch to using that.
 // http://crbug.com/159735
 namespace {
 
 // Dot14 has 14 bits for decimal places, and the remainder for whole numbers.
 typedef int Dot14;
 #define DOT14_ONE       (1 << 14)
 #define DOT14_HALF      (1 << 13)
 
 #define Dot14ToFloat(x) ((x) / 16384.f)
 
-static inline Dot14 Dot14Mul(Dot14 a, Dot14 b)
-{
+static inline Dot14 Dot14Mul(Dot14 a, Dot14 b) {
     return (a * b + DOT14_HALF) >> 14;
 }
 
-static inline Dot14 EvalCubic(Dot14 t, Dot14 A, Dot14 B, Dot14 C)
-{
+static inline Dot14 EvalCubic(Dot14 t, Dot14 A, Dot14 B, Dot14 C) {
     return Dot14Mul(Dot14Mul(Dot14Mul(C, t) + B, t) + A, t);
 }
 
-static inline Dot14 PinAndConvert(SkScalar x)
-{
+static inline Dot14 PinAndConvert(SkScalar x) {
     if (x <= 0)
         return 0;
     if (x >= SK_Scalar1)
         return DOT14_ONE;
     return SkScalarToFixed(x) >> 2;
 }
 
-SkScalar SkUnitCubicInterp(SkScalar bx, SkScalar by, SkScalar cx, SkScalar cy, SkScalar value)
-{
+SkScalar SkUnitCubicInterp(SkScalar bx, SkScalar by,

[danakj, 2012/11/16 00:32:13]

I thought you have to put 1 parameter per line if they don't all fine on one
line? (not that i'm a fan)

[tfarina, 2012/11/16 00:36:35]

this is a pair of x, y. Yes, I have thought about writing one arg per line. But
I think it makes more sense when it's like this, i.e, the types are related.

Otherwise, I would have written one arg per line.

I can wrap one per line if you are strong about this.

[danakj, 2012/11/16 00:38:22]

No, the less line wrapping the better IMO

+                           SkScalar cx, SkScalar cy,
+                           SkScalar value) {
     Dot14 x = PinAndConvert(value);
 
     if (x == 0) return 0;
     if (x == DOT14_ONE) return SK_Scalar1;
 
     Dot14 b = PinAndConvert(bx);
     Dot14 c = PinAndConvert(cx);
 
     // Now compute our coefficients from the control points.
     //  t   -> 3b
@@ skipping 17 matching lines @@
 
     // Now we have t, so compute the coefficient for Y and evaluate.
     b = PinAndConvert(by);
     c = PinAndConvert(cy);
     A = 3 * b;
     B = 3 * (c - 2 * b);
     C = 3 * (b - c) + DOT14_ONE;
     return SkFixedToScalar(EvalCubic(t, A, B, C) << 2);
 }
 
-}  // anonymous namespace
+}  // namespace
 
 namespace cc {
 
-TimingFunction::TimingFunction()
-{
+TimingFunction::TimingFunction() {
 }
 
-TimingFunction::~TimingFunction()
-{
+TimingFunction::~TimingFunction() {
 }
 
-double TimingFunction::duration() const
-{
+double TimingFunction::duration() const {
     return 1.0;
 }
 
-scoped_ptr<CubicBezierTimingFunction> CubicBezierTimingFunction::create(double x1, double y1, double x2, double y2)
-{
+scoped_ptr<CubicBezierTimingFunction> CubicBezierTimingFunction::create(
+    double x1, double y1, double x2, double y2) {
     return make_scoped_ptr(new CubicBezierTimingFunction(x1, y1, x2, y2));
 }
 
-CubicBezierTimingFunction::CubicBezierTimingFunction(double x1, double y1, double x2, double y2)
-    : m_x1(SkDoubleToScalar(x1))
-    , m_y1(SkDoubleToScalar(y1))
-    , m_x2(SkDoubleToScalar(x2))
-    , m_y2(SkDoubleToScalar(y2))
-{
+CubicBezierTimingFunction::CubicBezierTimingFunction(double x1, double y1,
+                                                     double x2, double y2)
+    : x1_(SkDoubleToScalar(x1)),
+      y1_(SkDoubleToScalar(y1)),
+      x2_(SkDoubleToScalar(x2)),
+      y2_(SkDoubleToScalar(y2)) {
 }
 
-CubicBezierTimingFunction::~CubicBezierTimingFunction()
-{
+CubicBezierTimingFunction::~CubicBezierTimingFunction() {
 }
 
-float CubicBezierTimingFunction::getValue(double x) const
-{
-    SkScalar value = SkUnitCubicInterp(m_x1, m_y1, m_x2, m_y2, x);
-    return SkScalarToFloat(value);
+float CubicBezierTimingFunction::getValue(double x) const {
+  SkScalar value = SkUnitCubicInterp(x1_, y1_, x2_, y2_, x);
+  return SkScalarToFloat(value);
 }
 
-scoped_ptr<AnimationCurve> CubicBezierTimingFunction::clone() const
-{
-    return make_scoped_ptr(new CubicBezierTimingFunction(*this)).PassAs<AnimationCurve>();
+scoped_ptr<AnimationCurve> CubicBezierTimingFunction::clone() const {
+  return make_scoped_ptr(
+      new CubicBezierTimingFunction(*this)).PassAs<AnimationCurve>();
 }
 
 // These numbers come from http://www.w3.org/TR/css3-transitions/#transition-timing-function_tag.
-scoped_ptr<TimingFunction> EaseTimingFunction::create()
-{
-    return CubicBezierTimingFunction::create(0.25, 0.1, 0.25, 1).PassAs<TimingFunction>();
+scoped_ptr<TimingFunction> EaseTimingFunction::create() {
+  return CubicBezierTimingFunction::create(
+      0.25, 0.1, 0.25, 1).PassAs<TimingFunction>();
 }
 
-scoped_ptr<TimingFunction> EaseInTimingFunction::create()
-{
-    return CubicBezierTimingFunction::create(0.42, 0, 1.0, 1).PassAs<TimingFunction>();
+scoped_ptr<TimingFunction> EaseInTimingFunction::create() {
+  return CubicBezierTimingFunction::create(
+      0.42, 0, 1.0, 1).PassAs<TimingFunction>();
 }
 
-scoped_ptr<TimingFunction> EaseOutTimingFunction::create()
-{
-    return CubicBezierTimingFunction::create(0, 0, 0.58, 1).PassAs<TimingFunction>();
+scoped_ptr<TimingFunction> EaseOutTimingFunction::create() {
+  return CubicBezierTimingFunction::create(
+      0, 0, 0.58, 1).PassAs<TimingFunction>();
 }
 
-scoped_ptr<TimingFunction> EaseInOutTimingFunction::create()
-{
-    return CubicBezierTimingFunction::create(0.42, 0, 0.58, 1).PassAs<TimingFunction>();
+scoped_ptr<TimingFunction> EaseInOutTimingFunction::create() {
+  return CubicBezierTimingFunction::create(
+      0.42, 0, 0.58, 1).PassAs<TimingFunction>();
 }
 
 }  // namespace cc