Move config table to GrGLCaps from GrGLGpu.

src/gpu/gl/GrGLGpu.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 "GrGLGpu.h"
 #include "GrGLGLSL.h"
@@ skipping 169 matching lines @@
     return nullptr;
 }
 
 static bool gPrintStartupSpew;
 
 GrGLGpu::GrGLGpu(GrGLContext* ctx, GrContext* context)
     : GrGpu(context)
     , fGLContext(ctx) {
     SkASSERT(ctx);
     fCaps.reset(SkRef(ctx->caps()));
-    this->generateConfigTable();
 
     fHWBoundTextureUniqueIDs.reset(this->glCaps().maxFragmentTextureUnits());
 
     GrGLClearErr(this->glInterface());
     if (gPrintStartupSpew) {
         const GrGLubyte* vendor;
         const GrGLubyte* renderer;
         const GrGLubyte* version;
         GL_CALL_RET(vendor, GetString(GR_GL_VENDOR));
         GL_CALL_RET(renderer, GetString(GR_GL_RENDERER));
@@ skipping 487 matching lines @@
 
     // in case we need a temporary, trimmed copy of the src pixels
 #if defined(GOOGLE3)
     // Stack frame size is limited in GOOGLE3.
     SkAutoSMalloc<64 * 128> tempStorage;
 #else
     SkAutoSMalloc<128 * 128> tempStorage;
 #endif
 
     // Internal format comes from the texture desc.
-    GrGLenum internalFormat = fConfigTable[desc.fConfig].fInternalFormatTexImage;
+    GrGLenum internalFormat = this->glCaps().configGLFormats(desc.fConfig).fInternalFormatTexImage;
 
     // External format and type come from the upload data.
-    GrGLenum externalFormat = fConfigTable[dataConfig].fExternalFormatForTexImage;
-    GrGLenum externalType = fConfigTable[dataConfig].fExternalType;
+    GrGLenum externalFormat = this->glCaps().configGLFormats(desc.fConfig).fExternalFormatForTexImage;

[egdaniel, 2015/12/21 15:10:44]

100 chars, maybe save the ConfigFormat for all these calls

[bsalomon, 2015/12/21 15:59:43]

Actually there is a worse issue here: the second two are supposed to use
dataConfig not desc.fConfig, fixed that (and wrapped the lines).

+    GrGLenum externalType = this->glCaps().configGLFormats(desc.fConfig).fExternalType;
 
     /*
      *  Check whether to allocate a temporary buffer for flipping y or
      *  because our srcData has extra bytes past each row. If so, we need
      *  to trim those off here, since GL ES may not let us specify
      *  GL_UNPACK_ROW_LENGTH.
      */
     bool restoreGLRowLength = false;
     bool swFlipY = false;
     bool glFlipY = false;
@@ skipping 107 matching lines @@
         SkASSERT(height <= desc.fHeight);
     }
 #endif
 
     // Make sure that the width and height that we pass to OpenGL
     // is a multiple of the block size.
     size_t dataSize = GrCompressedFormatDataSize(desc.fConfig, width, height);
 
     // We only need the internal format for compressed 2D textures. There is on
     // sized vs base internal format distinction for compressed textures.
-    GrGLenum internalFormat = fConfigTable[desc.fConfig].fSizedInternalFormat;
+    GrGLenum internalFormat =this->glCaps().configGLFormats(desc.fConfig).fSizedInternalFormat;
 
     if (isNewTexture) {
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         GL_ALLOC_CALL(this->glInterface(),
                       CompressedTexImage2D(target,
                                            0, // level
                                            internalFormat,
                                            width, height,
                                            0, // border
                                            SkToInt(dataSize),
@@ skipping 91 matching lines @@
         GL_CALL(GenFramebuffers(1, &idDesc->fRTFBOID));
         GL_CALL(GenRenderbuffers(1, &idDesc->fMSColorRenderbufferID));
         if (!idDesc->fRTFBOID ||
             !idDesc->fMSColorRenderbufferID) {
             goto FAILED;
         }
         // All ES versions (thus far) require sized internal formats for render buffers.
         // TODO: Always use sized internal format?
         // If this rule gets more complicated, add a field to ConfigEntry rather than logic here.
         colorRenderbufferFormat = kGLES_GrGLStandard == this->glStandard() ?
-                                                fConfigTable[desc.fConfig].fSizedInternalFormat :
-                                                fConfigTable[desc.fConfig].fBaseInternalFormat;
+                            this->glCaps().configGLFormats(desc.fConfig).fSizedInternalFormat :
+                            this->glCaps().configGLFormats(desc.fConfig).fBaseInternalFormat;
     } else {
         idDesc->fRTFBOID = idDesc->fTexFBOID;
     }
 
     // below here we may bind the FBO
     fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
     if (idDesc->fRTFBOID != idDesc->fTexFBOID) {
         SkASSERT(desc.fSampleCnt > 0);
         GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER, idDesc->fMSColorRenderbufferID));
         if (!renderbuffer_storage_msaa(*fGLContext,
@@ skipping 232 matching lines @@
         } else {
             format->fTotalBits = format->fStencilBits;
         }
     }
 }
 }
 
 int GrGLGpu::getCompatibleStencilIndex(GrPixelConfig config) {
     static const int kSize = 16;
     SkASSERT(this->caps()->isConfigRenderable(config, false));
-    if (ConfigEntry::kUnknown_StencilIndex == fConfigTable[config].fStencilFormatIndex) {
-        // Default to unsupported
-        fConfigTable[config].fStencilFormatIndex = ConfigEntry::kUnsupported_StencilFormatIndex;
+    if (!this->glCaps().hasStencilFormatBeenDeterminedForConfig(config)) {
+        // Default to unsupported, set this if we find a stencil format that works.
+        int firstWorkingStencilFormatIndex = -1;
         // Create color texture
         GrGLuint colorID = 0;
         GL_CALL(GenTextures(1, &colorID));
         this->setScratchTextureUnit();
         GL_CALL(BindTexture(GR_GL_TEXTURE_2D, colorID));
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_MAG_FILTER,
                               GR_GL_NEAREST));
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_MIN_FILTER,
                               GR_GL_NEAREST));
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_WRAP_S,
                               GR_GL_CLAMP_TO_EDGE));
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_WRAP_T,
                               GR_GL_CLAMP_TO_EDGE));
 
-        GrGLenum internalFormat = fConfigTable[config].fInternalFormatTexImage;
-        GrGLenum externalFormat = fConfigTable[config].fExternalFormatForTexImage;
-        GrGLenum externalType = fConfigTable[config].fExternalType;
+        const GrGLCaps::ConfigFormats colorFormats = this->glCaps().configGLFormats(config);
 
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         GL_ALLOC_CALL(this->glInterface(), TexImage2D(GR_GL_TEXTURE_2D,
                                                       0,
-                                                      internalFormat,
+                                                      colorFormats.fInternalFormatTexImage,
                                                       kSize,
                                                       kSize,
                                                       0,
-                                                      externalFormat,
-                                                      externalType,
+                                                      colorFormats.fExternalFormatForTexImage,
+                                                      colorFormats.fExternalType,
                                                       NULL));
-        if (GR_GL_NO_ERROR != GR_GL_GET_ERROR(this->glInterface())) {
+        if (GR_GL_NO_ERROR != CHECK_ALLOC_ERROR(this->glInterface())) {
             GL_CALL(DeleteTextures(1, &colorID));
-            return ConfigEntry::kUnsupported_StencilFormatIndex;
+            return -1;
         }
 
         // unbind the texture from the texture unit before binding it to the frame buffer
         GL_CALL(BindTexture(GR_GL_TEXTURE_2D, 0));
 
         // Create Framebuffer
         GrGLuint fb = 0;
         GL_CALL(GenFramebuffers(1, &fb));
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, fb));
         fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
         GL_CALL(FramebufferTexture2D(GR_GL_FRAMEBUFFER,
                                      GR_GL_COLOR_ATTACHMENT0,
                                      GR_GL_TEXTURE_2D,
                                      colorID,
                                      0));
+        GrGLuint sbRBID = 0;
+        GL_CALL(GenRenderbuffers(1, &sbRBID));
 
         // look over formats till I find a compatible one
         int stencilFmtCnt = this->glCaps().stencilFormats().count();
-        GrGLuint sbRBID = 0;
-        for (int i = 0; i < stencilFmtCnt; ++i) {
-            const GrGLCaps::StencilFormat& sFmt = this->glCaps().stencilFormats()[i];
-
-            GL_CALL(GenRenderbuffers(1, &sbRBID));
-            if (!sbRBID) {
-                break;
-            }
+        if (sbRBID) {
             GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER, sbRBID));
-            CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
-            GL_ALLOC_CALL(this->glInterface(), RenderbufferStorage(GR_GL_RENDERBUFFER,
-                                                                   sFmt.fInternalFormat,
-                                                                   kSize, kSize));
-            if (GR_GL_NO_ERROR == GR_GL_GET_ERROR(this->glInterface())) {
-                GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                                GR_GL_STENCIL_ATTACHMENT,
-                                                GR_GL_RENDERBUFFER, sbRBID));
-                if (sFmt.fPacked) {
+            for (int i = 0; i < stencilFmtCnt && sbRBID; ++i) {
+                const GrGLCaps::StencilFormat& sFmt = this->glCaps().stencilFormats()[i];
+                CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
+                GL_ALLOC_CALL(this->glInterface(), RenderbufferStorage(GR_GL_RENDERBUFFER,
+                                                                       sFmt.fInternalFormat,
+                                                                       kSize, kSize));
+                if (GR_GL_NO_ERROR == CHECK_ALLOC_ERROR(this->glInterface())) {
                     GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                                    GR_GL_DEPTH_ATTACHMENT,
+                                                    GR_GL_STENCIL_ATTACHMENT,
                                                     GR_GL_RENDERBUFFER, sbRBID));
-                } else {
-                    GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                                    GR_GL_DEPTH_ATTACHMENT,
-                                                    GR_GL_RENDERBUFFER, 0));
-                }
-                GrGLenum status;
-                GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
-                if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
+                    if (sFmt.fPacked) {
+                        GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
+                                                        GR_GL_DEPTH_ATTACHMENT,
+                                                        GR_GL_RENDERBUFFER, sbRBID));
+                    } else {
+                        GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
+                                                        GR_GL_DEPTH_ATTACHMENT,
+                                                        GR_GL_RENDERBUFFER, 0));
+                    }
+                    GrGLenum status;
+                    GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
+                    if (status == GR_GL_FRAMEBUFFER_COMPLETE) {
+                        firstWorkingStencilFormatIndex = i;
+                        break;
+                    }
                     GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
                                                     GR_GL_STENCIL_ATTACHMENT,
                                                     GR_GL_RENDERBUFFER, 0));
                     if (sFmt.fPacked) {
                         GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
                                                         GR_GL_DEPTH_ATTACHMENT,
                                                         GR_GL_RENDERBUFFER, 0));
                     }
-                } else {
-                    fConfigTable[config].fStencilFormatIndex = i;
-                    break;
                 }
             }
-            sbRBID = 0;
+            GL_CALL(DeleteRenderbuffers(1, &sbRBID));
         }
         GL_CALL(DeleteTextures(1, &colorID));
-        GL_CALL(DeleteRenderbuffers(1, &sbRBID));
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
         GL_CALL(DeleteFramebuffers(1, &fb));
+        fGLContext->caps()->setStencilFormatIndexForConfig(config, firstWorkingStencilFormatIndex);
     }
-    SkASSERT(ConfigEntry::kUnknown_StencilIndex != fConfigTable[config].fStencilFormatIndex);
-    return fConfigTable[config].fStencilFormatIndex;
+    int index;
+    return this->glCaps().getStencilFormatIndexForConfig(config, &index) ? index : -1;

[egdaniel, 2015/12/21 15:10:45]

This seems strange to have getStencilFIFC return a bool only to return -1 here.
Does it make more sense for getStencilFIFC to simply return kUnsupported (since
we assert that it is not unknown in call).

[bsalomon, 2015/12/21 15:59:43]

Agreed it's weird. Done.

 }
 
 GrStencilAttachment* GrGLGpu::createStencilAttachmentForRenderTarget(const GrRenderTarget* rt,
                                                                      int width,
                                                                      int height) {
     // All internally created RTs are also textures. We don't create
     // SBs for a client's standalone RT (that is a RT that isn't also a texture).
     SkASSERT(rt->asTexture());
     SkASSERT(width >= rt->width());
     SkASSERT(height >= rt->height());
@@ skipping 646 matching lines @@
     GrGLRenderTarget* tgt = static_cast<GrGLRenderTarget*>(surface->asRenderTarget());
     if (!tgt) {
         return false;
     }
 
     // OpenGL doesn't do sRGB <-> linear conversions when reading and writing pixels.
     if (GrPixelConfigIsSRGB(surface->config()) != GrPixelConfigIsSRGB(config)) {
         return false;
     }
 
-    GrGLenum format = fConfigTable[config].fExternalFormat;
-    GrGLenum type = fConfigTable[config].fExternalType;
+    GrGLenum format = this->glCaps().configGLFormats(config).fExternalFormat;
+    GrGLenum type = this->glCaps().configGLFormats(config).fExternalType;
     bool flipY = kBottomLeft_GrSurfaceOrigin == surface->origin();
 
     // resolve the render target if necessary
     switch (tgt->getResolveType()) {
         case GrGLRenderTarget::kCantResolve_ResolveType:
             return false;
         case GrGLRenderTarget::kAutoResolves_ResolveType:
             this->flushRenderTarget(tgt, &SkIRect::EmptyIRect());
             break;
         case GrGLRenderTarget::kCanResolve_ResolveType:
@@ skipping 594 matching lines @@
             case GrPipelineBuilder::kBoth_DrawFace:
                 GL_CALL(Disable(GR_GL_CULL_FACE));
                 break;
             default:
                 SkFAIL("Unknown draw face.");
         }
         fHWDrawFace = face;
     }
 }
 
-void GrGLGpu::generateConfigTable() {
-    fConfigTable[kUnknown_GrPixelConfig].fBaseInternalFormat = 0;
-    fConfigTable[kUnknown_GrPixelConfig].fSizedInternalFormat = 0;
-    fConfigTable[kUnknown_GrPixelConfig].fExternalFormat = 0;
-    fConfigTable[kUnknown_GrPixelConfig].fExternalType = 0;
-
-    fConfigTable[kRGBA_8888_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
-    fConfigTable[kRGBA_8888_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA8;
-    fConfigTable[kRGBA_8888_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
-    fConfigTable[kRGBA_8888_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_BYTE;
-
-    if (this->glCaps().bgraIsInternalFormat()) {
-        fConfigTable[kBGRA_8888_GrPixelConfig].fBaseInternalFormat = GR_GL_BGRA;
-        fConfigTable[kBGRA_8888_GrPixelConfig].fSizedInternalFormat = GR_GL_BGRA8;
-    } else {
-        fConfigTable[kBGRA_8888_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
-        fConfigTable[kBGRA_8888_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA8;
-    }
-    fConfigTable[kBGRA_8888_GrPixelConfig].fExternalFormat= GR_GL_BGRA;
-    fConfigTable[kBGRA_8888_GrPixelConfig].fExternalType  = GR_GL_UNSIGNED_BYTE;
-
-
-    fConfigTable[kSRGBA_8888_GrPixelConfig].fBaseInternalFormat = GR_GL_SRGB_ALPHA;
-    fConfigTable[kSRGBA_8888_GrPixelConfig].fSizedInternalFormat = GR_GL_SRGB8_ALPHA8;
-    // GL does not do srgb<->rgb conversions when transferring between cpu and gpu. Thus, the
-    // external format is GL_RGBA. See below for note about ES2.0 and glTex[Sub]Image.
-    fConfigTable[kSRGBA_8888_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
-    fConfigTable[kSRGBA_8888_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_BYTE;
-
-
-    fConfigTable[kRGB_565_GrPixelConfig].fBaseInternalFormat = GR_GL_RGB;
-    if (this->glCaps().ES2CompatibilitySupport()) {
-        fConfigTable[kRGB_565_GrPixelConfig].fSizedInternalFormat = GR_GL_RGB565;
-    } else {
-        fConfigTable[kRGB_565_GrPixelConfig].fSizedInternalFormat = GR_GL_RGB5;
-    }
-    fConfigTable[kRGB_565_GrPixelConfig].fExternalFormat = GR_GL_RGB;
-    fConfigTable[kRGB_565_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_SHORT_5_6_5;
-
-    fConfigTable[kRGBA_4444_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
-    fConfigTable[kRGBA_4444_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA4;
-    fConfigTable[kRGBA_4444_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
-    fConfigTable[kRGBA_4444_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_SHORT_4_4_4_4;
-
-
-    if (this->glCaps().textureRedSupport()) {
-        fConfigTable[kAlpha_8_GrPixelConfig].fBaseInternalFormat = GR_GL_RED;
-        fConfigTable[kAlpha_8_GrPixelConfig].fSizedInternalFormat = GR_GL_R8;
-        fConfigTable[kAlpha_8_GrPixelConfig].fExternalFormat = GR_GL_RED;
-    } else {
-        fConfigTable[kAlpha_8_GrPixelConfig].fBaseInternalFormat = GR_GL_ALPHA;
-        fConfigTable[kAlpha_8_GrPixelConfig].fSizedInternalFormat = GR_GL_ALPHA8;
-        fConfigTable[kAlpha_8_GrPixelConfig].fExternalFormat = GR_GL_ALPHA;
-    }
-    fConfigTable[kAlpha_8_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_BYTE;
-
-    fConfigTable[kRGBA_float_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
-    fConfigTable[kRGBA_float_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA32F;
-    fConfigTable[kRGBA_float_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
-    fConfigTable[kRGBA_float_GrPixelConfig].fExternalType = GR_GL_FLOAT;
-
-    if (this->glCaps().textureRedSupport()) {
-        fConfigTable[kAlpha_half_GrPixelConfig].fBaseInternalFormat = GR_GL_RED;
-        fConfigTable[kAlpha_half_GrPixelConfig].fSizedInternalFormat = GR_GL_R16F;
-        fConfigTable[kAlpha_half_GrPixelConfig].fExternalFormat = GR_GL_RED;
-    } else {
-        fConfigTable[kAlpha_half_GrPixelConfig].fBaseInternalFormat = GR_GL_ALPHA;
-        fConfigTable[kAlpha_half_GrPixelConfig].fSizedInternalFormat = GR_GL_ALPHA16F;
-        fConfigTable[kAlpha_half_GrPixelConfig].fExternalFormat = GR_GL_ALPHA;
-    }
-    if (kGL_GrGLStandard == this->glStandard() || this->glVersion() >= GR_GL_VER(3, 0)) {
-        fConfigTable[kAlpha_half_GrPixelConfig].fExternalType = GR_GL_HALF_FLOAT;
-    } else {
-        fConfigTable[kAlpha_half_GrPixelConfig].fExternalType = GR_GL_HALF_FLOAT_OES;
-    }
-
-    fConfigTable[kRGBA_half_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
-    fConfigTable[kRGBA_half_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA16F;
-    fConfigTable[kRGBA_half_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
-    if (kGL_GrGLStandard == this->glStandard() || this->glVersion() >= GR_GL_VER(3, 0)) {
-        fConfigTable[kRGBA_half_GrPixelConfig].fExternalType = GR_GL_HALF_FLOAT;
-    } else {
-        fConfigTable[kRGBA_half_GrPixelConfig].fExternalType = GR_GL_HALF_FLOAT_OES;
-    }
-
-    // No sized/unsized internal format distinction for compressed formats, no external format.
-
-    fConfigTable[kIndex_8_GrPixelConfig].fBaseInternalFormat = GR_GL_PALETTE8_RGBA8;
-    fConfigTable[kIndex_8_GrPixelConfig].fSizedInternalFormat = GR_GL_PALETTE8_RGBA8;
-    fConfigTable[kIndex_8_GrPixelConfig].fExternalFormat = 0;
-    fConfigTable[kIndex_8_GrPixelConfig].fExternalType = 0;
-
-    switch(this->glCaps().latcAlias()) {
-        case GrGLCaps::kLATC_LATCAlias:
-            fConfigTable[kLATC_GrPixelConfig].fBaseInternalFormat =
-                GR_GL_COMPRESSED_LUMINANCE_LATC1;
-            fConfigTable[kLATC_GrPixelConfig].fSizedInternalFormat =
-                GR_GL_COMPRESSED_LUMINANCE_LATC1;
-            break;
-        case GrGLCaps::kRGTC_LATCAlias:
-            fConfigTable[kLATC_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_RED_RGTC1;
-            fConfigTable[kLATC_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_RED_RGTC1;
-            break;
-        case GrGLCaps::k3DC_LATCAlias:
-            fConfigTable[kLATC_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_3DC_X;
-            fConfigTable[kLATC_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_3DC_X;
-            break;
-    }
-    fConfigTable[kLATC_GrPixelConfig].fExternalFormat = 0;
-    fConfigTable[kLATC_GrPixelConfig].fExternalType = 0;
-
-    fConfigTable[kETC1_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_ETC1_RGB8;
-    fConfigTable[kETC1_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_ETC1_RGB8;
-    fConfigTable[kETC1_GrPixelConfig].fExternalFormat = 0;
-    fConfigTable[kETC1_GrPixelConfig].fExternalType = 0;
-
-    fConfigTable[kR11_EAC_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_R11_EAC;
-    fConfigTable[kR11_EAC_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_R11_EAC;
-    fConfigTable[kR11_EAC_GrPixelConfig].fExternalFormat = 0;
-    fConfigTable[kR11_EAC_GrPixelConfig].fExternalType = 0;
-
-    fConfigTable[kASTC_12x12_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_RGBA_ASTC_12x12;
-    fConfigTable[kASTC_12x12_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_RGBA_ASTC_12x12;
-    fConfigTable[kASTC_12x12_GrPixelConfig].fExternalFormat = 0;
-    fConfigTable[kASTC_12x12_GrPixelConfig].fExternalType = 0;
-
-    // Bulk populate the texture internal/external formats here and then deal with exceptions below.
-
-    // ES 2.0 requires that the internal/external formats match.
-    bool useSizedFormats = (kGL_GrGLStandard == this->glStandard() ||
-                            this->glVersion() >= GR_GL_VER(3,0));
-    for (int i = 0; i < kGrPixelConfigCnt; ++i) {
-        // Almost always we want to pass fExternalFormat as the <format> param to glTex[Sub]Image.
-        fConfigTable[i].fExternalFormatForTexImage = fConfigTable[i].fExternalFormat;
-        fConfigTable[i].fInternalFormatTexImage = useSizedFormats ?
-                                                        fConfigTable[i].fSizedInternalFormat :
-                                                        fConfigTable[i].fBaseInternalFormat;
-    }
-    // OpenGL ES 2.0 + GL_EXT_sRGB allows GL_SRGB_ALPHA to be specified as the <format>
-    // param to Tex(Sub)Image. ES 2.0 requires the <internalFormat> and <format> params to match.
-    // Thus, on ES 2.0 we will use GL_SRGB_ALPHA as the <format> param.
-    // On OpenGL and ES 3.0+ GL_SRGB_ALPHA does not work for the <format> param to glTexImage.
-    if (this->glStandard() == kGLES_GrGLStandard && this->glVersion() == GR_GL_VER(2,0)) {
-        fConfigTable[kSRGBA_8888_GrPixelConfig].fExternalFormatForTexImage = GR_GL_SRGB_ALPHA;
-    }
-
-    // If BGRA is supported as an internal format it must always be specified to glTex[Sub]Image
-    // as a base format.
-    // GL_EXT_texture_format_BGRA8888:
-    //      This extension GL_BGRA as an unsized internal format. However, it is written against ES
-    //      2.0 and therefore doesn't define a value for GL_BGRA8 as ES 2.0 uses unsized internal
-    //      formats.
-    // GL_APPLE_texture_format_BGRA8888: 
-    //     ES 2.0: the extension makes BGRA an external format but not an internal format.
-    //     ES 3.0: the extension explicitly states GL_BGRA8 is not a valid internal format for
-    //             glTexImage (just for glTexStorage).
-    if (useSizedFormats && this->glCaps().bgraIsInternalFormat())  {
-        fConfigTable[kBGRA_8888_GrPixelConfig].fInternalFormatTexImage = GR_GL_BGRA;
-    }
-
-#ifdef SK_DEBUG
-    // Make sure we initialized everything.
-    ConfigEntry defaultEntry;
-    for (int i = 0; i < kGrPixelConfigCnt; ++i) {
-        SkASSERT(defaultEntry.fBaseInternalFormat != fConfigTable[i].fBaseInternalFormat);
-        SkASSERT(defaultEntry.fSizedInternalFormat != fConfigTable[i].fSizedInternalFormat);
-        SkASSERT(defaultEntry.fExternalFormat != fConfigTable[i].fExternalFormat);
-        SkASSERT(defaultEntry.fExternalType != fConfigTable[i].fExternalType);
-    }
-#endif
-}
-
 void GrGLGpu::setTextureUnit(int unit) {
     SkASSERT(unit >= 0 && unit < fHWBoundTextureUniqueIDs.count());
     if (unit != fHWActiveTextureUnitIdx) {
         GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + unit));
         fHWActiveTextureUnitIdx = unit;
     }
 }
 
 void GrGLGpu::setScratchTextureUnit() {
     // Bind the last texture unit since it is the least likely to be used by GrGLProgram.
@@ skipping 674 matching lines @@
     info->fID = 0;
     GL_CALL(GenTextures(1, &info->fID));
     GL_CALL(ActiveTexture(GR_GL_TEXTURE0));
     GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, 1));
     GL_CALL(BindTexture(info->fTarget, info->fID));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_MAG_FILTER, GR_GL_NEAREST));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_MIN_FILTER, GR_GL_NEAREST));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_WRAP_S, GR_GL_CLAMP_TO_EDGE));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_WRAP_T, GR_GL_CLAMP_TO_EDGE));
 
-    GrGLenum internalFormat = fConfigTable[config].fInternalFormatTexImage;
-    GrGLenum externalFormat = fConfigTable[config].fExternalFormatForTexImage;
-    GrGLenum externalType = fConfigTable[config].fExternalType;
+    GrGLenum internalFormat = this->glCaps().configGLFormats(config).fInternalFormatTexImage;
+    GrGLenum externalFormat = this->glCaps().configGLFormats(config).fExternalFormatForTexImage;
+    GrGLenum externalType = this->glCaps().configGLFormats(config).fExternalType;
 
     GL_CALL(TexImage2D(info->fTarget, 0, internalFormat, w, h, 0, externalFormat,
                        externalType, pixels));
 
 #ifdef SK_IGNORE_GL_TEXTURE_TARGET
     GrGLuint id = info->fID;
     delete info;
     return id;
 #else
     return reinterpret_cast<GrBackendObject>(info);
@@ skipping 85 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }