Rename enums in GrContextFactory to remove "GL"

dm/DMGpuSupport.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef DMGpuSupport_DEFINED
 #define DMGpuSupport_DEFINED
 
@@ skipping 12 matching lines @@
 
 #  include "GrContext.h"
 #  include "GrContextFactory.h"
 
 namespace DM {
 
 static const bool kGPUDisabled = false;
 
 static inline sk_sp<SkSurface> NewGpuSurface(
         sk_gpu_test::GrContextFactory* grFactory,
-        sk_gpu_test::GrContextFactory::GLContextType type,
-        sk_gpu_test::GrContextFactory::GLContextOptions options,
+        sk_gpu_test::GrContextFactory::ContextType type,
+        sk_gpu_test::GrContextFactory::ContextOptions options,
         SkImageInfo info,
         int samples,
         bool useDIText) {
     uint32_t flags = useDIText ? SkSurfaceProps::kUseDeviceIndependentFonts_Flag : 0;
     SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
     return SkSurface::MakeRenderTarget(grFactory->get(type, options), SkBudgeted::kNo,
                                        info, samples, &props);
 }
 
 }  // namespace DM
@@ skipping 14 matching lines @@
     void dumpCacheStats(SkString*) const {}
     void dumpGpuStats(SkString*) const {}
 };
 
 namespace sk_gpu_test {
 class GrContextFactory {
 public:
     GrContextFactory() {};
     explicit GrContextFactory(const GrContextOptions&) {}
 
-    typedef int GLContextType;
+    typedef int ContextType;
 
-    static const GLContextType kANGLE_GLContextType         = 0,
-                               kANGLE_GL_GLContextType      = 0,
-                               kCommandBuffer_GLContextType = 0,
-                               kDebug_GLContextType         = 0,
-                               kMESA_GLContextType          = 0,
-                               kNVPR_GLContextType          = 0,
-                               kNative_GLContextType        = 0,
-                               kNull_GLContextType          = 0;
-    static const int kGLContextTypeCnt = 1;
-    enum GLContextOptions {
-        kNone_GLContextOptions = 0,
-        kEnableNVPR_GLContextOptions = 0x1,
+    static const ContextType kANGLE_ContextType         = 0,
+                             kANGLE_GL_ContextType      = 0,
+                             kCommandBuffer_ContextType = 0,
+                             kDebugGL_ContextType       = 0,
+                             kMESA_ContextType          = 0,
+                             kNVPR_ContextType          = 0,
+                             kNativeGL_ContextType      = 0,
+                             kGL_ContextType            = 0,
+                             kGLES_ContextType          = 0,
+                             kNullGL_ContextType        = 0;
+    static const int kContextTypeCnt = 1;
+    enum ContextOptions {
+        kNone_ContextOptions = 0,
+        kEnableNVPR_ContextOptions = 0x1,
     };
     void destroyContexts() {}
 
     void abandonContexts() {}
 
     void releaseResourcesAndAbandonContexts() {}
 };
 }  // namespace sk_gpu_test
 
 namespace DM {
 
 static const bool kGPUDisabled = true;
 
 static inline SkSurface* NewGpuSurface(sk_gpu_test::GrContextFactory*,
-                                       sk_gpu_test::GrContextFactory::GLContextType,
-                                       sk_gpu_test::GrContextFactory::GLContextOptions,
+                                       sk_gpu_test::GrContextFactory::ContextType,
+                                       sk_gpu_test::GrContextFactory::ContextOptions,
                                        SkImageInfo,
                                        int,
                                        bool) {
     return nullptr;
 }
 
 }  // namespace DM
 
 #endif//SK_SUPPORT_GPU
 
 #endif//DMGpuSupport_DEFINED