Refactoring: get rid of the SkBenchmark void* parameter.

bench/SortBench.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBenchmark.h"
 #include "SkRandom.h"
 #include "SkTSort.h"
@@ skipping 86 matching lines @@
 
 class SortBench : public SkBenchmark {
     SkString    fName;
     enum { MAX = 100000 };
     int         fUnsorted[MAX];
     int         fSorted[MAX];
     int         fCount;
     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;
         }
         fName.printf("sort_%s_%s", gSorts[s].fName, gRec[t].fName);
         fCount = n;
         gRec[t].fProc(fUnsorted, n);
         fSortProc = gSorts[s].fProc;
         fIsRendering = false;
     }
 
@@ skipping 13 matching lines @@
 #endif
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-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); )