Add entry point for passing options to the GrContextFactory

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "Benchmark.h"
 #include "CrashHandler.h"
 #include "GMBench.h"
 #include "ResultsWriter.h"
 #include "SKPBench.h"
 #include "Stats.h"
 #include "Timer.h"
 
 #include "SkOSFile.h"
 #include "SkCanvas.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkString.h"
 #include "SkSurface.h"
 
 #if SK_SUPPORT_GPU
     #include "gl/GrGLDefines.h"
     #include "GrContextFactory.h"
-    GrContextFactory gGrFactory;
+    GrContextFactory* gGrFactory;
 #endif

[bsalomon, 2014/08/13 00:49:33]

Maybe just make this the autotdelete? I think it has overloaded ->

[krajcevski, 2014/08/13 14:46:00]

Done.

 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 static const int kAutoTuneLoops = -1;
 
 static const int kDefaultLoops =
 #ifdef SK_DEBUG
     1;
 #else
     kAutoTuneLoops;
@@ skipping 240 matching lines @@
     }
     return false;
 }
 
 #if SK_SUPPORT_GPU
 static bool is_gpu_config_allowed(const char* name, GrContextFactory::GLContextType ctxType,
                                   int sampleCnt) {
     if (!is_cpu_config_allowed(name)) {
         return false;
     }
-    if (const GrContext* ctx = gGrFactory.get(ctxType)) {
+    if (const GrContext* ctx = gGrFactory->get(ctxType)) {
         return sampleCnt <= ctx->getMaxSampleCount();
     }
     return false;
 }
 #endif
 
 #if SK_SUPPORT_GPU
 #define kBogusGLContextType GrContextFactory::kNative_GLContextType
 #else
 #define kBogusGLContextType 0
@@ skipping 53 matching lines @@
     info.fWidth = bench->getSize().fX;
     info.fHeight = bench->getSize().fY;
 
     Target* target = new Target(config);
 
     if (Benchmark::kRaster_Backend == config.backend) {
         target->surface.reset(SkSurface::NewRaster(info));
     }
 #if SK_SUPPORT_GPU
     else if (Benchmark::kGPU_Backend == config.backend) {
-        target->surface.reset(SkSurface::NewRenderTarget(gGrFactory.get(config.ctxType), info,
+        target->surface.reset(SkSurface::NewRenderTarget(gGrFactory->get(config.ctxType), info,
                                                          config.samples));
-        target->gl = gGrFactory.getGLContext(config.ctxType);
+        target->gl = gGrFactory->getGLContext(config.ctxType);
     }
 #endif
 
     if (Benchmark::kNonRendering_Backend != config.backend && !target->surface.get()) {
         delete target;
         return NULL;
     }
     return target;
 }
 
@@ skipping 143 matching lines @@
     const char* fSourceType;
     int fCurrentScale;
     int fCurrentSKP;
 };
 
 int nanobench_main();
 int nanobench_main() {
     SetupCrashHandler();
     SkAutoGraphics ag;
 
+#if SK_SUPPORT_GPU
+    // Setup GrContextFactory
+    SkAutoTDelete<GrContextFactory> gGrFactoryPtr;
+    gGrFactoryPtr.reset(SkNEW_ARGS(GrContextFactory, (GrContext::Options())));
+    gGrFactory = gGrFactoryPtr.get();
+#endif
+
     if (kAutoTuneLoops != FLAGS_loops) {
         FLAGS_samples     = 1;
         FLAGS_gpuFrameLag = 0;
     }
 
     if (!FLAGS_writePath.isEmpty()) {
         SkDebugf("Writing files to %s.\n", FLAGS_writePath[0]);
         if (!sk_mkdir(FLAGS_writePath[0])) {
             SkDebugf("Could not create %s. Files won't be written.\n", FLAGS_writePath[0]);
             FLAGS_writePath.set(0, NULL);
@@ skipping 123 matching lines @@
                         , stats.plot.c_str()
                         , config
                         , bench->getName()
                         );
             }
         }
         targets.deleteAll();
 
     #if SK_SUPPORT_GPU
         if (FLAGS_abandonGpuContext) {
-            gGrFactory.abandonContexts();
+            gGrFactory->abandonContexts();
         }
         if (FLAGS_resetGpuContext || FLAGS_abandonGpuContext) {
-            gGrFactory.destroyContexts();
+            gGrFactory->destroyContexts();
         }
     #endif
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif