Refactor GrGLUniformManager::UniformHandle to initialize itself by default

src/gpu/gl/GrGLProgram.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 "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 735 matching lines @@
         GL_CALL(DeleteProgram(fProgramID));
         fProgramID = 0;
         return false;
     }
     return true;
 }
 
 void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
     GrGLint texUnitIdx = 0;
-    if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopySamplerUni) {
+    if (fUniformHandles.fDstCopySamplerUni.isValid()) {
         fUniformManager.setSampler(fUniformHandles.fDstCopySamplerUni, texUnitIdx);
         fDstCopyTexUnit = texUnitIdx++;
     }
 
     for (int e = 0; e < fColorEffects.count(); ++e) {
         this->initEffectSamplerUniforms(&fColorEffects[e], &texUnitIdx);
     }
 
     for (int e = 0; e < fCoverageEffects.count(); ++e) {
         this->initEffectSamplerUniforms(&fCoverageEffects[e], &texUnitIdx);
     }
 }
 
 void GrGLProgram::initEffectSamplerUniforms(EffectAndSamplers* effect, int* texUnitIdx) {
     int numSamplers = effect->fSamplerUnis.count();
     effect->fTextureUnits.reset(numSamplers);
     for (int s = 0; s < numSamplers; ++s) {
         UniformHandle handle = effect->fSamplerUnis[s];
-        if (GrGLUniformManager::kInvalidUniformHandle != handle) {
+        if (handle.isValid()) {
             fUniformManager.setSampler(handle, *texUnitIdx);
             effect->fTextureUnits[s] = (*texUnitIdx)++;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLProgram::setEffectData(GrGpuGL* gpu,
                                 const GrEffectStage& stage,
                                 const EffectAndSamplers& effect) {
 
     // Let the GrGLEffect set its data.
     bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
     GrDrawEffect drawEffect(stage, explicitLocalCoords);
     effect.fGLEffect->setData(fUniformManager, drawEffect);
 
     // Bind the texures for the effect.
     int numSamplers = effect.fSamplerUnis.count();
     GrAssert((*stage.getEffect())->numTextures() == numSamplers);
     for (int s = 0; s < numSamplers; ++s) {
         UniformHandle handle = effect.fSamplerUnis[s];
-        if (GrGLUniformManager::kInvalidUniformHandle != handle) {
+        if (handle.isValid()) {
             const GrTextureAccess& access = (*stage.getEffect())->textureAccess(s);
             GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
             int unit = effect.fTextureUnits[s];
             gpu->bindTexture(unit, access.getParams(), texture);
         }
     }
 }
 
 void GrGLProgram::setData(GrGpuGL* gpu,
                           GrDrawState::BlendOptFlags blendOpts,
@@ skipping 14 matching lines @@
     } else {
         color = drawState.getColor();
         coverage = drawState.getCoverage();
     }
 
     this->setColor(drawState, color, sharedState);
     this->setCoverage(drawState, coverage, sharedState);
     this->setMatrixAndRenderTargetHeight(drawState);
 
     // Setup the SkXfermode::Mode-based colorfilter uniform if necessary
-    if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fColorFilterUni &&
+    if (fUniformHandles.fColorFilterUni.isValid() &&
         fColorFilterColor != drawState.getColorFilterColor()) {
         GrGLfloat c[4];
         GrColorToRGBAFloat(drawState.getColorFilterColor(), c);
         fUniformManager.set4fv(fUniformHandles.fColorFilterUni, 0, 1, c);
         fColorFilterColor = drawState.getColorFilterColor();
     }
 
     if (NULL != dstCopy) {
-        if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopyTopLeftUni) {
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopyScaleUni);
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
-                     fUniformHandles.fDstCopySamplerUni);
+        if (fUniformHandles.fDstCopyTopLeftUni.isValid()) {
             fUniformManager.set2f(fUniformHandles.fDstCopyTopLeftUni,
                                   static_cast<GrGLfloat>(dstCopy->offset().fX),
                                   static_cast<GrGLfloat>(dstCopy->offset().fY));
             fUniformManager.set2f(fUniformHandles.fDstCopyScaleUni,
                                   1.f / dstCopy->texture()->width(),
                                   1.f / dstCopy->texture()->height());
             GrGLTexture* texture = static_cast<GrGLTexture*>(dstCopy->texture());
             static GrTextureParams kParams; // the default is clamp, nearest filtering.
             gpu->bindTexture(fDstCopyTexUnit, kParams, texture);
         } else {
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
-                    fUniformHandles.fDstCopyScaleUni);
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
-                    fUniformHandles.fDstCopySamplerUni);
+            GrAssert(!fUniformHandles.fDstCopyScaleUni.isValid());
+            GrAssert(!fUniformHandles.fDstCopySamplerUni.isValid());
         }
     } else {
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyTopLeftUni);
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyScaleUni);
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopySamplerUni);
+        GrAssert(!fUniformHandles.fDstCopyTopLeftUni.isValid());
+        GrAssert(!fUniformHandles.fDstCopyScaleUni.isValid());
+        GrAssert(!fUniformHandles.fDstCopySamplerUni.isValid());
     }
 
     for (int e = 0; e < fColorEffects.count(); ++e) {
         // We may have omitted the GrGLEffect because of the color filter logic in genProgram.
         // This can be removed when the color filter is an effect.
         if (NULL != fColorEffects[e].fGLEffect) {
             this->setEffectData(gpu, *colorStages[e], fColorEffects[e]);
         }
     }
 
@@ skipping 20 matching lines @@
                     GL_CALL(VertexAttrib4fv(header.fColorAttributeIndex, c));
                     sharedState->fConstAttribColor = color;
                     sharedState->fConstAttribColorIndex = header.fColorAttributeIndex;
                 }
                 break;
             case GrGLProgramDesc::kUniform_ColorInput:
                 if (fColor != color) {
                     // OpenGL ES doesn't support unsigned byte varieties of glUniform
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(color, c);
-                    GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
-                             fUniformHandles.fColorUni);
                     fUniformManager.set4fv(fUniformHandles.fColorUni, 0, 1, c);
                     fColor = color;
                 }
                 sharedState->fConstAttribColorIndex = -1;
                 break;
             case GrGLProgramDesc::kSolidWhite_ColorInput:
             case GrGLProgramDesc::kTransBlack_ColorInput:
                 sharedState->fConstAttribColorIndex = -1;
                 break;
             default:
@@ skipping 19 matching lines @@
                     GL_CALL(VertexAttrib4fv(header.fCoverageAttributeIndex, c));
                     sharedState->fConstAttribCoverage = coverage;
                     sharedState->fConstAttribCoverageIndex = header.fCoverageAttributeIndex;
                 }
                 break;
             case GrGLProgramDesc::kUniform_ColorInput:
                 if (fCoverage != coverage) {
                     // OpenGL ES doesn't support unsigned byte varieties of glUniform
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(coverage, c);
-                    GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
-                             fUniformHandles.fCoverageUni);
                     fUniformManager.set4fv(fUniformHandles.fCoverageUni, 0, 1, c);
                     fCoverage = coverage;
                 }
                 sharedState->fConstAttribCoverageIndex = -1;
                 break;
             case GrGLProgramDesc::kSolidWhite_ColorInput:
             case GrGLProgramDesc::kTransBlack_ColorInput:
                 sharedState->fConstAttribCoverageIndex = -1;
                 break;
             default:
                 GrCrash("Unknown coverage type.");
         }
     } else {
         sharedState->fConstAttribCoverageIndex = -1;
     }
 }
 
 void GrGLProgram::setMatrixAndRenderTargetHeight(const GrDrawState& drawState) {
     const GrRenderTarget* rt = drawState.getRenderTarget();
     SkISize size;
     size.set(rt->width(), rt->height());
 
     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
-    if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fRTHeightUni &&
+    if (fUniformHandles.fRTHeightUni.isValid() &&
         fMatrixState.fRenderTargetSize.fHeight != size.fHeight) {
         fUniformManager.set1f(fUniformHandles.fRTHeightUni, SkIntToScalar(size.fHeight));
     }
 
     if (fMatrixState.fRenderTargetOrigin != rt->origin() ||
         !fMatrixState.fViewMatrix.cheapEqualTo(drawState.getViewMatrix()) ||
         fMatrixState.fRenderTargetSize != size) {
         SkMatrix m;
         if (kBottomLeft_GrSurfaceOrigin == rt->origin()) {
             m.setAll(
@@ skipping 19 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }