Rename enums in GrContextFactory to remove "GL"

tools/gpu/GrContextFactory.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 "GrContextFactory.h"
 #include "gl/GLTestContext.h"
@@ skipping 56 matching lines @@
     for (Context& context : fContexts) {
         if (context.fGLContext) {
             context.fGLContext->makeCurrent();
             context.fGrContext->releaseResourcesAndAbandonContext();
             delete(context.fGLContext);
             context.fGLContext = nullptr;
         }
     }
 }
 
-GrContextFactory::ContextInfo GrContextFactory::getContextInfo(GLContextType type,
-                                                               GLContextOptions options) {
+#if defined(SK_BUILD_FOR_UNIX) || defined(SK_BUILD_FOR_WIN) || defined(SK_BUILD_FOR_MAC)
+const GrContextFactory::ContextType GrContextFactory::kNativeGL_ContextType =
+    GrContextFactory::kGL_ContextType;
+#else
+const GrContextFactory::ContextType GrContextFactory::kNativeGL_ContextType =
+    GrContextFactory::kGLES_ContextType;
+#endif
+
+GrContextFactory::ContextInfo GrContextFactory::getContextInfo(ContextType type,
+                                                               ContextOptions options) {
     for (int i = 0; i < fContexts.count(); ++i) {
         Context& context = fContexts[i];
         if (!context.fGLContext) {
             continue;
         }
         if (context.fType == type &&
             context.fOptions == options) {
             context.fGLContext->makeCurrent();
             return ContextInfo(context.fGrContext, context.fGLContext);
         }
     }
     SkAutoTDelete<GLTestContext> glCtx;
     SkAutoTUnref<GrContext> grCtx;
     switch (type) {
-        case kNative_GLContextType:
-            glCtx.reset(CreatePlatformGLTestContext(kNone_GrGLStandard));
-            break;
-        case kGL_GLContextType:
+        case kGL_ContextType:
             glCtx.reset(CreatePlatformGLTestContext(kGL_GrGLStandard));
             break;
-        case kGLES_GLContextType:
+        case kGLES_ContextType:
             glCtx.reset(CreatePlatformGLTestContext(kGLES_GrGLStandard));
             break;
 #if SK_ANGLE
 #ifdef SK_BUILD_FOR_WIN
-        case kANGLE_GLContextType:
+        case kANGLE_ContextType:
             glCtx.reset(CreateANGLEDirect3DGLTestContext());
             break;
 #endif
-        case kANGLE_GL_GLContextType:
+        case kANGLE_GL_ContextType:
             glCtx.reset(CreateANGLEOpenGLGLTestContext());
             break;
 #endif
 #if SK_COMMAND_BUFFER
-        case kCommandBuffer_GLContextType:
+        case kCommandBuffer_ContextType:
             glCtx.reset(CommandBufferGLTestContext::Create());
             break;
 #endif
 #if SK_MESA
-        case kMESA_GLContextType:
+        case kMESA_ContextType:
             glCtx.reset(CreateMesaGLTestContext());
             break;
 #endif
-        case kNull_GLContextType:
+        case kNullGL_ContextType:
             glCtx.reset(CreateNullGLTestContext());
             break;
-        case kDebug_GLContextType:
+        case kDebugGL_ContextType:
             glCtx.reset(CreateDebugGLTestContext());
             break;
     }
     if (nullptr == glCtx.get()) {
         return ContextInfo();
     }
 
     SkASSERT(glCtx->isValid());
 
     // Block NVPR from non-NVPR types.
     SkAutoTUnref<const GrGLInterface> glInterface(SkRef(glCtx->gl()));
-    if (!(kEnableNVPR_GLContextOptions & options)) {
+    if (!(kEnableNVPR_ContextOptions & options)) {
         glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface));
         if (!glInterface) {
             return ContextInfo();
         }
     }
 
     glCtx->makeCurrent();
 #ifdef SK_VULKAN
-    if (kEnableNVPR_GLContextOptions & options) {
+    if (kEnableNVPR_ContextOptions & options) {
         return ContextInfo();
     } else {
         GrBackendContext p3dctx = reinterpret_cast<GrBackendContext>(GrVkBackendContext::Create());
         grCtx.reset(GrContext::Create(kVulkan_GrBackend, p3dctx, fGlobalOptions));
     }
 #else
     GrBackendContext p3dctx = reinterpret_cast<GrBackendContext>(glInterface.get());
     grCtx.reset(GrContext::Create(kOpenGL_GrBackend, p3dctx, fGlobalOptions));
 #endif
     if (!grCtx.get()) {
         return ContextInfo();
     }
-    if (kEnableNVPR_GLContextOptions & options) {
+    if (kEnableNVPR_ContextOptions & options) {
         if (!grCtx->caps()->shaderCaps()->pathRenderingSupport()) {
             return ContextInfo();
         }
     }
-    if (kRequireSRGBSupport_GLContextOptions & options) {
+    if (kRequireSRGBSupport_ContextOptions & options) {
         if (!grCtx->caps()->srgbSupport()) {
             return ContextInfo();
         }
     }
 
     Context& context = fContexts.push_back();
     context.fGLContext = glCtx.release();
     context.fGrContext = SkRef(grCtx.get());
     context.fType = type;
     context.fOptions = options;
     return ContextInfo(context.fGrContext, context.fGLContext);
 }
 }  // namespace sk_gpu_test