Remove Sk prefix from some bench classes.

bench/MathBench.cpp

-#include "SkBenchmark.h"
+#include "Benchmark.h"
 #include "SkColorPriv.h"
 #include "SkMatrix.h"
+#include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkString.h"
-#include "SkPaint.h"
 
 static float sk_fsel(float pred, float result_ge, float result_lt) {
     return pred >= 0 ? result_ge : result_lt;
 }
 
 static float fast_floor(float x) {
 //    float big = sk_fsel(x, 0x1.0p+23, -0x1.0p+23);
     float big = sk_fsel(x, (float)(1 << 23), -(float)(1 << 23));
     return (x + big) - big;
 }
 
-class MathBench : public SkBenchmark {
+class MathBench : public Benchmark {
     enum {
         kBuffer = 100,
     };
     SkString    fName;
     float       fSrc[kBuffer], fDst[kBuffer];
 public:
     MathBench(const char name[])  {
         fName.printf("math_%s", name);
 
         SkRandom rand;
@@ skipping 18 matching lines @@
     }
 
     virtual void onDraw(const int loops, SkCanvas*) {
         int n = loops * this->mulLoopCount();
         for (int i = 0; i < n; i++) {
             this->performTest(fDst, fSrc, kBuffer);
         }
     }
 
 private:
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 class MathBenchU32 : public MathBench {
 public:
     MathBenchU32(const char name[]) : INHERITED(name) {}
 
 protected:
     virtual void performITest(uint32_t* SK_RESTRICT dst,
                               const uint32_t* SK_RESTRICT src,
                               int count) = 0;
@@ skipping 187 matching lines @@
 static bool isFinite(const SkRect& r) {
     // x * 0 will be NaN iff x is infinity or NaN.
     // a + b will be NaN iff either a or b is NaN.
     float value = r.fLeft * 0 + r.fTop * 0 + r.fRight * 0 + r.fBottom * 0;
 
     // value is either NaN or it is finite (zero).
     // value==value will be true iff value is not NaN
     return value == value;
 }
 
-class IsFiniteBench : public SkBenchmark {
+class IsFiniteBench : public Benchmark {
     enum {
         N = 1000,
     };
     float fData[N];
 public:
 
     IsFiniteBench(int index)  {
         SkRandom rand;
 
         for (int i = 0; i < N; ++i) {
@@ skipping 45 matching lines @@
     }
 
     virtual const char* onGetName() {
         return fName;
     }
 
 private:
     IsFiniteProc    fProc;
     const char*     fName;
 
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
-class FloorBench : public SkBenchmark {
+class FloorBench : public Benchmark {
     enum {
         ARRAY = 1000,
     };
     float fData[ARRAY];
     bool fFast;
 public:
 
     FloorBench(bool fast) : fFast(fast) {
         SkRandom rand;
 
@@ skipping 37 matching lines @@
         }
     }
 
     virtual const char* onGetName() {
         return fName;
     }
 
 private:
     const char*     fName;
 
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
-class CLZBench : public SkBenchmark {
+class CLZBench : public Benchmark {
     enum {
         ARRAY = 1000,
     };
     uint32_t fData[ARRAY];
     bool fUsePortable;
 
 public:
     CLZBench(bool usePortable) : fUsePortable(usePortable) {
 
         SkRandom rand;
@@ skipping 36 matching lines @@
         }
     }
 
     virtual const char* onGetName() {
         return fName;
     }
 
 private:
     const char* fName;
 
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class NormalizeBench : public SkBenchmark {
+class NormalizeBench : public Benchmark {
     enum {
         ARRAY =1000,
     };
     SkVector fVec[ARRAY];
 
 public:
     NormalizeBench() {
         SkRandom rand;
         for (int i = 0; i < ARRAY; ++i) {
             fVec[i].set(rand.nextSScalar1(), rand.nextSScalar1());
@@ skipping 21 matching lines @@
         }
     }
 
     virtual const char* onGetName() {
         return fName;
     }
 
 private:
     const char* fName;
 
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class FixedMathBench : public SkBenchmark {
+class FixedMathBench : public Benchmark {
     enum {
         N = 1000,
     };
     float fData[N];
     SkFixed fResult[N];
 public:
 
     FixedMathBench()  {
         SkRandom rand;
         for (int i = 0; i < N; ++i) {
@@ skipping 18 matching lines @@
         if (paint.getAlpha() == 0) {
             SkDebugf("%d\n", fResult[0]);
         }
     }
 
     virtual const char* onGetName() {
         return "float_to_fixed";
     }
 
 private:
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
-class DivModBench : public SkBenchmark {
+class DivModBench : public Benchmark {
     SkString fName;
 public:
     explicit DivModBench(const char* name) {
         fName.printf("divmod_%s", name);
     }
 
     virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ skipping 42 matching lines @@
 
 DEF_BENCH( return new FloorBench(false); )
 DEF_BENCH( return new FloorBench(true); )
 
 DEF_BENCH( return new CLZBench(false); )
 DEF_BENCH( return new CLZBench(true); )
 
 DEF_BENCH( return new NormalizeBench(); )
 
 DEF_BENCH( return new FixedMathBench(); )