Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

src/gpu/effects/GrTextureDomainEffect.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureDomainEffect.h"
 #include "GrSimpleTextureEffect.h"
 #include "GrTBackendEffectFactory.h"
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLEffectMatrix.h"
 #include "SkFloatingPoint.h"
 
 class GrGLTextureDomainEffect : public GrGLEffect {
 public:
     GrGLTextureDomainEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
 
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
                           EffectKey,
                           const char* outputColor,
                           const char* inputColor,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;
 
     static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
 
 private:
-    GrGLUniformManager::UniformHandle fNameUni;
+    GrGLUniform*      fNameUni;
     GrGLEffectMatrix                  fEffectMatrix;
     GrGLfloat                         fPrevDomain[4];
 
     typedef GrGLEffect INHERITED;
 };
 
 GrGLTextureDomainEffect::GrGLTextureDomainEffect(const GrBackendEffectFactory& factory,
                                                  const GrDrawEffect& drawEffect)
     : INHERITED(factory)
-    , fNameUni(GrGLUniformManager::kInvalidUniformHandle)
+    , fNameUni(NULL)
     , fEffectMatrix(drawEffect.castEffect<GrTextureDomainEffect>().coordsType()) {
     fPrevDomain[0] = SK_FloatNaN;
 }
 
 void GrGLTextureDomainEffect::emitCode(GrGLShaderBuilder* builder,
                                        const GrDrawEffect& drawEffect,
                                        EffectKey key,
                                        const char* outputColor,
                                        const char* inputColor,
                                        const TextureSamplerArray& samplers) {
     const GrTextureDomainEffect& texDom = drawEffect.castEffect<GrTextureDomainEffect>();
 
     const char* coords;
     fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, &coords);
     const char* domain;
     fNameUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                    kVec4f_GrSLType, "TexDom", &domain);
+                                   kVec4f_GrSLType, "TexDom", &domain)->glUniform();
     if (GrTextureDomainEffect::kClamp_WrapMode == texDom.wrapMode()) {
 
         builder->fsCodeAppendf("\tvec2 clampCoord = clamp(%s, %s.xy, %s.zw);\n",
                                 coords, domain, domain);
 
         builder->fsCodeAppendf("\t%s = ", outputColor);
         builder->appendTextureLookupAndModulate(GrGLShaderBuilder::kFragment_ShaderType,
                                                 inputColor,
                                                 samplers[0],
                                                 "clampCoord");
@@ skipping 29 matching lines @@
             builder->fsCodeAppendf("\t%s = any(outside) ? vec4(0.0, 0.0, 0.0, 0.0) : ", outputColor);
             builder->appendTextureLookupAndModulate(GrGLShaderBuilder::kFragment_ShaderType,
                                                     inputColor,
                                                     samplers[0],
                                                     coords);
             builder->fsCodeAppend(";\n");
         }
     }
 }
 
-void GrGLTextureDomainEffect::setData(const GrGLUniformManager& uman,
+void GrGLTextureDomainEffect::setData(const GrGLContext& context,
                                       const GrDrawEffect& drawEffect) {
     const GrTextureDomainEffect& texDom = drawEffect.castEffect<GrTextureDomainEffect>();
     const SkRect& domain = texDom.domain();
 
     float values[4] = {
         SkScalarToFloat(domain.left()),
         SkScalarToFloat(domain.top()),
         SkScalarToFloat(domain.right()),
         SkScalarToFloat(domain.bottom())
     };
     // vertical flip if necessary
     if (kBottomLeft_GrSurfaceOrigin == texDom.texture(0)->origin()) {
         values[1] = 1.0f - values[1];
         values[3] = 1.0f - values[3];
         // The top and bottom were just flipped, so correct the ordering
         // of elements so that values = (l, t, r, b).
         SkTSwap(values[1], values[3]);
     }
     if (0 != memcmp(values, fPrevDomain, 4 * sizeof(GrGLfloat))) {
-        uman.set4fv(fNameUni, 0, 1, values);
+        fNameUni->set4fv(context, 0, 1, values);
         memcpy(fPrevDomain, values, 4 * sizeof(GrGLfloat));
     }
-    fEffectMatrix.setData(uman,
+    fEffectMatrix.setData(context,
                           texDom.getMatrix(),
                           drawEffect,
                           texDom.texture(0));
 }
 
 GrGLEffect::EffectKey GrGLTextureDomainEffect::GenKey(const GrDrawEffect& drawEffect,
                                                       const GrGLCaps&) {
     const GrTextureDomainEffect& texDom = drawEffect.castEffect<GrTextureDomainEffect>();
     EffectKey key = texDom.wrapMode();
     key <<= GrGLEffectMatrix::kKeyBits;
@@ skipping 93 matching lines @@
     const SkMatrix& matrix = GrEffectUnitTest::TestMatrix(random);
     bool bilerp = random->nextBool();
     CoordsType coords = random->nextBool() ? kLocal_CoordsType : kPosition_CoordsType;
     return GrTextureDomainEffect::Create(textures[texIdx],
                                          matrix,
                                          domain,
                                          wrapMode,
                                          bilerp ? GrTextureParams::kBilerp_FilterMode : GrTextureParams::kNone_FilterMode,
                                          coords);
 }