Refactoring: get rid of the SkBenchmark void* parameter.

bench/MathBench.cpp

 #include "SkBenchmark.h"
 #include "SkColorPriv.h"
 #include "SkMatrix.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 {
     enum {
         kBuffer = 100,
     };
     SkString    fName;
     float       fSrc[kBuffer], fDst[kBuffer];
 public:
-    MathBench(void* param, const char name[]) : INHERITED(param) {
+    MathBench(const char name[])  {
         fName.printf("math_%s", name);
 
         SkRandom rand;
         for (int i = 0; i < kBuffer; ++i) {
             fSrc[i] = rand.nextSScalar1();
         }
 
         fIsRendering = false;
     }
 
@@ skipping 14 matching lines @@
             this->performTest(fDst, fSrc, kBuffer);
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 class MathBenchU32 : public MathBench {
 public:
-    MathBenchU32(void* param, const char name[]) : INHERITED(param, name) {}
+    MathBenchU32(const char name[]) : INHERITED(name) {}
 
 protected:
     virtual void performITest(uint32_t* SK_RESTRICT dst,
                               const uint32_t* SK_RESTRICT src,
                               int count) = 0;
 
     virtual void performTest(float* SK_RESTRICT dst,
                              const float* SK_RESTRICT src,
                              int count) SK_OVERRIDE {
         uint32_t* d = SkTCast<uint32_t*>(dst);
         const uint32_t* s = SkTCast<const uint32_t*>(src);
         this->performITest(d, s, count);
     }
 private:
     typedef MathBench INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class NoOpMathBench : public MathBench {
 public:
-    NoOpMathBench(void* param) : INHERITED(param, "noOp") {}
+    NoOpMathBench() : INHERITED("noOp") {}
 protected:
     virtual void performTest(float* SK_RESTRICT dst,
                               const float* SK_RESTRICT src,
                               int count) {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[i] + 1;
         }
     }
 private:
     typedef MathBench INHERITED;
 };
 
 class SlowISqrtMathBench : public MathBench {
 public:
-    SlowISqrtMathBench(void* param) : INHERITED(param, "slowIsqrt") {}
+    SlowISqrtMathBench() : INHERITED("slowIsqrt") {}
 protected:
     virtual void performTest(float* SK_RESTRICT dst,
                               const float* SK_RESTRICT src,
                               int count) {
         for (int i = 0; i < count; ++i) {
             dst[i] = 1.0f / sk_float_sqrt(src[i]);
         }
     }
 private:
     typedef MathBench INHERITED;
 };
 
 static inline float SkFastInvSqrt(float x) {
     float xhalf = 0.5f*x;
     int i = *SkTCast<int*>(&x);
     i = 0x5f3759df - (i>>1);
     x = *SkTCast<float*>(&i);
     x = x*(1.5f-xhalf*x*x);
 //    x = x*(1.5f-xhalf*x*x); // this line takes err from 10^-3 to 10^-6
     return x;
 }
 
 class FastISqrtMathBench : public MathBench {
 public:
-    FastISqrtMathBench(void* param) : INHERITED(param, "fastIsqrt") {}
+    FastISqrtMathBench() : INHERITED("fastIsqrt") {}
 protected:
     virtual void performTest(float* SK_RESTRICT dst,
                               const float* SK_RESTRICT src,
                               int count) {
         for (int i = 0; i < count; ++i) {
             dst[i] = SkFastInvSqrt(src[i]);
         }
     }
 private:
     typedef MathBench INHERITED;
 };
 
 static inline uint32_t QMul64(uint32_t value, U8CPU alpha) {
     SkASSERT((uint8_t)alpha == alpha);
     const uint32_t mask = 0xFF00FF;
 
     uint64_t tmp = value;
     tmp = (tmp & mask) | ((tmp & ~mask) << 24);
     tmp *= alpha;
     return (uint32_t) (((tmp >> 8) & mask) | ((tmp >> 32) & ~mask));
 }
 
 class QMul64Bench : public MathBenchU32 {
 public:
-    QMul64Bench(void* param) : INHERITED(param, "qmul64") {}
+    QMul64Bench() : INHERITED("qmul64") {}
 protected:
     virtual void performITest(uint32_t* SK_RESTRICT dst,
                               const uint32_t* SK_RESTRICT src,
                               int count) SK_OVERRIDE {
         for (int i = 0; i < count; ++i) {
             dst[i] = QMul64(src[i], (uint8_t)i);
         }
     }
 private:
     typedef MathBenchU32 INHERITED;
 };
 
 class QMul32Bench : public MathBenchU32 {
 public:
-    QMul32Bench(void* param) : INHERITED(param, "qmul32") {}
+    QMul32Bench() : INHERITED("qmul32") {}
 protected:
     virtual void performITest(uint32_t* SK_RESTRICT dst,
                               const uint32_t* SK_RESTRICT src,
                               int count) SK_OVERRIDE {
         for (int i = 0; i < count; ++i) {
             dst[i] = SkAlphaMulQ(src[i], (uint8_t)i);
         }
     }
 private:
     typedef MathBenchU32 INHERITED;
@@ skipping 71 matching lines @@
     return value == value;
 }
 
 class IsFiniteBench : public SkBenchmark {
     enum {
         N = 1000,
     };
     float fData[N];
 public:
 
-    IsFiniteBench(void* param, int index) : INHERITED(param) {
+    IsFiniteBench(int index)  {
         SkRandom rand;
 
         for (int i = 0; i < N; ++i) {
             fData[i] = rand.nextSScalar1();
         }
 
         if (index < 0) {
             fProc = NULL;
             fName = "isfinite_rect";
         } else {
@@ skipping 46 matching lines @@
 };
 
 class FloorBench : public SkBenchmark {
     enum {
         ARRAY = 1000,
     };
     float fData[ARRAY];
     bool fFast;
 public:
 
-    FloorBench(void* param, bool fast) : INHERITED(param), fFast(fast) {
+    FloorBench(bool fast) : fFast(fast) {
         SkRandom rand;
 
         for (int i = 0; i < ARRAY; ++i) {
             fData[i] = rand.nextSScalar1();
         }
 
         if (fast) {
             fName = "floor_fast";
         } else {
             fName = "floor_std";
@@ skipping 37 matching lines @@
 };
 
 class CLZBench : public SkBenchmark {
     enum {
         ARRAY = 1000,
     };
     uint32_t fData[ARRAY];
     bool fUsePortable;
 
 public:
-    CLZBench(void* param, bool usePortable)
-        : INHERITED(param)
-        , fUsePortable(usePortable) {
+    CLZBench(bool usePortable) : fUsePortable(usePortable) {
 
         SkRandom rand;
         for (int i = 0; i < ARRAY; ++i) {
             fData[i] = rand.nextU();
         }
 
         if (fUsePortable) {
             fName = "clz_portable";
         } else {
             fName = "clz_intrinsic";
@@ skipping 37 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class NormalizeBench : public SkBenchmark {
     enum {
         ARRAY =1000,
     };
     SkVector fVec[ARRAY];
 
 public:
-    NormalizeBench(void* param)
-    : INHERITED(param) {
-
+    NormalizeBench() {
         SkRandom rand;
         for (int i = 0; i < ARRAY; ++i) {
             fVec[i].set(rand.nextSScalar1(), rand.nextSScalar1());
         }
 
         fName = "point_normalize";
         fIsRendering = false;
     }
 
     // just so the compiler doesn't remove our loops
@@ skipping 24 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 class FixedMathBench : public SkBenchmark {
     enum {
         N = 1000,
     };
     float fData[N];
     SkFixed fResult[N];
 public:
 
-    FixedMathBench(void* param) : INHERITED(param) {
+    FixedMathBench()  {
         SkRandom rand;
         for (int i = 0; i < this->getLoops(); ++i) {
             fData[i%N] = rand.nextSScalar1();
         }
 
         fIsRendering = false;
     }
 
 protected:
     virtual void onDraw(SkCanvas*) {
@@ skipping 12 matching lines @@
     virtual const char* onGetName() {
         return "float_to_fixed";
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new NoOpMathBench(p); )
-DEF_BENCH( return new SlowISqrtMathBench(p); )
-DEF_BENCH( return new FastISqrtMathBench(p); )
-DEF_BENCH( return new QMul64Bench(p); )
-DEF_BENCH( return new QMul32Bench(p); )
+DEF_BENCH( return new NoOpMathBench(); )
+DEF_BENCH( return new SlowISqrtMathBench(); )
+DEF_BENCH( return new FastISqrtMathBench(); )
+DEF_BENCH( return new QMul64Bench(); )
+DEF_BENCH( return new QMul32Bench(); )
 
-DEF_BENCH( return new IsFiniteBench(p, -1); )
-DEF_BENCH( return new IsFiniteBench(p, 0); )
-DEF_BENCH( return new IsFiniteBench(p, 1); )
-DEF_BENCH( return new IsFiniteBench(p, 2); )
-DEF_BENCH( return new IsFiniteBench(p, 3); )
-DEF_BENCH( return new IsFiniteBench(p, 4); )
-DEF_BENCH( return new IsFiniteBench(p, 5); )
+DEF_BENCH( return new IsFiniteBench(-1); )
+DEF_BENCH( return new IsFiniteBench(0); )
+DEF_BENCH( return new IsFiniteBench(1); )
+DEF_BENCH( return new IsFiniteBench(2); )
+DEF_BENCH( return new IsFiniteBench(3); )
+DEF_BENCH( return new IsFiniteBench(4); )
+DEF_BENCH( return new IsFiniteBench(5); )
 
-DEF_BENCH( return new FloorBench(p, false); )
-DEF_BENCH( return new FloorBench(p, true); )
+DEF_BENCH( return new FloorBench(false); )
+DEF_BENCH( return new FloorBench(true); )
 
-DEF_BENCH( return new CLZBench(p, false); )
-DEF_BENCH( return new CLZBench(p, true); )
+DEF_BENCH( return new CLZBench(false); )
+DEF_BENCH( return new CLZBench(true); )
 
-DEF_BENCH( return new NormalizeBench(p); )
+DEF_BENCH( return new NormalizeBench(); )
 
-DEF_BENCH( return new FixedMathBench(p); )
+DEF_BENCH( return new FixedMathBench(); )