Move the GrGLGpu config stencil format index into ConfigTable

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 142 matching lines @@
     GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff);
     GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff);
     GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff);
 
     // assertion for gXfermodeCoeff2Blend have to be in GrGpu scope
     GR_STATIC_ASSERT(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gXfermodeCoeff2Blend));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// Used in the map of pixel configs to stencil format indices. This value is used to
-// indicate that a stencil format has not yet been set for the given config.
-static const int kUnknownStencilIndex = -1;
-// This value is used as the stencil index when no stencil configs are supported with the
-// given pixel config.
-static const int kUnsupportedStencilIndex = -2;
-
-///////////////////////////////////////////////////////////////////////////////
 
 GrGpu* GrGLGpu::Create(GrBackendContext backendContext, const GrContextOptions& options,
                        GrContext* context) {
     SkAutoTUnref<const GrGLInterface> glInterface(
         reinterpret_cast<const GrGLInterface*>(backendContext));
     if (!glInterface) {
         glInterface.reset(GrGLDefaultInterface());
     } else {
         glInterface->ref();
     }
@@ skipping 34 matching lines @@
         SkDebugf("------ EXTENSIONS\n");
         this->glContext().extensions().print();
         SkDebugf("\n");
         SkDebugf("%s", this->glCaps().dump().c_str());
     }
 
     fProgramCache = new ProgramCache(this);
 
     SkASSERT(this->glCaps().maxVertexAttributes() >= GrGeometryProcessor::kMaxVertexAttribs);
 
-    for (int i = 0; i < kGrPixelConfigCnt; ++i) {
-        fPixelConfigToStencilIndex[i] = kUnknownStencilIndex;
-    }
     fHWProgramID = 0;
     fTempSrcFBOID = 0;
     fTempDstFBOID = 0;
     fStencilClearFBOID = 0;
 
     if (this->glCaps().shaderCaps()->pathRenderingSupport()) {
         fPathRendering.reset(new GrGLPathRendering(this));
     }
     this->createCopyPrograms();
     fWireRectProgram.fProgram = 0;
@@ skipping 1034 matching lines @@
             format->fTotalBits += format->fStencilBits;
         } else {
             format->fTotalBits = format->fStencilBits;
         }
     }
 }
 }
 
 int GrGLGpu::getCompatibleStencilIndex(GrPixelConfig config) {
     static const int kSize = 16;
-    if (kUnknownStencilIndex == fPixelConfigToStencilIndex[config]) {
+    if (ConfigEntry::kUnknown_StencilIndex == fConfigTable[config].fStencilFormatIndex) {
         // Default to unsupported
-        fPixelConfigToStencilIndex[config] = kUnsupportedStencilIndex;
+        fConfigTable[config].fStencilFormatIndex = ConfigEntry::kUnsupported_StencilFormatIndex;
         // 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 = 0x0; // suppress warning
         GrGLenum externalFormat = 0x0; // suppress warning
         GrGLenum externalType = 0x0;   // suppress warning
         bool useSizedFormat = use_sized_format_for_texture(false, this->ctxInfo(), config);
         if (!this->configToGLFormats(config, useSizedFormat, &internalFormat,
                                      &externalFormat, &externalType)) {
             GL_CALL(DeleteTextures(1, &colorID));
-            fPixelConfigToStencilIndex[config] = kUnsupportedStencilIndex;
-            return kUnsupportedStencilIndex;
+            return ConfigEntry::kUnsupported_StencilFormatIndex;
         }
 
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         GL_ALLOC_CALL(this->glInterface(), TexImage2D(GR_GL_TEXTURE_2D,
                                                       0, internalFormat,
                                                       kSize,
                                                       kSize,
                                                       0,
                                                       externalFormat,
                                                       externalType,
                                                       NULL));
         if (GR_GL_NO_ERROR != GR_GL_GET_ERROR(this->glInterface())) {
             GL_CALL(DeleteTextures(1, &colorID));
-            fPixelConfigToStencilIndex[config] = kUnsupportedStencilIndex;
-            return kUnsupportedStencilIndex;
+            return ConfigEntry::kUnsupported_StencilFormatIndex;
         }
 
         // 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;
@@ skipping 36 matching lines @@
                 if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
                     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 {
-                    fPixelConfigToStencilIndex[config] = i;
+                    fConfigTable[config].fStencilFormatIndex = i;
                     break;
                 }
             }
             sbRBID = 0;
         }
         GL_CALL(DeleteTextures(1, &colorID));
         GL_CALL(DeleteRenderbuffers(1, &sbRBID));
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
         GL_CALL(DeleteFramebuffers(1, &fb));
     }
-    SkASSERT(kUnknownStencilIndex != fPixelConfigToStencilIndex[config]);
-    return fPixelConfigToStencilIndex[config];
+    SkASSERT(ConfigEntry::kUnknown_StencilIndex != fConfigTable[config].fStencilFormatIndex);
+    return fConfigTable[config].fStencilFormatIndex;
 }
 
 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());
 
     int samples = rt->numStencilSamples();
     GrGLStencilAttachment::IDDesc sbDesc;
 
     int sIdx = this->getCompatibleStencilIndex(rt->config());
-    if (sIdx == kUnsupportedStencilIndex) {
+    if (sIdx < 0) {
         return nullptr;
     }
 
     if (!sbDesc.fRenderbufferID) {
         GL_CALL(GenRenderbuffers(1, &sbDesc.fRenderbufferID));
     }
     if (!sbDesc.fRenderbufferID) {
         return nullptr;
     }
     GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER, sbDesc.fRenderbufferID));
@@ skipping 2233 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }