Rename enums/functions that collide in chromium style in platform/

third_party/WebKit/Source/platform/animation/TimingFunction.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 24 matching lines @@
 #include "wtf/RefCounted.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class PLATFORM_EXPORT TimingFunction : public RefCounted<TimingFunction> {
 public:
 
-    enum Type {
+    enum FunctionType {
         LinearFunction, CubicBezierFunction, StepsFunction
     };
 
     virtual ~TimingFunction() { }
 
-    Type type() const { return m_type; }
+    FunctionType type() const { return m_type; }
 
     virtual String toString() const = 0;
 
     // Evaluates the timing function at the given fraction. The accuracy parameter provides a hint as to the required
     // accuracy and is not guaranteed.
     virtual double evaluate(double fraction, double accuracy) const = 0;
 
     // This function returns the minimum and maximum values obtainable when
     // calling evaluate();
     virtual void range(double* minValue, double* maxValue) const = 0;
@@ skipping 15 matching lines @@
         { }
     };
 
     // Partitions the timing function into a number of regions,
     // representing the ranges in which the function's value is < 0.5
     // and >= 0.5, and hence whether interpolation 0 or 1 should be
     // used.
     virtual void partition(Vector<PartitionRegion>& regions) const = 0;
 
 protected:
-    TimingFunction(Type type)
+    TimingFunction(FunctionType type)
         : m_type(type)
     {
     }
 
 private:
-    Type m_type;
+    FunctionType m_type;
 };
 
 class PLATFORM_EXPORT LinearTimingFunction final : public TimingFunction {
 public:
     static LinearTimingFunction* shared()
     {
         DEFINE_STATIC_REF(LinearTimingFunction, linear, (adoptRef(new LinearTimingFunction())));
         return linear;
     }
 
     ~LinearTimingFunction() override { }
 
     String toString() const override;
 
     double evaluate(double fraction, double) const override;
     void range(double* minValue, double* maxValue) const override;
     void partition(Vector<PartitionRegion>& regions) const override;
 private:
     LinearTimingFunction()
         : TimingFunction(LinearFunction)
     {
     }
 };
 
 class PLATFORM_EXPORT CubicBezierTimingFunction final : public TimingFunction {
 public:
-    enum SubType {
+    enum FunctionSubType {
         Ease,
         EaseIn,
         EaseOut,
         EaseInOut,
         Custom
     };
 
     static PassRefPtr<CubicBezierTimingFunction> create(double x1, double y1, double x2, double y2)
     {
         return adoptRef(new CubicBezierTimingFunction(Custom, x1, y1, x2, y2));
     }
 
-    static CubicBezierTimingFunction* preset(SubType subType)
+    static CubicBezierTimingFunction* preset(FunctionSubType subType)
     {
         switch (subType) {
         case Ease:
             {
                 DEFINE_STATIC_REF(CubicBezierTimingFunction, ease, (adoptRef(new CubicBezierTimingFunction(Ease, 0.25, 0.1, 0.25, 1.0))));
                 return ease;
             }
         case EaseIn:
             {
                 DEFINE_STATIC_REF(CubicBezierTimingFunction, easeIn, (adoptRef(new CubicBezierTimingFunction(EaseIn, 0.42, 0.0, 1.0, 1.0))));
@@ skipping 21 matching lines @@
 
     double evaluate(double fraction, double accuracy) const override;
     void range(double* minValue, double* maxValue) const override;
     void partition(Vector<PartitionRegion>& regions) const override;
 
     double x1() const { return m_x1; }
     double y1() const { return m_y1; }
     double x2() const { return m_x2; }
     double y2() const { return m_y2; }
 
-    SubType subType() const { return m_subType; }
+    FunctionSubType subType() const { return m_subType; }
 
 private:
-    explicit CubicBezierTimingFunction(SubType subType, double x1, double y1, double x2, double y2)
+    explicit CubicBezierTimingFunction(FunctionSubType subType, double x1, double y1, double x2, double y2)
         : TimingFunction(CubicBezierFunction)
         , m_x1(x1)
         , m_y1(y1)
         , m_x2(x2)
         , m_y2(y2)
         , m_subType(subType)
     {
     }
 
     // Finds points on the cubic bezier that cross the given horizontal
     // line, storing their x values in solution1-3 and returning the
     // number of solutions found.
     size_t findIntersections(double intersectionY, double& solution1, double& solution2, double& solution3) const;
 
     double m_x1;
     double m_y1;
     double m_x2;
     double m_y2;
-    SubType m_subType;
+    FunctionSubType m_subType;
     mutable OwnPtr<UnitBezier> m_bezier;
 };
 
 class PLATFORM_EXPORT StepsTimingFunction final : public TimingFunction {
 public:
     enum StepAtPosition {
         Start,
         Middle,
         End
     };
@@ skipping 24 matching lines @@
 
     ~StepsTimingFunction() override { }
 
     String toString() const override;
 
     double evaluate(double fraction, double) const override;
     void range(double* minValue, double* maxValue) const override;
     void partition(Vector<PartitionRegion>& regions) const override;
 
     int numberOfSteps() const { return m_steps; }
-    StepAtPosition stepAtPosition() const { return m_stepAtPosition; }
+    StepAtPosition getStepAtPosition() const { return m_stepAtPosition; }
 
 private:
     StepsTimingFunction(int steps, StepAtPosition stepAtPosition)
         : TimingFunction(StepsFunction)
         , m_steps(steps)
         , m_stepAtPosition(stepAtPosition)
     {
     }
 
     int m_steps;
@@ skipping 13 matching lines @@
         value->type() == TimingFunction::typeName##Function, \
         value.type() == TimingFunction::typeName##Function)
 
 DEFINE_TIMING_FUNCTION_TYPE_CASTS(Linear);
 DEFINE_TIMING_FUNCTION_TYPE_CASTS(CubicBezier);
 DEFINE_TIMING_FUNCTION_TYPE_CASTS(Steps);
 
 } // namespace blink
 
 #endif // TimingFunction_h