Major bench refactoring.

bench/GradientBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 141 matching lines @@
             SkDEBUGFAIL("unknown geometry type");
             return "error";
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GradientBench : public SkBenchmark {
     SkString fName;
     SkShader* fShader;
-    int      fCount;
+    int      fRepeat;
     enum {
         W   = 400,
         H   = 400,
-        N   = 1
     };
 public:
     GradientBench(void* param, 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) {
             fName.append("_");
             fName.append(geomtypename(geomType));
         }
 
         fName.append(data.fName);
 
         const SkPoint pts[2] = {
             { 0, 0 },
             { SkIntToScalar(W), SkIntToScalar(H) }
         };
 
-        fCount = SkBENCHLOOP(N * gGrads[gradType].fRepeat);
+        fRepeat = gGrads[gradType].fRepeat;
         fShader = gGrads[gradType].fMaker(pts, data, tm, NULL, scale);
         fGeomType = geomType;
     }
 
     virtual ~GradientBench() {
         fShader->unref();
     }
 
 protected:
     virtual const char* onGetName() {
         return fName.c_str();
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         SkPaint paint;
         this->setupPaint(&paint);
 
         paint.setShader(fShader);
 
         SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
-        for (int i = 0; i < fCount; i++) {
+        for (int i = 0; i < this->getLoops() * fRepeat; i++) {
             switch (fGeomType) {
                case kRect_GeomType:
                    canvas->drawRect(r, paint);
                    break;
                case kOval_GeomType:
                    canvas->drawOval(r, paint);
                    break;
             }
         }
     }
@@ skipping 22 matching lines @@
     virtual void onDraw(SkCanvas* canvas) {
         SkPaint paint;
         this->setupPaint(&paint);
 
         const SkRect r = { 0, 0, SkIntToScalar(4), SkIntToScalar(4) };
         const SkPoint pts[] = {
             { 0, 0 },
             { SkIntToScalar(100), SkIntToScalar(100) },
         };
 
-        for (int i = 0; i < SkBENCHLOOP(1000); i++) {
+        for (int i = 0; i < this->getLoops(); i++) {
             const int gray = i % 256;
             const int alpha = fHasAlpha ? gray : 0xFF;
             SkColor colors[] = {
                 SK_ColorBLACK,
                 SkColorSetARGB(alpha, gray, gray, gray),
                 SK_ColorWHITE };
             SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL,
                                                          SK_ARRAY_COUNT(colors),
                                                          SkShader::kClamp_TileMode);
             paint.setShader(s)->unref();
@@ skipping 21 matching lines @@
 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 Gradient2Bench(p, false); )
 DEF_BENCH( return new Gradient2Bench(p, true); )