Rename GrGLBinding->GrGLStandard, no longer a bitfield

src/gpu/gl/GrGLCaps.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLCaps.h"
 #include "GrGLContext.h"
@@ skipping 77 matching lines @@
     return *this;
 }
 
 void GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
 
     this->reset();
     if (!ctxInfo.isInitialized()) {
         return;
     }
 
-    GrGLBinding binding = ctxInfo.binding();
+    GrGLStandard standard = ctxInfo.standard();
     GrGLVersion version = ctxInfo.version();
 
     /**************************************************************************
      * Caps specific to GrGLCaps
      **************************************************************************/
 
-    if (kES_GrGLBinding == binding) {
+    if (kGLES_GrGLStandard == standard) {
         GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,
                           &fMaxFragmentUniformVectors);
     } else {
-        SkASSERT(kDesktop_GrGLBinding == binding);
+        SkASSERT(kGL_GrGLStandard == standard);
         GrGLint max;
         GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max);
         fMaxFragmentUniformVectors = max / 4;
         if (version >= GR_GL_VER(3, 2)) {
             GrGLint profileMask;
             GR_GL_GetIntegerv(gli, GR_GL_CONTEXT_PROFILE_MASK, &profileMask);
             fIsCoreProfile = SkToBool(profileMask & GR_GL_CONTEXT_CORE_PROFILE_BIT);
         }
         if (!fIsCoreProfile) {
             fFixedFunctionSupport = true;
             GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_COORDS, &fMaxFixedFunctionTextureCoords);
             // Sanity check
             SkASSERT(fMaxFixedFunctionTextureCoords > 0 && fMaxFixedFunctionTextureCoords < 128);
         }
     }
     GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_ATTRIBS, &fMaxVertexAttributes);
     GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &fMaxFragmentTextureUnits);
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         fRGBA8RenderbufferSupport = true;
     } else {
         fRGBA8RenderbufferSupport = version >= GR_GL_VER(3,0) ||
                                     ctxInfo.hasExtension("GL_OES_rgb8_rgba8") ||
                                     ctxInfo.hasExtension("GL_ARM_rgba8");
     }
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         fBGRAFormatSupport = version >= GR_GL_VER(1,2) ||
                              ctxInfo.hasExtension("GL_EXT_bgra");
     } else {
         if (ctxInfo.hasExtension("GL_APPLE_texture_format_BGRA8888")) {
             fBGRAFormatSupport = true;
         } else if (ctxInfo.hasExtension("GL_EXT_texture_format_BGRA8888")) {
             fBGRAFormatSupport = true;
             fBGRAIsInternalFormat = true;
         }
         SkASSERT(fBGRAFormatSupport ||
                  kSkia8888_GrPixelConfig != kBGRA_8888_GrPixelConfig);
     }
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         fTextureSwizzleSupport = version >= GR_GL_VER(3,3) ||
                                  ctxInfo.hasExtension("GL_ARB_texture_swizzle");
     } else {
         fTextureSwizzleSupport = version >= GR_GL_VER(3,0);
     }
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         fUnpackRowLengthSupport = true;
         fUnpackFlipYSupport = false;
         fPackRowLengthSupport = true;
         fPackFlipYSupport = false;
     } else {
         fUnpackRowLengthSupport = version >= GR_GL_VER(3,0) ||
                                   ctxInfo.hasExtension("GL_EXT_unpack_subimage");
         fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy");
         fPackRowLengthSupport = version >= GR_GL_VER(3,0) ||
                                 ctxInfo.hasExtension("GL_NV_pack_subimage");
         fPackFlipYSupport =
             ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order");
     }
 
-    fTextureUsageSupport = (kES_GrGLBinding == binding) &&
+    fTextureUsageSupport = (kGLES_GrGLStandard == standard) &&
                             ctxInfo.hasExtension("GL_ANGLE_texture_usage");
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         // The EXT version can apply to either GL or GLES.
         fTexStorageSupport = version >= GR_GL_VER(4,2) ||
                              ctxInfo.hasExtension("GL_ARB_texture_storage") ||
                              ctxInfo.hasExtension("GL_EXT_texture_storage");
     } else {
         // Qualcomm Adreno drivers appear to have issues with texture storage.
         fTexStorageSupport = (version >= GR_GL_VER(3,0) &&
                               kQualcomm_GrGLVendor != ctxInfo.vendor()) ||
                              ctxInfo.hasExtension("GL_EXT_texture_storage");
     }
 
     // ARB_texture_rg is part of OpenGL 3.0, but mesa doesn't support it if
     // it doesn't have ARB_texture_rg extension.
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         if (ctxInfo.isMesa()) {
             fTextureRedSupport = ctxInfo.hasExtension("GL_ARB_texture_rg");
         } else {
             fTextureRedSupport = version >= GR_GL_VER(3,0) ||
                                  ctxInfo.hasExtension("GL_ARB_texture_rg");
         }
     } else {
         fTextureRedSupport =  version >= GR_GL_VER(3,0) ||
                               ctxInfo.hasExtension("GL_EXT_texture_rg");
     }
 
-    fImagingSupport = kDesktop_GrGLBinding == binding &&
+    fImagingSupport = kGL_GrGLStandard == standard &&
                       ctxInfo.hasExtension("GL_ARB_imaging");
 
     // ES 2 only guarantees RGBA/uchar + one other format/type combo for
     // ReadPixels. The other format has to checked at run-time since it
     // can change based on which render target is bound
-    fTwoFormatLimit = kES_GrGLBinding == binding;
+    fTwoFormatLimit = kGLES_GrGLStandard == standard;
 
     // Known issue on at least some Intel platforms:
     // http://code.google.com/p/skia/issues/detail?id=946
     if (kIntel_GrGLVendor != ctxInfo.vendor()) {
         fFragCoordsConventionSupport = ctxInfo.glslGeneration() >= k150_GrGLSLGeneration ||
                                        ctxInfo.hasExtension("GL_ARB_fragment_coord_conventions");
     }
 
     // SGX and Mali GPUs that are based on a tiled-deferred architecture that have trouble with
     // frequently changing VBOs. We've measured a performance increase using non-VBO vertex
     // data for dynamic content on these GPUs. Perhaps we should read the renderer string and
     // limit this decision to specific GPU families rather than basing it on the vendor alone.
     if (!GR_GL_MUST_USE_VBO &&
         (kARM_GrGLVendor == ctxInfo.vendor() || kImagination_GrGLVendor == ctxInfo.vendor())) {
         fUseNonVBOVertexAndIndexDynamicData = true;
     }
 
     fDiscardFBSupport = ctxInfo.hasExtension("GL_EXT_discard_framebuffer");
 
     if (kARM_GrGLVendor == ctxInfo.vendor() || kImagination_GrGLVendor == ctxInfo.vendor()) {
         fFullClearIsFree = true;
     }
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) ||
                                     ctxInfo.hasExtension("GL_ARB_vertex_array_object");
     } else {
         fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) ||
                                     ctxInfo.hasExtension("GL_OES_vertex_array_object");
     }
 
-    if (kES_GrGLBinding == binding) {
+    if (kGLES_GrGLStandard == standard) {
         if (ctxInfo.hasExtension("GL_EXT_shader_framebuffer_fetch")) {
             fFBFetchType = kEXT_FBFetchType;
         } else if (ctxInfo.hasExtension("GL_NV_shader_framebuffer_fetch")) {
             fFBFetchType = kNV_FBFetchType;
         }
     }
 
     this->initFSAASupport(ctxInfo, gli);
     this->initStencilFormats(ctxInfo);
 
     /**************************************************************************
      * GrDrawTargetCaps fields
      **************************************************************************/
     GrGLint numFormats;
     GR_GL_GetIntegerv(gli, GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
     if (numFormats) {
         SkAutoSTMalloc<10, GrGLint> formats(numFormats);
         GR_GL_GetIntegerv(gli, GR_GL_COMPRESSED_TEXTURE_FORMATS, formats);
         for (int i = 0; i < numFormats; ++i) {
             if (formats[i] == GR_GL_PALETTE8_RGBA8) {
                 f8BitPaletteSupport = true;
                 break;
             }
         }
     }
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         // we could also look for GL_ATI_separate_stencil extension or
         // GL_EXT_stencil_two_side but they use different function signatures
         // than GL2.0+ (and than each other).
         fTwoSidedStencilSupport = (ctxInfo.version() >= GR_GL_VER(2,0));
         // supported on GL 1.4 and higher or by extension
         fStencilWrapOpsSupport = (ctxInfo.version() >= GR_GL_VER(1,4)) ||
                                   ctxInfo.hasExtension("GL_EXT_stencil_wrap");
     } else {
         // ES 2 has two sided stencil and stencil wrap
         fTwoSidedStencilSupport = true;
         fStencilWrapOpsSupport = true;
     }
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         fBufferLockSupport = true; // we require VBO support and the desktop VBO extension includes
                                    // glMapBuffer.
     } else {
         fBufferLockSupport = ctxInfo.hasExtension("GL_OES_mapbuffer");
     }
 
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         SkASSERT(ctxInfo.version() >= GR_GL_VER(2,0) ||
                  ctxInfo.hasExtension("GL_ARB_texture_non_power_of_two"));
         fNPOTTextureTileSupport = true;
         fMipMapSupport = true;
     } else {
         // Unextended ES2 supports NPOT textures with clamp_to_edge and non-mip filters only
         // ES3 has no limitations.
         fNPOTTextureTileSupport = ctxInfo.version() >= GR_GL_VER(3,0) ||
                                   ctxInfo.hasExtension("GL_OES_texture_npot");
         // ES2 supports MIP mapping for POT textures but our caps don't allow for limited MIP
         // support. The OES extension or ES 3.0 allow for MIPS on NPOT textures. So, apparently,
         // does the undocumented GL_IMG_texture_npot extension. This extension does not seem to
         // to alllow arbitrary wrap modes, however.
         fMipMapSupport = fNPOTTextureTileSupport || ctxInfo.hasExtension("GL_IMG_texture_npot");
     }
 
-    fHWAALineSupport = (kDesktop_GrGLBinding == binding);
+    fHWAALineSupport = (kGL_GrGLStandard == standard);
 
     GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureSize);
     GR_GL_GetIntegerv(gli, GR_GL_MAX_RENDERBUFFER_SIZE, &fMaxRenderTargetSize);
     // Our render targets are always created with textures as the color
     // attachment, hence this min:
     fMaxRenderTargetSize = GrMin(fMaxTextureSize, fMaxRenderTargetSize);
 
     fPathRenderingSupport = GR_GL_USE_NV_PATH_RENDERING &&
                             ctxInfo.hasExtension("GL_NV_path_rendering");
     SkASSERT(!fPathRenderingSupport || fFixedFunctionSupport);
 
     fDstReadInShaderSupport = kNone_FBFetchType != fFBFetchType;
 
     // Disable scratch texture reuse on Mali and Adreno devices
     fReuseScratchTextures = kARM_GrGLVendor != ctxInfo.vendor() &&
                             kQualcomm_GrGLVendor != ctxInfo.vendor();
 
     // Enable supported shader-related caps
-    if (kDesktop_GrGLBinding == binding) {
+    if (kGL_GrGLStandard == standard) {
         fDualSourceBlendingSupport = ctxInfo.version() >= GR_GL_VER(3,3) ||
                                      ctxInfo.hasExtension("GL_ARB_blend_func_extended");
         fShaderDerivativeSupport = true;
         // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS
         fGeometryShaderSupport = ctxInfo.version() >= GR_GL_VER(3,2) &&
                                  ctxInfo.glslGeneration() >= k150_GrGLSLGeneration;
     } else {
         fShaderDerivativeSupport = ctxInfo.hasExtension("GL_OES_standard_derivatives");
     }
 
@@ skipping 34 matching lines @@
 
     // ES 3.0
     // Same as ES 2.0 except R8 and RGBA8 are supported without extensions (the functions called
     // below already account for this).
 
     enum {
         kNo_MSAA = 0,
         kYes_MSAA = 1,
     };
 
-    if (kDesktop_GrGLBinding == ctxInfo.binding()) {
+    if (kGL_GrGLStandard == ctxInfo.standard()) {
         // Post 3.0 we will get R8
         // Prior to 3.0 we will get ALPHA8 (with GL_ARB_framebuffer_object)
         if (ctxInfo.version() >= GR_GL_VER(3,0) ||
             ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {
             fConfigRenderSupport[kAlpha_8_GrPixelConfig][kNo_MSAA] = true;
             fConfigRenderSupport[kAlpha_8_GrPixelConfig][kYes_MSAA] = true;
         }
     } else {
         // On ES we can only hope for R8
         fConfigRenderSupport[kAlpha_8_GrPixelConfig][kNo_MSAA] = fTextureRedSupport;
         fConfigRenderSupport[kAlpha_8_GrPixelConfig][kYes_MSAA] = fTextureRedSupport;
     }
 
-    if (kDesktop_GrGLBinding != ctxInfo.binding()) {
+    if (kGL_GrGLStandard != ctxInfo.standard()) {
         // only available in ES
         fConfigRenderSupport[kRGB_565_GrPixelConfig][kNo_MSAA] = true;
         fConfigRenderSupport[kRGB_565_GrPixelConfig][kYes_MSAA] = true;
     }
 
     // we no longer support 444 as a render target
     fConfigRenderSupport[kRGBA_4444_GrPixelConfig][kNo_MSAA]  = false;
     fConfigRenderSupport[kRGBA_4444_GrPixelConfig][kYes_MSAA]  = false;
 
     if (this->fRGBA8RenderbufferSupport) {
@@ skipping 48 matching lines @@
     GR_GL_GetIntegerv(intf,
                       GR_GL_IMPLEMENTATION_COLOR_READ_TYPE,
                       &otherType);
 
     return (GrGLenum)otherFormat == format && (GrGLenum)otherType == type;
 }
 
 void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
 
     fMSFBOType = kNone_MSFBOType;
-    if (kDesktop_GrGLBinding != ctxInfo.binding()) {
+    if (kGL_GrGLStandard != ctxInfo.standard()) {
         // We prefer the EXT/IMG extension over ES3 MSAA because we've observed
         // ES3 driver bugs on at least one device with a tiled GPU (N10).
         if (ctxInfo.hasExtension("GL_EXT_multisampled_render_to_texture")) {
             fMSFBOType = kES_EXT_MsToTexture_MSFBOType;
         } else if (ctxInfo.hasExtension("GL_IMG_multisampled_render_to_texture")) {
             fMSFBOType = kES_IMG_MsToTexture_MSFBOType;
         } else if (!GR_GL_IGNORE_ES3_MSAA && ctxInfo.version() >= GR_GL_VER(3,0)) {
             fMSFBOType = GrGLCaps::kES_3_0_MSFBOType;
         } else if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {
             // chrome's extension is equivalent to the EXT msaa
@@ skipping 27 matching lines @@
 
     static const StencilFormat
                   // internal Format      stencil bits      total bits        packed?
         gS8    = {GR_GL_STENCIL_INDEX8,   8,                8,                false},
         gS16   = {GR_GL_STENCIL_INDEX16,  16,               16,               false},
         gD24S8 = {GR_GL_DEPTH24_STENCIL8, 8,                32,               true },
         gS4    = {GR_GL_STENCIL_INDEX4,   4,                4,                false},
     //  gS     = {GR_GL_STENCIL_INDEX,    kUnknownBitCount, kUnknownBitCount, false},
         gDS    = {GR_GL_DEPTH_STENCIL,    kUnknownBitCount, kUnknownBitCount, true };
 
-    if (kDesktop_GrGLBinding == ctxInfo.binding()) {
+    if (kGL_GrGLStandard == ctxInfo.standard()) {
         bool supportsPackedDS =
             ctxInfo.version() >= GR_GL_VER(3,0) ||
             ctxInfo.hasExtension("GL_EXT_packed_depth_stencil") ||
             ctxInfo.hasExtension("GL_ARB_framebuffer_object");
 
         // S1 thru S16 formats are in GL 3.0+, EXT_FBO, and ARB_FBO since we
         // require FBO support we can expect these are legal formats and don't
         // check. These also all support the unsized GL_STENCIL_INDEX.
         fStencilFormats.push_back() = gS8;
         fStencilFormats.push_back() = gS16;
@@ skipping 135 matching lines @@
     r.appendf("Two Format Limit: %s\n", (fTwoFormatLimit ? "YES": "NO"));
     r.appendf("Fragment coord conventions support: %s\n",
              (fFragCoordsConventionSupport ? "YES": "NO"));
     r.appendf("Vertex array object support: %s\n", (fVertexArrayObjectSupport ? "YES": "NO"));
     r.appendf("Use non-VBO for dynamic data: %s\n",
              (fUseNonVBOVertexAndIndexDynamicData ? "YES" : "NO"));
     r.appendf("Discard FrameBuffer support: %s\n", (fDiscardFBSupport ? "YES" : "NO"));
     r.appendf("Full screen clear is free: %s\n", (fFullClearIsFree ? "YES" : "NO"));
     return r;
 }