Refactoring: get rid of the SkBenchmark void* parameter.

bench/AAClipBench.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 "SkAAClip.h"
 #include "SkPath.h"
 #include "SkRegion.h"
 #include "SkString.h"
 #include "SkCanvas.h"
 #include "SkRandom.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // This bench tests out AA/BW clipping via canvas' clipPath and clipRect calls
 class AAClipBench : public SkBenchmark {
     SkString fName;
     SkPath   fClipPath;
     SkRect   fClipRect;
     SkRect   fDrawRect;
     bool     fDoPath;
     bool     fDoAA;
 
 public:
-    AAClipBench(void* param, bool doPath, bool doAA)
-        : INHERITED(param)
-        , fDoPath(doPath)
+    AAClipBench(bool doPath, bool doAA)
+        : fDoPath(doPath)
         , fDoAA(doAA) {
 
         fName.printf("aaclip_%s_%s",
                      doPath ? "path" : "rect",
                      doAA ? "AA" : "BW");
 
         fClipRect.set(SkFloatToScalar(10.5f), SkFloatToScalar(10.5f),
                       SkFloatToScalar(50.5f), SkFloatToScalar(50.5f));
         fClipPath.addRoundRect(fClipRect, SkIntToScalar(10), SkIntToScalar(10));
         fDrawRect.set(SkIntToScalar(0), SkIntToScalar(0),
@@ skipping 51 matching lines @@
     bool     fDoAA;
     SkRect   fDrawRect;
     SkRandom fRandom;
 
     static const int kNestingDepth = 3;
     static const int kImageSize = 400;
 
     SkPoint fSizes[kNestingDepth+1];
 
 public:
-    NestedAAClipBench(void* param, bool doAA)
-        : INHERITED(param)
-        , fDoAA(doAA) {
-
+    NestedAAClipBench(bool doAA) : fDoAA(doAA) {
         fName.printf("nested_aaclip_%s", doAA ? "AA" : "BW");
 
         fDrawRect = SkRect::MakeLTRB(0, 0,
                                      SkIntToScalar(kImageSize),
                                      SkIntToScalar(kImageSize));
 
         fSizes[0].set(SkIntToScalar(kImageSize), SkIntToScalar(kImageSize));
 
         for (int i = 1; i < kNestingDepth+1; ++i) {
             fSizes[i].set(fSizes[i-1].fX/2, fSizes[i-1].fY/2);
@@ skipping 62 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 class AAClipBuilderBench : public SkBenchmark {
     SkString fName;
     SkPath   fPath;
     SkRect   fRect;
     SkRegion fRegion;
     bool     fDoPath;
     bool     fDoAA;
 
 public:
-    AAClipBuilderBench(void* param, bool doPath, bool doAA) : INHERITED(param) {
+    AAClipBuilderBench(bool doPath, bool doAA)  {
         fDoPath = doPath;
         fDoAA = doAA;
 
         fName.printf("aaclip_build_%s_%s", doPath ? "path" : "rect",
                      doAA ? "AA" : "BW");
 
         fRegion.setRect(0, 0, 640, 480);
         fRect.set(fRegion.getBounds());
         fRect.inset(SK_Scalar1/4, SK_Scalar1/4);
         fPath.addRoundRect(fRect, SkIntToScalar(20), SkIntToScalar(20));
@@ skipping 14 matching lines @@
             }
         }
     }
 private:
     typedef SkBenchmark INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 class AAClipRegionBench : public SkBenchmark {
 public:
-    AAClipRegionBench(void* param) : INHERITED(param) {
+    AAClipRegionBench()  {
         SkPath path;
         // test conversion of a complex clip to a aaclip
         path.addCircle(0, 0, SkIntToScalar(200));
         path.addCircle(0, 0, SkIntToScalar(180));
         // evenodd means we've constructed basically a stroked circle
         path.setFillType(SkPath::kEvenOdd_FillType);
 
         SkIRect bounds;
         path.getBounds().roundOut(&bounds);
         fRegion.setPath(path, SkRegion(bounds));
     }
 
 protected:
     virtual const char* onGetName() { return "aaclip_setregion"; }
     virtual void onDraw(SkCanvas*) {
         for (int i = 0; i < this->getLoops(); ++i) {
             SkAAClip clip;
             clip.setRegion(fRegion);
         }
     }
 
 private:
     SkRegion fRegion;
     typedef SkBenchmark INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, false, false)); }
-static SkBenchmark* Fact1(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, false, true)); }
-static SkBenchmark* Fact2(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, true, false)); }
-static SkBenchmark* Fact3(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, true, true)); }
+DEF_BENCH( return SkNEW_ARGS(AAClipBuilderBench, (false, false)); )
+DEF_BENCH( return SkNEW_ARGS(AAClipBuilderBench, (false, true)); )
+DEF_BENCH( return SkNEW_ARGS(AAClipBuilderBench, (true, false)); )
+DEF_BENCH( return SkNEW_ARGS(AAClipBuilderBench, (true, true)); )
+DEF_BENCH( return SkNEW_ARGS(AAClipRegionBench, ()); )
+DEF_BENCH( return SkNEW_ARGS(AAClipBench, (false, false)); )
+DEF_BENCH( return SkNEW_ARGS(AAClipBench, (false, true)); )
+DEF_BENCH( return SkNEW_ARGS(AAClipBench, (true, false)); )
+DEF_BENCH( return SkNEW_ARGS(AAClipBench, (true, true)); )
+DEF_BENCH( return SkNEW_ARGS(NestedAAClipBench, (false)); )
+DEF_BENCH( return SkNEW_ARGS(NestedAAClipBench, (true)); )
 
-static BenchRegistry gReg0(Fact0);
-static BenchRegistry gReg1(Fact1);
-static BenchRegistry gReg2(Fact2);
-static BenchRegistry gReg3(Fact3);
-
-static SkBenchmark* Fact01(void* p) { return SkNEW_ARGS(AAClipRegionBench, (p)); }
-static BenchRegistry gReg01(Fact01);
-
-static SkBenchmark* Fact000(void* p) { return SkNEW_ARGS(AAClipBench, (p, false, false)); }
-static SkBenchmark* Fact001(void* p) { return SkNEW_ARGS(AAClipBench, (p, false, true)); }
-static SkBenchmark* Fact002(void* p) { return SkNEW_ARGS(AAClipBench, (p, true, false)); }
-static SkBenchmark* Fact003(void* p) { return SkNEW_ARGS(AAClipBench, (p, true, true)); }
-
-static BenchRegistry gReg000(Fact000);
-static BenchRegistry gReg001(Fact001);
-static BenchRegistry gReg002(Fact002);
-static BenchRegistry gReg003(Fact003);
-
-static SkBenchmark* Fact004(void* p) { return SkNEW_ARGS(NestedAAClipBench, (p, false)); }
-static SkBenchmark* Fact005(void* p) { return SkNEW_ARGS(NestedAAClipBench, (p, true)); }
-
-static BenchRegistry gReg004(Fact004);
-static BenchRegistry gReg005(Fact005);