Implement a benchmark for GrResourceCache

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 "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 198 matching lines @@
             path->lineTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
         }
     }
     virtual int complexity() SK_OVERRIDE { return 2; }
 private:
     typedef PathBench INHERITED;
 };
 
 class RandomPathBench : public SkBenchmark {
 public:
-    RandomPathBench()  {
-        fIsRendering = false;
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
 protected:
     void createData(int minVerbs,
                     int maxVerbs,
                     bool allowMoves = true,
                     SkRect* bounds = NULL) {
         SkRect tempBounds;
         if (NULL == bounds) {
             tempBounds.setXYWH(0, 0, SK_Scalar1, SK_Scalar1);
@@ skipping 523 matching lines @@
 
 class ConservativelyContainsBench : public SkBenchmark {
 public:
     enum Type {
         kRect_Type,
         kRoundRect_Type,
         kOval_Type,
     };
 
     ConservativelyContainsBench(Type type)  {
-        fIsRendering = false;
         fParity = false;
         fName = "conservatively_contains_";
         switch (type) {
             case kRect_Type:
                 fName.append("rect");
                 fPath.addRect(kBaseRect);
                 break;
             case kRoundRect_Type:
                 fName.append("round_rect");
                 fPath.addRoundRect(kBaseRect, kRRRadii[0], kRRRadii[1]);
                 break;
             case kOval_Type:
                 fName.append("oval");
                 fPath.addOval(kBaseRect);
                 break;
         }
     }
 
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
+    }
+
 private:
     virtual const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < this->getLoops(); ++i) {
             const SkRect& rect = fQueryRects[i % kQueryRectCnt];
             fParity = fParity != fPath.conservativelyContainsRect(rect);
         }
@@ skipping 103 matching lines @@
     }
 }
 
 class ConicBench : public SkBenchmark {
 public:
     ConicBench()  {
         SkRandom rand;
         for (int i = 0; i < CONICS; ++i) {
             rand_conic(&fConics[i], rand);
         }
-        fIsRendering = false;
+    }
+
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
 protected:
     enum {
         CONICS = 100
     };
     SkConic fConics[CONICS];
 
 private:
     typedef SkBenchmark INHERITED;
@@ skipping 117 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() )