Refactor GrGLUniformManager::UniformHandle to initialize itself by default

src/gpu/gl/GrGLShaderBuilder.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 GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
@@ skipping 15 matching lines @@
   manipulate that state.
 */
 class GrGLShaderBuilder {
 public:
     /**
      * Passed to GrGLEffects to add texture reads to their shader code.
      */
     class TextureSampler {
     public:
         TextureSampler()
-            : fConfigComponentMask(0)
-            , fSamplerUniform(GrGLUniformManager::kInvalidUniformHandle) {
+            : fConfigComponentMask(0) {
             // we will memcpy the first 4 bytes from passed in swizzle. This ensures the string is
             // terminated.
             fSwizzle[4] = '\0';
         }
 
         TextureSampler(const TextureSampler& other) { *this = other; }
 
         TextureSampler& operator= (const TextureSampler& other) {
             GrAssert(0 == fConfigComponentMask);
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle == fSamplerUniform);
+            GrAssert(!fSamplerUniform.isValid());
 
             fConfigComponentMask = other.fConfigComponentMask;
             fSamplerUniform = other.fSamplerUniform;
             return *this;
         }
 
         // bitfield of GrColorComponentFlags present in the texture's config.
         uint32_t configComponentMask() const { return fConfigComponentMask; }
 
         const char* swizzle() const { return fSwizzle; }
 
         bool isInitialized() const { return 0 != fConfigComponentMask; }
 
     private:
         // The idx param is used to ensure multiple samplers within a single effect have unique
         // uniform names. swizzle is a four char max string made up of chars 'r', 'g', 'b', and 'a'.
         void init(GrGLShaderBuilder* builder,
                   uint32_t configComponentMask,
                   const char* swizzle,
                   int idx) {
             GrAssert(!this->isInitialized());
             GrAssert(0 != configComponentMask);
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle == fSamplerUniform);
+            GrAssert(!fSamplerUniform.isValid());
 
             GrAssert(NULL != builder);
             SkString name;
             name.printf("Sampler%d", idx);
             fSamplerUniform = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                                   kSampler2D_GrSLType,
                                                   name.c_str());
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle != fSamplerUniform);
+            GrAssert(fSamplerUniform.isValid());
 
             fConfigComponentMask = configComponentMask;
             memcpy(fSwizzle, swizzle, 4);
         }
 
         void init(GrGLShaderBuilder* builder, const GrTextureAccess* access, int idx) {
             GrAssert(NULL != access);
             this->init(builder,
                        GrPixelConfigComponentMask(access->getTexture()->config()),
                        access->getSwizzle(),
@@ skipping 132 matching lines @@
                                                  const char* name,
                                                  const char** outName = NULL) {
         return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
     }
     GrGLUniformManager::UniformHandle addUniformArray(uint32_t visibility,
                                                       GrSLType type,
                                                       const char* name,
                                                       int arrayCount,
                                                       const char** outName = NULL);
 
-    const GrGLShaderVar& getUniformVariable(GrGLUniformManager::UniformHandle) const;
+    const GrGLShaderVar& getUniformVariable(GrGLUniformManager::UniformHandle u) const {
+        return fUniformManager.getBuilderUniform(fUniforms, u).fVariable;
+    }
 
     /**
      * Shortcut for getUniformVariable(u).c_str()
      */
     const char* getUniformCStr(GrGLUniformManager::UniformHandle u) const {
         return this->getUniformVariable(u).c_str();
     }
 
    /** Add a vertex attribute to the current program that is passed in from the vertex data.
        Returns false if the attribute was already there, true otherwise. */
@@ skipping 216 matching lines @@
     bool                                fTopLeftFragPosRead;
 
     SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
     GrGLShaderVar*                      fPositionVar;
     GrGLShaderVar*                      fLocalCoordsVar;
 
 };
 
 #endif