Support using OpenGL ES context on desktop

gm/gmmain.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.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 49 matching lines @@
 #include "SkGpuDevice.h"
 typedef GrContextFactory::GLContextType GLContextType;
 #define DEFAULT_CACHE_VALUE -1
 static int gGpuCacheSizeBytes;
 static int gGpuCacheSizeCount;
 #else
 class GrContextFactory;
 class GrContext;
 class GrSurface;
 typedef int GLContextType;
+typedef int GrGLStandard;
 #endif
 
 #define DEBUGFAIL_SEE_STDERR SkDEBUGFAIL("see stderr for message")
 
 DECLARE_bool(useDocumentInsteadOfDevice);
 
 #ifdef SK_SUPPORT_PDF
     #include "SkPDFDevice.h"
     #include "SkPDFDocument.h"
 #endif
@@ skipping 1248 matching lines @@
 #endif
 #ifdef SK_BUILD_NATIVE_PDF_RENDERER
     { &SkNativeRasterizePDF,  "native",  true },
 #endif  // SK_BUILD_NATIVE_PDF_RENDERER
     // The following exists so that this array is never zero length.
     { &SkNoRasterizePDF,      "none",    false},
 };
 
 static const char kDefaultsConfigStr[] = "defaults";
 static const char kExcludeConfigChar = '~';
+#if SK_SUPPORT_GPU
+static const char kGpuAPINameGL[] = "gl";
+static const char kGpuAPINameGLES[] = "gles";
+#endif
 
 static SkString configUsage() {
     SkString result;
     result.appendf("Space delimited list of which configs to run. Possible options: [");
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         SkASSERT(gRec[i].fName != kDefaultsConfigStr);
         if (i > 0) {
             result.append("|");
         }
         result.appendf("%s", gRec[i].fName);
@@ skipping 69 matching lines @@
 #define TOSTRING(x) TOSTRING_INTERNAL(x)
 
 // Alphabetized ignoring "no" prefix ("readPath", "noreplay", "resourcePath").
 DEFINE_string(config, "", configUsage().c_str());
 DEFINE_string(pdfRasterizers, "default", pdfRasterizerUsage().c_str());
 DEFINE_bool(deferred, false, "Exercise the deferred rendering test pass.");
 DEFINE_bool(dryRun, false, "Don't actually run the tests, just print what would have been done.");
 DEFINE_string(excludeConfig, "", "Space delimited list of configs to skip.");
 DEFINE_bool(forceBWtext, false, "Disable text anti-aliasing.");
 #if SK_SUPPORT_GPU
+DEFINE_string(gpuAPI, "", "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_string(gpuCacheSize, "", "<bytes> <count>: Limit the gpu cache to byte size or "
               "object count. " TOSTRING(DEFAULT_CACHE_VALUE) " for either value means "
               "use the default. 0 for either disables the cache.");
 #endif
 DEFINE_bool(hierarchy, false, "Whether to use multilevel directory structure "
             "when reading/writing files.");
 DEFINE_string(ignoreErrorTypes, kDefaultIgnorableErrorTypes.asString(" ").c_str(),
               "Space-separated list of ErrorTypes that should be ignored. If any *other* error "
               "types are encountered, the tool will exit with a nonzero return value.");
 DEFINE_string(ignoreFailuresFile, "", "Path to file containing a list of tests for which we "
@@ skipping 257 matching lines @@
  * Run this test in a number of different configs (8888, 565, PDF,
  * etc.), confirming that the resulting bitmaps match expectations
  * (which may be different for each config).
  *
  * Returns all errors encountered while doing so.
  */
 ErrorCombination run_multiple_configs(GMMain &gmmain, GM *gm,
                                       const SkTDArray<size_t> &configs,
                                       const SkTDArray<const PDFRasterizerData*> &pdfRasterizers,
                                       const SkTDArray<SkScalar> &tileGridReplayScales,
-                                      GrContextFactory *grFactory);
+                                      GrContextFactory *grFactory,
+                                      GrGLStandard gpuAPI);
 ErrorCombination run_multiple_configs(GMMain &gmmain, GM *gm,
                                       const SkTDArray<size_t> &configs,
                                       const SkTDArray<const PDFRasterizerData*> &pdfRasterizers,
                                       const SkTDArray<SkScalar> &tileGridReplayScales,
-                                      GrContextFactory *grFactory) {
+                                      GrContextFactory *grFactory,
+                                      GrGLStandard gpuAPI) {
     const char renderModeDescriptor[] = "";
     ErrorCombination errorsForAllConfigs;
     uint32_t gmFlags = gm->getFlags();
 
     for (int i = 0; i < configs.count(); i++) {
         ConfigData config = gRec[configs[i]];
         const SkString shortNamePlusConfig = gmmain.make_shortname_plus_config(gm->getName(),
                                                                                config.fName);
 
         // Skip any tests that we don't even need to try.
@@ skipping 29 matching lines @@
         // Now we know that we want to run this test and record its
         // success or failure.
         ErrorCombination errorsForThisConfig;
         GrSurface* gpuTarget = NULL;
 #if SK_SUPPORT_GPU
         SkAutoTUnref<GrSurface> auGpuTarget;
         if ((errorsForThisConfig.isEmpty()) && (kGPU_Backend == config.fBackend)) {
             if (FLAGS_resetGpuContext) {
                 grFactory->destroyContexts();
             }
-            GrContext* gr = grFactory->get(config.fGLContextType);
+            GrContext* gr = grFactory->get(config.fGLContextType, gpuAPI);
             bool grSuccess = false;
             if (gr) {
                 // create a render target to back the device
                 GrTextureDesc desc;
                 desc.fConfig = kSkia8888_GrPixelConfig;
                 desc.fFlags = kRenderTarget_GrTextureFlagBit;
                 desc.fWidth = gm->getISize().width();
                 desc.fHeight = gm->getISize().height();
                 desc.fSampleCnt = config.fSampleCnt;
                 auGpuTarget.reset(gr->createUncachedTexture(desc, NULL, 0));
@@ skipping 150 matching lines @@
                         return false;
                     }
                 }
             }
         }
     }
     return true;
 }
 
 static bool parse_flags_configs(SkTDArray<size_t>* outConfigs,
-                         GrContextFactory* grFactory) {
+                         GrContextFactory* grFactory, GrGLStandard gpuAPI) {
     SkTDArray<size_t> excludeConfigs;
 
     for (int i = 0; i < FLAGS_config.count(); i++) {
         const char* config = FLAGS_config[i];
         bool exclude = false;
         if (*config == kExcludeConfigChar) {
             exclude = true;
             config += 1;
         }
         int index = findConfig(config);
@@ skipping 46 matching lines @@
             // now assert that there was only one copy in configs[]
             SkASSERT(outConfigs->find(excludeConfigs[i]) < 0);
         }
     }
 
 #if SK_SUPPORT_GPU
     SkASSERT(grFactory != NULL);
     for (int i = 0; i < outConfigs->count(); ++i) {
         size_t index = (*outConfigs)[i];
         if (kGPU_Backend == gRec[index].fBackend) {
-            GrContext* ctx = grFactory->get(gRec[index].fGLContextType);
+            GrContext* ctx = grFactory->get(gRec[index].fGLContextType, gpuAPI);
             if (NULL == ctx) {
                 SkDebugf("GrContext could not be created for config %s. Config will be skipped.\n",
                          gRec[index].fName);
                 outConfigs->remove(i);
                 --i;
                 continue;
             }
             if (gRec[index].fSampleCnt > ctx->getMaxSampleCount()) {
                 SkDebugf("Sample count (%d) of config %s is not supported."
                          " Config will be skipped.\n",
@@ skipping 133 matching lines @@
             return false;
         }
         *sizeBytes = atoi(FLAGS_gpuCacheSize[0]);
         *sizeCount = atoi(FLAGS_gpuCacheSize[1]);
     } else {
         *sizeBytes = DEFAULT_CACHE_VALUE;
         *sizeCount = DEFAULT_CACHE_VALUE;
     }
     return true;
 }
+
+static bool parse_flags_gl_standard(GrGLStandard* gpuAPI) {
+    if (0 == FLAGS_gpuAPI.count()) {
+        *gpuAPI = kNone_GrGLStandard;
+        return true;
+    }
+    if (1 == FLAGS_gpuAPI.count()) {
+        if (FLAGS_gpuAPI.contains(kGpuAPINameGL)) {
+            *gpuAPI = kGL_GrGLStandard;
+            return true;
+        }
+        if (FLAGS_gpuAPI.contains(kGpuAPINameGLES)) {
+            *gpuAPI = kGLES_GrGLStandard;
+            return true;
+        }
+    }
+    SkDebugf("--gpuAPI invalid api value");
+    return false;
+}
 #endif
 
 static bool parse_flags_tile_grid_replay_scales(SkTDArray<SkScalar>* outScales) {
     *outScales->append() = SK_Scalar1; // By default only test at scale 1.0
     if (FLAGS_tileGridReplayScales.count() > 0) {
         outScales->reset();
         for (int i = 0; i < FLAGS_tileGridReplayScales.count(); i++) {
             double val = atof(FLAGS_tileGridReplayScales[i]);
             if (0 < val) {
                 *outScales->append() = SkDoubleToScalar(val);
@@ skipping 70 matching lines @@
     setSystemPreferences();
     GMMain gmmain;
 
     SkTDArray<size_t> configs;
 
     int moduloRemainder = -1;
     int moduloDivisor = -1;
     SkTDArray<const PDFRasterizerData*> pdfRasterizers;
     SkTDArray<SkScalar> tileGridReplayScales;
 #if SK_SUPPORT_GPU
+    GrGLStandard gpuAPI = kNone_GrGLStandard;
     GrContextFactory* grFactory = new GrContextFactory;
 #else
+    GrGLStandard gpuAPI = 0;
     GrContextFactory* grFactory = NULL;
 #endif
 
     if (FLAGS_dryRun) {
         SkDebugf( "Doing a dry run; no tests will actually be executed.\n");
     }
 
     if (!parse_flags_modulo(&moduloRemainder, &moduloDivisor) ||
         !parse_flags_ignore_error_types(&gmmain.fIgnorableErrorTypes) ||
         !parse_flags_ignore_tests(gmmain.fIgnorableTestNames) ||
 #if SK_SUPPORT_GPU
         !parse_flags_gpu_cache(&gGpuCacheSizeBytes, &gGpuCacheSizeCount) ||
+        !parse_flags_gl_standard(&gpuAPI) ||
 #endif
         !parse_flags_tile_grid_replay_scales(&tileGridReplayScales) ||
         !parse_flags_jpeg_quality() ||
-        !parse_flags_configs(&configs, grFactory) ||
+        !parse_flags_configs(&configs, grFactory, gpuAPI) ||
         !parse_flags_pdf_rasterizers(configs, &pdfRasterizers) ||
         !parse_flags_gmmain_paths(&gmmain)) {
         return -1;
     }
 
     if (FLAGS_verbose) {
         if (FLAGS_writePath.count() == 1) {
             SkDebugf("writing to %s\n", FLAGS_writePath[0]);
         }
         if (NULL != gmmain.fMismatchPath) {
@@ skipping 61 matching lines @@
 
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, shortName)) {
             continue;
         }
 
         gmsRun++;
         SkISize size = gm->getISize();
         SkDebugf("%sdrawing... %s [%d %d]\n", moduloStr.c_str(), shortName,
                  size.width(), size.height());
         if (!FLAGS_dryRun)
-            run_multiple_configs(gmmain, gm, configs, pdfRasterizers, tileGridReplayScales, grFactory);
+            run_multiple_configs(gmmain, gm, configs, pdfRasterizers, tileGridReplayScales, 
+                                 grFactory, gpuAPI);
     }
 
     if (FLAGS_dryRun)
         return 0;
 
     SkTArray<SkString> modes;
     gmmain.GetRenderModesEncountered(modes);
     int modeCount = modes.count();
 
     // Now that we have run all the tests and thus know the full set of renderModes that we
@@ skipping 56 matching lines @@
         stream.write(jsonStdString.c_str(), jsonStdString.length());
     }
 
 #if SK_SUPPORT_GPU
 
 #if GR_CACHE_STATS
     for (int i = 0; i < configs.count(); i++) {
         ConfigData config = gRec[configs[i]];
 
         if (FLAGS_verbose && (kGPU_Backend == config.fBackend)) {
-            GrContext* gr = grFactory->get(config.fGLContextType);
+            GrContext* gr = grFactory->get(config.fGLContextType, gpuAPI);
 
             SkDebugf("config: %s %x\n", config.fName, gr);
             gr->printCacheStats();
         }
     }
 #endif
 
 #if GR_DUMP_FONT_CACHE
     for (int i = 0; i < configs.count(); i++) {
         ConfigData config = gRec[configs[i]];
 
         if (kGPU_Backend == config.fBackend) {
-            GrContext* gr = grFactory->get(config.fGLContextType);
+            GrContext* gr = grFactory->get(config.fGLContextType, gpuAPI);
 
            gr->dumpFontCache();
         }
     }
 #endif
 
     delete grFactory;
 #endif
     SkGraphics::Term();
 
     return (reportError) ? -1 : 0;
 }
 
 void GMMain::installFilter(SkCanvas* canvas) {
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #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