Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

src/effects/SkBicubicImageFilter.cpp

 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBicubicImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
 #include "SkMatrix.h"
 #include "SkRect.h"
 #include "SkUnPreMultiply.h"
 
 #if SK_SUPPORT_GPU
 #include "gl/GrGLEffectMatrix.h"
+#include "gl/GrGLShaderBuilder.h"
 #include "effects/GrSingleTextureEffect.h"
 #include "GrTBackendEffectFactory.h"
 #include "GrContext.h"
 #include "GrTexture.h"
 #include "SkImageFilterUtils.h"
 #endif
 
 SkBicubicImageFilter::SkBicubicImageFilter(const SkSize& scale, const SkScalar coefficients[16], SkImageFilter* input)
   : INHERITED(input),
     fScale(scale) {
@@ skipping 164 matching lines @@
                       const GrDrawEffect&);
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
                           EffectKey,
                           const char* outputColor,
                           const char* inputColor,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
 
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;
 
 private:
-    typedef GrGLUniformManager::UniformHandle        UniformHandle;
-
-    UniformHandle       fCoefficientsUni;
-    UniformHandle       fImageIncrementUni;
+    GrGLUniform* fCoefficientsUni;
+    GrGLUniform* fImageIncrementUni;
 
     GrGLEffectMatrix    fEffectMatrix;
 
     typedef GrGLEffect INHERITED;
 };
 
 GrGLBicubicEffect::GrGLBicubicEffect(const GrBackendEffectFactory& factory,
                                      const GrDrawEffect& drawEffect)
     : INHERITED(factory)
-    , fCoefficientsUni(GrGLUniformManager::kInvalidUniformHandle)
-    , fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle)
+    , fCoefficientsUni(NULL)
+    , fImageIncrementUni(NULL)
     , fEffectMatrix(drawEffect.castEffect<GrBicubicEffect>().coordsType()) {
 }
 
 void GrGLBicubicEffect::emitCode(GrGLShaderBuilder* builder,
                                  const GrDrawEffect&,
                                  EffectKey key,
                                  const char* outputColor,
                                  const char* inputColor,
                                  const TextureSamplerArray& samplers) {
     const char* coords;
     fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, &coords);
-    fCoefficientsUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                           kMat44f_GrSLType, "Coefficients");
-    fImageIncrementUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                             kVec2f_GrSLType, "ImageIncrement");
+    GrGLShaderBuilder::Uniform* coefficientsUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kMat44f_GrSLType, "Coefficients");
+    fCoefficientsUni = coefficientsUni->glUniform();
 
-    const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
-    const char* coeff = builder->getUniformCStr(fCoefficientsUni);
+    GrGLShaderBuilder::Uniform* imageIncrementUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec2f_GrSLType, "ImageIncrement");
+    fImageIncrementUni = imageIncrementUni->glUniform();
+
+    const char* imgInc = imageIncrementUni->c_str();
+    const char* coeff = coefficientsUni->c_str();
 
     SkString cubicBlendName;
 
     static const GrGLShaderVar gCubicBlendArgs[] = {
         GrGLShaderVar("coefficients",  kMat44f_GrSLType),
         GrGLShaderVar("t",             kFloat_GrSLType),
         GrGLShaderVar("c0",            kVec4f_GrSLType),
         GrGLShaderVar("c1",            kVec4f_GrSLType),
         GrGLShaderVar("c2",            kVec4f_GrSLType),
         GrGLShaderVar("c3",            kVec4f_GrSLType),
@@ skipping 26 matching lines @@
 
 GrGLEffect::EffectKey GrGLBicubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
     const GrBicubicEffect& bicubic = drawEffect.castEffect<GrBicubicEffect>();
     EffectKey matrixKey = GrGLEffectMatrix::GenKey(bicubic.getMatrix(),
                                                    drawEffect,
                                                    bicubic.coordsType(),
                                                    bicubic.texture(0));
     return matrixKey;
 }
 
-void GrGLBicubicEffect::setData(const GrGLUniformManager& uman,
+void GrGLBicubicEffect::setData(const GrGLContext& context,
                                 const GrDrawEffect& drawEffect) {
     const GrBicubicEffect& effect = drawEffect.castEffect<GrBicubicEffect>();
     GrTexture& texture = *effect.texture(0);
     float imageIncrement[2];
     imageIncrement[0] = 1.0f / texture.width();
     imageIncrement[1] = 1.0f / texture.height();
-    uman.set2fv(fImageIncrementUni, 0, 1, imageIncrement);
-    uman.setMatrix4f(fCoefficientsUni, effect.coefficients());
-    fEffectMatrix.setData(uman,
+    fImageIncrementUni->set2fv(context, 0, 1, imageIncrement);
+    fCoefficientsUni->setMatrix4f(context, effect.coefficients());
+    fEffectMatrix.setData(context,
                           effect.getMatrix(),
                           drawEffect,
                           effect.texture(0));
 }
 
 GrBicubicEffect::GrBicubicEffect(GrTexture* texture,
                                  const SkScalar coefficients[16])
   : INHERITED(texture, MakeDivByTextureWHMatrix(texture)) {
     for (int y = 0; y < 4; y++) {
         for (int x = 0; x < 4; x++) {
@@ skipping 64 matching lines @@
     GrPaint paint;
     paint.addColorEffect(GrBicubicEffect::Create(srcTexture, fCoefficients))->unref();
     SkRect srcRect;
     srcBM.getBounds(&srcRect);
     context->drawRectToRect(paint, dstRect, srcRect);
     return SkImageFilterUtils::WrapTexture(dst, desc.fWidth, desc.fHeight, result);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////