Simplify benchmark internal API.

bench/RectBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
 #include "SkCanvas.h"
 #include "SkCommandLineFlags.h"
@@ skipping 44 matching lines @@
         }
         return fName.c_str();
     }
 
 protected:
     virtual void drawThisRect(SkCanvas* c, const SkRect& r, const SkPaint& p) {
         c->drawRect(r, p);
     }
 
     virtual const char* onGetName() { return computeName("rects"); }
-    virtual void onDraw(SkCanvas* canvas) {
+    virtual void onDraw(const int loops, SkCanvas* canvas) {
         SkPaint paint;
         if (fStroke > 0) {
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setStrokeWidth(SkIntToScalar(fStroke));
         }
-        for (int i = 0; i < this->getLoops(); i++) {
+        for (int i = 0; i < loops; i++) {
             paint.setColor(fColors[i % N]);
             this->setupPaint(&paint);
             this->drawThisRect(canvas, fRects[i % N], paint);
         }
     }
 private:
     typedef SkBenchmark INHERITED;
 };
 
 class SrcModeRectBench : public RectBench {
@@ skipping 52 matching lines @@
     SkCanvas::PointMode fMode;
     const char* fName;
 
     PointsBench(SkCanvas::PointMode mode, const char* name)
         : RectBench(2)
         , fMode(mode) {
         fName = name;
     }
 
 protected:
-    virtual void onDraw(SkCanvas* canvas) {
+    virtual void onDraw(const int loops, SkCanvas* canvas) {
         SkScalar gSizes[] = {
             SkIntToScalar(7), 0
         };
         size_t sizes = SK_ARRAY_COUNT(gSizes);
 
         if (FLAGS_strokeWidth >= 0) {
             gSizes[0] = (SkScalar)FLAGS_strokeWidth;
             sizes = 1;
         }
 
         SkPaint paint;
         paint.setStrokeCap(SkPaint::kRound_Cap);
 
-        for (int loop = 0; loop < this->getLoops(); loop++) {
+        for (int loop = 0; loop < loops; loop++) {
             for (size_t i = 0; i < sizes; i++) {
                 paint.setStrokeWidth(gSizes[i]);
                 this->setupPaint(&paint);
                 canvas->drawPoints(fMode, N * 2, SkTCast<SkPoint*>(fRects), paint);
                 paint.setColor(fColors[i % N]);
             }
         }
     }
     virtual const char* onGetName() { return fName; }
 };
 
 class AARectBench : public SkBenchmark {
 public:
     enum {
         W = 640,
         H = 480,
     };
 
     AARectBench(bool rotate) : fRotate(rotate) {}
 
 protected:
 
     virtual const char* onGetName() {
         if (fRotate) {
             return "aarects_rotated";
         }
         return "aarects";
     }
 
-    virtual void onDraw(SkCanvas* canvas) {
+    virtual void onDraw(const int loops, SkCanvas* canvas) {
         static const SkScalar kHalfRectSize = 0.75f;
 
         SkPaint paint;
         this->setupPaint(&paint);
         paint.setAntiAlias(true);
         paint.setColor(SK_ColorBLACK);
         SkRect r = { -kHalfRectSize, -kHalfRectSize, kHalfRectSize, kHalfRectSize };
         int rot = 0;
 
-        for (int i = 0; i < this->getLoops(); i++) {
+        for (int i = 0; i < loops; i++) {
             // Draw small aa rects in a grid across the screen
             for (SkScalar y = kHalfRectSize+SK_Scalar1; y < H; y += 2*kHalfRectSize+2) {
                 for (SkScalar x = kHalfRectSize+SK_Scalar1; x < W; x += 2*kHalfRectSize+2) {
                     canvas->save();
                     canvas->translate(x, y);
 
                     if (fRotate) {
                         SkMatrix rotate;
                         rotate.setRotate(SkIntToScalar(rot));
                         canvas->concat(rotate);
@@ skipping 27 matching lines @@
     SkCanvas::PointMode fMode;
     const char* fName;
 
     BlitMaskBench(SkCanvas::PointMode mode,
                   BlitMaskBench::kMaskType type, const char* name) :
         RectBench(2), fMode(mode), _type(type) {
         fName = name;
     }
 
 protected:
-    virtual void onDraw(SkCanvas* canvas) {
+    virtual void onDraw(const int loops, SkCanvas* canvas) {
         SkScalar gSizes[] = {
             SkIntToScalar(13), SkIntToScalar(24)
         };
         size_t sizes = SK_ARRAY_COUNT(gSizes);
 
         if (FLAGS_strokeWidth >= 0) {
             gSizes[0] = (SkScalar)FLAGS_strokeWidth;
             sizes = 1;
         }
         SkRandom rand;
         SkColor color = 0xFF000000;
         U8CPU alpha = 0xFF;
         SkPaint paint;
         paint.setStrokeCap(SkPaint::kRound_Cap);
         if (_type == KMaskShader) {
             SkBitmap srcBM;
             srcBM.setConfig(SkBitmap::kARGB_8888_Config, 10, 1);
             srcBM.allocPixels();
             srcBM.eraseColor(0xFF00FF00);
 
             SkShader* s;
             s  = SkShader::CreateBitmapShader(srcBM, SkShader::kClamp_TileMode,
                                               SkShader::kClamp_TileMode);
             paint.setShader(s)->unref();
         }
-        for (int loop = 0; loop < this->getLoops(); loop++) {
+        for (int loop = 0; loop < loops; loop++) {
             for (size_t i = 0; i < sizes; i++) {
                 switch (_type) {
                     case kMaskOpaque:
                         color = fColors[i];
                         alpha = 0xFF;
                         break;
                     case kMaskBlack:
                         alpha = 0xFF;
                         color = 0xFF000000;
                         break;
@@ skipping 51 matching lines @@
                       BlitMaskBench::kMaskBlack, "maskblack")
                       ); )
 DEF_BENCH( return SkNEW_ARGS(BlitMaskBench,
                       (SkCanvas::kPoints_PointMode,
                       BlitMaskBench::kMaskColor, "maskcolor")
                       ); )
 DEF_BENCH( return SkNEW_ARGS(BlitMaskBench,
                      (SkCanvas::kPoints_PointMode,
                      BlitMaskBench::KMaskShader, "maskshader")
                      ); )