Rename GrGLUniformManager to GrGLProgramResourceManager

src/gpu/effects/GrMatrixConvolutionEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrMatrixConvolutionEffect.h"
 #include "gl/GrGLShaderBuilder.h"
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLTexture.h"
 #include "GrTBackendEffectFactory.h"
 
 class GrGLMatrixConvolutionEffect : public GrGLEffect {
 public:
     GrGLMatrixConvolutionEffect(const GrBackendEffectFactory& factory,
                                 const GrDrawEffect& effect);
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
                           const GrEffectKey&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
 
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramResourceManager&, const GrDrawEffect&) SK_OVERRIDE;
 
 private:
-    typedef GrGLUniformManager::UniformHandle        UniformHandle;
+    typedef GrGLProgramResourceManager::UniformHandle        UniformHandle;
     typedef GrMatrixConvolutionEffect::TileMode TileMode;
     SkISize             fKernelSize;
     TileMode            fTileMode;
     bool                fConvolveAlpha;
 
     UniformHandle       fBoundsUni;
     UniformHandle       fKernelUni;
     UniformHandle       fImageIncrementUni;
     UniformHandle       fKernelOffsetUni;
     UniformHandle       fGainUni;
@@ skipping 109 matching lines @@
 
 void GrGLMatrixConvolutionEffect::GenKey(const GrDrawEffect& drawEffect,
                                          const GrGLCaps&, GrEffectKeyBuilder* b) {
     const GrMatrixConvolutionEffect& m = drawEffect.castEffect<GrMatrixConvolutionEffect>();
     uint32_t key = encodeXY(m.kernelSize().width(), m.kernelSize().height());
     key |= m.tileMode() << 7;
     key |= m.convolveAlpha() ? 1 << 9 : 0;
     b->add32(key);
 }
 
-void GrGLMatrixConvolutionEffect::setData(const GrGLUniformManager& uman,
+void GrGLMatrixConvolutionEffect::setData(const GrGLProgramResourceManager& prman,
                                           const GrDrawEffect& drawEffect) {
     const GrMatrixConvolutionEffect& conv = drawEffect.castEffect<GrMatrixConvolutionEffect>();
     GrTexture& texture = *conv.texture(0);
     // the code we generated was for a specific kernel size
     SkASSERT(conv.kernelSize() == fKernelSize);
     SkASSERT(conv.tileMode() == fTileMode);
     float imageIncrement[2];
     float ySign = texture.origin() == kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
     imageIncrement[0] = 1.0f / texture.width();
     imageIncrement[1] = ySign / texture.height();
-    uman.set2fv(fImageIncrementUni, 1, imageIncrement);
-    uman.set2fv(fKernelOffsetUni, 1, conv.kernelOffset());
-    uman.set1fv(fKernelUni, fKernelSize.width() * fKernelSize.height(), conv.kernel());
-    uman.set1f(fGainUni, conv.gain());
-    uman.set1f(fBiasUni, conv.bias());
+    prman.set2fv(fImageIncrementUni, 1, imageIncrement);
+    prman.set2fv(fKernelOffsetUni, 1, conv.kernelOffset());
+    prman.set1fv(fKernelUni, fKernelSize.width() * fKernelSize.height(), conv.kernel());
+    prman.set1f(fGainUni, conv.gain());
+    prman.set1f(fBiasUni, conv.bias());
     const SkIRect& bounds = conv.bounds();
     float left = (float) bounds.left() / texture.width();
     float top = (float) bounds.top() / texture.height();
     float right = (float) bounds.right() / texture.width();
     float bottom = (float) bounds.bottom() / texture.height();
     if (texture.origin() == kBottomLeft_GrSurfaceOrigin) {
-        uman.set4f(fBoundsUni, left, 1.0f - bottom, right, 1.0f - top);
+        prman.set4f(fBoundsUni, left, 1.0f - bottom, right, 1.0f - top);
     } else {
-        uman.set4f(fBoundsUni, left, top, right, bottom);
+        prman.set4f(fBoundsUni, left, top, right, bottom);
     }
 }
 
 GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrTexture* texture,
                                                      const SkIRect& bounds,
                                                      const SkISize& kernelSize,
                                                      const SkScalar* kernel,
                                                      SkScalar gain,
                                                      SkScalar bias,
                                                      const SkIPoint& kernelOffset,
@@ skipping 64 matching lines @@
     return GrMatrixConvolutionEffect::Create(textures[texIdx],
                                              bounds,
                                              kernelSize,
                                              kernel.get(),
                                              gain,
                                              bias,
                                              kernelOffset,
                                              tileMode,
                                              convolveAlpha);
 }