Support using OpenGL ES context on desktop

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"
@@ skipping 31 matching lines @@
     kDeferredSilent_BenchMode,
     kRecord_BenchMode,
     kPictureRecord_BenchMode
 };
 const char* BenchMode_Name[] = {
     "normal", "deferred", "deferredSilent", "record", "picturerecord"
 };
 
 static const char kDefaultsConfigStr[] = "defaults";
 
+#if SK_SUPPORT_GPU
+static const char kGpuApiNameGL[] = "gl";
+static const char kGpuApiNameGLES[] = "gles";
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 
 class Iter {
 public:
     Iter() : fBenches(BenchRegistry::Head()), fGMs(skiagm::GMRegistry::Head()) {}
 
     SkBenchmark* next() {
         if (fBenches) {
             BenchRegistry::Factory f = fBenches->factory();
             fBenches = fBenches->next();
@@ skipping 169 matching lines @@
 
 DEFINE_bool(rotate, false,  "Rotate canvas before bench run?");
 DEFINE_bool(scale,  false,  "Scale canvas before bench run?");
 DEFINE_bool(clip,   false,  "Clip canvas before bench run?");
 
 DEFINE_bool(forceAA,        true,     "Force anti-aliasing?");
 DEFINE_bool(forceFilter,    false,    "Force bitmap filtering?");
 DEFINE_string(forceDither, "default", "Force dithering: true, false, or default?");
 DEFINE_bool(forceBlend,     false,    "Force alpha blending?");
 
+DEFINE_string(forceGpuApi, "", "Force use of specific gpu API.  Using \"gl\" "
+              "forces OpenGL API. Using \"gles\" forces OpenGL ES API. "
+              "Defaults to empty string, which selects the API native to the "
+              "system.");
 DEFINE_int32(gpuCacheBytes, -1, "GPU cache size limit in bytes.  0 to disable cache.");
 DEFINE_int32(gpuCacheCount, -1, "GPU cache size limit in object count.  0 to disable cache.");
 
 DEFINE_bool2(leaks, l, false, "show leaked ref cnt'd objects.");
 DEFINE_string(match, "",  "[~][^]substring[$] [...] of test name to run.\n"
                           "Multiple matches may be separated by spaces.\n"
                           "~ causes a matching test to always be skipped\n"
                           "^ requires the start of the test to match\n"
                           "$ requires the end of the test to match\n"
                           "^ and $ requires an exact match\n"
@@ skipping 109 matching lines @@
                 --i;
             }
         }
     }
     // Set the resource path.
     if (!FLAGS_resourcePath.isEmpty()) {
         SkBenchmark::SetResourcePath(FLAGS_resourcePath[0]);
     }
 
 #if SK_SUPPORT_GPU
+    GrGLStandard forcedGpuApi = kNone_GrGLStandard;
+    if (1 == FLAGS_forceGpuApi.count()) {
+        if (strcmp(FLAGS_forceGpuApi[0], kGpuApiNameGL) == 0) {
+            forcedGpuApi = kGL_GrGLStandard;
+        } else if (strcmp(FLAGS_forceGpuApi[0], kGpuApiNameGLES) == 0) {
+            forcedGpuApi = kGLES_GrGLStandard;
+        }
+    }
+
     for (int i = 0; i < configs.count(); ++i) {
         const Config& config = gConfigs[configs[i]];
 
         if (SkBenchmark::kGPU_Backend == config.backend) {
-            GrContext* context = gContextFactory.get(config.contextType);
+            GrContext* context = gContextFactory.get(config.contextType, forcedGpuApi);
             if (NULL == context) {
                 SkDebugf("GrContext could not be created for config %s. Config will be skipped.\n",
                     config.name);
                 configs.remove(i);
                 --i;
                 continue;
             }
             if (config.sampleCount > context->getMaxSampleCount()){
                 SkDebugf(
                     "Sample count (%d) for config %s is not supported. Config will be skipped.\n",
@@ skipping 39 matching lines @@
     writer.option("build", "RELEASE");
 #endif
 
     // Set texture cache limits if non-default.
     for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
 #if SK_SUPPORT_GPU
         const Config& config = gConfigs[i];
         if (SkBenchmark::kGPU_Backend != config.backend) {
             continue;
         }
-        GrContext* context = gContextFactory.get(config.contextType);
+        GrContext* context = gContextFactory.get(config.contextType, forcedGpuApi);
         if (NULL == context) {
             continue;
         }
 
         size_t bytes;
         int count;
         context->getResourceCacheLimits(&count, &bytes);
         if (-1 != FLAGS_gpuCacheBytes) {
             bytes = static_cast<size_t>(FLAGS_gpuCacheBytes);
         }
@@ skipping 25 matching lines @@
             const Config& config = gConfigs[configIndex];
 
             if (!bench->isSuitableFor(config.backend)) {
                 continue;
             }
 
             GrContext* context = NULL;
 #if SK_SUPPORT_GPU
             SkGLContextHelper* glContext = NULL;
             if (SkBenchmark::kGPU_Backend == config.backend) {
-                context = gContextFactory.get(config.contextType);
+                context = gContextFactory.get(config.contextType, forcedGpuApi);
                 if (NULL == context) {
                     continue;
                 }
                 glContext = gContextFactory.getGLContext(config.contextType);
             }
 #endif
 
             SkAutoTUnref<SkCanvas> canvas;
             SkAutoTUnref<SkPicture> recordFrom;
             SkPictureRecorder recorderTo;
@@ skipping 212 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