Fold color attachment verification bit into GrGLCaps::ConfigInfo

src/gpu/gl/GrGLCaps.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrGLCaps_DEFINED
 #define GrGLCaps_DEFINED
@@ skipping 163 matching lines @@
             fConfigTable[config].fStencilFormatIndex = index;
         }
     }
 
     /**
      * Call to note that a color config has been verified as a valid color
      * attachment. This may save future calls to glCheckFramebufferStatus
      * using isConfigVerifiedColorAttachment().
      */
     void markConfigAsValidColorAttachment(GrPixelConfig config) {
-        fVerifiedColorConfigs.markVerified(config);
+        fConfigTable[config].fFlags |= ConfigInfo::kVerifiedColorAttachment_Flag;
     }
 
     /**
      * Call to check whether a config has been verified as a valid color
      * attachment.
      */
     bool isConfigVerifiedColorAttachment(GrPixelConfig config) const {
-        return fVerifiedColorConfigs.isVerified(config);
+        return SkToBool(fConfigTable[config].fFlags & ConfigInfo::kVerifiedColorAttachment_Flag);
     }
 
     /**
      * Reports the type of MSAA FBO support.
      */
     MSFBOType msFBOType() const { return fMSFBOType; }
 
     /**
      * Does the supported MSAA FBO extension have MSAA renderbuffers?
      */
@@ skipping 131 matching lines @@
 
     const GrGLSLCaps* glslCaps() const { return reinterpret_cast<GrGLSLCaps*>(fShaderCaps.get()); }
 
 private:
     void init(const GrContextOptions&, const GrGLContextInfo&, const GrGLInterface*);
     void initGLSL(const GrGLContextInfo&);
     bool hasPathRenderingSupport(const GrGLContextInfo&, const GrGLInterface*);
 
     void onApplyOptionsOverrides(const GrContextOptions& options) override;
 
-    /**
-     * Maintains a bit per GrPixelConfig. It is used to avoid redundantly
-     * performing glCheckFrameBufferStatus for the same config.
-     */
-    struct VerifiedColorConfigs {
-        VerifiedColorConfigs() {
-            this->reset();
-        }
-
-        void reset() {
-            for (int i = 0; i < kNumUints; ++i) {
-                fVerifiedColorConfigs[i] = 0;
-            }
-        }
-
-        static const int kNumUints = (kGrPixelConfigCnt  + 31) / 32;
-        uint32_t fVerifiedColorConfigs[kNumUints];
-
-        void markVerified(GrPixelConfig config) {
-#if !GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT
-                return;
-#endif
-            int u32Idx = config / 32;
-            int bitIdx = config % 32;
-            fVerifiedColorConfigs[u32Idx] |= 1 << bitIdx;
-        }
-
-        bool isVerified(GrPixelConfig config) const {
-#if !GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT
-            return false;
-#endif
-            int u32Idx = config / 32;
-            int bitIdx = config % 32;
-            return SkToBool(fVerifiedColorConfigs[u32Idx] & (1 << bitIdx));
-        }
-    };
-
     void initFSAASupport(const GrGLContextInfo&, const GrGLInterface*);
     void initBlendEqationSupport(const GrGLContextInfo&);
     void initStencilFormats(const GrGLContextInfo&);
     // This must be called after initFSAASupport().
     void initConfigRenderableTable(const GrGLContextInfo&, bool srgbSupport);
     void initConfigTexturableTable(const GrGLContextInfo&, const GrGLInterface*, bool srgbSupport);
 
     bool doReadPixelsSupported(const GrGLInterface* intf, GrGLenum format, GrGLenum type) const;
 
     void initShaderPrecisionTable(const GrGLContextInfo& ctxInfo,
                                   const GrGLInterface* intf,
                                   GrGLSLCaps* glslCaps);
 
     void initConfigSwizzleTable(const GrGLContextInfo& ctxInfo, GrGLSLCaps* glslCaps);
 
     void initConfigTable(const GrGLContextInfo&);
 
-    // tracks configs that have been verified to pass the FBO completeness when
-    // used as a color attachment
-    VerifiedColorConfigs fVerifiedColorConfigs;
-
     SkTArray<StencilFormat, true> fStencilFormats;
 
     int fMaxFragmentUniformVectors;
     int fMaxVertexAttributes;
     int fMaxFragmentTextureUnits;
 
     MSFBOType           fMSFBOType;
     InvalidateFBType    fInvalidateFBType;
     MapBufferType       fMapBufferType;
     TransferBufferType  fTransferBufferType;
@@ skipping 18 matching lines @@
     bool fUseNonVBOVertexAndIndexDynamicData : 1;
     bool fIsCoreProfile : 1;
     bool fBindFragDataLocationSupport : 1;
     bool fSRGBWriteControl : 1;
     bool fRGBA8888PixelsOpsAreSlow : 1;
     bool fPartialFBOReadIsSlow : 1;
     bool fBindUniformLocationSupport : 1;
     bool fExternalTextureSupport : 1;
 
     struct ConfigInfo {
-        ConfigInfo() : fStencilFormatIndex(kUnknown_StencilIndex) {};
+        ConfigInfo() : fStencilFormatIndex(kUnknown_StencilIndex), fFlags(0) {};
 
         ConfigFormats fFormats;
 
-        // Index into GrGLCaps's list of stencil formats. Support is determined experimentally and
-        // lazily.
-        int      fStencilFormatIndex;
-
         enum {
             // This indicates that a stencil format has not yet been determined for the config.
             kUnknown_StencilIndex = -1,
             // This indicates that there is no supported stencil format for the config.
             kUnsupported_StencilFormatIndex = -2
         };
+
+        // Index fStencilFormats.
+        int      fStencilFormatIndex;
+
+        enum {
+            kVerifiedColorAttachment_Flag = 0x1
+        };
+        uint32_t fFlags;
     };
 
     ConfigInfo fConfigTable[kGrPixelConfigCnt];
 
     struct ReadPixelsSupportedFormat {
         GrGLenum fFormat;
         GrGLenum fType;
         GrGLenum fFboFormat;
 
         bool operator==(const ReadPixelsSupportedFormat& rhs) const {
             return fFormat    == rhs.fFormat
                 && fType      == rhs.fType
                 && fFboFormat == rhs.fFboFormat;
         }
     };
     mutable SkTHashMap<ReadPixelsSupportedFormat, bool> fReadPixelsSupportedCache;
 
     typedef GrCaps INHERITED;
 };
 
 #endif