Remove Sk prefix from some bench classes.

bench/PathBench.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 "Benchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkShader.h"
 #include "SkString.h"
 #include "SkTArray.h"
 
 enum Flags {
     kStroke_Flag = 1 << 0,
     kBig_Flag    = 1 << 1
 };
 
 #define FLAGS00  Flags(0)
 #define FLAGS01  Flags(kStroke_Flag)
 #define FLAGS10  Flags(kBig_Flag)
 #define FLAGS11  Flags(kStroke_Flag | kBig_Flag)
 
-class PathBench : public SkBenchmark {
+class PathBench : public Benchmark {
     SkPaint     fPaint;
     SkString    fName;
     Flags       fFlags;
 public:
     PathBench(Flags flags) : fFlags(flags) {
         fPaint.setStyle(flags & kStroke_Flag ? SkPaint::kStroke_Style :
                         SkPaint::kFill_Style);
         fPaint.setStrokeWidth(SkIntToScalar(5));
         fPaint.setStrokeJoin(SkPaint::kBevel_Join);
     }
@@ skipping 28 matching lines @@
             count >>= 2;
         }
         count >>= (3 * complexity());
 
         for (int i = 0; i < count; i++) {
             canvas->drawPath(path, paint);
         }
     }
 
 private:
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 class TrianglePathBench : public PathBench {
 public:
     TrianglePathBench(Flags flags) : INHERITED(flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("triangle");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
@@ skipping 119 matching lines @@
         path->moveTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
         for (size_t i = 1; i < 100; i++) {
             path->lineTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
         }
     }
     virtual int complexity() SK_OVERRIDE { return 2; }
 private:
     typedef PathBench INHERITED;
 };
 
-class RandomPathBench : public SkBenchmark {
+class RandomPathBench : public Benchmark {
 public:
     virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
     void createData(int minVerbs,
                     int maxVerbs,
                     bool allowMoves = true,
                     SkRect* bounds = NULL) {
@@ skipping 77 matching lines @@
         kNumVerbs    = 1 << 5,
         kNumPoints   = 1 << 5,
     };
     SkAutoTArray<int>           fVerbCnts;
     SkAutoTArray<SkPath::Verb>  fVerbs;
     SkAutoTArray<SkPoint>       fPoints;
     int                         fCurrPath;
     int                         fCurrVerb;
     int                         fCurrPoint;
     SkRandom                    fRandom;
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 class PathCreateBench : public RandomPathBench {
 public:
     PathCreateBench()  {
     }
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
         return "path_create";
@@ skipping 234 matching lines @@
         // must be a pow 2
         kPathCnt = 1 << 5,
     };
     SkAutoTArray<SkPath> fPaths0;
     SkAutoTArray<SkPath> fPaths1;
     SkMatrix         fMatrix;
     typedef RandomPathBench INHERITED;
 };
 
 
-class CirclesBench : public SkBenchmark {
+class CirclesBench : public Benchmark {
 protected:
     SkString            fName;
     Flags               fFlags;
 
 public:
     CirclesBench(Flags flags) : fFlags(flags) {
         fName.printf("circles_%s", fFlags & kStroke_Flag ? "stroke" : "fill");
     }
 
 protected:
@@ skipping 31 matching lines @@
             temp.arcTo(r, 0, 0, false);
             temp.addOval(r, SkPath::kCCW_Direction);
             temp.arcTo(r, 360, 0, true);
             temp.close();
 
             canvas->drawPath(temp, paint);
         }
     }
 
 private:
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 
 // Chrome creates its own round rects with each corner possibly being different.
 // In its "zero radius" incarnation it creates degenerate round rects.
 // Note: PathTest::test_arb_round_rect_is_convex and
 // test_arb_zero_rad_round_rect_is_rect perform almost exactly
 // the same test (but with no drawing)
-class ArbRoundRectBench : public SkBenchmark {
+class ArbRoundRectBench : public Benchmark {
 protected:
     SkString            fName;
 
 public:
     ArbRoundRectBench(bool zeroRad) : fZeroRad(zeroRad) {
         if (zeroRad) {
             fName.printf("zeroradroundrect");
         } else {
             fName.printf("arbroundrect");
         }
@@ skipping 74 matching lines @@
                 make_arb_round_rect(&temp, r, r.width() / 10, r.height() / 15);
             }
 
             canvas->drawPath(temp, paint);
         }
     }
 
 private:
     bool fZeroRad;      // should 0 radius rounds rects be tested?
 
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
-class ConservativelyContainsBench : public SkBenchmark {
+class ConservativelyContainsBench : public Benchmark {
 public:
     enum Type {
         kRect_Type,
         kRoundRect_Type,
         kOval_Type,
     };
 
     ConservativelyContainsBench(Type type)  {
         fParity = false;
         fName = "conservatively_contains_";
@@ skipping 52 matching lines @@
     static const SkSize kQueryMin; // minimum query rect size, should be <= kQueryMax
     static const SkSize kQueryMax; // max query rect size, should < kBounds
     static const SkRect kBaseRect; // rect that is used to construct the path
     static const SkScalar kRRRadii[2]; // x and y radii for round rect
 
     SkString            fName;
     SkPath              fPath;
     bool                fParity;
     SkTDArray<SkRect>   fQueryRects;
 
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkGeometry.h"
 
-class ConicBench_Chop5 : public SkBenchmark {
+class ConicBench_Chop5 : public Benchmark {
     SkConic fRQ;
 public:
     ConicBench_Chop5()  {
         fRQ.fPts[0].set(0, 0);
         fRQ.fPts[1].set(100, 0);
         fRQ.fPts[2].set(100, 100);
         fRQ.fW = SkScalarCos(SK_ScalarPI/4);
     }
 
 private:
     virtual const char* onGetName() SK_OVERRIDE {
         return "ratquad-chop-0.5";
     }
 
     virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         SkConic dst[2];
         for (int i = 0; i < loops; ++i) {
             fRQ.chopAt(0.5f, dst);
         }
     }
 
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
-class ConicBench_ChopHalf : public SkBenchmark {
+class ConicBench_ChopHalf : public Benchmark {
     SkConic fRQ;
 public:
     ConicBench_ChopHalf()  {
         fRQ.fPts[0].set(0, 0);
         fRQ.fPts[1].set(100, 0);
         fRQ.fPts[2].set(100, 100);
         fRQ.fW = SkScalarCos(SK_ScalarPI/4);
     }
 
 private:
     virtual const char* onGetName() SK_OVERRIDE {
         return "ratquad-chop-half";
     }
 
     virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         SkConic dst[2];
         for (int i = 0; i < loops; ++i) {
             fRQ.chop(dst);
         }
     }
 
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void rand_conic(SkConic* conic, SkRandom& rand) {
     for (int i = 0; i < 3; ++i) {
         conic->fPts[i].set(rand.nextUScalar1() * 100, rand.nextUScalar1() * 100);
     }
     if (rand.nextUScalar1() > 0.5f) {
         conic->fW = rand.nextUScalar1();
     } else {
         conic->fW = 1 + rand.nextUScalar1() * 4;
     }
 }
 
-class ConicBench : public SkBenchmark {
+class ConicBench : public Benchmark {
 public:
     ConicBench()  {
         SkRandom rand;
         for (int i = 0; i < CONICS; ++i) {
             rand_conic(&fConics[i], rand);
         }
     }
 
     virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
     enum {
         CONICS = 100
     };
     SkConic fConics[CONICS];
 
 private:
-    typedef SkBenchmark INHERITED;
+    typedef Benchmark INHERITED;
 };
 
 class ConicBench_ComputeError : public ConicBench {
 public:
     ConicBench_ComputeError()  {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
         return "conic-compute-error";
     }
@@ skipping 107 matching lines @@
 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() )
 DEF_BENCH( return new ConicBench_ChopHalf() )
 DEF_BENCH( return new ConicBench_ComputeError() )
 DEF_BENCH( return new ConicBench_asQuadTol() )
 DEF_BENCH( return new ConicBench_quadPow2() )