Allow GMs ato be used as benchmarks. Make convex_poly_clip opt in.

bench/benchmain.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 "BenchTimer.h"
 #include "ResultsWriter.h"
 #include "SkBenchLogger.h"
 #include "SkBenchmark.h"
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
 #include "SkDeferredCanvas.h"
+#include "SkGMBench.h"
 #include "SkGraphics.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkString.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrContextFactory.h"
 #include "GrRenderTarget.h"
 #include "SkGpuDevice.h"
 #include "gl/GrGLDefines.h"
 #else
 class GrContext;
 #endif // SK_SUPPORT_GPU
 
 #include <limits>
 
+class AutoUnrefArray {

[reed1, 2014/02/03 13:20:42]

Does this need a new class from scratch? Can you use/subclass SkTDArray, which
already has unrefAll()?

[bsalomon, 2014/02/03 14:02:45]

Done. Inherited in order to override the destructor.

+public:
+    AutoUnrefArray() {}
+    ~AutoUnrefArray() {
+        int count = fObjs.count();
+        for (int i = 0; i < count; ++i) {
+            fObjs[i]->unref();
+        }
+    }
+    const SkRefCnt*& push_back() { return *fObjs.append(); }
+
+private:
+    SkTDArray<const SkRefCnt*> fObjs;
+};
+
+class GMBenchFactory : public SkBenchmarkFactory {
+public:
+    GMBenchFactory(const skiagm::GMRegistry* gmreg)
+        : fGMFactory(gmreg->factory())
+        , fSelfRegistry(this) {
+    }
+
+    virtual SkBenchmark* operator()() const SK_OVERRIDE {
+        skiagm::GM* gm = fGMFactory(NULL);
+        return new SkGMBench(gm);
+    }
+
+private:
+    skiagm::GMRegistry::Factory fGMFactory;
+    BenchRegistry               fSelfRegistry;
+};
+
+static void register_gm_benches() {
+    static bool gOnce;
+    static AutoUnrefArray gUnreffer;
+
+    if (!gOnce) {
+        const skiagm::GMRegistry* gmreg = skiagm::GMRegistry::Head();
+        while (gmreg) {
+            skiagm::GM* gm = gmreg->factory()(NULL);
+            if (NULL != gm  && skiagm::GM::kAsBench_Flag & gm->getFlags()) {
+                gUnreffer.push_back() = SkNEW_ARGS(GMBenchFactory, (gmreg));
+            }
+            SkDELETE(gm);
+            gmreg = gmreg->next();
+        }
+        gOnce = true;
+    }
+}
+
 enum BenchMode {
     kNormal_BenchMode,
     kDeferred_BenchMode,
     kDeferredSilent_BenchMode,
     kRecord_BenchMode,
     kPictureRecord_BenchMode
 };
 const char* BenchMode_Name[] = {
     "normal", "deferred", "deferredSilent", "record", "picturerecord"
 };
@@ skipping 11 matching lines @@
 }
 
 class Iter {
 public:
     Iter() : fBench(BenchRegistry::Head()) {}
 
     SkBenchmark* next() {
         if (fBench) {
             BenchRegistry::Factory f = fBench->factory();
             fBench = fBench->next();
-            return f();
+            return (*f)();
         }
         return NULL;
     }
 
 private:
     const BenchRegistry* fBench;
 };
 
 class AutoPrePostDraw {
 public:
@@ skipping 211 matching lines @@
     if (currRaw < FLAGS_minMs) {
         return false;
     }
     const double low = 1 - FLAGS_error, high = 1 + FLAGS_error;
     const double ratio = currPerLoop / prevPerLoop;
     return low < ratio && ratio < high;
 }
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
+    register_gm_benches();
     SkCommandLineFlags::Parse(argc, argv);
 #if SK_ENABLE_INST_COUNT
     if (FLAGS_leaks) {
         gPrintInstCount = true;
     }
 #endif
     SkAutoGraphics ag;
 
     // First, parse some flags.
     SkBenchLogger logger;
@@ skipping 385 matching lines @@
     gContextFactory.destroyContexts();
 #endif
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif