Refactoring: get rid of the SkBenchmark void* parameter.

bench/RectBench.cpp

 
 /*
  * Copyright 2011 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 "SkCommandLineFlags.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkShader.h"
 #include "SkString.h"
 
 DEFINE_double(strokeWidth, -1.0, "If set, use this stroke width in RectBench.");
 
 class RectBench : public SkBenchmark {
 public:
     int fShift, fStroke;
     enum {
         W = 640,
         H = 480,
         N = 300,
     };
     SkRect  fRects[N];
     SkColor fColors[N];
 
-    RectBench(void* param, int shift, int stroke = 0)
-        : INHERITED(param)
-        , fShift(shift)
+    RectBench(int shift, int stroke = 0)
+        : fShift(shift)
         , fStroke(stroke) {
         SkRandom rand;
         const SkScalar offset = SK_Scalar1/3;
         for (int i = 0; i < N; i++) {
             int x = rand.nextU() % W;
             int y = rand.nextU() % H;
             int w = rand.nextU() % W;
             int h = rand.nextU() % H;
             w >>= shift;
             h >>= shift;
@@ skipping 32 matching lines @@
             this->setupPaint(&paint);
             this->drawThisRect(canvas, fRects[i % N], paint);
         }
     }
 private:
     typedef SkBenchmark INHERITED;
 };
 
 class SrcModeRectBench : public RectBench {
 public:
-    SrcModeRectBench(void* param) : INHERITED(param, 1, 0) {
+    SrcModeRectBench() : INHERITED(1, 0) {
         fMode = SkXfermode::Create(SkXfermode::kSrc_Mode);
     }
 
     virtual ~SrcModeRectBench() {
         SkSafeUnref(fMode);
     }
 
 protected:
     virtual void setupPaint(SkPaint* paint) SK_OVERRIDE {
         this->INHERITED::setupPaint(paint);
@@ skipping 10 matching lines @@
 
 private:
     SkString fName;
     SkXfermode* fMode;
 
     typedef RectBench INHERITED;
 };
 
 class OvalBench : public RectBench {
 public:
-    OvalBench(void* param, int shift, int stroke = 0) : RectBench(param, shift, stroke) {}
+    OvalBench(int shift, int stroke = 0) : RectBench(shift, stroke) {}
 protected:
     virtual void drawThisRect(SkCanvas* c, const SkRect& r, const SkPaint& p) {
         c->drawOval(r, p);
     }
     virtual const char* onGetName() { return computeName("ovals"); }
 };
 
 class RRectBench : public RectBench {
 public:
-    RRectBench(void* param, int shift, int stroke = 0) : RectBench(param, shift, stroke) {}
+    RRectBench(int shift, int stroke = 0) : RectBench(shift, stroke) {}
 protected:
     virtual void drawThisRect(SkCanvas* c, const SkRect& r, const SkPaint& p) {
         c->drawRoundRect(r, r.width() / 4, r.height() / 4, p);
     }
     virtual const char* onGetName() { return computeName("rrects"); }
 };
 
 class PointsBench : public RectBench {
 public:
     SkCanvas::PointMode fMode;
     const char* fName;
 
-    PointsBench(void* param, SkCanvas::PointMode mode, const char* name) :
-        RectBench(param, 2), fMode(mode) {
+    PointsBench(SkCanvas::PointMode mode, const char* name)
+        : RectBench(2)
+        , fMode(mode) {
         fName = name;
     }
 
 protected:
     virtual void onDraw(SkCanvas* canvas) {
         SkScalar gSizes[] = {
             SkIntToScalar(7), 0
         };
         size_t sizes = SK_ARRAY_COUNT(gSizes);
 
@@ skipping 17 matching lines @@
     virtual const char* onGetName() { return fName; }
 };
 
 class AARectBench : public SkBenchmark {
 public:
     enum {
         W = 640,
         H = 480,
     };
 
-    AARectBench(void* param, bool rotate) : INHERITED(param), fRotate(rotate) {}
+    AARectBench(bool rotate) : fRotate(rotate) {}
 
 protected:
 
     virtual const char* onGetName() {
         if (fRotate) {
             return "aarects_rotated";
         }
         return "aarects";
     }
 
@@ skipping 41 matching lines @@
 public:
     enum kMaskType {
         kMaskOpaque = 0,
         kMaskBlack,
         kMaskColor,
         KMaskShader
     };
     SkCanvas::PointMode fMode;
     const char* fName;
 
-    BlitMaskBench(void* param, SkCanvas::PointMode mode,
+    BlitMaskBench(SkCanvas::PointMode mode,
                   BlitMaskBench::kMaskType type, const char* name) :
-                  RectBench(param, 2), fMode(mode), _type(type) {
+        RectBench(2), fMode(mode), _type(type) {
         fName = name;
     }
 
 protected:
     virtual void onDraw(SkCanvas* canvas) {
         SkScalar gSizes[] = {
             SkIntToScalar(13), SkIntToScalar(24)
         };
         size_t sizes = SK_ARRAY_COUNT(gSizes);
 
@@ skipping 43 matching lines @@
            }
         }
     }
     virtual const char* onGetName() { return fName; }
 private:
     typedef RectBench INHERITED;
     kMaskType _type;
 };
 
 
-DEF_BENCH( return SkNEW_ARGS(RectBench, (p, 1)); )
-DEF_BENCH( return SkNEW_ARGS(RectBench, (p, 1, 4)); )
-DEF_BENCH( return SkNEW_ARGS(RectBench, (p, 3)); )
-DEF_BENCH( return SkNEW_ARGS(RectBench, (p, 3, 4)); )
-DEF_BENCH( return SkNEW_ARGS(OvalBench, (p, 1)); )
-DEF_BENCH( return SkNEW_ARGS(OvalBench, (p, 3)); )
-DEF_BENCH( return SkNEW_ARGS(OvalBench, (p, 1, 4)); )
-DEF_BENCH( return SkNEW_ARGS(OvalBench, (p, 3, 4)); )
-DEF_BENCH( return SkNEW_ARGS(RRectBench, (p, 1)); )
-DEF_BENCH( return SkNEW_ARGS(RRectBench, (p, 1, 4)); )
-DEF_BENCH( return SkNEW_ARGS(RRectBench, (p, 3)); )
-DEF_BENCH( return SkNEW_ARGS(RRectBench, (p, 3, 4)); )
-DEF_BENCH( return SkNEW_ARGS(PointsBench, (p, SkCanvas::kPoints_PointMode, "points")); )
-DEF_BENCH( return SkNEW_ARGS(PointsBench, (p, SkCanvas::kLines_PointMode, "lines")); )
-DEF_BENCH( return SkNEW_ARGS(PointsBench, (p, SkCanvas::kPolygon_PointMode, "polygon")); )
+DEF_BENCH( return SkNEW_ARGS(RectBench, (1)); )
+DEF_BENCH( return SkNEW_ARGS(RectBench, (1, 4)); )
+DEF_BENCH( return SkNEW_ARGS(RectBench, (3)); )
+DEF_BENCH( return SkNEW_ARGS(RectBench, (3, 4)); )
+DEF_BENCH( return SkNEW_ARGS(OvalBench, (1)); )
+DEF_BENCH( return SkNEW_ARGS(OvalBench, (3)); )
+DEF_BENCH( return SkNEW_ARGS(OvalBench, (1, 4)); )
+DEF_BENCH( return SkNEW_ARGS(OvalBench, (3, 4)); )
+DEF_BENCH( return SkNEW_ARGS(RRectBench, (1)); )
+DEF_BENCH( return SkNEW_ARGS(RRectBench, (1, 4)); )
+DEF_BENCH( return SkNEW_ARGS(RRectBench, (3)); )
+DEF_BENCH( return SkNEW_ARGS(RRectBench, (3, 4)); )
+DEF_BENCH( return SkNEW_ARGS(PointsBench, (SkCanvas::kPoints_PointMode, "points")); )
+DEF_BENCH( return SkNEW_ARGS(PointsBench, (SkCanvas::kLines_PointMode, "lines")); )
+DEF_BENCH( return SkNEW_ARGS(PointsBench, (SkCanvas::kPolygon_PointMode, "polygon")); )
 
-DEF_BENCH( return SkNEW_ARGS(SrcModeRectBench, (p)); )
+DEF_BENCH( return SkNEW_ARGS(SrcModeRectBench, ()); )
 
-DEF_BENCH( return SkNEW_ARGS(AARectBench, (p, false)); )
-DEF_BENCH( return SkNEW_ARGS(AARectBench, (p, true)); )
+DEF_BENCH( return SkNEW_ARGS(AARectBench, (false)); )
+DEF_BENCH( return SkNEW_ARGS(AARectBench, (true)); )
 
 /* init the blitmask bench
  */
 DEF_BENCH( return SkNEW_ARGS(BlitMaskBench,
-                      (p, SkCanvas::kPoints_PointMode,
+                      (SkCanvas::kPoints_PointMode,
                       BlitMaskBench::kMaskOpaque, "maskopaque")
                       ); )
 DEF_BENCH( return SkNEW_ARGS(BlitMaskBench,
-                      (p, SkCanvas::kPoints_PointMode,
+                      (SkCanvas::kPoints_PointMode,
                       BlitMaskBench::kMaskBlack, "maskblack")
                       ); )
 DEF_BENCH( return SkNEW_ARGS(BlitMaskBench,
-                      (p, SkCanvas::kPoints_PointMode,
+                      (SkCanvas::kPoints_PointMode,
                       BlitMaskBench::kMaskColor, "maskcolor")
                       ); )
 DEF_BENCH( return SkNEW_ARGS(BlitMaskBench,
-                     (p, SkCanvas::kPoints_PointMode,
+                     (SkCanvas::kPoints_PointMode,
                      BlitMaskBench::KMaskShader, "maskshader")
                      ); )