Refactoring: get rid of the SkBenchmark void* parameter.

bench/HairlinePathBench.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
@@ skipping 14 matching lines @@
     10, 10, 15, 5, 20, 20,
     30, 5, 25, 20, 15, 12,
     21, 21, 30, 30, 12, 4,
     32, 28, 20, 18, 12, 10
 };
 
 static const int kMaxPathSize = 10;
 
 class HairlinePathBench : public SkBenchmark {
 public:
-    HairlinePathBench(void* param, Flags flags) : INHERITED(param), fFlags(flags) {
+    HairlinePathBench(Flags flags) : fFlags(flags) {
         fPaint.setStyle(SkPaint::kStroke_Style);
         fPaint.setStrokeWidth(SkIntToScalar(0));
     }
 
     virtual void appendName(SkString*) = 0;
     virtual void makePath(SkPath*) = 0;
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
         fName.printf("path_hairline_%s_%s_",
@@ skipping 24 matching lines @@
 
 private:
     SkPaint     fPaint;
     SkString    fName;
     Flags       fFlags;
     typedef SkBenchmark INHERITED;
 };
 
 class LinePathBench : public HairlinePathBench {
 public:
-    LinePathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    LinePathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("line");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
@@ skipping 11 matching lines @@
             path->lineTo(SkIntToScalar(points[base3] + xTrans),
                          SkIntToScalar(points[base3+1] + yTrans));
         }
     }
 private:
     typedef HairlinePathBench INHERITED;
 };
 
 class QuadPathBench : public HairlinePathBench {
 public:
-    QuadPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    QuadPathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("quad");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
@@ skipping 11 matching lines @@
                          SkIntToScalar(points[base3] + xTrans),
                          SkIntToScalar(points[base3+1] + yTrans));
         }
     }
 private:
     typedef HairlinePathBench INHERITED;
 };
 
 class ConicPathBench : public HairlinePathBench {
 public:
-    ConicPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    ConicPathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("conic");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         SkRandom randWeight;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
@@ skipping 14 matching lines @@
                          SkIntToScalar(points[base3+1] + yTrans),
                          weight);
         }
     }
 private:
     typedef HairlinePathBench INHERITED;
 };
 
 class CubicPathBench : public HairlinePathBench {
 public:
-    CubicPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    CubicPathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("cubic");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
@@ skipping 17 matching lines @@
     }
 private:
     typedef HairlinePathBench INHERITED;
 };
 
 // FLAG00 - no AA, small
 // FLAG01 - no AA, small
 // FLAG10 - AA, big
 // FLAG11 - AA, big
 
-DEF_BENCH( return new LinePathBench(p, FLAGS00); )
-DEF_BENCH( return new LinePathBench(p, FLAGS01); )
-DEF_BENCH( return new LinePathBench(p, FLAGS10); )
-DEF_BENCH( return new LinePathBench(p, FLAGS11); )
+DEF_BENCH( return new LinePathBench(FLAGS00); )
+DEF_BENCH( return new LinePathBench(FLAGS01); )
+DEF_BENCH( return new LinePathBench(FLAGS10); )
+DEF_BENCH( return new LinePathBench(FLAGS11); )
 
-DEF_BENCH( return new QuadPathBench(p, FLAGS00); )
-DEF_BENCH( return new QuadPathBench(p, FLAGS01); )
-DEF_BENCH( return new QuadPathBench(p, FLAGS10); )
-DEF_BENCH( return new QuadPathBench(p, FLAGS11); )
+DEF_BENCH( return new QuadPathBench(FLAGS00); )
+DEF_BENCH( return new QuadPathBench(FLAGS01); )
+DEF_BENCH( return new QuadPathBench(FLAGS10); )
+DEF_BENCH( return new QuadPathBench(FLAGS11); )
 
 // Don't have default path renderer for conics yet on GPU, so must use AA
-// DEF_BENCH( return new ConicPathBench(p, FLAGS00); )
-// DEF_BENCH( return new ConicPathBench(p, FLAGS01); )
-DEF_BENCH( return new ConicPathBench(p, FLAGS10); )
-DEF_BENCH( return new ConicPathBench(p, FLAGS11); )
+// DEF_BENCH( return new ConicPathBench(FLAGS00); )
+// DEF_BENCH( return new ConicPathBench(FLAGS01); )
+DEF_BENCH( return new ConicPathBench(FLAGS10); )
+DEF_BENCH( return new ConicPathBench(FLAGS11); )
 
-DEF_BENCH( return new CubicPathBench(p, FLAGS00); )
-DEF_BENCH( return new CubicPathBench(p, FLAGS01); )
-DEF_BENCH( return new CubicPathBench(p, FLAGS10); )
-DEF_BENCH( return new CubicPathBench(p, FLAGS11); )
+DEF_BENCH( return new CubicPathBench(FLAGS00); )
+DEF_BENCH( return new CubicPathBench(FLAGS01); )
+DEF_BENCH( return new CubicPathBench(FLAGS10); )
+DEF_BENCH( return new CubicPathBench(FLAGS11); )