diff --git a/bench/AAClipBench.cpp b/bench/AAClipBench.cpp
index 3c04bd4..856411d 100644
--- a/bench/AAClipBench.cpp
+++ b/bench/AAClipBench.cpp
@@ -24,9 +24,8 @@
     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",
@@ -98,10 +97,7 @@
     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,
@@ -184,7 +180,7 @@
     bool     fDoAA;
 
 public:
-    AAClipBuilderBench(void* param, bool doPath, bool doAA) : INHERITED(param) {
+    AAClipBuilderBench(bool doPath, bool doAA)  {
         fDoPath = doPath;
         fDoAA = doAA;
 
@@ -219,7 +215,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 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));
@@ -248,31 +244,15 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-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);
diff --git a/bench/BicubicBench.cpp b/bench/BicubicBench.cpp
index ece7cbe..d0e48f6 100644
--- a/bench/BicubicBench.cpp
+++ b/bench/BicubicBench.cpp
@@ -19,10 +19,10 @@
     SkString       fName;
 
 public:
-    BicubicBench(void* param, float x, float y)
-        :  INHERITED(param), fScale(SkSize::Make(SkFloatToScalar(x), SkFloatToScalar(y))) {
+    BicubicBench(float x, float y)
+        : fScale(SkSize::Make(SkFloatToScalar(x), SkFloatToScalar(y))) {
         fName.printf("bicubic_%gx%g",
-            SkScalarToFloat(fScale.fWidth), SkScalarToFloat(fScale.fHeight));
+                     SkScalarToFloat(fScale.fWidth), SkScalarToFloat(fScale.fHeight));
     }
 
 protected:
@@ -52,12 +52,7 @@
     typedef SkBenchmark INHERITED;
 };
 
-static SkBenchmark* Fact00(void* p) { return new BicubicBench(p, 10.0f, 10.0f); }
-static SkBenchmark* Fact01(void* p) { return new BicubicBench(p, 2.5f, 10.0f); }
-static SkBenchmark* Fact02(void* p) { return new BicubicBench(p, 10.0f, 2.5f); }
-static SkBenchmark* Fact03(void* p) { return new BicubicBench(p, 2.5f, 2.5f); }
-
-static BenchRegistry gReg00(Fact00);
-static BenchRegistry gReg01(Fact01);
-static BenchRegistry gReg02(Fact02);
-static BenchRegistry gReg03(Fact03);
+DEF_BENCH( return new BicubicBench(10.0f, 10.0f); )
+DEF_BENCH( return new BicubicBench(2.5f, 10.0f); )
+DEF_BENCH( return new BicubicBench(10.0f, 2.5f); )
+DEF_BENCH( return new BicubicBench(2.5f, 2.5f); )
diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp
index 698a680..9b3a6a2 100644
--- a/bench/BitmapBench.cpp
+++ b/bench/BitmapBench.cpp
@@ -84,10 +84,9 @@
     enum { W = 128 };
     enum { H = 128 };
 public:
-    BitmapBench(void* param, bool isOpaque, SkBitmap::Config c,
+    BitmapBench(bool isOpaque, SkBitmap::Config c,
                 bool forceUpdate = false, bool bitmapVolatile = false)
-        : INHERITED(param)
-        , fIsOpaque(isOpaque)
+        : fIsOpaque(isOpaque)
         , fForceUpdate(forceUpdate)
         , fIsVolatile(bitmapVolatile)
         , fConfig(c) {
@@ -200,9 +199,9 @@
     uint32_t    fFlags;
     SkString    fFullName;
 public:
-    FilterBitmapBench(void* param, bool isOpaque, SkBitmap::Config c,
+    FilterBitmapBench(bool isOpaque, SkBitmap::Config c,
                       bool forceUpdate, bool isVolitile, uint32_t flags)
-        : INHERITED(param, isOpaque, c, forceUpdate, isVolitile)
+        : INHERITED(isOpaque, c, forceUpdate, isVolitile)
         , fFlags(flags) {
     }
 
@@ -279,9 +278,9 @@
     SkString    fFullName;
     SourceAlpha fSourceAlpha;
 public:
-    SourceAlphaBitmapBench(void* param, SourceAlpha alpha, SkBitmap::Config c,
+    SourceAlphaBitmapBench(SourceAlpha alpha, SkBitmap::Config c,
                 bool forceUpdate = false, bool bitmapVolatile = false)
-        : INHERITED(param, false, c, forceUpdate, bitmapVolatile)
+        : INHERITED(false, c, forceUpdate, bitmapVolatile)
         , fSourceAlpha(alpha) {
     }
 
@@ -358,31 +357,31 @@
     typedef BitmapBench INHERITED;
 };
 
-DEF_BENCH( return new BitmapBench(p, false, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kRGB_565_Config); )
-DEF_BENCH( return new BitmapBench(p, false, SkBitmap::kIndex8_Config); )
-DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kIndex8_Config); )
-DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true); )
-DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false); )
+DEF_BENCH( return new BitmapBench(false, SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new BitmapBench(true, SkBitmap::kRGB_565_Config); )
+DEF_BENCH( return new BitmapBench(false, SkBitmap::kIndex8_Config); )
+DEF_BENCH( return new BitmapBench(true, SkBitmap::kIndex8_Config); )
+DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config, true, true); )
+DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config, true, false); )
 
 // scale filter -> S32_opaque_D32_filter_DX_{SSE2,SSSE3} and Fact9 is also for S32_D16_filter_DX_SSE2
-DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kBilerp_Flag); )
 
 // scale rotate filter -> S32_opaque_D32_filter_DXDY_{SSE2,SSSE3}
-DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
 
-DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag | kBicubic_Flag); )
-DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag | kBicubic_Flag); )
+DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag | kBicubic_Flag); )
+DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag | kBicubic_Flag); )
 
 // source alpha tests -> S32A_Opaque_BlitRow32_{arm,neon}
-DEF_BENCH( return new SourceAlphaBitmapBench(p, SourceAlphaBitmapBench::kOpaque_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(p, SourceAlphaBitmapBench::kTransparent_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(p, SourceAlphaBitmapBench::kTwoStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(p, SourceAlphaBitmapBench::kThreeStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kOpaque_SourceAlpha, SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTransparent_SourceAlpha, SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTwoStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kThreeStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
diff --git a/bench/BitmapRectBench.cpp b/bench/BitmapRectBench.cpp
index f917445..1dd98ef 100644
--- a/bench/BitmapRectBench.cpp
+++ b/bench/BitmapRectBench.cpp
@@ -48,7 +48,7 @@
     static const int kWidth = 128;
     static const int kHeight = 128;
 public:
-    BitmapRectBench(void* param, U8CPU alpha, bool doFilter, bool slightMatrix) : INHERITED(param) {
+    BitmapRectBench(U8CPU alpha, bool doFilter, bool slightMatrix)  {
         fAlpha = SkToU8(alpha);
         fDoFilter = doFilter;
         fSlightMatrix = slightMatrix;
@@ -101,10 +101,10 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new BitmapRectBench(p, 0xFF, false, false))
-DEF_BENCH(return new BitmapRectBench(p, 0x80, false, false))
-DEF_BENCH(return new BitmapRectBench(p, 0xFF, true, false))
-DEF_BENCH(return new BitmapRectBench(p, 0x80, true, false))
+DEF_BENCH(return new BitmapRectBench(0xFF, false, false))
+DEF_BENCH(return new BitmapRectBench(0x80, false, false))
+DEF_BENCH(return new BitmapRectBench(0xFF, true, false))
+DEF_BENCH(return new BitmapRectBench(0x80, true, false))
 
-DEF_BENCH(return new BitmapRectBench(p, 0xFF, false, true))
-DEF_BENCH(return new BitmapRectBench(p, 0xFF, true, true))
+DEF_BENCH(return new BitmapRectBench(0xFF, false, true))
+DEF_BENCH(return new BitmapRectBench(0xFF, true, true))
diff --git a/bench/BitmapScaleBench.cpp b/bench/BitmapScaleBench.cpp
index 62f8d1b..cc2a33a 100644
--- a/bench/BitmapScaleBench.cpp
+++ b/bench/BitmapScaleBench.cpp
@@ -20,7 +20,7 @@
     SkString    fName;
 
 public:
-    BitmapScaleBench(void *param, int is, int os) : INHERITED(param) {
+    BitmapScaleBench( int is, int os)  {
         fInputSize = is;
         fOutputSize = os;
 
@@ -88,7 +88,7 @@
 
 class BitmapFilterScaleBench: public BitmapScaleBench {
  public:
-    BitmapFilterScaleBench(void *param, int is, int os) : INHERITED(param, is, os) {
+    BitmapFilterScaleBench( int is, int os) : INHERITED(is, os) {
         setName( "filter" );
     }
 protected:
@@ -103,12 +103,12 @@
     typedef BitmapScaleBench INHERITED;
 };
 
-DEF_BENCH(return new BitmapFilterScaleBench(p, 10, 90);)
-DEF_BENCH(return new BitmapFilterScaleBench(p, 30, 90);)
-DEF_BENCH(return new BitmapFilterScaleBench(p, 80, 90);)
-DEF_BENCH(return new BitmapFilterScaleBench(p, 90, 90);)
-DEF_BENCH(return new BitmapFilterScaleBench(p, 90, 80);)
-DEF_BENCH(return new BitmapFilterScaleBench(p, 90, 30);)
-DEF_BENCH(return new BitmapFilterScaleBench(p, 90, 10);)
-DEF_BENCH(return new BitmapFilterScaleBench(p, 256, 64);)
-DEF_BENCH(return new BitmapFilterScaleBench(p, 64, 256);)
+DEF_BENCH(return new BitmapFilterScaleBench(10, 90);)
+DEF_BENCH(return new BitmapFilterScaleBench(30, 90);)
+DEF_BENCH(return new BitmapFilterScaleBench(80, 90);)
+DEF_BENCH(return new BitmapFilterScaleBench(90, 90);)
+DEF_BENCH(return new BitmapFilterScaleBench(90, 80);)
+DEF_BENCH(return new BitmapFilterScaleBench(90, 30);)
+DEF_BENCH(return new BitmapFilterScaleBench(90, 10);)
+DEF_BENCH(return new BitmapFilterScaleBench(256, 64);)
+DEF_BENCH(return new BitmapFilterScaleBench(64, 256);)
diff --git a/bench/BlurBench.cpp b/bench/BlurBench.cpp
index 0ac0b53..77fbc49 100644
--- a/bench/BlurBench.cpp
+++ b/bench/BlurBench.cpp
@@ -33,8 +33,7 @@
     SkString    fName;
 
 public:
-    BlurBench(void* param, SkScalar rad, SkBlurMaskFilter::BlurStyle bs, uint32_t flags = 0)
-        : INHERITED(param) {
+    BlurBench(SkScalar rad, SkBlurMaskFilter::BlurStyle bs, uint32_t flags = 0) {
         fRadius = rad;
         fStyle = bs;
         fFlags = flags;
@@ -79,32 +78,32 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kInner_BlurStyle);)
+DEF_BENCH(return new BlurBench(SMALL, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurBench(SMALL, SkBlurMaskFilter::kSolid_BlurStyle);)
+DEF_BENCH(return new BlurBench(SMALL, SkBlurMaskFilter::kOuter_BlurStyle);)
+DEF_BENCH(return new BlurBench(SMALL, SkBlurMaskFilter::kInner_BlurStyle);)
 
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kInner_BlurStyle);)
+DEF_BENCH(return new BlurBench(BIG, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurBench(BIG, SkBlurMaskFilter::kSolid_BlurStyle);)
+DEF_BENCH(return new BlurBench(BIG, SkBlurMaskFilter::kOuter_BlurStyle);)
+DEF_BENCH(return new BlurBench(BIG, SkBlurMaskFilter::kInner_BlurStyle);)
 
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kInner_BlurStyle);)
+DEF_BENCH(return new BlurBench(REALBIG, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurBench(REALBIG, SkBlurMaskFilter::kSolid_BlurStyle);)
+DEF_BENCH(return new BlurBench(REALBIG, SkBlurMaskFilter::kOuter_BlurStyle);)
+DEF_BENCH(return new BlurBench(REALBIG, SkBlurMaskFilter::kInner_BlurStyle);)
 
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kInner_BlurStyle);)
+DEF_BENCH(return new BlurBench(REAL, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurBench(REAL, SkBlurMaskFilter::kSolid_BlurStyle);)
+DEF_BENCH(return new BlurBench(REAL, SkBlurMaskFilter::kOuter_BlurStyle);)
+DEF_BENCH(return new BlurBench(REAL, SkBlurMaskFilter::kInner_BlurStyle);)
 
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+DEF_BENCH(return new BlurBench(SMALL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
 
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+DEF_BENCH(return new BlurBench(BIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
 
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+DEF_BENCH(return new BlurBench(REALBIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
 
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+DEF_BENCH(return new BlurBench(REAL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
 
-DEF_BENCH(return new BlurBench(p, 0, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurBench(0, SkBlurMaskFilter::kNormal_BlurStyle);)
diff --git a/bench/BlurImageFilterBench.cpp b/bench/BlurImageFilterBench.cpp
index 3d69147..f6bc0e4 100644
--- a/bench/BlurImageFilterBench.cpp
+++ b/bench/BlurImageFilterBench.cpp
@@ -23,8 +23,8 @@
 
 class BlurImageFilterBench : public SkBenchmark {
 public:
-    BlurImageFilterBench(void* param, SkScalar sigmaX, SkScalar sigmaY,  bool small) :
-        INHERITED(param), fIsSmall(small), fInitialized(false), fSigmaX(sigmaX), fSigmaY(sigmaY) {
+    BlurImageFilterBench(SkScalar sigmaX, SkScalar sigmaY,  bool small) :
+        fIsSmall(small), fInitialized(false), fSigmaX(sigmaX), fSigmaY(sigmaY) {
         fName.printf("blur_image_filter_%s_%.2f_%.2f", fIsSmall ? "small" : "large",
             SkScalarToFloat(sigmaX), SkScalarToFloat(sigmaY));
     }
@@ -84,7 +84,7 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new BlurImageFilterBench(p, BLUR_SIGMA_SMALL, BLUR_SIGMA_SMALL, true);)
-DEF_BENCH(return new BlurImageFilterBench(p, BLUR_SIGMA_SMALL, BLUR_SIGMA_SMALL, false);)
-DEF_BENCH(return new BlurImageFilterBench(p, BLUR_SIGMA_LARGE, BLUR_SIGMA_LARGE, true);)
-DEF_BENCH(return new BlurImageFilterBench(p, BLUR_SIGMA_LARGE, BLUR_SIGMA_LARGE, false);)
+DEF_BENCH(return new BlurImageFilterBench(BLUR_SIGMA_SMALL, BLUR_SIGMA_SMALL, true);)
+DEF_BENCH(return new BlurImageFilterBench(BLUR_SIGMA_SMALL, BLUR_SIGMA_SMALL, false);)
+DEF_BENCH(return new BlurImageFilterBench(BLUR_SIGMA_LARGE, BLUR_SIGMA_LARGE, true);)
+DEF_BENCH(return new BlurImageFilterBench(BLUR_SIGMA_LARGE, BLUR_SIGMA_LARGE, false);)
diff --git a/bench/BlurRectBench.cpp b/bench/BlurRectBench.cpp
index 5de16cd..8161d07 100644
--- a/bench/BlurRectBench.cpp
+++ b/bench/BlurRectBench.cpp
@@ -26,7 +26,7 @@
     SkString    fName;
 
 public:
-    BlurRectBench(void *param, SkScalar rad) : INHERITED(param) {
+    BlurRectBench(SkScalar rad) {
         fRadius = rad;
 
         if (fRadius > SkIntToScalar(25)) {
@@ -76,7 +76,7 @@
 
 class BlurRectDirectBench: public BlurRectBench {
  public:
-    BlurRectDirectBench(void *param, SkScalar rad) : INHERITED(param, rad) {
+    BlurRectDirectBench(SkScalar rad) : INHERITED(rad) {
         SkString name;
 
         if (SkScalarFraction(rad) != 0) {
@@ -101,7 +101,7 @@
 class BlurRectSeparableBench: public BlurRectBench {
 
 public:
-    BlurRectSeparableBench(void *param, SkScalar rad) : INHERITED(param, rad) {
+    BlurRectSeparableBench(SkScalar rad) : INHERITED(rad) {
         fSrcMask.fImage = NULL;
     }
 
@@ -128,7 +128,7 @@
 
 class BlurRectBoxFilterBench: public BlurRectSeparableBench {
 public:
-    BlurRectBoxFilterBench(void *param, SkScalar rad) : INHERITED(param, rad) {
+    BlurRectBoxFilterBench(SkScalar rad) : INHERITED(rad) {
         SkString name;
 
         if (SkScalarFraction(rad) != 0) {
@@ -156,7 +156,7 @@
 
 class BlurRectGaussianBench: public BlurRectSeparableBench {
 public:
-    BlurRectGaussianBench(void *param, SkScalar rad) : INHERITED(param, rad) {
+    BlurRectGaussianBench(SkScalar rad) : INHERITED(rad) {
         SkString name;
 
         if (SkScalarFraction(rad) != 0) {
@@ -181,24 +181,24 @@
     typedef BlurRectSeparableBench INHERITED;
 };
 
-DEF_BENCH(return new BlurRectBoxFilterBench(p, SMALL);)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, BIG);)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, REALBIG);)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, REAL);)
-DEF_BENCH(return new BlurRectGaussianBench(p, SMALL);)
-DEF_BENCH(return new BlurRectGaussianBench(p, BIG);)
-DEF_BENCH(return new BlurRectGaussianBench(p, REALBIG);)
-DEF_BENCH(return new BlurRectGaussianBench(p, REAL);)
-DEF_BENCH(return new BlurRectDirectBench(p, SMALL);)
-DEF_BENCH(return new BlurRectDirectBench(p, BIG);)
-DEF_BENCH(return new BlurRectDirectBench(p, REALBIG);)
-DEF_BENCH(return new BlurRectDirectBench(p, REAL);)
+DEF_BENCH(return new BlurRectBoxFilterBench(SMALL);)
+DEF_BENCH(return new BlurRectBoxFilterBench(BIG);)
+DEF_BENCH(return new BlurRectBoxFilterBench(REALBIG);)
+DEF_BENCH(return new BlurRectBoxFilterBench(REAL);)
+DEF_BENCH(return new BlurRectGaussianBench(SMALL);)
+DEF_BENCH(return new BlurRectGaussianBench(BIG);)
+DEF_BENCH(return new BlurRectGaussianBench(REALBIG);)
+DEF_BENCH(return new BlurRectGaussianBench(REAL);)
+DEF_BENCH(return new BlurRectDirectBench(SMALL);)
+DEF_BENCH(return new BlurRectDirectBench(BIG);)
+DEF_BENCH(return new BlurRectDirectBench(REALBIG);)
+DEF_BENCH(return new BlurRectDirectBench(REAL);)
 
-DEF_BENCH(return new BlurRectDirectBench(p, kMedium);)
-DEF_BENCH(return new BlurRectDirectBench(p, kMedBig);)
+DEF_BENCH(return new BlurRectDirectBench(kMedium);)
+DEF_BENCH(return new BlurRectDirectBench(kMedBig);)
 
-DEF_BENCH(return new BlurRectBoxFilterBench(p, kMedium);)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, kMedBig);)
+DEF_BENCH(return new BlurRectBoxFilterBench(kMedium);)
+DEF_BENCH(return new BlurRectBoxFilterBench(kMedBig);)
 
 #if 0
 // disable Gaussian benchmarks; the algorithm works well enough
@@ -206,24 +206,24 @@
 // to use in production for non-trivial radii, so no real point
 // in having the bots benchmark it all the time.
 
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(1));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(2));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(3));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(4));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(5));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(6));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(7));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(8));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(9));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(10));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(11));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(12));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(13));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(14));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(15));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(16));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(17));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(18));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(19));)
-DEF_BENCH(return new BlurRectGaussianBench(p, SkIntToScalar(20));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(1));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(2));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(3));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(4));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(5));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(6));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(7));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(8));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(9));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(10));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(11));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(12));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(13));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(14));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(15));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(16));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(17));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(18));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(19));)
+DEF_BENCH(return new BlurRectGaussianBench(SkIntToScalar(20));)
 #endif
diff --git a/bench/ChartBench.cpp b/bench/ChartBench.cpp
index 6990049..e63021f 100644
--- a/bench/ChartBench.cpp
+++ b/bench/ChartBench.cpp
@@ -91,7 +91,7 @@
 // filling
 class ChartBench : public SkBenchmark {
 public:
-    ChartBench(void* param, bool aa) : SkBenchmark(param) {
+    ChartBench(bool aa) {
         fShift = 0;
         fAA = aa;
         fSize.fWidth = -1;
@@ -194,8 +194,5 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return new ChartBench(p, true); }
-static SkBenchmark* Fact1(void* p) { return new ChartBench(p, false); }
-
-static BenchRegistry gReg0(Fact0);
-static BenchRegistry gReg1(Fact1);
+DEF_BENCH( return new ChartBench(true); )
+DEF_BENCH( return new ChartBench(false); )
diff --git a/bench/ChecksumBench.cpp b/bench/ChecksumBench.cpp
index 7cc6008..3e7a739 100644
--- a/bench/ChecksumBench.cpp
+++ b/bench/ChecksumBench.cpp
@@ -28,7 +28,7 @@
     ChecksumType fType;
 
 public:
-    ComputeChecksumBench(void* param, ChecksumType type) : INHERITED(param), fType(type) {
+    ComputeChecksumBench(ChecksumType type) : fType(type) {
         SkRandom rand;
         for (int i = 0; i < U32COUNT; ++i) {
             fData[i] = rand.nextU();
@@ -88,13 +88,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return new ComputeChecksumBench(p, kChecksum_ChecksumType); }
-static SkBenchmark* Fact1(void* p) { return new ComputeChecksumBench(p, kMD5_ChecksumType); }
-static SkBenchmark* Fact2(void* p) { return new ComputeChecksumBench(p, kSHA1_ChecksumType); }
-static SkBenchmark* Fact3(void* p) { return new ComputeChecksumBench(p, kMurmur3_ChecksumType); }
-
-
-static BenchRegistry gReg0(Fact0);
-static BenchRegistry gReg1(Fact1);
-static BenchRegistry gReg2(Fact2);
-static BenchRegistry gReg3(Fact3);
+DEF_BENCH( return new ComputeChecksumBench(kChecksum_ChecksumType); )
+DEF_BENCH( return new ComputeChecksumBench(kMD5_ChecksumType); )
+DEF_BENCH( return new ComputeChecksumBench(kSHA1_ChecksumType); )
+DEF_BENCH( return new ComputeChecksumBench(kMurmur3_ChecksumType); )
diff --git a/bench/ChromeBench.cpp b/bench/ChromeBench.cpp
index fb6dcb2..9392065 100644
--- a/bench/ChromeBench.cpp
+++ b/bench/ChromeBench.cpp
@@ -456,7 +456,7 @@
         N = 431
     };
 public:
-    ScrollGmailBench(void* param) : INHERITED(param) { }
+    ScrollGmailBench()  { }
 
 protected:
 
@@ -491,10 +491,6 @@
     typedef SkBenchmark INHERITED;
 };
 
-static inline SkBenchmark* ScrollGmailFactory(void* p) {
-    return SkNEW_ARGS(ScrollGmailBench, (p));
-}
-
 // Disabled this benchmark: it takes 15x longer than any other benchmark
 // and is probably not giving us important information.
-//static BenchRegistry gScrollGmailReg(ScrollGmailFactory);
+// DEF_BENCH(return SkNEW(ScrollGmailBench));
diff --git a/bench/CmapBench.cpp b/bench/CmapBench.cpp
index c721e9c..1d2a5ee 100644
--- a/bench/CmapBench.cpp
+++ b/bench/CmapBench.cpp
@@ -69,7 +69,7 @@
     SkPaint      fPaint;
 
 public:
-    CMAPBench(void* param, TypefaceProc proc, const char name[]) : SkBenchmark(param) {
+    CMAPBench(TypefaceProc proc, const char name[]) {
         fProc = proc;
         fName.printf("cmap_%s", name);
 
@@ -96,7 +96,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new CMAPBench(p, containsText_proc, "paint_containsText"); )
-DEF_BENCH( return new CMAPBench(p, textToGlyphs_proc, "paint_textToGlyphs"); )
-DEF_BENCH( return new CMAPBench(p, charsToGlyphs_proc, "face_charsToGlyphs"); )
-DEF_BENCH( return new CMAPBench(p, charsToGlyphsNull_proc, "face_charsToGlyphs_null"); )
+DEF_BENCH( return new CMAPBench(containsText_proc, "paint_containsText"); )
+DEF_BENCH( return new CMAPBench(textToGlyphs_proc, "paint_textToGlyphs"); )
+DEF_BENCH( return new CMAPBench(charsToGlyphs_proc, "face_charsToGlyphs"); )
+DEF_BENCH( return new CMAPBench(charsToGlyphsNull_proc, "face_charsToGlyphs_null"); )
diff --git a/bench/ColorFilterBench.cpp b/bench/ColorFilterBench.cpp
index 2ac78ae..e30b005 100644
--- a/bench/ColorFilterBench.cpp
+++ b/bench/ColorFilterBench.cpp
@@ -18,8 +18,7 @@
 class ColorFilterBaseBench : public SkBenchmark {
 
 public:
-    ColorFilterBaseBench(void* param, bool small) : INHERITED(param), fIsSmall(small) {
-    }
+    ColorFilterBaseBench(bool small) : fIsSmall(small) { }
 
 protected:
     SkRect getFilterRect() const {
@@ -64,7 +63,7 @@
 class ColorFilterDimBrightBench : public ColorFilterBaseBench {
 
 public:
-    ColorFilterDimBrightBench(void* param, bool small) : INHERITED(param, small) {
+    ColorFilterDimBrightBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -94,7 +93,7 @@
 class ColorFilterBrightGrayBench : public ColorFilterBaseBench {
 
 public:
-    ColorFilterBrightGrayBench(void* param, bool small) : INHERITED(param, small) {
+    ColorFilterBrightGrayBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -121,7 +120,7 @@
 class ColorFilterGrayBrightBench : public ColorFilterBaseBench {
 
 public:
-    ColorFilterGrayBrightBench(void* param, bool small) : INHERITED(param, small) {
+    ColorFilterGrayBrightBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -148,7 +147,7 @@
 class ColorFilterBlueBrightBench : public ColorFilterBaseBench {
 
 public:
-    ColorFilterBlueBrightBench(void* param, bool small) : INHERITED(param, small) {
+    ColorFilterBlueBrightBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -175,7 +174,7 @@
 class ColorFilterBrightBlueBench : public ColorFilterBaseBench {
 
 public:
-    ColorFilterBrightBlueBench(void* param, bool small) : INHERITED(param, small) {
+    ColorFilterBrightBlueBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -202,7 +201,7 @@
 class ColorFilterBrightBench : public ColorFilterBaseBench {
 
 public:
-    ColorFilterBrightBench(void* param, bool small) : INHERITED(param, small) {
+    ColorFilterBrightBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -228,7 +227,7 @@
 class ColorFilterBlueBench : public ColorFilterBaseBench {
 
 public:
-    ColorFilterBlueBench(void* param, bool small) : INHERITED(param, small) {
+    ColorFilterBlueBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -254,7 +253,7 @@
 class ColorFilterGrayBench : public ColorFilterBaseBench {
 
 public:
-    ColorFilterGrayBench(void* param, bool small) : INHERITED(param, small) {
+    ColorFilterGrayBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -280,7 +279,7 @@
 class TableColorFilterBench : public ColorFilterBaseBench {
 
 public:
-    TableColorFilterBench(void* param, bool small) : INHERITED(param, small) {
+    TableColorFilterBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -317,22 +316,22 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new ColorFilterDimBrightBench(p, true); )
-DEF_BENCH( return new ColorFilterBrightGrayBench(p, true); )
-DEF_BENCH( return new ColorFilterGrayBrightBench(p, true); )
-DEF_BENCH( return new ColorFilterBlueBrightBench(p, true); )
-DEF_BENCH( return new ColorFilterBrightBlueBench(p, true); )
-DEF_BENCH( return new ColorFilterBrightBench(p, true); )
-DEF_BENCH( return new ColorFilterBlueBench(p, true); )
-DEF_BENCH( return new ColorFilterGrayBench(p, true); )
-DEF_BENCH( return new TableColorFilterBench(p, true); )
+DEF_BENCH( return new ColorFilterDimBrightBench(true); )
+DEF_BENCH( return new ColorFilterBrightGrayBench(true); )
+DEF_BENCH( return new ColorFilterGrayBrightBench(true); )
+DEF_BENCH( return new ColorFilterBlueBrightBench(true); )
+DEF_BENCH( return new ColorFilterBrightBlueBench(true); )
+DEF_BENCH( return new ColorFilterBrightBench(true); )
+DEF_BENCH( return new ColorFilterBlueBench(true); )
+DEF_BENCH( return new ColorFilterGrayBench(true); )
+DEF_BENCH( return new TableColorFilterBench(true); )
 
-DEF_BENCH( return new ColorFilterDimBrightBench(p, false); )
-DEF_BENCH( return new ColorFilterBrightGrayBench(p, false); )
-DEF_BENCH( return new ColorFilterGrayBrightBench(p, false); )
-DEF_BENCH( return new ColorFilterBlueBrightBench(p, false); )
-DEF_BENCH( return new ColorFilterBrightBlueBench(p, false); )
-DEF_BENCH( return new ColorFilterBrightBench(p, false); )
-DEF_BENCH( return new ColorFilterBlueBench(p, false); )
-DEF_BENCH( return new ColorFilterGrayBench(p, false); )
-DEF_BENCH( return new TableColorFilterBench(p, false); )
+DEF_BENCH( return new ColorFilterDimBrightBench(false); )
+DEF_BENCH( return new ColorFilterBrightGrayBench(false); )
+DEF_BENCH( return new ColorFilterGrayBrightBench(false); )
+DEF_BENCH( return new ColorFilterBlueBrightBench(false); )
+DEF_BENCH( return new ColorFilterBrightBlueBench(false); )
+DEF_BENCH( return new ColorFilterBrightBench(false); )
+DEF_BENCH( return new ColorFilterBlueBench(false); )
+DEF_BENCH( return new ColorFilterGrayBench(false); )
+DEF_BENCH( return new TableColorFilterBench(false); )
diff --git a/bench/DashBench.cpp b/bench/DashBench.cpp
index 84fe3ab..040dfd5 100644
--- a/bench/DashBench.cpp
+++ b/bench/DashBench.cpp
@@ -38,8 +38,8 @@
     bool                fDoClip;
 
 public:
-    DashBench(void* param, const SkScalar intervals[], int count, int width,
-              bool doClip = false) : INHERITED(param) {
+    DashBench(const SkScalar intervals[], int count, int width,
+              bool doClip = false)  {
         fIntervals.append(count, intervals);
         for (int i = 0; i < count; ++i) {
             fIntervals[i] *= width;
@@ -99,8 +99,8 @@
 
 class RectDashBench : public DashBench {
 public:
-    RectDashBench(void* param, const SkScalar intervals[], int count, int width)
-    : INHERITED(param, intervals, count, width) {
+    RectDashBench(const SkScalar intervals[], int count, int width)
+    : INHERITED(intervals, count, width) {
         fName.append("_rect");
     }
 
@@ -181,7 +181,7 @@
     SkAutoTUnref<SkPathEffect> fPE;
 
 public:
-    MakeDashBench(void* param, void (*proc)(SkPath*), const char name[]) : INHERITED(param) {
+    MakeDashBench(void (*proc)(SkPath*), const char name[])  {
         fName.printf("makedash_%s", name);
         proc(&fPath);
 
@@ -218,7 +218,7 @@
     SkAutoTUnref<SkPathEffect> fPE;
 
 public:
-    DashLineBench(void* param, SkScalar width, bool isRound) : INHERITED(param) {
+    DashLineBench(SkScalar width, bool isRound)  {
         fName.printf("dashline_%g_%s", SkScalarToFloat(width), isRound ? "circle" : "square");
         fStrokeWidth = width;
         fIsRound = isRound;
@@ -256,8 +256,8 @@
     SkAutoTUnref<SkPathEffect> fPathEffect;
 
 public:
-    DrawPointsDashingBench(void* param, int dashLength, int strokeWidth, bool doAA)
-        : INHERITED(param) {
+    DrawPointsDashingBench(int dashLength, int strokeWidth, bool doAA)
+         {
         fName.printf("drawpointsdash_%d_%d%s", dashLength, strokeWidth, doAA ? "_aa" : "_bw");
         fStrokeWidth = strokeWidth;
         fDoAA = doAA;
@@ -316,7 +316,7 @@
         return gNames[lt];
     }
 
-    GiantDashBench(void* param, LineType lt, SkScalar width) : INHERITED(param) {
+    GiantDashBench(LineType lt, SkScalar width)  {
         fName.printf("giantdashline_%s_%g", LineTypeName(lt), width);
         fStrokeWidth = width;
 
@@ -380,39 +380,39 @@
 
 #define PARAM(array)    array, SK_ARRAY_COUNT(array)
 
-DEF_BENCH( return new DashBench(p, PARAM(gDots), 0); )
-DEF_BENCH( return new DashBench(p, PARAM(gDots), 1); )
-DEF_BENCH( return new DashBench(p, PARAM(gDots), 1, true); )
-DEF_BENCH( return new DashBench(p, PARAM(gDots), 4); )
-DEF_BENCH( return new MakeDashBench(p, make_poly, "poly"); )
-DEF_BENCH( return new MakeDashBench(p, make_quad, "quad"); )
-DEF_BENCH( return new MakeDashBench(p, make_cubic, "cubic"); )
-DEF_BENCH( return new DashLineBench(p, 0, false); )
-DEF_BENCH( return new DashLineBench(p, SK_Scalar1, false); )
-DEF_BENCH( return new DashLineBench(p, 2 * SK_Scalar1, false); )
-DEF_BENCH( return new DashLineBench(p, 0, true); )
-DEF_BENCH( return new DashLineBench(p, SK_Scalar1, true); )
-DEF_BENCH( return new DashLineBench(p, 2 * SK_Scalar1, true); )
+DEF_BENCH( return new DashBench(PARAM(gDots), 0); )
+DEF_BENCH( return new DashBench(PARAM(gDots), 1); )
+DEF_BENCH( return new DashBench(PARAM(gDots), 1, true); )
+DEF_BENCH( return new DashBench(PARAM(gDots), 4); )
+DEF_BENCH( return new MakeDashBench(make_poly, "poly"); )
+DEF_BENCH( return new MakeDashBench(make_quad, "quad"); )
+DEF_BENCH( return new MakeDashBench(make_cubic, "cubic"); )
+DEF_BENCH( return new DashLineBench(0, false); )
+DEF_BENCH( return new DashLineBench(SK_Scalar1, false); )
+DEF_BENCH( return new DashLineBench(2 * SK_Scalar1, false); )
+DEF_BENCH( return new DashLineBench(0, true); )
+DEF_BENCH( return new DashLineBench(SK_Scalar1, true); )
+DEF_BENCH( return new DashLineBench(2 * SK_Scalar1, true); )
 
-DEF_BENCH( return new DrawPointsDashingBench(p, 1, 1, false); )
-DEF_BENCH( return new DrawPointsDashingBench(p, 1, 1, true); )
-DEF_BENCH( return new DrawPointsDashingBench(p, 3, 1, false); )
-DEF_BENCH( return new DrawPointsDashingBench(p, 3, 1, true); )
-DEF_BENCH( return new DrawPointsDashingBench(p, 5, 5, false); )
-DEF_BENCH( return new DrawPointsDashingBench(p, 5, 5, true); )
+DEF_BENCH( return new DrawPointsDashingBench(1, 1, false); )
+DEF_BENCH( return new DrawPointsDashingBench(1, 1, true); )
+DEF_BENCH( return new DrawPointsDashingBench(3, 1, false); )
+DEF_BENCH( return new DrawPointsDashingBench(3, 1, true); )
+DEF_BENCH( return new DrawPointsDashingBench(5, 5, false); )
+DEF_BENCH( return new DrawPointsDashingBench(5, 5, true); )
 
 /* Disable the GiantDashBench for Android devices until we can better control
  * the memory usage. (https://code.google.com/p/skia/issues/detail?id=1430)
  */
 #ifndef SK_BUILD_FOR_ANDROID
-DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kHori_LineType, 0); )
-DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kVert_LineType, 0); )
-DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kDiag_LineType, 0); )
+DEF_BENCH( return new GiantDashBench(GiantDashBench::kHori_LineType, 0); )
+DEF_BENCH( return new GiantDashBench(GiantDashBench::kVert_LineType, 0); )
+DEF_BENCH( return new GiantDashBench(GiantDashBench::kDiag_LineType, 0); )
 
 // pass 2 to explicitly avoid any 1-is-the-same-as-hairline special casing
 
 // hori_2 is just too slow to enable at the moment
-DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kHori_LineType, 2); )
-DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kVert_LineType, 2); )
-DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kDiag_LineType, 2); )
+DEF_BENCH( return new GiantDashBench(GiantDashBench::kHori_LineType, 2); )
+DEF_BENCH( return new GiantDashBench(GiantDashBench::kVert_LineType, 2); )
+DEF_BENCH( return new GiantDashBench(GiantDashBench::kDiag_LineType, 2); )
 #endif
diff --git a/bench/DecodeBench.cpp b/bench/DecodeBench.cpp
index c45654c..4397eef 100644
--- a/bench/DecodeBench.cpp
+++ b/bench/DecodeBench.cpp
@@ -21,7 +21,7 @@
     SkBitmap::Config fPrefConfig;
     SkString fName;
 public:
-    DecodeBench(void* param, SkBitmap::Config c) : SkBenchmark(param) {
+    DecodeBench(SkBitmap::Config c) {
         fPrefConfig = c;
 
         const char* fname = strrchr(FLAGS_decodeBenchFilename[0], '/');
@@ -51,10 +51,6 @@
     typedef SkBenchmark INHERITED;
 };
 
-static SkBenchmark* Fact0(void* p) { return new DecodeBench(p, SkBitmap::kARGB_8888_Config); }
-static SkBenchmark* Fact1(void* p) { return new DecodeBench(p, SkBitmap::kRGB_565_Config); }
-static SkBenchmark* Fact2(void* p) { return new DecodeBench(p, SkBitmap::kARGB_4444_Config); }
-
-static BenchRegistry gReg0(Fact0);
-static BenchRegistry gReg1(Fact1);
-static BenchRegistry gReg2(Fact2);
+DEF_BENCH( return new DecodeBench(SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new DecodeBench(SkBitmap::kRGB_565_Config); )
+DEF_BENCH( return new DecodeBench(SkBitmap::kARGB_4444_Config); )
diff --git a/bench/DeferredCanvasBench.cpp b/bench/DeferredCanvasBench.cpp
index 4caf229..2ef4c6b 100644
--- a/bench/DeferredCanvasBench.cpp
+++ b/bench/DeferredCanvasBench.cpp
@@ -11,7 +11,7 @@
 
 class DeferredCanvasBench : public SkBenchmark {
 public:
-    DeferredCanvasBench(void* param, const char name[]) : INHERITED(param) {
+    DeferredCanvasBench(const char name[])  {
         fName.printf("deferred_canvas_%s", name);
     }
 
@@ -70,8 +70,8 @@
 // overhead of SkDeferredCanvas
 class DeferredRecordBench : public DeferredCanvasBench {
 public:
-    DeferredRecordBench(void* param)
-        : INHERITED(param, "record") {
+    DeferredRecordBench()
+        : INHERITED("record") {
     }
 
 protected:
@@ -105,6 +105,4 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return new DeferredRecordBench(p); }
-
-static BenchRegistry gReg0(Fact0);
+DEF_BENCH( return new DeferredRecordBench(); )
diff --git a/bench/DeferredSurfaceCopyBench.cpp b/bench/DeferredSurfaceCopyBench.cpp
index 7c9abea..2aaebe7 100644
--- a/bench/DeferredSurfaceCopyBench.cpp
+++ b/bench/DeferredSurfaceCopyBench.cpp
@@ -21,7 +21,7 @@
         kSurfaceHeight = 1000,
     };
 public:
-    DeferredSurfaceCopyBench(void* param, bool discardableContents) : SkBenchmark(param) {
+    DeferredSurfaceCopyBench(bool discardableContents) {
         fDiscardableContents = discardableContents;
     }
 
@@ -78,8 +78,5 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return new DeferredSurfaceCopyBench(p, false); }
-static SkBenchmark* Fact1(void* p) { return new DeferredSurfaceCopyBench(p, true); }
-
-static BenchRegistry gReg0(Fact0);
-static BenchRegistry gReg1(Fact1);
+DEF_BENCH( return new DeferredSurfaceCopyBench(false); )
+DEF_BENCH( return new DeferredSurfaceCopyBench(true); )
diff --git a/bench/DisplacementBench.cpp b/bench/DisplacementBench.cpp
index bf1ee73..3d0f215 100644
--- a/bench/DisplacementBench.cpp
+++ b/bench/DisplacementBench.cpp
@@ -17,8 +17,8 @@
 
 class DisplacementBaseBench : public SkBenchmark {
 public:
-    DisplacementBaseBench(void* param, bool small) :
-        INHERITED(param), fInitialized(false), fIsSmall(small) {
+    DisplacementBaseBench(bool small) :
+        fInitialized(false), fIsSmall(small) {
     }
 
 protected:
@@ -90,7 +90,7 @@
 
 class DisplacementZeroBench : public DisplacementBaseBench {
 public:
-    DisplacementZeroBench(void* param, bool small) : INHERITED(param, small) {
+    DisplacementZeroBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -117,7 +117,7 @@
 
 class DisplacementAlphaBench : public DisplacementBaseBench {
 public:
-    DisplacementAlphaBench(void* param, bool small) : INHERITED(param, small) {
+    DisplacementAlphaBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -143,7 +143,7 @@
 
 class DisplacementFullBench : public DisplacementBaseBench {
 public:
-    DisplacementFullBench(void* param, bool small) : INHERITED(param, small) {
+    DisplacementFullBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -169,9 +169,9 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new DisplacementZeroBench(p, true); )
-DEF_BENCH( return new DisplacementAlphaBench(p, true); )
-DEF_BENCH( return new DisplacementFullBench(p, true); )
-DEF_BENCH( return new DisplacementZeroBench(p, false); )
-DEF_BENCH( return new DisplacementAlphaBench(p, false); )
-DEF_BENCH( return new DisplacementFullBench(p, false); )
+DEF_BENCH( return new DisplacementZeroBench(true); )
+DEF_BENCH( return new DisplacementAlphaBench(true); )
+DEF_BENCH( return new DisplacementFullBench(true); )
+DEF_BENCH( return new DisplacementZeroBench(false); )
+DEF_BENCH( return new DisplacementAlphaBench(false); )
+DEF_BENCH( return new DisplacementFullBench(false); )
diff --git a/bench/FSRectBench.cpp b/bench/FSRectBench.cpp
index 0083dd4..80f10bd 100644
--- a/bench/FSRectBench.cpp
+++ b/bench/FSRectBench.cpp
@@ -17,10 +17,7 @@
  */
 class FSRectBench : public SkBenchmark {
 public:
-    FSRectBench(void* param)
-        : INHERITED(param)
-        , fInit(false) {
-    }
+    FSRectBench() : fInit(false) { }
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE { return "fullscreen_rects"; }
@@ -63,4 +60,4 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH( return SkNEW_ARGS(FSRectBench, (p)); )
+DEF_BENCH( return SkNEW_ARGS(FSRectBench, ()); )
diff --git a/bench/FontCacheBench.cpp b/bench/FontCacheBench.cpp
index c206d5b..c682f43 100644
--- a/bench/FontCacheBench.cpp
+++ b/bench/FontCacheBench.cpp
@@ -25,7 +25,7 @@
 
 class FontCacheBench : public SkBenchmark {
 public:
-    FontCacheBench(void* param) : INHERITED(param) {}
+    FontCacheBench()  {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -109,7 +109,7 @@
 
 class FontCacheEfficiency : public SkBenchmark {
 public:
-    FontCacheEfficiency(void* param) : INHERITED(param) {
+    FontCacheEfficiency()  {
         if (false) dump_array(NULL, 0);
         if (false) rotr(0, 0);
     }
@@ -152,7 +152,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new FontCacheBench(p); )
+DEF_BENCH( return new FontCacheBench(); )
 
 // undefine this to run the efficiency test
-//DEF_BENCH( return new FontCacheEfficiency(p); )
+//DEF_BENCH( return new FontCacheEfficiency(); )
diff --git a/bench/FontScalerBench.cpp b/bench/FontScalerBench.cpp
index ac4f60e..d4a9674 100644
--- a/bench/FontScalerBench.cpp
+++ b/bench/FontScalerBench.cpp
@@ -19,7 +19,7 @@
     SkString fText;
     bool     fDoLCD;
 public:
-    FontScalerBench(void* param, bool doLCD) : INHERITED(param) {
+    FontScalerBench(bool doLCD)  {
         fName.printf("fontscaler_%s", doLCD ? "lcd" : "aa");
         fText.set("abcdefghijklmnopqrstuvwxyz01234567890");
         fDoLCD = doLCD;
@@ -55,8 +55,5 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return SkNEW_ARGS(FontScalerBench, (p, false)); }
-static SkBenchmark* Fact1(void* p) { return SkNEW_ARGS(FontScalerBench, (p, true)); }
-
-static BenchRegistry gReg0(Fact0);
-static BenchRegistry gReg1(Fact1);
+DEF_BENCH( return SkNEW_ARGS(FontScalerBench, (false)); )
+DEF_BENCH( return SkNEW_ARGS(FontScalerBench, (true)); )
diff --git a/bench/GameBench.cpp b/bench/GameBench.cpp
index 5fc9c03..7812285 100644
--- a/bench/GameBench.cpp
+++ b/bench/GameBench.cpp
@@ -27,11 +27,10 @@
         kPartial_Clear
     };
 
-    GameBench(void* param, Type type, Clear clear,
+    GameBench(Type type, Clear clear,
               bool aligned = false, bool useAtlas = false,
               bool useDrawVertices = false)
-        : INHERITED(param)
-        , fType(type)
+        : fType(type)
         , fClear(clear)
         , fAligned(aligned)
         , fUseAtlas(useAtlas)
@@ -313,27 +312,27 @@
 };
 
 // Partial clear
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kScale_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kScale_Type,
                                             GameBench::kPartial_Clear)); )
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kTranslate_Type,
                                             GameBench::kPartial_Clear)); )
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kTranslate_Type,
                                             GameBench::kPartial_Clear, true)); )
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kRotate_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kRotate_Type,
                                             GameBench::kPartial_Clear)); )
 
 // Full clear
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kScale_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kScale_Type,
                                             GameBench::kFull_Clear)); )
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kTranslate_Type,
                                             GameBench::kFull_Clear)); )
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kTranslate_Type,
                                             GameBench::kFull_Clear, true)); )
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kRotate_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kRotate_Type,
                                             GameBench::kFull_Clear)); )
 
 // Atlased
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kTranslate_Type,
                                             GameBench::kFull_Clear, false, true)); )
-DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type,
+DEF_BENCH( return SkNEW_ARGS(GameBench, (GameBench::kTranslate_Type,
                                             GameBench::kFull_Clear, false, true, true)); )
diff --git a/bench/GrMemoryPoolBench.cpp b/bench/GrMemoryPoolBench.cpp
index 5ad1afa..4fae591 100644
--- a/bench/GrMemoryPoolBench.cpp
+++ b/bench/GrMemoryPoolBench.cpp
@@ -35,7 +35,7 @@
  */
 class GrMemoryPoolBenchStack : public SkBenchmark {
 public:
-    GrMemoryPoolBenchStack(void* param) : INHERITED(param) {
+    GrMemoryPoolBenchStack()  {
         fIsRendering = false;
     }
 protected:
@@ -86,7 +86,7 @@
  */
 class GrMemoryPoolBenchRandom : public SkBenchmark {
 public:
-    GrMemoryPoolBenchRandom(void* param) : INHERITED(param) {
+    GrMemoryPoolBenchRandom()  {
         fIsRendering = false;
     }
 protected:
@@ -123,7 +123,7 @@
         M = 4 * (1 << 10),
     };
 public:
-    GrMemoryPoolBenchQueue(void* param) : INHERITED(param) {
+    GrMemoryPoolBenchQueue()  {
         fIsRendering = false;
     }
 protected:
@@ -151,12 +151,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact1(void* p) { return new GrMemoryPoolBenchStack(p); }
-static SkBenchmark* Fact2(void* p) { return new GrMemoryPoolBenchRandom(p); }
-static SkBenchmark* Fact3(void* p) { return new GrMemoryPoolBenchQueue(p); }
-
-static BenchRegistry gReg01(Fact1);
-static BenchRegistry gReg02(Fact2);
-static BenchRegistry gReg03(Fact3);
-
+DEF_BENCH( return new GrMemoryPoolBenchStack(); )
+DEF_BENCH( return new GrMemoryPoolBenchRandom(); )
+DEF_BENCH( return new GrMemoryPoolBenchQueue(); )
 #endif
diff --git a/bench/GradientBench.cpp b/bench/GradientBench.cpp
index 8dec68b..029c365 100644
--- a/bench/GradientBench.cpp
+++ b/bench/GradientBench.cpp
@@ -165,13 +165,13 @@
         H   = 400,
     };
 public:
-    GradientBench(void* param, GradType gradType,
+    GradientBench(GradType gradType,
                   GradData data = gGradData[0],
                   SkShader::TileMode tm = SkShader::kClamp_TileMode,
                   GeomType geomType = kRect_GeomType,
                   float scale = 1.0f
         )
-        : INHERITED(param) {
+         {
         fName.printf("gradient_%s_%s", gGrads[gradType].fName,
                      tilemodename(tm));
         if (geomType != kRect_GeomType) {
@@ -230,7 +230,7 @@
     bool     fHasAlpha;
 
 public:
-    Gradient2Bench(void* param, bool hasAlpha) : INHERITED(param) {
+    Gradient2Bench(bool hasAlpha)  {
         fName.printf("gradient_create_%s", hasAlpha ? "alpha" : "opaque");
         fHasAlpha = hasAlpha;
     }
@@ -269,26 +269,26 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH( return new GradientBench(p, kLinear_GradType); )
-DEF_BENCH( return new GradientBench(p, kLinear_GradType, gGradData[1]); )
-DEF_BENCH( return new GradientBench(p, kLinear_GradType, gGradData[0], SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(kLinear_GradType); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1]); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kMirror_TileMode); )
 
 // Draw a radial gradient of radius 1/2 on a rectangle; half the lines should
 // be completely pinned, the other half should pe partially pinned
-DEF_BENCH( return new GradientBench(p, kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); )
 
 // Draw a radial gradient on a circle of equal size; all the lines should
 // hit the unpinned fast path (so long as GradientBench.W == H)
-DEF_BENCH( return new GradientBench(p, kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kOval_GeomType); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kOval_GeomType); )
 
-DEF_BENCH( return new GradientBench(p, kRadial_GradType, gGradData[0], SkShader::kMirror_TileMode); )
-DEF_BENCH( return new GradientBench(p, kSweep_GradType); )
-DEF_BENCH( return new GradientBench(p, kSweep_GradType, gGradData[1]); )
-DEF_BENCH( return new GradientBench(p, kRadial2_GradType); )
-DEF_BENCH( return new GradientBench(p, kRadial2_GradType, gGradData[1]); )
-DEF_BENCH( return new GradientBench(p, kRadial2_GradType, gGradData[0], SkShader::kMirror_TileMode); )
-DEF_BENCH( return new GradientBench(p, kConical_GradType); )
-DEF_BENCH( return new GradientBench(p, kConical_GradType, gGradData[1]); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(kSweep_GradType); )
+DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[1]); )
+DEF_BENCH( return new GradientBench(kRadial2_GradType); )
+DEF_BENCH( return new GradientBench(kRadial2_GradType, gGradData[1]); )
+DEF_BENCH( return new GradientBench(kRadial2_GradType, gGradData[0], SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(kConical_GradType); )
+DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[1]); )
 
-DEF_BENCH( return new Gradient2Bench(p, false); )
-DEF_BENCH( return new Gradient2Bench(p, true); )
+DEF_BENCH( return new Gradient2Bench(false); )
+DEF_BENCH( return new Gradient2Bench(true); )
diff --git a/bench/HairlinePathBench.cpp b/bench/HairlinePathBench.cpp
index 3ba0972..c596475 100644
--- a/bench/HairlinePathBench.cpp
+++ b/bench/HairlinePathBench.cpp
@@ -32,7 +32,7 @@
 
 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));
     }
@@ -77,7 +77,7 @@
 
 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");
@@ -109,7 +109,7 @@
 
 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");
@@ -141,7 +141,7 @@
 
 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");
@@ -176,7 +176,7 @@
 
 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");
@@ -214,23 +214,23 @@
 // 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); )
diff --git a/bench/ImageCacheBench.cpp b/bench/ImageCacheBench.cpp
index c0a2d3d..ea295fd 100644
--- a/bench/ImageCacheBench.cpp
+++ b/bench/ImageCacheBench.cpp
@@ -17,7 +17,7 @@
         CACHE_COUNT = 500
     };
 public:
-    ImageCacheBench(void* param) : INHERITED(param) , fCache(CACHE_COUNT * 100) {
+    ImageCacheBench()  : fCache(CACHE_COUNT * 100) {
         fBM.setConfig(SkBitmap::kARGB_8888_Config, DIM, DIM);
         fBM.allocPixels();
     }
@@ -56,4 +56,4 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new ImageCacheBench(p); )
+DEF_BENCH( return new ImageCacheBench(); )
diff --git a/bench/ImageDecodeBench.cpp b/bench/ImageDecodeBench.cpp
index 2e50ec5..3a61163 100644
--- a/bench/ImageDecodeBench.cpp
+++ b/bench/ImageDecodeBench.cpp
@@ -21,8 +21,7 @@
 class ImageDecodeBench : public SkBenchmark {
 public:
     ImageDecodeBench(void* p, const char* filename)
-    : INHERITED(p)
-    , fName("image_decode_")
+    : fName("image_decode_")
     , fFilename(filename)
     , fStream()
     , fValid(false) {
@@ -87,5 +86,5 @@
 };
 
 // These are files which call decodePalette
-//DEF_BENCH( return SkNEW_ARGS(ImageDecodeBench, (p, "/usr/local/google/home/scroggo/Downloads/images/hal_163x90.png")); )
-//DEF_BENCH( return SkNEW_ARGS(ImageDecodeBench, (p, "/usr/local/google/home/scroggo/Downloads/images/box_19_top-left.png")); )
+//DEF_BENCH( return SkNEW_ARGS(ImageDecodeBench, ("/usr/local/google/home/scroggo/Downloads/images/hal_163x90.png")); )
+//DEF_BENCH( return SkNEW_ARGS(ImageDecodeBench, ("/usr/local/google/home/scroggo/Downloads/images/box_19_top-left.png")); )
diff --git a/bench/InterpBench.cpp b/bench/InterpBench.cpp
index 513618b..f43c37e 100644
--- a/bench/InterpBench.cpp
+++ b/bench/InterpBench.cpp
@@ -16,7 +16,7 @@
     int16_t     fDst[kBuffer];
     float       fFx, fDx;
 public:
-    InterpBench(void* param, const char name[]) : INHERITED(param) {
+    InterpBench(const char name[])  {
         fName.printf("interp_%s", name);
         fFx = 3.3f;
         fDx = 0.1257f;
@@ -45,7 +45,7 @@
 
 class Fixed16D16Interp : public InterpBench {
 public:
-    Fixed16D16Interp(void* param) : INHERITED(param, "16.16") {}
+    Fixed16D16Interp() : INHERITED("16.16") {}
 
 protected:
     virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
@@ -64,7 +64,7 @@
 
 class Fixed32D32Interp : public InterpBench {
 public:
-    Fixed32D32Interp(void* param) : INHERITED(param, "32.32") {}
+    Fixed32D32Interp() : INHERITED("32.32") {}
 
 protected:
     virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
@@ -95,7 +95,7 @@
 
 class Fixed16D48Interp : public InterpBench {
 public:
-    Fixed16D48Interp(void* param) : INHERITED(param, "16.48") {}
+    Fixed16D48Interp() : INHERITED("16.48") {}
 
 protected:
     virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
@@ -115,7 +115,7 @@
 
 class FloatInterp : public InterpBench {
 public:
-    FloatInterp(void* param) : INHERITED(param, "float") {}
+    FloatInterp() : INHERITED("float") {}
 
 protected:
     virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
@@ -133,7 +133,7 @@
 
 class DoubleInterp : public InterpBench {
 public:
-    DoubleInterp(void* param) : INHERITED(param, "double") {}
+    DoubleInterp() : INHERITED("double") {}
 
 protected:
     virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
@@ -153,14 +153,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* M0(void* p) { return new Fixed16D16Interp(p); }
-static SkBenchmark* M1(void* p) { return new Fixed32D32Interp(p); }
-static SkBenchmark* M2(void* p) { return new Fixed16D48Interp(p); }
-static SkBenchmark* M3(void* p) { return new FloatInterp(p); }
-static SkBenchmark* M4(void* p) { return new DoubleInterp(p); }
-
-static BenchRegistry gReg0(M0);
-static BenchRegistry gReg1(M1);
-static BenchRegistry gReg2(M2);
-static BenchRegistry gReg3(M3);
-static BenchRegistry gReg4(M4);
+DEF_BENCH( return new Fixed16D16Interp(); )
+DEF_BENCH( return new Fixed32D32Interp(); )
+DEF_BENCH( return new Fixed16D48Interp(); )
+DEF_BENCH( return new FloatInterp(); )
+DEF_BENCH( return new DoubleInterp(); )
diff --git a/bench/LightingBench.cpp b/bench/LightingBench.cpp
index 37c098b..7a1b599 100644
--- a/bench/LightingBench.cpp
+++ b/bench/LightingBench.cpp
@@ -17,8 +17,7 @@
 
 class LightingBaseBench : public SkBenchmark {
 public:
-    LightingBaseBench(void* param, bool small) : INHERITED(param), fIsSmall(small) {
-    }
+    LightingBaseBench(bool small) : fIsSmall(small) { }
 
 protected:
     void draw(SkCanvas* canvas, SkImageFilter* imageFilter) const {
@@ -98,7 +97,7 @@
 
 class LightingPointLitDiffuseBench : public LightingBaseBench {
 public:
-    LightingPointLitDiffuseBench(void* param, bool small) : INHERITED(param, small) {
+    LightingPointLitDiffuseBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -117,7 +116,7 @@
 
 class LightingDistantLitDiffuseBench : public LightingBaseBench {
 public:
-    LightingDistantLitDiffuseBench(void* param, bool small) : INHERITED(param, small) {
+    LightingDistantLitDiffuseBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -136,7 +135,7 @@
 
 class LightingSpotLitDiffuseBench : public LightingBaseBench {
 public:
-    LightingSpotLitDiffuseBench(void* param, bool small) : INHERITED(param, small) {
+    LightingSpotLitDiffuseBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -156,7 +155,7 @@
 
 class LightingPointLitSpecularBench : public LightingBaseBench {
 public:
-    LightingPointLitSpecularBench(void* param, bool small) : INHERITED(param, small) {
+    LightingPointLitSpecularBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -175,7 +174,7 @@
 
 class LightingDistantLitSpecularBench : public LightingBaseBench {
 public:
-    LightingDistantLitSpecularBench(void* param, bool small) : INHERITED(param, small) {
+    LightingDistantLitSpecularBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -194,7 +193,7 @@
 
 class LightingSpotLitSpecularBench : public LightingBaseBench {
 public:
-    LightingSpotLitSpecularBench(void* param, bool small) : INHERITED(param, small) {
+    LightingSpotLitSpecularBench(bool small) : INHERITED(small) {
     }
 
 protected:
@@ -214,15 +213,15 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new LightingPointLitDiffuseBench(p, true); )
-DEF_BENCH( return new LightingPointLitDiffuseBench(p, false); )
-DEF_BENCH( return new LightingDistantLitDiffuseBench(p, true); )
-DEF_BENCH( return new LightingDistantLitDiffuseBench(p, false); )
-DEF_BENCH( return new LightingSpotLitDiffuseBench(p, true); )
-DEF_BENCH( return new LightingSpotLitDiffuseBench(p, false); )
-DEF_BENCH( return new LightingPointLitSpecularBench(p, true); )
-DEF_BENCH( return new LightingPointLitSpecularBench(p, false); )
-DEF_BENCH( return new LightingDistantLitSpecularBench(p, true); )
-DEF_BENCH( return new LightingDistantLitSpecularBench(p, false); )
-DEF_BENCH( return new LightingSpotLitSpecularBench(p, true); )
-DEF_BENCH( return new LightingSpotLitSpecularBench(p, false); )
+DEF_BENCH( return new LightingPointLitDiffuseBench(true); )
+DEF_BENCH( return new LightingPointLitDiffuseBench(false); )
+DEF_BENCH( return new LightingDistantLitDiffuseBench(true); )
+DEF_BENCH( return new LightingDistantLitDiffuseBench(false); )
+DEF_BENCH( return new LightingSpotLitDiffuseBench(true); )
+DEF_BENCH( return new LightingSpotLitDiffuseBench(false); )
+DEF_BENCH( return new LightingPointLitSpecularBench(true); )
+DEF_BENCH( return new LightingPointLitSpecularBench(false); )
+DEF_BENCH( return new LightingDistantLitSpecularBench(true); )
+DEF_BENCH( return new LightingDistantLitSpecularBench(false); )
+DEF_BENCH( return new LightingSpotLitSpecularBench(true); )
+DEF_BENCH( return new LightingSpotLitSpecularBench(false); )
diff --git a/bench/LineBench.cpp b/bench/LineBench.cpp
index 7a54d3c..e69a40a 100644
--- a/bench/LineBench.cpp
+++ b/bench/LineBench.cpp
@@ -26,7 +26,7 @@
     SkPoint fPts[PTS];
 
 public:
-    LineBench(void* param, SkScalar width, bool doAA) : INHERITED(param) {
+    LineBench(SkScalar width, bool doAA)  {
         fStrokeWidth = width;
         fDoAA = doAA;
         fName.printf("lines_%g_%s", width, doAA ? "AA" : "BW");
@@ -59,8 +59,8 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new LineBench(p, 0,            false);)
-DEF_BENCH(return new LineBench(p, SK_Scalar1,   false);)
-DEF_BENCH(return new LineBench(p, 0,            true);)
-DEF_BENCH(return new LineBench(p, SK_Scalar1/2, true);)
-DEF_BENCH(return new LineBench(p, SK_Scalar1,   true);)
+DEF_BENCH(return new LineBench(0,            false);)
+DEF_BENCH(return new LineBench(SK_Scalar1,   false);)
+DEF_BENCH(return new LineBench(0,            true);)
+DEF_BENCH(return new LineBench(SK_Scalar1/2, true);)
+DEF_BENCH(return new LineBench(SK_Scalar1,   true);)
diff --git a/bench/MagnifierBench.cpp b/bench/MagnifierBench.cpp
index 6d48a61..b5561a2 100644
--- a/bench/MagnifierBench.cpp
+++ b/bench/MagnifierBench.cpp
@@ -17,8 +17,8 @@
 
 class MagnifierBench : public SkBenchmark {
 public:
-    MagnifierBench(void* param, bool small) :
-        INHERITED(param), fIsSmall(small), fInitialized(false) {
+    MagnifierBench(bool small) :
+        fIsSmall(small), fInitialized(false) {
     }
 
 protected:
@@ -83,5 +83,5 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new MagnifierBench(p, true); )
-DEF_BENCH( return new MagnifierBench(p, false); )
+DEF_BENCH( return new MagnifierBench(true); )
+DEF_BENCH( return new MagnifierBench(false); )
diff --git a/bench/MathBench.cpp b/bench/MathBench.cpp
index 7bf7d93..c34be44 100644
--- a/bench/MathBench.cpp
+++ b/bench/MathBench.cpp
@@ -22,7 +22,7 @@
     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;
@@ -57,7 +57,7 @@
 
 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,
@@ -79,7 +79,7 @@
 
 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,
@@ -94,7 +94,7 @@
 
 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,
@@ -119,7 +119,7 @@
 
 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,
@@ -144,7 +144,7 @@
 
 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,
@@ -159,7 +159,7 @@
 
 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,
@@ -251,7 +251,7 @@
     float fData[N];
 public:
 
-    IsFiniteBench(void* param, int index) : INHERITED(param) {
+    IsFiniteBench(int index)  {
         SkRandom rand;
 
         for (int i = 0; i < N; ++i) {
@@ -318,7 +318,7 @@
     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) {
@@ -376,9 +376,7 @@
     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) {
@@ -436,9 +434,7 @@
     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());
@@ -483,7 +479,7 @@
     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();
@@ -516,26 +512,26 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-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(); )
diff --git a/bench/Matrix44Bench.cpp b/bench/Matrix44Bench.cpp
index b79233c..a4b36d8 100644
--- a/bench/Matrix44Bench.cpp
+++ b/bench/Matrix44Bench.cpp
@@ -13,7 +13,7 @@
 class Matrix44Bench : public SkBenchmark {
     SkString    fName;
 public:
-    Matrix44Bench(void* param, const char name[]) : INHERITED(param) {
+    Matrix44Bench(const char name[])  {
         fName.printf("matrix44_%s", name);
         fIsRendering = false;
     }
@@ -39,7 +39,7 @@
 
 class EqualsMatrix44Bench : public Matrix44Bench {
 public:
-    EqualsMatrix44Bench(void* param) : INHERITED(param, "equals") {
+    EqualsMatrix44Bench() : INHERITED("equals") {
         fM1.set(0, 0, 0);
         fM2.set(3, 3, 0);
     }
@@ -58,7 +58,7 @@
 
 class SetIdentityMatrix44Bench : public Matrix44Bench {
 public:
-    SetIdentityMatrix44Bench(void* param) : INHERITED(param, "setidentity") {
+    SetIdentityMatrix44Bench() : INHERITED("setidentity") {
         double rowMajor[16] =
                 { 1, 2, 3, 4,
                   5, 6, 7, 8,
@@ -79,7 +79,7 @@
 
 class PreScaleMatrix44Bench : public Matrix44Bench {
 public:
-    PreScaleMatrix44Bench(void* param) : INHERITED(param, "prescale") {
+    PreScaleMatrix44Bench() : INHERITED("prescale") {
         fX = fY = fZ = SkDoubleToMScalar(1.5);
     }
 protected:
@@ -97,7 +97,7 @@
 
 class InvertMatrix44Bench : public Matrix44Bench {
 public:
-    InvertMatrix44Bench(void* param) : INHERITED(param, "invert") {
+    InvertMatrix44Bench() : INHERITED("invert") {
         fM0.set(0, 0, -1.1);
         fM0.set(0, 1, 2.1);
         fM0.set(0, 2, -3.1);
@@ -128,7 +128,7 @@
 
 class InvertAffineMatrix44Bench : public Matrix44Bench {
 public:
-    InvertAffineMatrix44Bench(void* param) : INHERITED(param, "invertaffine") {
+    InvertAffineMatrix44Bench() : INHERITED("invertaffine") {
         fM0.set(0, 0, -1.1);
         fM0.set(0, 1, 2.1);
         fM0.set(0, 2, -3.1);
@@ -156,7 +156,7 @@
 
 class InvertScaleTranslateMatrix44Bench : public Matrix44Bench {
 public:
-    InvertScaleTranslateMatrix44Bench(void* param) : INHERITED(param, "invertscaletranslate") {
+    InvertScaleTranslateMatrix44Bench() : INHERITED("invertscaletranslate") {
         fM0.set(0, 0, -1.1);
         fM0.set(0, 3, 4.1);
 
@@ -179,7 +179,7 @@
 
 class InvertTranslateMatrix44Bench : public Matrix44Bench {
 public:
-    InvertTranslateMatrix44Bench(void* param) : INHERITED(param, "inverttranslate") {
+    InvertTranslateMatrix44Bench() : INHERITED("inverttranslate") {
         fM0.set(0, 3, 4.1);
         fM0.set(1, 3, 8.1);
         fM0.set(2, 3, -12.1);
@@ -197,7 +197,7 @@
 
 class PostScaleMatrix44Bench : public Matrix44Bench {
 public:
-    PostScaleMatrix44Bench(void* param) : INHERITED(param, "postscale") {
+    PostScaleMatrix44Bench() : INHERITED("postscale") {
         fX = fY = fZ = SkDoubleToMScalar(1.5);
     }
 protected:
@@ -215,7 +215,7 @@
 
 class SetConcatMatrix44Bench : public Matrix44Bench {
 public:
-    SetConcatMatrix44Bench(void* param) : INHERITED(param, "setconcat") {
+    SetConcatMatrix44Bench() : INHERITED("setconcat") {
         fX = fY = fZ = SkDoubleToMScalar(1.5);
         fM1.setScale(fX, fY, fZ);
         fM2.setTranslate(fX, fY, fZ);
@@ -235,7 +235,7 @@
 
 class GetTypeMatrix44Bench : public Matrix44Bench {
 public:
-    GetTypeMatrix44Bench(void* param) : INHERITED(param, "gettype") {}
+    GetTypeMatrix44Bench() : INHERITED("gettype") {}
 protected:
     // Putting random generation of the matrix inside performTest()
     // would help us avoid anomalous runs, but takes up 25% or
@@ -251,13 +251,13 @@
     typedef Matrix44Bench INHERITED;
 };
 
-DEF_BENCH( return new SetIdentityMatrix44Bench(p); )
-DEF_BENCH( return new EqualsMatrix44Bench(p); )
-DEF_BENCH( return new PreScaleMatrix44Bench(p); )
-DEF_BENCH( return new PostScaleMatrix44Bench(p); )
-DEF_BENCH( return new InvertMatrix44Bench(p); )
-DEF_BENCH( return new InvertAffineMatrix44Bench(p); )
-DEF_BENCH( return new InvertScaleTranslateMatrix44Bench(p); )
-DEF_BENCH( return new InvertTranslateMatrix44Bench(p); )
-DEF_BENCH( return new SetConcatMatrix44Bench(p); )
-DEF_BENCH( return new GetTypeMatrix44Bench(p); )
+DEF_BENCH( return new SetIdentityMatrix44Bench(); )
+DEF_BENCH( return new EqualsMatrix44Bench(); )
+DEF_BENCH( return new PreScaleMatrix44Bench(); )
+DEF_BENCH( return new PostScaleMatrix44Bench(); )
+DEF_BENCH( return new InvertMatrix44Bench(); )
+DEF_BENCH( return new InvertAffineMatrix44Bench(); )
+DEF_BENCH( return new InvertScaleTranslateMatrix44Bench(); )
+DEF_BENCH( return new InvertTranslateMatrix44Bench(); )
+DEF_BENCH( return new SetConcatMatrix44Bench(); )
+DEF_BENCH( return new GetTypeMatrix44Bench(); )
diff --git a/bench/MatrixBench.cpp b/bench/MatrixBench.cpp
index c2cc5a2..796c7e5 100644
--- a/bench/MatrixBench.cpp
+++ b/bench/MatrixBench.cpp
@@ -14,7 +14,7 @@
 class MatrixBench : public SkBenchmark {
     SkString    fName;
 public:
-    MatrixBench(void* param, const char name[]) : INHERITED(param) {
+    MatrixBench(const char name[])  {
         fName.printf("matrix_%s", name);
         fIsRendering = false;
     }
@@ -52,7 +52,7 @@
 
 class EqualsMatrixBench : public MatrixBench {
 public:
-    EqualsMatrixBench(void* param) : INHERITED(param, "equals") {}
+    EqualsMatrixBench() : INHERITED("equals") {}
 protected:
     virtual void performTest() {
         SkMatrix m0, m1, m2;
@@ -70,7 +70,7 @@
 
 class ScaleMatrixBench : public MatrixBench {
 public:
-    ScaleMatrixBench(void* param) : INHERITED(param, "scale") {
+    ScaleMatrixBench() : INHERITED("scale") {
         fSX = fSY = SkFloatToScalar(1.5f);
         fM0.reset();
         fM1.setScale(fSX, fSY);
@@ -103,7 +103,7 @@
 // using floating point precision only.
 class FloatConcatMatrixBench : public MatrixBench {
 public:
-    FloatConcatMatrixBench(void* p) : INHERITED(p, "concat_floatfloat") {
+    FloatConcatMatrixBench() : INHERITED("concat_floatfloat") {
         init9(mya);
         init9(myb);
         init9(myr);
@@ -146,7 +146,7 @@
 // intermediate results during computations.
 class FloatDoubleConcatMatrixBench : public MatrixBench {
 public:
-    FloatDoubleConcatMatrixBench(void* p) : INHERITED(p, "concat_floatdouble") {
+    FloatDoubleConcatMatrixBench() : INHERITED("concat_floatdouble") {
         init9(mya);
         init9(myb);
         init9(myr);
@@ -184,7 +184,7 @@
 // using double precision only.
 class DoubleConcatMatrixBench : public MatrixBench {
 public:
-    DoubleConcatMatrixBench(void* p) : INHERITED(p, "concat_double") {
+    DoubleConcatMatrixBench() : INHERITED("concat_double") {
         init9(mya);
         init9(myb);
         init9(myr);
@@ -220,8 +220,8 @@
 
 class GetTypeMatrixBench : public MatrixBench {
 public:
-    GetTypeMatrixBench(void* param)
-        : INHERITED(param, "gettype") {
+    GetTypeMatrixBench()
+        : INHERITED("gettype") {
         fArray[0] = (float) fRnd.nextS();
         fArray[1] = (float) fRnd.nextS();
         fArray[2] = (float) fRnd.nextS();
@@ -265,7 +265,7 @@
 
 class ScaleTransMixedMatrixBench : public MatrixBench {
  public:
-    ScaleTransMixedMatrixBench(void* p) : INHERITED(p, "scaletrans_mixed") {
+    ScaleTransMixedMatrixBench() : INHERITED("scaletrans_mixed") {
         fMatrix.setAll(fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1(),
                        fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1(),
                        fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1());
@@ -306,7 +306,7 @@
 
 class ScaleTransDoubleMatrixBench : public MatrixBench {
  public:
-    ScaleTransDoubleMatrixBench(void* p) : INHERITED(p, "scaletrans_double") {
+    ScaleTransDoubleMatrixBench() : INHERITED("scaletrans_double") {
         init9(fMatrix);
         int i;
         for (i = 0; i < kCount; i++) {
@@ -346,7 +346,7 @@
 
 class DecomposeMatrixBench : public MatrixBench {
 public:
-    DecomposeMatrixBench(void* param) : INHERITED(param, "decompose") {}
+    DecomposeMatrixBench() : INHERITED("decompose") {}
 
 protected:
     virtual void onPreDraw() {
@@ -374,8 +374,8 @@
 
 class InvertMapRectMatrixBench : public MatrixBench {
 public:
-    InvertMapRectMatrixBench(void* param, const char* name, int flags)
-        : INHERITED(param, name)
+    InvertMapRectMatrixBench(const char* name, int flags)
+        : INHERITED(name)
         , fFlags(flags) {
         fMatrix.reset();
         fIteration = 0;
@@ -429,47 +429,47 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new EqualsMatrixBench(p); )
-DEF_BENCH( return new ScaleMatrixBench(p); )
-DEF_BENCH( return new FloatConcatMatrixBench(p); )
-DEF_BENCH( return new FloatDoubleConcatMatrixBench(p); )
-DEF_BENCH( return new DoubleConcatMatrixBench(p); )
-DEF_BENCH( return new GetTypeMatrixBench(p); )
-DEF_BENCH( return new DecomposeMatrixBench(p); )
+DEF_BENCH( return new EqualsMatrixBench(); )
+DEF_BENCH( return new ScaleMatrixBench(); )
+DEF_BENCH( return new FloatConcatMatrixBench(); )
+DEF_BENCH( return new FloatDoubleConcatMatrixBench(); )
+DEF_BENCH( return new DoubleConcatMatrixBench(); )
+DEF_BENCH( return new GetTypeMatrixBench(); )
+DEF_BENCH( return new DecomposeMatrixBench(); )
 
-DEF_BENCH( return new InvertMapRectMatrixBench(p, "invert_maprect_identity", 0); )
+DEF_BENCH( return new InvertMapRectMatrixBench("invert_maprect_identity", 0); )
 
-DEF_BENCH(return new InvertMapRectMatrixBench(p,
+DEF_BENCH(return new InvertMapRectMatrixBench(
                                   "invert_maprect_rectstaysrect",
                                   InvertMapRectMatrixBench::kScale_Flag |
                                   InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH(return new InvertMapRectMatrixBench(p,
+DEF_BENCH(return new InvertMapRectMatrixBench(
                                   "invert_maprect_translate",
                                   InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH(return new InvertMapRectMatrixBench(p,
+DEF_BENCH(return new InvertMapRectMatrixBench(
                                   "invert_maprect_nonpersp",
                                   InvertMapRectMatrixBench::kScale_Flag |
                                   InvertMapRectMatrixBench::kRotate_Flag |
                                   InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH( return new InvertMapRectMatrixBench(p,
+DEF_BENCH( return new InvertMapRectMatrixBench(
                                "invert_maprect_persp",
                                InvertMapRectMatrixBench::kPerspective_Flag); )
 
-DEF_BENCH( return new InvertMapRectMatrixBench(p,
+DEF_BENCH( return new InvertMapRectMatrixBench(
                            "invert_maprect_typemask_rectstaysrect",
                            InvertMapRectMatrixBench::kUncachedTypeMask_Flag |
                            InvertMapRectMatrixBench::kScale_Flag |
                            InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH( return new InvertMapRectMatrixBench(p,
+DEF_BENCH( return new InvertMapRectMatrixBench(
                            "invert_maprect_typemask_nonpersp",
                            InvertMapRectMatrixBench::kUncachedTypeMask_Flag |
                            InvertMapRectMatrixBench::kScale_Flag |
                            InvertMapRectMatrixBench::kRotate_Flag |
                            InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH( return new ScaleTransMixedMatrixBench(p); )
-DEF_BENCH( return new ScaleTransDoubleMatrixBench(p); )
+DEF_BENCH( return new ScaleTransMixedMatrixBench(); )
+DEF_BENCH( return new ScaleTransDoubleMatrixBench(); )
diff --git a/bench/MatrixConvolutionBench.cpp b/bench/MatrixConvolutionBench.cpp
index db25d99..0ef32fd 100644
--- a/bench/MatrixConvolutionBench.cpp
+++ b/bench/MatrixConvolutionBench.cpp
@@ -13,8 +13,8 @@
 
 class MatrixConvolutionBench : public SkBenchmark {
 public:
-    MatrixConvolutionBench(void* param, SkMatrixConvolutionImageFilter::TileMode tileMode, bool convolveAlpha)
-        : INHERITED(param), fName("matrixconvolution") {
+    MatrixConvolutionBench(SkMatrixConvolutionImageFilter::TileMode tileMode, bool convolveAlpha)
+        : fName("matrixconvolution") {
         SkISize kernelSize = SkISize::Make(3, 3);
         SkScalar kernel[9] = {
             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
@@ -54,12 +54,7 @@
     SkString fName;
 };
 
-static SkBenchmark* Fact00(void* p) { return new MatrixConvolutionBench(p, SkMatrixConvolutionImageFilter::kClamp_TileMode, true); }
-static SkBenchmark* Fact01(void* p) { return new MatrixConvolutionBench(p, SkMatrixConvolutionImageFilter::kRepeat_TileMode, true); }
-static SkBenchmark* Fact02(void* p) { return new MatrixConvolutionBench(p, SkMatrixConvolutionImageFilter::kClampToBlack_TileMode, true); }
-static SkBenchmark* Fact03(void* p) { return new MatrixConvolutionBench(p, SkMatrixConvolutionImageFilter::kClampToBlack_TileMode, false); }
-
-static BenchRegistry gReg00(Fact00);
-static BenchRegistry gReg01(Fact01);
-static BenchRegistry gReg02(Fact02);
-static BenchRegistry gReg03(Fact03);
+DEF_BENCH( return new MatrixConvolutionBench(SkMatrixConvolutionImageFilter::kClamp_TileMode, true); )
+DEF_BENCH( return new MatrixConvolutionBench(SkMatrixConvolutionImageFilter::kRepeat_TileMode, true); )
+DEF_BENCH( return new MatrixConvolutionBench(SkMatrixConvolutionImageFilter::kClampToBlack_TileMode, true); )
+DEF_BENCH( return new MatrixConvolutionBench(SkMatrixConvolutionImageFilter::kClampToBlack_TileMode, false); )
diff --git a/bench/MemoryBench.cpp b/bench/MemoryBench.cpp
index ae14dac..6e8e4a8 100644
--- a/bench/MemoryBench.cpp
+++ b/bench/MemoryBench.cpp
@@ -16,7 +16,7 @@
     SkString    fName;
     size_t      fMinSize;
 public:
-    ChunkAllocBench(void* param, size_t minSize) : INHERITED(param) {
+    ChunkAllocBench(size_t minSize)  {
         fMinSize = minSize;
         fName.printf("chunkalloc_" SK_SIZE_T_SPECIFIER, minSize);
         fIsRendering = false;
@@ -50,8 +50,5 @@
     typedef SkBenchmark INHERITED;
 };
 
-static SkBenchmark* F0(void* p) { return new ChunkAllocBench(p, 64); }
-static SkBenchmark* F1(void* p) { return new ChunkAllocBench(p, 8*1024); }
-
-static BenchRegistry gR0(F0);
-static BenchRegistry gR1(F1);
+DEF_BENCH( return new ChunkAllocBench(64); )
+DEF_BENCH( return new ChunkAllocBench(8*1024); )
diff --git a/bench/MemsetBench.cpp b/bench/MemsetBench.cpp
index efbfa1f..affae29 100644
--- a/bench/MemsetBench.cpp
+++ b/bench/MemsetBench.cpp
@@ -28,7 +28,7 @@
     };
 
 public:
-    MemsetBench(void* param, MemsetType type, size_t minSize, size_t maxSize) : INHERITED(param) {
+    MemsetBench(MemsetType type, size_t minSize, size_t maxSize)  {
         SkASSERT((minSize < maxSize) && (maxSize <= kBufferSize));
         fMinSize = minSize;
         fMaxSize = maxSize;
@@ -57,8 +57,8 @@
 class Memset32Bench : public MemsetBench {
     uint32_t kBuffer[kBufferSize + 3];
 public:
-    Memset32Bench(void* param, size_t minSize, size_t maxSize)
-        : INHERITED(param, MEMSET32, minSize, maxSize) {}
+    Memset32Bench(size_t minSize, size_t maxSize)
+        : INHERITED(MEMSET32, minSize, maxSize) {}
 
 protected:
     virtual void performTest() SK_OVERRIDE {
@@ -76,8 +76,8 @@
 class Memset16Bench : public MemsetBench {
     uint16_t kBuffer[kBufferSize + 7];
 public:
-    Memset16Bench(void* param, size_t minSize, size_t maxSize)
-        : INHERITED(param, MEMSET16, minSize, maxSize) {}
+    Memset16Bench(size_t minSize, size_t maxSize)
+        : INHERITED(MEMSET16, minSize, maxSize) {}
 
 protected:
     virtual void performTest() SK_OVERRIDE {
@@ -96,18 +96,18 @@
     typedef MemsetBench INHERITED;
 };
 
-DEF_BENCH(return new Memset32Bench(p, 1, 600);)
-DEF_BENCH(return new Memset32Bench(p, 600, 800);)
-DEF_BENCH(return new Memset32Bench(p, 800, 1000);)
-DEF_BENCH(return new Memset32Bench(p, 1000, 2000);)
-DEF_BENCH(return new Memset32Bench(p, 2000, 3000);)
-DEF_BENCH(return new Memset32Bench(p, 3000, 4000);)
-DEF_BENCH(return new Memset32Bench(p, 4000, 5000);)
+DEF_BENCH(return new Memset32Bench(1, 600);)
+DEF_BENCH(return new Memset32Bench(600, 800);)
+DEF_BENCH(return new Memset32Bench(800, 1000);)
+DEF_BENCH(return new Memset32Bench(1000, 2000);)
+DEF_BENCH(return new Memset32Bench(2000, 3000);)
+DEF_BENCH(return new Memset32Bench(3000, 4000);)
+DEF_BENCH(return new Memset32Bench(4000, 5000);)
 
-DEF_BENCH(return new Memset16Bench(p, 1, 600);)
-DEF_BENCH(return new Memset16Bench(p, 600, 800);)
-DEF_BENCH(return new Memset16Bench(p, 800, 1000);)
-DEF_BENCH(return new Memset16Bench(p, 1000, 2000);)
-DEF_BENCH(return new Memset16Bench(p, 2000, 3000);)
-DEF_BENCH(return new Memset16Bench(p, 3000, 4000);)
-DEF_BENCH(return new Memset16Bench(p, 4000, 5000);)
+DEF_BENCH(return new Memset16Bench(1, 600);)
+DEF_BENCH(return new Memset16Bench(600, 800);)
+DEF_BENCH(return new Memset16Bench(800, 1000);)
+DEF_BENCH(return new Memset16Bench(1000, 2000);)
+DEF_BENCH(return new Memset16Bench(2000, 3000);)
+DEF_BENCH(return new Memset16Bench(3000, 4000);)
+DEF_BENCH(return new Memset16Bench(4000, 5000);)
diff --git a/bench/MergeBench.cpp b/bench/MergeBench.cpp
index 98a918a..51be22f 100644
--- a/bench/MergeBench.cpp
+++ b/bench/MergeBench.cpp
@@ -17,8 +17,7 @@
 
 class MergeBench : public SkBenchmark {
 public:
-    MergeBench(void* param, bool small) : INHERITED(param), fIsSmall(small), fInitialized(false) {
-    }
+    MergeBench(bool small) : fIsSmall(small), fInitialized(false) { }
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -98,5 +97,5 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new MergeBench(p, true); )
-DEF_BENCH( return new MergeBench(p, false); )
+DEF_BENCH( return new MergeBench(true); )
+DEF_BENCH( return new MergeBench(false); )
diff --git a/bench/MorphologyBench.cpp b/bench/MorphologyBench.cpp
index 2d4b4ee..d042e6d 100644
--- a/bench/MorphologyBench.cpp
+++ b/bench/MorphologyBench.cpp
@@ -36,8 +36,8 @@
     SkString       fName;
 
 public:
-    MorphologyBench(void* param, SkScalar rad, MorphologyType style)
-        :  INHERITED(param) {
+    MorphologyBench(SkScalar rad, MorphologyType style)
+         {
         fRadius = rad;
         fStyle = style;
         const char* name = rad > 0 ? gStyleName[style] : "none";
@@ -87,30 +87,17 @@
     typedef SkBenchmark INHERITED;
 };
 
-static SkBenchmark* Fact00(void* p) { return new MorphologyBench(p, SMALL, kErode_MT); }
-static SkBenchmark* Fact01(void* p) { return new MorphologyBench(p, SMALL, kDilate_MT); }
-
-static SkBenchmark* Fact10(void* p) { return new MorphologyBench(p, BIG, kErode_MT); }
-static SkBenchmark* Fact11(void* p) { return new MorphologyBench(p, BIG, kDilate_MT); }
-
-static SkBenchmark* Fact20(void* p) { return new MorphologyBench(p, REAL, kErode_MT); }
-static SkBenchmark* Fact21(void* p) { return new MorphologyBench(p, REAL, kDilate_MT); }
-
-static SkBenchmark* FactNone(void* p) { return new MorphologyBench(p, 0, kErode_MT); }
-
 // Fixed point can be 100x slower than float on these tests, causing
 // bench to timeout.
 #ifndef SK_SCALAR_IS_FIXED
+DEF_BENCH( return new MorphologyBench(SMALL, kErode_MT); )
+DEF_BENCH( return new MorphologyBench(SMALL, kDilate_MT); )
 
-static BenchRegistry gReg00(Fact00);
-static BenchRegistry gReg01(Fact01);
+DEF_BENCH( return new MorphologyBench(BIG, kErode_MT); )
+DEF_BENCH( return new MorphologyBench(BIG, kDilate_MT); )
 
-static BenchRegistry gReg10(Fact10);
-static BenchRegistry gReg11(Fact11);
+DEF_BENCH( return new MorphologyBench(REAL, kErode_MT); )
+DEF_BENCH( return new MorphologyBench(REAL, kDilate_MT); )
 
-static BenchRegistry gReg20(Fact20);
-static BenchRegistry gReg21(Fact21);
-
-static BenchRegistry gRegNone(FactNone);
-
+DEF_BENCH( return new MorphologyBench(0, kErode_MT); )
 #endif
diff --git a/bench/MutexBench.cpp b/bench/MutexBench.cpp
index 5a7058d..1d037ec 100644
--- a/bench/MutexBench.cpp
+++ b/bench/MutexBench.cpp
@@ -9,7 +9,7 @@
 
 class MutexBench : public SkBenchmark {
 public:
-    MutexBench(void* param) : INHERITED(param) {
+    MutexBench()  {
         fIsRendering = false;
     }
 protected:
@@ -31,6 +31,4 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact(void* p) { return new MutexBench(p); }
-
-static BenchRegistry gReg01(Fact);
+DEF_BENCH( return new MutexBench(); )
diff --git a/bench/PathBench.cpp b/bench/PathBench.cpp
index 37b47dd..d8a2ca9 100644
--- a/bench/PathBench.cpp
+++ b/bench/PathBench.cpp
@@ -30,7 +30,7 @@
     SkString    fName;
     Flags       fFlags;
 public:
-    PathBench(void* param, Flags flags) : INHERITED(param), fFlags(flags) {
+    PathBench(Flags flags) : fFlags(flags) {
         fPaint.setStyle(flags & kStroke_Flag ? SkPaint::kStroke_Style :
                         SkPaint::kFill_Style);
         fPaint.setStrokeWidth(SkIntToScalar(5));
@@ -79,7 +79,7 @@
 
 class TrianglePathBench : public PathBench {
 public:
-    TrianglePathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    TrianglePathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("triangle");
@@ -99,7 +99,7 @@
 
 class RectPathBench : public PathBench {
 public:
-    RectPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    RectPathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("rect");
@@ -114,7 +114,7 @@
 
 class OvalPathBench : public PathBench {
 public:
-    OvalPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    OvalPathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("oval");
@@ -129,7 +129,7 @@
 
 class CirclePathBench: public PathBench {
 public:
-    CirclePathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    CirclePathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("circle");
@@ -144,7 +144,7 @@
 
 class SawToothPathBench : public PathBench {
 public:
-    SawToothPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
+    SawToothPathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("sawtooth");
@@ -174,9 +174,7 @@
 
 class LongCurvedPathBench : public PathBench {
 public:
-    LongCurvedPathBench(void * param, Flags flags)
-        : INHERITED(param, flags) {
-    }
+    LongCurvedPathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("long_curved");
@@ -199,9 +197,7 @@
 
 class LongLinePathBench : public PathBench {
 public:
-    LongLinePathBench(void * param, Flags flags)
-        : INHERITED(param, flags) {
-    }
+    LongLinePathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("long_line");
@@ -220,7 +216,7 @@
 
 class RandomPathBench : public SkBenchmark {
 public:
-    RandomPathBench(void* param) : INHERITED(param) {
+    RandomPathBench()  {
         fIsRendering = false;
     }
 
@@ -321,7 +317,7 @@
 
 class PathCreateBench : public RandomPathBench {
 public:
-    PathCreateBench(void* param) : INHERITED(param) {
+    PathCreateBench()  {
     }
 
 protected:
@@ -358,7 +354,7 @@
 
 class PathCopyBench : public RandomPathBench {
 public:
-    PathCopyBench(void* param) : INHERITED(param) {
+    PathCopyBench()  {
     }
 
 protected:
@@ -398,10 +394,7 @@
 
 class PathTransformBench : public RandomPathBench {
 public:
-    PathTransformBench(bool inPlace, void* param)
-        : INHERITED(param)
-        , fInPlace(inPlace) {
-    }
+    PathTransformBench(bool inPlace) : fInPlace(inPlace) {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -454,9 +447,7 @@
 
 class PathEqualityBench : public RandomPathBench {
 public:
-    PathEqualityBench(void* param)
-        : INHERITED(param) {
-    }
+    PathEqualityBench() { }
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -509,9 +500,7 @@
         kReversePathTo_AddType,
     };
 
-    SkBench_AddPathTest(AddType type, void* param)
-        : INHERITED(param)
-        , fType(type) {
+    SkBench_AddPathTest(AddType type) : fType(type) {
         fMatrix.setRotate(60 * SK_Scalar1);
     }
 
@@ -621,7 +610,7 @@
     Flags               fFlags;
 
 public:
-    CirclesBench(void* param, Flags flags) : INHERITED(param), fFlags(flags) {
+    CirclesBench(Flags flags) : fFlags(flags) {
         fName.printf("circles_%s", fFlags & kStroke_Flag ? "stroke" : "fill");
     }
 
@@ -681,7 +670,7 @@
     SkString            fName;
 
 public:
-    ArbRoundRectBench(void* param, bool zeroRad) : INHERITED(param), fZeroRad(zeroRad) {
+    ArbRoundRectBench(bool zeroRad) : fZeroRad(zeroRad) {
         if (zeroRad) {
             fName.printf("zeroradroundrect");
         } else {
@@ -782,7 +771,7 @@
         kOval_Type,
     };
 
-    ConservativelyContainsBench(void* param, Type type) : INHERITED(param) {
+    ConservativelyContainsBench(Type type)  {
         fIsRendering = false;
         fParity = false;
         fName = "conservatively_contains_";
@@ -858,7 +847,7 @@
 class ConicBench_Chop5 : public SkBenchmark {
     SkConic fRQ;
 public:
-    ConicBench_Chop5(void* param) : INHERITED(param) {
+    ConicBench_Chop5()  {
         fRQ.fPts[0].set(0, 0);
         fRQ.fPts[1].set(100, 0);
         fRQ.fPts[2].set(100, 100);
@@ -883,7 +872,7 @@
 class ConicBench_ChopHalf : public SkBenchmark {
     SkConic fRQ;
 public:
-    ConicBench_ChopHalf(void* param) : INHERITED(param) {
+    ConicBench_ChopHalf()  {
         fRQ.fPts[0].set(0, 0);
         fRQ.fPts[1].set(100, 0);
         fRQ.fPts[2].set(100, 100);
@@ -920,7 +909,7 @@
 
 class ConicBench : public SkBenchmark {
 public:
-    ConicBench(void* param) : INHERITED(param) {
+    ConicBench()  {
         SkRandom rand;
         for (int i = 0; i < CONICS; ++i) {
             rand_conic(&fConics[i], rand);
@@ -940,7 +929,7 @@
 
 class ConicBench_ComputeError : public ConicBench {
 public:
-    ConicBench_ComputeError(void* param) : INHERITED(param) {}
+    ConicBench_ComputeError()  {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -962,7 +951,7 @@
 
 class ConicBench_asQuadTol : public ConicBench {
 public:
-    ConicBench_asQuadTol(void* param) : INHERITED(param) {}
+    ConicBench_asQuadTol()  {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -983,7 +972,7 @@
 
 class ConicBench_quadPow2 : public ConicBench {
 public:
-    ConicBench_quadPow2(void* param) : INHERITED(param) {}
+    ConicBench_quadPow2()  {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -1010,57 +999,57 @@
 const SkRect ConservativelyContainsBench::kBaseRect = SkRect::MakeXYWH(SkIntToScalar(25), SkIntToScalar(25), SkIntToScalar(50), SkIntToScalar(50));
 const SkScalar ConservativelyContainsBench::kRRRadii[2] = {SkIntToScalar(5), SkIntToScalar(10)};
 
-DEF_BENCH( return new TrianglePathBench(p, FLAGS00); )
-DEF_BENCH( return new TrianglePathBench(p, FLAGS01); )
-DEF_BENCH( return new TrianglePathBench(p, FLAGS10); )
-DEF_BENCH( return new TrianglePathBench(p, FLAGS11); )
+DEF_BENCH( return new TrianglePathBench(FLAGS00); )
+DEF_BENCH( return new TrianglePathBench(FLAGS01); )
+DEF_BENCH( return new TrianglePathBench(FLAGS10); )
+DEF_BENCH( return new TrianglePathBench(FLAGS11); )
 
-DEF_BENCH( return new RectPathBench(p, FLAGS00); )
-DEF_BENCH( return new RectPathBench(p, FLAGS01); )
-DEF_BENCH( return new RectPathBench(p, FLAGS10); )
-DEF_BENCH( return new RectPathBench(p, FLAGS11); )
+DEF_BENCH( return new RectPathBench(FLAGS00); )
+DEF_BENCH( return new RectPathBench(FLAGS01); )
+DEF_BENCH( return new RectPathBench(FLAGS10); )
+DEF_BENCH( return new RectPathBench(FLAGS11); )
 
-DEF_BENCH( return new OvalPathBench(p, FLAGS00); )
-DEF_BENCH( return new OvalPathBench(p, FLAGS01); )
-DEF_BENCH( return new OvalPathBench(p, FLAGS10); )
-DEF_BENCH( return new OvalPathBench(p, FLAGS11); )
+DEF_BENCH( return new OvalPathBench(FLAGS00); )
+DEF_BENCH( return new OvalPathBench(FLAGS01); )
+DEF_BENCH( return new OvalPathBench(FLAGS10); )
+DEF_BENCH( return new OvalPathBench(FLAGS11); )
 
-DEF_BENCH( return new CirclePathBench(p, FLAGS00); )
-DEF_BENCH( return new CirclePathBench(p, FLAGS01); )
-DEF_BENCH( return new CirclePathBench(p, FLAGS10); )
-DEF_BENCH( return new CirclePathBench(p, FLAGS11); )
+DEF_BENCH( return new CirclePathBench(FLAGS00); )
+DEF_BENCH( return new CirclePathBench(FLAGS01); )
+DEF_BENCH( return new CirclePathBench(FLAGS10); )
+DEF_BENCH( return new CirclePathBench(FLAGS11); )
 
-DEF_BENCH( return new SawToothPathBench(p, FLAGS00); )
-DEF_BENCH( return new SawToothPathBench(p, FLAGS01); )
+DEF_BENCH( return new SawToothPathBench(FLAGS00); )
+DEF_BENCH( return new SawToothPathBench(FLAGS01); )
 
-DEF_BENCH( return new LongCurvedPathBench(p, FLAGS00); )
-DEF_BENCH( return new LongCurvedPathBench(p, FLAGS01); )
-DEF_BENCH( return new LongLinePathBench(p, FLAGS00); )
-DEF_BENCH( return new LongLinePathBench(p, FLAGS01); )
+DEF_BENCH( return new LongCurvedPathBench(FLAGS00); )
+DEF_BENCH( return new LongCurvedPathBench(FLAGS01); )
+DEF_BENCH( return new LongLinePathBench(FLAGS00); )
+DEF_BENCH( return new LongLinePathBench(FLAGS01); )
 
-DEF_BENCH( return new PathCreateBench(p); )
-DEF_BENCH( return new PathCopyBench(p); )
-DEF_BENCH( return new PathTransformBench(true, p); )
-DEF_BENCH( return new PathTransformBench(false, p); )
-DEF_BENCH( return new PathEqualityBench(p); )
+DEF_BENCH( return new PathCreateBench(); )
+DEF_BENCH( return new PathCopyBench(); )
+DEF_BENCH( return new PathTransformBench(true); )
+DEF_BENCH( return new PathTransformBench(false); )
+DEF_BENCH( return new PathEqualityBench(); )
 
-DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAdd_AddType, p); )
-DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAddTrans_AddType, p); )
-DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAddMatrix_AddType, p); )
-DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kPathTo_AddType, p); )
-DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kReverseAdd_AddType, p); )
-DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kReversePathTo_AddType, p); )
+DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAdd_AddType); )
+DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAddTrans_AddType); )
+DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAddMatrix_AddType); )
+DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kPathTo_AddType); )
+DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kReverseAdd_AddType); )
+DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kReversePathTo_AddType); )
 
-DEF_BENCH( return new CirclesBench(p, FLAGS00); )
-DEF_BENCH( return new CirclesBench(p, FLAGS01); )
-DEF_BENCH( return new ArbRoundRectBench(p, false); )
-DEF_BENCH( return new ArbRoundRectBench(p, true); )
-DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kRect_Type); )
-DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kRoundRect_Type); )
-DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kOval_Type); )
+DEF_BENCH( return new CirclesBench(FLAGS00); )
+DEF_BENCH( return new CirclesBench(FLAGS01); )
+DEF_BENCH( return new ArbRoundRectBench(false); )
+DEF_BENCH( return new ArbRoundRectBench(true); )
+DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::kRect_Type); )
+DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::kRoundRect_Type); )
+DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::kOval_Type); )
 
-DEF_BENCH( return new ConicBench_Chop5(p) )
-DEF_BENCH( return new ConicBench_ChopHalf(p) )
-DEF_BENCH( return new ConicBench_ComputeError(p) )
-DEF_BENCH( return new ConicBench_asQuadTol(p) )
-DEF_BENCH( return new ConicBench_quadPow2(p) )
+DEF_BENCH( return new ConicBench_Chop5() )
+DEF_BENCH( return new ConicBench_ChopHalf() )
+DEF_BENCH( return new ConicBench_ComputeError() )
+DEF_BENCH( return new ConicBench_asQuadTol() )
+DEF_BENCH( return new ConicBench_quadPow2() )
diff --git a/bench/PathIterBench.cpp b/bench/PathIterBench.cpp
index c5ac7e4..a18b29d 100644
--- a/bench/PathIterBench.cpp
+++ b/bench/PathIterBench.cpp
@@ -31,7 +31,7 @@
     bool        fRaw;
 
 public:
-    PathIterBench(void* param, bool raw) : INHERITED(param) {
+    PathIterBench(bool raw)  {
         fName.printf("pathiter_%s", raw ? "raw" : "consume");
         fRaw = raw;
 
@@ -89,8 +89,5 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* F0(void* p) { return new PathIterBench(p, false); }
-static SkBenchmark* F1(void* p) { return new PathIterBench(p, true); }
-
-static BenchRegistry gR0(F0);
-static BenchRegistry gR1(F1);
+DEF_BENCH( return new PathIterBench(false); )
+DEF_BENCH( return new PathIterBench(true); )
diff --git a/bench/PathUtilsBench.cpp b/bench/PathUtilsBench.cpp
index c3640f7..06ef5df 100644
--- a/bench/PathUtilsBench.cpp
+++ b/bench/PathUtilsBench.cpp
@@ -42,7 +42,7 @@
     char* bits[H * STRIDE];
 
 public:
-    PathUtilsBench(void* param, Proc proc, const char name[]) : INHERITED(param) {
+    PathUtilsBench(Proc proc, const char name[])  {
         fProc = proc;
         fName.printf("pathUtils_%s", name);
 
@@ -68,8 +68,5 @@
     typedef SkBenchmark INHERITED;
 };
 
-static SkBenchmark* PU_path(void* p) { return SkNEW_ARGS(PathUtilsBench, (p, path_proc, "path")); }
-static SkBenchmark* PU_region(void* p) { return SkNEW_ARGS(PathUtilsBench, (p, region_proc, "region")); }
-
-static BenchRegistry PU_Path(PU_path);
-static BenchRegistry PU_Region(PU_region);
+DEF_BENCH( return SkNEW_ARGS(PathUtilsBench, (path_proc, "path")); )
+DEF_BENCH( return SkNEW_ARGS(PathUtilsBench, (region_proc, "region")); )
diff --git a/bench/PerlinNoiseBench.cpp b/bench/PerlinNoiseBench.cpp
index 605acf4..7cbe5f8 100644
--- a/bench/PerlinNoiseBench.cpp
+++ b/bench/PerlinNoiseBench.cpp
@@ -12,7 +12,7 @@
     SkISize fSize;
 
 public:
-    PerlinNoiseBench(void* param) : INHERITED(param) {
+    PerlinNoiseBench()  {
         fSize = SkISize::Make(80, 80);
     }
 
@@ -59,4 +59,4 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new PerlinNoiseBench(p); )
+DEF_BENCH( return new PerlinNoiseBench(); )
diff --git a/bench/PicturePlaybackBench.cpp b/bench/PicturePlaybackBench.cpp
index 7f8fe6f..9d233ec 100644
--- a/bench/PicturePlaybackBench.cpp
+++ b/bench/PicturePlaybackBench.cpp
@@ -18,7 +18,7 @@
 
 class PicturePlaybackBench : public SkBenchmark {
 public:
-    PicturePlaybackBench(void* param, const char name[]) : INHERITED(param) {
+    PicturePlaybackBench(const char name[])  {
         fName.printf("picture_playback_%s", name);
         fPictureWidth = SkIntToScalar(PICTURE_WIDTH);
         fPictureHeight = SkIntToScalar(PICTURE_HEIGHT);
@@ -69,7 +69,7 @@
 
 class TextPlaybackBench : public PicturePlaybackBench {
 public:
-    TextPlaybackBench(void* param) : INHERITED(param, "drawText") { }
+    TextPlaybackBench() : INHERITED("drawText") { }
 protected:
     virtual void recordCanvas(SkCanvas* canvas) {
         SkPaint paint;
@@ -92,8 +92,8 @@
 
 class PosTextPlaybackBench : public PicturePlaybackBench {
 public:
-    PosTextPlaybackBench(void* param, bool drawPosH)
-        : INHERITED(param, drawPosH ? "drawPosTextH" : "drawPosText")
+    PosTextPlaybackBench(bool drawPosH)
+        : INHERITED(drawPosH ? "drawPosTextH" : "drawPosText")
         , fDrawPosH(drawPosH) { }
 protected:
     virtual void recordCanvas(SkCanvas* canvas) {
@@ -136,10 +136,6 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return new TextPlaybackBench(p); }
-static SkBenchmark* Fact1(void* p) { return new PosTextPlaybackBench(p, true); }
-static SkBenchmark* Fact2(void* p) { return new PosTextPlaybackBench(p, false); }
-
-static BenchRegistry gReg0(Fact0);
-static BenchRegistry gReg1(Fact1);
-static BenchRegistry gReg2(Fact2);
+DEF_BENCH( return new TextPlaybackBench(); )
+DEF_BENCH( return new PosTextPlaybackBench(true); )
+DEF_BENCH( return new PosTextPlaybackBench(false); )
diff --git a/bench/PictureRecordBench.cpp b/bench/PictureRecordBench.cpp
index cbfad38..e9d2b54 100644
--- a/bench/PictureRecordBench.cpp
+++ b/bench/PictureRecordBench.cpp
@@ -16,7 +16,7 @@
 
 class PictureRecordBench : public SkBenchmark {
 public:
-    PictureRecordBench(void* param, const char name[]) : INHERITED(param) {
+    PictureRecordBench(const char name[])  {
         fName.printf("picture_record_%s", name);
         fPictureWidth = SkIntToScalar(PICTURE_WIDTH);
         fPictureHeight = SkIntToScalar(PICTURE_HEIGHT);
@@ -61,8 +61,8 @@
  */
 class DictionaryRecordBench : public PictureRecordBench {
 public:
-    DictionaryRecordBench(void* param)
-        : INHERITED(param, "dictionaries") { }
+    DictionaryRecordBench()
+        : INHERITED("dictionaries") { }
 
 protected:
     virtual void recordCanvas(SkCanvas* canvas) {
@@ -123,8 +123,8 @@
  */
 class UniquePaintDictionaryRecordBench : public PictureRecordBench {
 public:
-    UniquePaintDictionaryRecordBench(void* param)
-        : INHERITED(param, "unique_paint_dictionary") { }
+    UniquePaintDictionaryRecordBench()
+        : INHERITED("unique_paint_dictionary") { }
 
 protected:
     virtual void recordCanvas(SkCanvas* canvas) {
@@ -150,8 +150,8 @@
  */
 class RecurringPaintDictionaryRecordBench : public PictureRecordBench {
 public:
-    RecurringPaintDictionaryRecordBench(void* param)
-        : INHERITED(param, "recurring_paint_dictionary") {
+    RecurringPaintDictionaryRecordBench()
+        : INHERITED("recurring_paint_dictionary") {
         SkRandom rand;
         for (int i = 0; i < ObjCount; i++) {
             fPaint[i].setColor(rand.nextU());
@@ -176,10 +176,6 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact0(void* p) { return new DictionaryRecordBench(p); }
-static SkBenchmark* Fact1(void* p) { return new UniquePaintDictionaryRecordBench(p); }
-static SkBenchmark* Fact2(void* p) { return new RecurringPaintDictionaryRecordBench(p); }
-
-static BenchRegistry gReg0(Fact0);
-static BenchRegistry gReg1(Fact1);
-static BenchRegistry gReg2(Fact2);
+DEF_BENCH( return new DictionaryRecordBench(); )
+DEF_BENCH( return new UniquePaintDictionaryRecordBench(); )
+DEF_BENCH( return new RecurringPaintDictionaryRecordBench(); )
diff --git a/bench/PremulAndUnpremulAlphaOpsBench.cpp b/bench/PremulAndUnpremulAlphaOpsBench.cpp
index eb494f4..aac5934 100644
--- a/bench/PremulAndUnpremulAlphaOpsBench.cpp
+++ b/bench/PremulAndUnpremulAlphaOpsBench.cpp
@@ -13,8 +13,7 @@
 
 class PremulAndUnpremulAlphaOpsBench : public SkBenchmark {
 public:
-    PremulAndUnpremulAlphaOpsBench(void* param, SkCanvas::Config8888 config)
-        : INHERITED(param) {
+    PremulAndUnpremulAlphaOpsBench(SkCanvas::Config8888 config) {
         fUnPremulConfig = config;
         fName.printf("premul_and_unpremul_alpha_%s",
                      (config ==  SkCanvas::kRGBA_Unpremul_Config8888) ?
@@ -60,14 +59,6 @@
     typedef SkBenchmark INHERITED;
 };
 
-static SkBenchmark* fact0(void* p) {
-    return new PremulAndUnpremulAlphaOpsBench(p,
-        SkCanvas::kRGBA_Unpremul_Config8888);
-}
-static SkBenchmark* fact1(void* p) {
-    return new PremulAndUnpremulAlphaOpsBench(p,
-        SkCanvas::kNative_Unpremul_Config8888);
-}
 
-static BenchRegistry gReg0(fact0);
-static BenchRegistry gReg1(fact1);
+DEF_BENCH(return new PremulAndUnpremulAlphaOpsBench(SkCanvas::kRGBA_Unpremul_Config8888));
+DEF_BENCH(return new PremulAndUnpremulAlphaOpsBench(SkCanvas::kNative_Unpremul_Config8888));
diff --git a/bench/RTreeBench.cpp b/bench/RTreeBench.cpp
index 99f8ca8..5b69b57 100644
--- a/bench/RTreeBench.cpp
+++ b/bench/RTreeBench.cpp
@@ -23,10 +23,9 @@
 // Time how long it takes to build an R-Tree either bulk-loaded or not
 class BBoxBuildBench : public SkBenchmark {
 public:
-    BBoxBuildBench(void* param, const char* name, MakeRectProc proc, bool bulkLoad,
+    BBoxBuildBench(const char* name, MakeRectProc proc, bool bulkLoad,
                     SkBBoxHierarchy* tree)
-        : INHERITED(param)
-        , fTree(tree)
+        : fTree(tree)
         , fProc(proc)
         , fBulkLoad(bulkLoad) {
         fName.append("rtree_");
@@ -73,10 +72,9 @@
         kFull_QueryType   // queries that cover everything
     };
 
-    BBoxQueryBench(void* param, const char* name, MakeRectProc proc, bool bulkLoad,
+    BBoxQueryBench(const char* name, MakeRectProc proc, bool bulkLoad,
                     QueryType q, SkBBoxHierarchy* tree)
-        : INHERITED(param)
-        , fTree(tree)
+        : fTree(tree)
         , fProc(proc)
         , fBulkLoad(bulkLoad)
         , fQuery(q) {
@@ -210,102 +208,82 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static inline SkBenchmark* Fact0(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "XYordered", &make_XYordered_rects, false,
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("XYordered", &make_XYordered_rects, false,
                       SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact1(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "XYordered", &make_XYordered_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("XYordered", &make_XYordered_rects, true,
                       SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact2(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "(unsorted)XYordered", &make_XYordered_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("(unsorted)XYordered", &make_XYordered_rects, true,
                       SkRTree::Create(5, 16, 1, false)));
-}
-static inline SkBenchmark* Fact3(void* p) {
-    return SkNEW_ARGS(BBoxQueryBench, (p, "XYordered", &make_XYordered_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxQueryBench, ("XYordered", &make_XYordered_rects, true,
                       BBoxQueryBench::kRandom_QueryType, SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact4(void* p) {
-    return SkNEW_ARGS(BBoxQueryBench, (p, "(unsorted)XYordered", &make_XYordered_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxQueryBench, ("(unsorted)XYordered", &make_XYordered_rects, true,
                       BBoxQueryBench::kRandom_QueryType, SkRTree::Create(5, 16, 1, false)));
-}
+)
 
-static inline SkBenchmark* Fact5(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "YXordered", &make_YXordered_rects, false,
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("YXordered", &make_YXordered_rects, false,
                       SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact6(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "YXordered", &make_YXordered_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("YXordered", &make_YXordered_rects, true,
                       SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact7(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "(unsorted)YXordered", &make_YXordered_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("(unsorted)YXordered", &make_YXordered_rects, true,
                       SkRTree::Create(5, 16, 1, false)));
-}
-static inline SkBenchmark* Fact8(void* p) {
-    return SkNEW_ARGS(BBoxQueryBench, (p, "YXordered", &make_YXordered_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxQueryBench, ("YXordered", &make_YXordered_rects, true,
                       BBoxQueryBench::kRandom_QueryType, SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact9(void* p) {
-    return SkNEW_ARGS(BBoxQueryBench, (p, "(unsorted)YXordered", &make_YXordered_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxQueryBench, ("(unsorted)YXordered", &make_YXordered_rects, true,
                       BBoxQueryBench::kRandom_QueryType, SkRTree::Create(5, 16, 1, false)));
-}
+)
 
-static inline SkBenchmark* Fact10(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "random", &make_random_rects, false,
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("random", &make_random_rects, false,
                       SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact11(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "random", &make_random_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("random", &make_random_rects, true,
                       SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact12(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "(unsorted)random", &make_random_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("(unsorted)random", &make_random_rects, true,
                       SkRTree::Create(5, 16, 1, false)));
-}
-static inline SkBenchmark* Fact13(void* p) {
-    return SkNEW_ARGS(BBoxQueryBench, (p, "random", &make_random_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxQueryBench, ("random", &make_random_rects, true,
                       BBoxQueryBench::kRandom_QueryType, SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact14(void* p) {
-    return SkNEW_ARGS(BBoxQueryBench, (p, "(unsorted)random", &make_random_rects, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxQueryBench, ("(unsorted)random", &make_random_rects, true,
                       BBoxQueryBench::kRandom_QueryType, SkRTree::Create(5, 16, 1, false)));
-}
+)
 
-static inline SkBenchmark* Fact15(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "concentric",
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("concentric",
                       &make_concentric_rects_increasing, true, SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact16(void* p) {
-    return SkNEW_ARGS(BBoxBuildBench, (p, "(unsorted)concentric",
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxBuildBench, ("(unsorted)concentric",
                       &make_concentric_rects_increasing, true, SkRTree::Create(5, 16, 1, false)));
-}
-static inline SkBenchmark* Fact17(void* p) {
-    return SkNEW_ARGS(BBoxQueryBench, (p, "concentric", &make_concentric_rects_increasing, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxQueryBench, ("concentric", &make_concentric_rects_increasing, true,
                       BBoxQueryBench::kRandom_QueryType, SkRTree::Create(5, 16)));
-}
-static inline SkBenchmark* Fact18(void* p) {
-    return SkNEW_ARGS(BBoxQueryBench, (p, "(unsorted)concentric", &make_concentric_rects_increasing, true,
+)
+DEF_BENCH(
+    return SkNEW_ARGS(BBoxQueryBench, ("(unsorted)concentric", &make_concentric_rects_increasing, true,
                       BBoxQueryBench::kRandom_QueryType, SkRTree::Create(5, 16, 1, false)));
-}
-
-static BenchRegistry gReg18(Fact18);
-static BenchRegistry gReg17(Fact17);
-static BenchRegistry gReg16(Fact16);
-static BenchRegistry gReg15(Fact15);
-static BenchRegistry gReg14(Fact14);
-static BenchRegistry gReg13(Fact13);
-static BenchRegistry gReg12(Fact12);
-static BenchRegistry gReg11(Fact11);
-static BenchRegistry gReg10(Fact10);
-static BenchRegistry gReg9(Fact9);
-static BenchRegistry gReg8(Fact8);
-static BenchRegistry gReg7(Fact7);
-static BenchRegistry gReg6(Fact6);
-static BenchRegistry gReg5(Fact5);
-static BenchRegistry gReg4(Fact4);
-static BenchRegistry gReg3(Fact3);
-static BenchRegistry gReg2(Fact2);
-static BenchRegistry gReg1(Fact1);
-static BenchRegistry gReg0(Fact0);
+)
diff --git a/bench/ReadPixBench.cpp b/bench/ReadPixBench.cpp
index 505ff32..f62917b 100644
--- a/bench/ReadPixBench.cpp
+++ b/bench/ReadPixBench.cpp
@@ -17,7 +17,7 @@
  */
 class ReadPixBench : public SkBenchmark {
 public:
-    ReadPixBench(void* param) : INHERITED(param) {}
+    ReadPixBench() {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -64,5 +64,4 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* fact(void* p) { return new ReadPixBench(p); }
-static BenchRegistry gReg(fact);
+DEF_BENCH( return new ReadPixBench(); )
diff --git a/bench/RectBench.cpp b/bench/RectBench.cpp
index 22c2645..2937e5d 100644
--- a/bench/RectBench.cpp
+++ b/bench/RectBench.cpp
@@ -26,9 +26,8 @@
     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;
@@ -81,7 +80,7 @@
 
 class SrcModeRectBench : public RectBench {
 public:
-    SrcModeRectBench(void* param) : INHERITED(param, 1, 0) {
+    SrcModeRectBench() : INHERITED(1, 0) {
         fMode = SkXfermode::Create(SkXfermode::kSrc_Mode);
     }
 
@@ -112,7 +111,7 @@
 
 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);
@@ -122,7 +121,7 @@
 
 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);
@@ -135,8 +134,9 @@
     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;
     }
 
@@ -174,7 +174,7 @@
         H = 480,
     };
 
-    AARectBench(void* param, bool rotate) : INHERITED(param), fRotate(rotate) {}
+    AARectBench(bool rotate) : fRotate(rotate) {}
 
 protected:
 
@@ -236,9 +236,9 @@
     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;
     }
 
@@ -302,42 +302,42 @@
 };
 
 
-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")
                      ); )
diff --git a/bench/RectoriBench.cpp b/bench/RectoriBench.cpp
index 0a0b71d..df695d5 100644
--- a/bench/RectoriBench.cpp
+++ b/bench/RectoriBench.cpp
@@ -16,7 +16,7 @@
 // to create an inner blurred rect
 class RectoriBench : public SkBenchmark {
 public:
-    RectoriBench(void* param) : INHERITED(param) {}
+    RectoriBench() {}
 
 protected:
 
@@ -102,5 +102,4 @@
     typedef SkBenchmark INHERITED;
 };
 
-
-DEF_BENCH( return SkNEW_ARGS(RectoriBench, (p)); )
+DEF_BENCH( return SkNEW_ARGS(RectoriBench, ()); )
diff --git a/bench/RefCntBench.cpp b/bench/RefCntBench.cpp
index 2cc7688..0110dbc 100644
--- a/bench/RefCntBench.cpp
+++ b/bench/RefCntBench.cpp
@@ -16,7 +16,7 @@
 
 class RefCntBench_Stack : public SkBenchmark {
 public:
-    RefCntBench_Stack(void* param) : INHERITED(param) {
+    RefCntBench_Stack() {
         fIsRendering = false;
     }
 protected:
@@ -53,7 +53,7 @@
 
 class RefCntBench_Heap : public SkBenchmark {
 public:
-    RefCntBench_Heap(void* param) : INHERITED(param) {
+    RefCntBench_Heap() {
         fIsRendering = false;
     }
 protected:
@@ -79,7 +79,7 @@
 
 class RefCntBench_New : public SkBenchmark {
 public:
-    RefCntBench_New(void* param) : INHERITED(param) {
+    RefCntBench_New() {
         fIsRendering = false;
     }
 protected:
@@ -106,7 +106,7 @@
 
 class WeakRefCntBench_Stack : public SkBenchmark {
 public:
-    WeakRefCntBench_Stack(void* param) : INHERITED(param) {
+    WeakRefCntBench_Stack() {
         fIsRendering = false;
     }
 protected:
@@ -136,7 +136,7 @@
 
 class WeakRefCntBench_Heap : public SkBenchmark {
 public:
-    WeakRefCntBench_Heap(void* param) : INHERITED(param) {
+    WeakRefCntBench_Heap() {
         fIsRendering = false;
     }
 protected:
@@ -162,7 +162,7 @@
 
 class WeakRefCntBench_New : public SkBenchmark {
 public:
-    WeakRefCntBench_New(void* param) : INHERITED(param) {
+    WeakRefCntBench_New() {
         fIsRendering = false;
     }
 protected:
@@ -187,18 +187,10 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact00(void* p) { return new RefCntBench_Stack(p); }
-static SkBenchmark* Fact01(void* p) { return new RefCntBench_Heap(p); }
-static SkBenchmark* Fact02(void* p) { return new RefCntBench_New(p); }
+DEF_BENCH( return new RefCntBench_Stack(); )
+DEF_BENCH( return new RefCntBench_Heap(); )
+DEF_BENCH( return new RefCntBench_New(); )
 
-static SkBenchmark* Fact10(void* p) { return new WeakRefCntBench_Stack(p); }
-static SkBenchmark* Fact11(void* p) { return new WeakRefCntBench_Heap(p); }
-static SkBenchmark* Fact12(void* p) { return new WeakRefCntBench_New(p); }
-
-static BenchRegistry gReg00(Fact00);
-static BenchRegistry gReg01(Fact01);
-static BenchRegistry gReg02(Fact02);
-
-static BenchRegistry gReg10(Fact10);
-static BenchRegistry gReg11(Fact11);
-static BenchRegistry gReg12(Fact12);
+DEF_BENCH( return new WeakRefCntBench_Stack(); )
+DEF_BENCH( return new WeakRefCntBench_Heap(); )
+DEF_BENCH( return new WeakRefCntBench_New(); )
diff --git a/bench/RegionBench.cpp b/bench/RegionBench.cpp
index ffd674a..e383113 100644
--- a/bench/RegionBench.cpp
+++ b/bench/RegionBench.cpp
@@ -88,7 +88,7 @@
         return SkIRect::MakeXYWH(x, y, w >> 1, h >> 1);
     }
 
-    RegionBench(void* param, int count, Proc proc, const char name[]) : INHERITED(param) {
+    RegionBench(int count, Proc proc, const char name[])  {
         fProc = proc;
         fName.printf("region_%s_%d", name, count);
 
@@ -116,22 +116,12 @@
 
 #define SMALL   16
 
-static SkBenchmark* gF0(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, union_proc, "union")); }
-static SkBenchmark* gF1(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, sect_proc, "intersect")); }
-static SkBenchmark* gF2(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, diff_proc, "difference")); }
-static SkBenchmark* gF3(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, diffrect_proc, "differencerect")); }
-static SkBenchmark* gF4(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, diffrectbig_proc, "differencerectbig")); }
-static SkBenchmark* gF5(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, containsrect_proc, "containsrect")); }
-static SkBenchmark* gF6(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, sectsrgn_proc, "intersectsrgn")); }
-static SkBenchmark* gF7(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, sectsrect_proc, "intersectsrect")); }
-static SkBenchmark* gF8(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, containsxy_proc, "containsxy")); }
-
-static BenchRegistry gR0(gF0);
-static BenchRegistry gR1(gF1);
-static BenchRegistry gR2(gF2);
-static BenchRegistry gR3(gF3);
-static BenchRegistry gR4(gF4);
-static BenchRegistry gR5(gF5);
-static BenchRegistry gR6(gF6);
-static BenchRegistry gR7(gF7);
-static BenchRegistry gR8(gF8);
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, union_proc, "union")); )
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, sect_proc, "intersect")); )
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, diff_proc, "difference")); )
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, diffrect_proc, "differencerect")); )
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, diffrectbig_proc, "differencerectbig")); )
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, containsrect_proc, "containsrect")); )
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, sectsrgn_proc, "intersectsrgn")); )
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, sectsrect_proc, "intersectsrect")); )
+DEF_BENCH( return SkNEW_ARGS(RegionBench, (SMALL, containsxy_proc, "containsxy")); )
diff --git a/bench/RegionContainBench.cpp b/bench/RegionContainBench.cpp
index c4cbc94..a799895 100644
--- a/bench/RegionContainBench.cpp
+++ b/bench/RegionContainBench.cpp
@@ -33,7 +33,7 @@
         return SkIRect::MakeXYWH(0, i*H/COUNT, w, H/COUNT);
     }
 
-    RegionContainBench(void* param, Proc proc, const char name[]) : INHERITED(param) {
+    RegionContainBench(Proc proc, const char name[])  {
         fProc = proc;
         fName.printf("region_contains_%s", name);
 
@@ -62,6 +62,4 @@
     typedef SkBenchmark INHERITED;
 };
 
-static SkBenchmark* gF0(void* p) { return SkNEW_ARGS(RegionContainBench, (p, sect_proc, "sect")); }
-
-static BenchRegistry gR0(gF0);
+DEF_BENCH( return SkNEW_ARGS(RegionContainBench, (sect_proc, "sect")); )
diff --git a/bench/RepeatTileBench.cpp b/bench/RepeatTileBench.cpp
index ab7ccf4..c311c4a 100644
--- a/bench/RepeatTileBench.cpp
+++ b/bench/RepeatTileBench.cpp
@@ -90,7 +90,7 @@
     bool             fIsOpaque;
     SkBitmap::Config fConfig;
 public:
-    RepeatTileBench(void* param, SkBitmap::Config c, bool isOpaque = false) : INHERITED(param) {
+    RepeatTileBench(SkBitmap::Config c, bool isOpaque = false)  {
         const int w = 50;
         const int h = 50;
         fConfig = c;
@@ -143,7 +143,7 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new RepeatTileBench(p, SkBitmap::kARGB_8888_Config, true))
-DEF_BENCH(return new RepeatTileBench(p, SkBitmap::kARGB_8888_Config, false))
-DEF_BENCH(return new RepeatTileBench(p, SkBitmap::kRGB_565_Config))
-DEF_BENCH(return new RepeatTileBench(p, SkBitmap::kIndex8_Config))
+DEF_BENCH(return new RepeatTileBench(SkBitmap::kARGB_8888_Config, true))
+DEF_BENCH(return new RepeatTileBench(SkBitmap::kARGB_8888_Config, false))
+DEF_BENCH(return new RepeatTileBench(SkBitmap::kRGB_565_Config))
+DEF_BENCH(return new RepeatTileBench(SkBitmap::kIndex8_Config))
diff --git a/bench/ScalarBench.cpp b/bench/ScalarBench.cpp
index b1014f4..536af28 100644
--- a/bench/ScalarBench.cpp
+++ b/bench/ScalarBench.cpp
@@ -14,7 +14,7 @@
 class ScalarBench : public SkBenchmark {
     SkString    fName;
 public:
-    ScalarBench(void* param, const char name[]) : INHERITED(param) {
+    ScalarBench(const char name[])  {
         fName.printf("scalar_%s", name);
         fIsRendering = false;
     }
@@ -62,7 +62,7 @@
 
 class FloatComparisonBench : public ScalarBench {
 public:
-    FloatComparisonBench(void* param) : INHERITED(param, "compare_float") {
+    FloatComparisonBench() : INHERITED("compare_float") {
         init9(fArray);
     }
 protected:
@@ -78,8 +78,8 @@
 
 class ForcedIntComparisonBench : public ScalarBench {
 public:
-    ForcedIntComparisonBench(void* param)
-    : INHERITED(param, "compare_forced_int") {
+    ForcedIntComparisonBench()
+    : INHERITED("compare_forced_int") {
         init9(fArray);
     }
 protected:
@@ -99,7 +99,7 @@
 
 class IsFiniteScalarBench : public ScalarBench {
 public:
-    IsFiniteScalarBench(void* param) : INHERITED(param, "isfinite") {
+    IsFiniteScalarBench() : INHERITED("isfinite") {
         SkRandom rand;
         for (size_t i = 0; i < ARRAY_N; ++i) {
             fArray[i] = rand.nextSScalar1();
@@ -137,7 +137,7 @@
     SkPoint fPts[PTS];
 
 public:
-    RectBoundsBench(void* param) : INHERITED(param) {
+    RectBoundsBench() {
         SkRandom rand;
         for (int i = 0; i < PTS; ++i) {
             fPts[i].fX = rand.nextSScalar1();
@@ -164,12 +164,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* S0(void* p) { return new FloatComparisonBench(p); }
-static SkBenchmark* S1(void* p) { return new ForcedIntComparisonBench(p); }
-static SkBenchmark* S2(void* p) { return new RectBoundsBench(p); }
-static SkBenchmark* S3(void* p) { return new IsFiniteScalarBench(p); }
-
-static BenchRegistry gReg0(S0);
-static BenchRegistry gReg1(S1);
-static BenchRegistry gReg2(S2);
-static BenchRegistry gReg3(S3);
+DEF_BENCH( return new FloatComparisonBench(); )
+DEF_BENCH( return new ForcedIntComparisonBench(); )
+DEF_BENCH( return new RectBoundsBench(); )
+DEF_BENCH( return new IsFiniteScalarBench(); )
diff --git a/bench/ShaderMaskBench.cpp b/bench/ShaderMaskBench.cpp
index 2738cff..71ca047 100644
--- a/bench/ShaderMaskBench.cpp
+++ b/bench/ShaderMaskBench.cpp
@@ -38,7 +38,7 @@
     SkString    fName;
     FontQuality fFQ;
 public:
-    ShaderMaskBench(void* param, bool isOpaque, FontQuality fq) : INHERITED(param) {
+    ShaderMaskBench(bool isOpaque, FontQuality fq)  {
         fFQ = fq;
         fText.set(STR);
 
@@ -91,16 +91,9 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact00(void* p) { return new ShaderMaskBench(p, true,  kBW); }
-static SkBenchmark* Fact01(void* p) { return new ShaderMaskBench(p, false, kBW); }
-static SkBenchmark* Fact10(void* p) { return new ShaderMaskBench(p, true,  kAA); }
-static SkBenchmark* Fact11(void* p) { return new ShaderMaskBench(p, false, kAA); }
-static SkBenchmark* Fact20(void* p) { return new ShaderMaskBench(p, true,  kLCD); }
-static SkBenchmark* Fact21(void* p) { return new ShaderMaskBench(p, false, kLCD); }
-
-static BenchRegistry gReg00(Fact00);
-static BenchRegistry gReg01(Fact01);
-static BenchRegistry gReg10(Fact10);
-static BenchRegistry gReg11(Fact11);
-static BenchRegistry gReg20(Fact20);
-static BenchRegistry gReg21(Fact21);
+DEF_BENCH( return new ShaderMaskBench(true,  kBW); )
+DEF_BENCH( return new ShaderMaskBench(false, kBW); )
+DEF_BENCH( return new ShaderMaskBench(true,  kAA); )
+DEF_BENCH( return new ShaderMaskBench(false, kAA); )
+DEF_BENCH( return new ShaderMaskBench(true,  kLCD); )
+DEF_BENCH( return new ShaderMaskBench(false, kLCD); )
diff --git a/bench/SkBenchmark.cpp b/bench/SkBenchmark.cpp
index 09e109e..4d361e7 100644
--- a/bench/SkBenchmark.cpp
+++ b/bench/SkBenchmark.cpp
@@ -15,7 +15,7 @@
 
 template BenchRegistry* BenchRegistry::gHead;
 
-SkBenchmark::SkBenchmark(void* /*ignored*/) {
+SkBenchmark::SkBenchmark() {
     fForceAlpha = 0xFF;
     fForceAA = true;
     fDither = SkTriState::kDefault;
diff --git a/bench/SkBenchmark.h b/bench/SkBenchmark.h
index 343bde2..811a1db 100644
--- a/bench/SkBenchmark.h
+++ b/bench/SkBenchmark.h
@@ -13,16 +13,16 @@
 #include "SkTRegistry.h"
 
 #define DEF_BENCH(code) \
-static SkBenchmark* SK_MACRO_APPEND_LINE(F_)(void* p) { code; } \
+static SkBenchmark* SK_MACRO_APPEND_LINE(F_)() { code; } \
 static BenchRegistry SK_MACRO_APPEND_LINE(R_)(SK_MACRO_APPEND_LINE(F_));
 
 /*
  *  With the above macros, you can register benches as follows (at the bottom
  *  of your .cpp)
  *
- *  DEF_BENCH(new MyBenchmark(p, ...))
- *  DEF_BENCH(new MyBenchmark(p, ...))
- *  DEF_BENCH(new MyBenchmark(p, ...))
+ *  DEF_BENCH(return new MyBenchmark(...))
+ *  DEF_BENCH(return new MyBenchmark(...))
+ *  DEF_BENCH(return new MyBenchmark(...))
  */
 
 
@@ -43,7 +43,7 @@
 public:
     SK_DECLARE_INST_COUNT(SkBenchmark)
 
-    SkBenchmark(void* defineDict);
+    SkBenchmark();
 
     const char* getName();
     SkIPoint getSize();
@@ -129,6 +129,6 @@
     typedef SkRefCnt INHERITED;
 };
 
-typedef SkTRegistry<SkBenchmark*(*)(void*)> BenchRegistry;
+typedef SkTRegistry<SkBenchmark*(*)()> BenchRegistry;
 
 #endif
diff --git a/bench/SortBench.cpp b/bench/SortBench.cpp
index 279c8ad..f8bb686 100644
--- a/bench/SortBench.cpp
+++ b/bench/SortBench.cpp
@@ -104,7 +104,7 @@
     SortProc    fSortProc;
 
 public:
-    SortBench(void* param, Type t, int n, SortType s) : INHERITED(param) {
+    SortBench(Type t, int n, SortType s)  {
         if (n > MAX) {
             n = MAX;
         }
@@ -138,32 +138,32 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* NewSkQSort(void* param, Type t) {
-    return new SortBench(param, t, N, kSKQSort);
+static SkBenchmark* NewSkQSort(Type t) {
+    return new SortBench(t, N, kSKQSort);
 }
-static SkBenchmark* NewSkHeap(void* param, Type t) {
-    return new SortBench(param, t, N, kSKHeap);
+static SkBenchmark* NewSkHeap(Type t) {
+    return new SortBench(t, N, kSKHeap);
 }
-static SkBenchmark* NewQSort(void* param, Type t) {
-    return new SortBench(param, t, N, kQSort);
+static SkBenchmark* NewQSort(Type t) {
+    return new SortBench(t, N, kQSort);
 }
 
-DEF_BENCH( return NewSkQSort(p, kRand); )
-DEF_BENCH( return NewSkHeap(p, kRand); )
-DEF_BENCH( return NewQSort(p, kRand); )
+DEF_BENCH( return NewSkQSort(kRand); )
+DEF_BENCH( return NewSkHeap(kRand); )
+DEF_BENCH( return NewQSort(kRand); )
 
-DEF_BENCH( return NewSkQSort(p, kRandN); )
-DEF_BENCH( return NewSkHeap(p, kRandN); )
-DEF_BENCH( return NewQSort(p, kRandN); )
+DEF_BENCH( return NewSkQSort(kRandN); )
+DEF_BENCH( return NewSkHeap(kRandN); )
+DEF_BENCH( return NewQSort(kRandN); )
 
-DEF_BENCH( return NewSkQSort(p, kFore); )
-DEF_BENCH( return NewSkHeap(p, kFore); )
-DEF_BENCH( return NewQSort(p, kFore); )
+DEF_BENCH( return NewSkQSort(kFore); )
+DEF_BENCH( return NewSkHeap(kFore); )
+DEF_BENCH( return NewQSort(kFore); )
 
-DEF_BENCH( return NewSkQSort(p, kBack); )
-DEF_BENCH( return NewSkHeap(p, kBack); )
-DEF_BENCH( return NewQSort(p, kBack); )
+DEF_BENCH( return NewSkQSort(kBack); )
+DEF_BENCH( return NewSkHeap(kBack); )
+DEF_BENCH( return NewQSort(kBack); )
 
-DEF_BENCH( return NewSkQSort(p, kSame); )
-DEF_BENCH( return NewSkHeap(p, kSame); )
-DEF_BENCH( return NewQSort(p, kSame); )
+DEF_BENCH( return NewSkQSort(kSame); )
+DEF_BENCH( return NewSkHeap(kSame); )
+DEF_BENCH( return NewQSort(kSame); )
diff --git a/bench/StrokeBench.cpp b/bench/StrokeBench.cpp
index 33772dd..769c09a 100644
--- a/bench/StrokeBench.cpp
+++ b/bench/StrokeBench.cpp
@@ -59,7 +59,7 @@
     RRectRec fRec;
     DrawProc fProc;
 public:
-    StrokeRRectBench(void* param, SkPaint::Join j, DrawProc proc) : SkBenchmark(param) {
+    StrokeRRectBench(SkPaint::Join j, DrawProc proc) {
         static const char* gJoinName[] = {
             "miter", "round", "bevel"
         };
@@ -91,14 +91,14 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kRound_Join, draw_rect); )
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kBevel_Join, draw_rect); )
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kMiter_Join, draw_rect); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kRound_Join, draw_rect); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kBevel_Join, draw_rect); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kMiter_Join, draw_rect); )
 
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kRound_Join, draw_rrect); )
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kBevel_Join, draw_rrect); )
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kMiter_Join, draw_rrect); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kRound_Join, draw_rrect); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kBevel_Join, draw_rrect); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kMiter_Join, draw_rrect); )
 
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kRound_Join, draw_oval); )
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kBevel_Join, draw_oval); )
-DEF_BENCH( return new StrokeRRectBench(p, SkPaint::kMiter_Join, draw_oval); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kRound_Join, draw_oval); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kBevel_Join, draw_oval); )
+DEF_BENCH( return new StrokeRRectBench(SkPaint::kMiter_Join, draw_oval); )
diff --git a/bench/TableBench.cpp b/bench/TableBench.cpp
index 8dcefbe..0646d26 100644
--- a/bench/TableBench.cpp
+++ b/bench/TableBench.cpp
@@ -28,10 +28,6 @@
     static const int kNumRows = 48;
     static const int kNumCols = 32;
 
-    TableBench(void* param)
-        : INHERITED(param) {
-    }
-
 protected:
     virtual const char* onGetName() {
         return "tablebench";
@@ -73,6 +69,4 @@
     typedef SkBenchmark INHERITED;
 };
 
-static SkBenchmark* gFactory(void* p) { return new TableBench(p); }
-
-static BenchRegistry gRegistry(gFactory);
+DEF_BENCH( return new TableBench(); )
diff --git a/bench/TextBench.cpp b/bench/TextBench.cpp
index 7aac2c0..cc665b7 100644
--- a/bench/TextBench.cpp
+++ b/bench/TextBench.cpp
@@ -46,8 +46,8 @@
     bool        fDoPos;
     SkPoint*    fPos;
 public:
-    TextBench(void* param, const char text[], int ps,
-              SkColor color, FontQuality fq, bool doPos = false) : INHERITED(param) {
+    TextBench(const char text[], int ps,
+              SkColor color, FontQuality fq, bool doPos = false)  {
         fPos = NULL;
         fFQ = fq;
         fDoPos = doPos;
@@ -130,30 +130,16 @@
 
 #define STR     "Hamburgefons"
 
-static SkBenchmark* Fact01(void* p) { return new TextBench(p, STR, 16, 0xFF000000, kBW); }
-static SkBenchmark* Fact02(void* p) { return new TextBench(p, STR, 16, 0xFFFF0000, kBW); }
-static SkBenchmark* Fact03(void* p) { return new TextBench(p, STR, 16, 0x88FF0000, kBW); }
+DEF_BENCH( return new TextBench(STR, 16, 0xFF000000, kBW); )
+DEF_BENCH( return new TextBench(STR, 16, 0xFFFF0000, kBW); )
+DEF_BENCH( return new TextBench(STR, 16, 0x88FF0000, kBW); )
 
-static SkBenchmark* Fact11(void* p) { return new TextBench(p, STR, 16, 0xFF000000, kAA); }
-static SkBenchmark* Fact12(void* p) { return new TextBench(p, STR, 16, 0xFFFF0000, kAA); }
-static SkBenchmark* Fact13(void* p) { return new TextBench(p, STR, 16, 0x88FF0000, kAA); }
+DEF_BENCH( return new TextBench(STR, 16, 0xFF000000, kAA); )
+DEF_BENCH( return new TextBench(STR, 16, 0xFFFF0000, kAA); )
+DEF_BENCH( return new TextBench(STR, 16, 0x88FF0000, kAA); )
 
-static SkBenchmark* Fact21(void* p) { return new TextBench(p, STR, 16, 0xFF000000, kLCD); }
-static SkBenchmark* Fact22(void* p) { return new TextBench(p, STR, 16, 0xFFFF0000, kLCD); }
-static SkBenchmark* Fact23(void* p) { return new TextBench(p, STR, 16, 0x88FF0000, kLCD); }
+DEF_BENCH( return new TextBench(STR, 16, 0xFF000000, kLCD); )
+DEF_BENCH( return new TextBench(STR, 16, 0xFFFF0000, kLCD); )
+DEF_BENCH( return new TextBench(STR, 16, 0x88FF0000, kLCD); )
 
-static SkBenchmark* Fact111(void* p) { return new TextBench(p, STR, 16, 0xFF000000, kAA, true); }
-
-static BenchRegistry gReg01(Fact01);
-static BenchRegistry gReg02(Fact02);
-static BenchRegistry gReg03(Fact03);
-
-static BenchRegistry gReg11(Fact11);
-static BenchRegistry gReg12(Fact12);
-static BenchRegistry gReg13(Fact13);
-
-static BenchRegistry gReg21(Fact21);
-static BenchRegistry gReg22(Fact22);
-static BenchRegistry gReg23(Fact23);
-
-static BenchRegistry gReg111(Fact111);
+DEF_BENCH( return new TextBench(STR, 16, 0xFF000000, kAA, true); )
diff --git a/bench/TileBench.cpp b/bench/TileBench.cpp
index 44235eb..60312a3 100644
--- a/bench/TileBench.cpp
+++ b/bench/TileBench.cpp
@@ -38,14 +38,12 @@
     static const int kHeight = 300;
 
 public:
-    ConstXTileBench(void* param,
-                    SkShader::TileMode xTile,
+    ConstXTileBench(SkShader::TileMode xTile,
                     SkShader::TileMode yTile,
                     bool doFilter,
                     bool doTrans,
                     bool doScale)
-        : INHERITED(param)
-        , fDoFilter(doFilter)
+        : fDoFilter(doFilter)
         , fDoTrans(doTrans)
         , fDoScale(doScale) {
         SkBitmap bm;
@@ -118,18 +116,18 @@
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, false, false, true))
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, false, false, false))
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, false, false, true))
+DEF_BENCH(return new ConstXTileBench(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, false, false, true))
+DEF_BENCH(return new ConstXTileBench(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, false, false, false))
+DEF_BENCH(return new ConstXTileBench(SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, false, false, true))
 
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, true, false, false))
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, true, false, true))
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, true, false, false))
+DEF_BENCH(return new ConstXTileBench(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, true, false, false))
+DEF_BENCH(return new ConstXTileBench(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, true, false, true))
+DEF_BENCH(return new ConstXTileBench(SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, true, false, false))
 
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, false, true, true))
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, false, true, false))
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, false, true, true))
+DEF_BENCH(return new ConstXTileBench(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, false, true, true))
+DEF_BENCH(return new ConstXTileBench(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, false, true, false))
+DEF_BENCH(return new ConstXTileBench(SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, false, true, true))
 
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, true, true, false))
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, true, true, true))
-DEF_BENCH(return new ConstXTileBench(p, SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, true, true, false))
+DEF_BENCH(return new ConstXTileBench(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, true, true, false))
+DEF_BENCH(return new ConstXTileBench(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, true, true, true))
+DEF_BENCH(return new ConstXTileBench(SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, true, true, false))
diff --git a/bench/VertBench.cpp b/bench/VertBench.cpp
index 79dcc9ad..39602b0 100644
--- a/bench/VertBench.cpp
+++ b/bench/VertBench.cpp
@@ -39,7 +39,7 @@
     }
 
 public:
-    VertBench(void* param) : INHERITED(param) {
+    VertBench() {
         const SkScalar dx = SkIntToScalar(W) / COL;
         const SkScalar dy = SkIntToScalar(H) / COL;
 
@@ -92,6 +92,4 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* Fact(void* p) { return SkNEW_ARGS(VertBench, (p)); }
-
-static BenchRegistry gReg(Fact);
+DEF_BENCH( return SkNEW_ARGS(VertBench, ()); )
diff --git a/bench/WritePixelsBench.cpp b/bench/WritePixelsBench.cpp
index a9b6763..949b5bc 100644
--- a/bench/WritePixelsBench.cpp
+++ b/bench/WritePixelsBench.cpp
@@ -13,9 +13,8 @@
 
 class WritePixelsBench : public SkBenchmark {
 public:
-    WritePixelsBench(void* param, SkCanvas::Config8888 config)
-        : INHERITED(param)
-        , fConfig(config)
+    WritePixelsBench(SkCanvas::Config8888 config)
+        : fConfig(config)
         , fName("writepix") {
         switch (config) {
             case SkCanvas::kNative_Premul_Config8888:
@@ -70,5 +69,5 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return SkNEW_ARGS(WritePixelsBench, (p, SkCanvas::kRGBA_Premul_Config8888)); )
-DEF_BENCH( return SkNEW_ARGS(WritePixelsBench, (p, SkCanvas::kRGBA_Unpremul_Config8888)); )
+DEF_BENCH( return SkNEW_ARGS(WritePixelsBench, (SkCanvas::kRGBA_Premul_Config8888)); )
+DEF_BENCH( return SkNEW_ARGS(WritePixelsBench, (SkCanvas::kRGBA_Unpremul_Config8888)); )
diff --git a/bench/WriterBench.cpp b/bench/WriterBench.cpp
index 948c0ad..0956b22 100644
--- a/bench/WriterBench.cpp
+++ b/bench/WriterBench.cpp
@@ -12,9 +12,7 @@
 
 class WriterBench : public SkBenchmark {
 public:
-    WriterBench(void* param) : INHERITED(param) {
-        fIsRendering = false;
-    }
+    WriterBench() { fIsRendering = false; }
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
@@ -38,5 +36,4 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-static SkBenchmark* fact(void* p) { return new WriterBench(p); }
-static BenchRegistry gReg(fact);
+DEF_BENCH( return new WriterBench(); )
diff --git a/bench/XfermodeBench.cpp b/bench/XfermodeBench.cpp
index 993fc8f..aed4c34 100644
--- a/bench/XfermodeBench.cpp
+++ b/bench/XfermodeBench.cpp
@@ -17,14 +17,13 @@
 // Benchmark that draws non-AA rects with an SkXfermode::Mode
 class XfermodeBench : public SkBenchmark {
 public:
-    XfermodeBench(void* param, SkXfermode::Mode mode) : SkBenchmark(param) {
+    XfermodeBench(SkXfermode::Mode mode) {
         fXfermode.reset(SkXfermode::Create(mode));
         SkASSERT(NULL != fXfermode.get() || SkXfermode::kSrcOver_Mode == mode);
         fName.printf("Xfermode_%s", SkXfermode::ModeName(mode));
     }
 
-    XfermodeBench(void* param, SkXfermode* xferMode, const char* name)
-        : SkBenchmark(param) {
+    XfermodeBench(SkXfermode* xferMode, const char* name) {
         SkASSERT(NULL != xferMode);
         fXfermode.reset(xferMode);
         fName.printf("Xfermode_%s", name);
@@ -68,8 +67,8 @@
 #define CONCAT_I(x, y) x ## y
 #define CONCAT(x, y) CONCAT_I(x, y) // allow for macro expansion
 #define BENCH(...) \
-    static SkBenchmark* CONCAT(Fact, __LINE__)(void *p) { return new XfermodeBench(p, __VA_ARGS__); };\
-    static BenchRegistry CONCAT(gReg, __LINE__)(CONCAT(Fact, __LINE__));
+    DEF_BENCH( return new XfermodeBench(__VA_ARGS__); );\
+
 
 BENCH(SkXfermode::kClear_Mode)
 BENCH(SkXfermode::kSrc_Mode)
diff --git a/bench/benchmain.cpp b/bench/benchmain.cpp
index 44bc0da..3a57f2d 100644
--- a/bench/benchmain.cpp
+++ b/bench/benchmain.cpp
@@ -57,7 +57,7 @@
         if (fBench) {
             BenchRegistry::Factory f = fBench->factory();
             fBench = fBench->next();
-            return f(NULL);
+            return f();
         }
         return NULL;
     }