diff --git a/gyp/gpu.gyp b/gyp/gpu.gyp
index cff89d3..6792db5 100644
--- a/gyp/gpu.gyp
+++ b/gyp/gpu.gyp
@@ -332,6 +332,9 @@
         '../src/gpu/gl/GrGLTexture.h',
         '../src/gpu/gl/GrGLUtil.cpp',
         '../src/gpu/gl/GrGLUtil.h',
+        '../src/gpu/gl/GrGLUniformManager.cpp',
+        '../src/gpu/gl/GrGLUniformManager.h',
+        '../src/gpu/gl/GrGLUniformHandle.h',
         '../src/gpu/gl/GrGLVertexBuffer.cpp',
         '../src/gpu/gl/GrGLVertexBuffer.h',
         '../src/gpu/gl/GrGpuGL.cpp',
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 99a51d4..21a553d 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -12,16 +12,15 @@
 #include "GrProgramStageFactory.h"
 #include "effects/GrSingleTextureEffect.h"
 #include "gl/GrGLProgramStage.h"
-#include "gl/GrGLSL.h"
 #include "gl/GrGLTexture.h"
 #include "GrCustomStage.h"
 
 class GrGLDiffuseLightingEffect;
 class GrGLSpecularLightingEffect;
 
-// For brevity, and these definitions are likely to move to a different class soon.
-typedef GrGLShaderBuilder::UniformHandle UniformHandle;
-static const UniformHandle kInvalidUniformHandle = GrGLShaderBuilder::kInvalidUniformHandle;
+// For brevity
+typedef GrGLUniformManager::UniformHandle UniformHandle;
+static const UniformHandle kInvalidUniformHandle = GrGLUniformManager::kInvalidUniformHandle;
 
 namespace {
 
@@ -30,19 +29,21 @@
 const SkScalar gOneHalf = SkFloatToScalar(0.5f);
 const SkScalar gOneQuarter = SkFloatToScalar(0.25f);
 
-void setUniformPoint3(const GrGLInterface* gl, GrGLint location, const SkPoint3& point) {
-    float x = SkScalarToFloat(point.fX);
-    float y = SkScalarToFloat(point.fY);
-    float z = SkScalarToFloat(point.fZ);
-    GR_GL_CALL(gl, Uniform3f(location, x, y, z));
+void setUniformPoint3(const GrGLUniformManager& uman, UniformHandle uni, const SkPoint3& point) {
+    GR_STATIC_ASSERT(offsetof(SkPoint3, fX) + sizeof(float) == offsetof(SkPoint3, fY));
+    GR_STATIC_ASSERT(offsetof(SkPoint3, fY) + sizeof(float) == offsetof(SkPoint3, fZ));
+    uman.set3fv(uni, 0, 1, &point.fX);
 }
 
-void setUniformNormal3(const GrGLInterface* gl, GrGLint location, const SkPoint3& point) {
-    setUniformPoint3(gl, location, SkPoint3(point.fX, -point.fY, point.fZ));
+void setUniformNormal3(const GrGLUniformManager& uman, UniformHandle uni, const SkPoint3& point) {
+    setUniformPoint3(uman, uni, SkPoint3(point.fX, -point.fY, point.fZ));
 }
 
-void setUniformPoint3FlipY(const GrGLInterface* gl, GrGLint location, const SkPoint3& point, int height) {
-    setUniformPoint3(gl, location, SkPoint3(point.fX, height-point.fY, point.fZ));
+void setUniformPoint3FlipY(const GrGLUniformManager& uman,
+                           UniformHandle uni,
+                           const SkPoint3& point,
+                           int height) {
+    setUniformPoint3(uman, uni, SkPoint3(point.fX, height-point.fY, point.fZ));
 }
 
 // Shift matrix components to the left, as we advance pixels to the right.
@@ -370,15 +371,13 @@
     virtual void emitLightColor(const GrGLShaderBuilder*,
                                 SkString* out,
                                 const char *surfaceToLight) const;
-    virtual void initUniforms(const GrGLShaderBuilder*, const GrGLInterface* gl, int programID);
-    virtual void setData(const GrGLInterface*, const GrRenderTarget* rt, const SkLight* light) const;
+    virtual void setData(const GrGLUniformManager&, const GrRenderTarget* rt, const SkLight* light) const;
 
 private:
     typedef SkRefCnt INHERITED;
 
 protected:
     UniformHandle fColorUni;
-    int fColorLocation;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -387,18 +386,13 @@
 public:
     virtual ~GrGLDistantLight() {}
     virtual void setupVariables(GrGLShaderBuilder* builder, int stage) SK_OVERRIDE;
-    virtual void initUniforms(const GrGLShaderBuilder*,
-                              const GrGLInterface* gl,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface* gl, const GrRenderTarget* rt, const SkLight* light) const SK_OVERRIDE;
+    virtual void setData(const GrGLUniformManager&, const GrRenderTarget* rt, const SkLight* light) const SK_OVERRIDE;
     virtual void emitSurfaceToLight(const GrGLShaderBuilder*,
                                     SkString* out,
                                     const char* z) const SK_OVERRIDE;
-
 private:
     typedef GrGLLight INHERITED;
     UniformHandle fDirectionUni;
-    int fDirectionLocation;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -407,20 +401,15 @@
 public:
     virtual ~GrGLPointLight() {}
     virtual void setupVariables(GrGLShaderBuilder* builder, int stage) SK_OVERRIDE;
-    virtual void initUniforms(const GrGLShaderBuilder*,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface* gl, const GrRenderTarget* rt, const SkLight* light) const SK_OVERRIDE;
+    virtual void setData(const GrGLUniformManager&, const GrRenderTarget* rt, const SkLight* light) const SK_OVERRIDE;
     virtual void emitVS(SkString* out) const SK_OVERRIDE;
     virtual void emitSurfaceToLight(const GrGLShaderBuilder*,
                                     SkString* out,
                                     const char* z) const SK_OVERRIDE;
-
 private:
     typedef GrGLLight INHERITED;
     SkPoint3 fLocation;
     UniformHandle fLocationUni;
-    int fLocationLocation;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -429,10 +418,7 @@
 public:
     virtual ~GrGLSpotLight() {}
     virtual void setupVariables(GrGLShaderBuilder* builder, int stage) SK_OVERRIDE;
-    virtual void initUniforms(const GrGLShaderBuilder* builder,
-                              const GrGLInterface* gl,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface* gl, const GrRenderTarget* rt, const SkLight* light) const SK_OVERRIDE;
+    virtual void setData(const GrGLUniformManager&, const GrRenderTarget* rt, const SkLight* light) const SK_OVERRIDE;
     virtual void emitVS(SkString* out) const SK_OVERRIDE;
     virtual void emitFuncs(const GrGLShaderBuilder* builder, SkString* out) const;
     virtual void emitSurfaceToLight(const GrGLShaderBuilder* builder,
@@ -446,17 +432,11 @@
     typedef GrGLLight INHERITED;
 
     UniformHandle   fLocationUni;
-    int             fLocationLocation;
     UniformHandle   fExponentUni;
-    int             fExponentLocation;
     UniformHandle   fCosOuterConeAngleUni;
-    int             fCosOuterConeAngleLocation;
     UniformHandle   fCosInnerConeAngleUni;
-    int             fCosInnerConeAngleLocation;
     UniformHandle   fConeScaleUni;
-    int             fConeScaleLocation;
     UniformHandle   fSUni;
-    int             fSLocation;
 };
 
 };
@@ -903,10 +883,7 @@
 
     static inline StageKey GenKey(const GrCustomStage& s);
 
-    virtual void initUniforms(const GrGLShaderBuilder* builder,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface*, 
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE;
@@ -915,9 +892,7 @@
     typedef GrGLProgramStage INHERITED;
 
     UniformHandle   fImageIncrementUni;
-    GrGLint         fImageIncrementLocation;
     UniformHandle   fSurfaceScaleUni;
-    GrGLint         fSurfaceScaleLocation;
     GrGLLight*      fLight;
 };
 
@@ -930,10 +905,7 @@
     virtual void setupVariables(GrGLShaderBuilder* builder,
                                 int stage) SK_OVERRIDE;
     virtual void emitLightFunc(const GrGLShaderBuilder*, SkString* funcs) SK_OVERRIDE;
-    virtual void initUniforms(const GrGLShaderBuilder*,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface*, 
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE;
@@ -942,7 +914,6 @@
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKDUni;
-    GrGLint         fKDLocation;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -954,10 +925,7 @@
     virtual void setupVariables(GrGLShaderBuilder* builder,
                                 int stage) SK_OVERRIDE;
     virtual void emitLightFunc(const GrGLShaderBuilder*, SkString* funcs) SK_OVERRIDE;
-    virtual void initUniforms(const GrGLShaderBuilder*,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface*, 
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE;
@@ -966,9 +934,7 @@
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKSUni;
-    GrGLint         fKSLocation;
     UniformHandle   fShininessUni;
-    GrGLint         fShininessLocation;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1015,9 +981,7 @@
                                        const GrCustomStage& stage)
     : GrGLProgramStage(factory)
     , fImageIncrementUni(kInvalidUniformHandle)
-    , fImageIncrementLocation(0)
-    , fSurfaceScaleUni(kInvalidUniformHandle)
-    , fSurfaceScaleLocation(0) {
+    , fSurfaceScaleUni(kInvalidUniformHandle) {
     const GrLightingEffect& m = static_cast<const GrLightingEffect&>(stage);
     fLight = m.light()->createGLLight();
 }
@@ -1041,17 +1005,6 @@
     fLight->emitVS(&builder->fVSCode);
 }
 
-void GrGLLightingEffect::initUniforms(const GrGLShaderBuilder* builder,
-                                      const GrGLInterface* gl,
-                                      int programID) {
-    const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
-    const char* surfScale = builder->getUniformCStr(fSurfaceScaleUni);
-
-    GR_GL_CALL_RET(gl, fSurfaceScaleLocation, GetUniformLocation(programID, surfScale));
-    GR_GL_CALL_RET(gl, fImageIncrementLocation, GetUniformLocation(programID, imgInc));
-    fLight->initUniforms(builder, gl, programID);
-}
-
 void GrGLLightingEffect::emitFS(GrGLShaderBuilder* builder,
                                 const char* outputColor,
                                 const char* inputColor,
@@ -1103,7 +1056,7 @@
     return static_cast<const GrLightingEffect&>(s).light()->type();
 }
 
-void GrGLLightingEffect::setData(const GrGLInterface* gl,
+void GrGLLightingEffect::setData(const GrGLUniformManager& uman,
                                  const GrCustomStage& data,
                                  const GrRenderTarget* rt,
                                  int stageNum) {
@@ -1111,9 +1064,9 @@
         static_cast<const GrLightingEffect&>(data);
     GrGLTexture* texture = static_cast<GrGLTexture*>(data.texture(0));
     float ySign = texture->orientation() == GrGLTexture::kTopDown_Orientation ? -1.0f : 1.0f;
-    GR_GL_CALL(gl, Uniform2f(fImageIncrementLocation, 1.0f / texture->width(), ySign / texture->height()));
-    GR_GL_CALL(gl, Uniform1f(fSurfaceScaleLocation, effect.surfaceScale()));
-    fLight->setData(gl, rt, effect.light());
+    uman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
+    uman.set1f(fSurfaceScaleUni, effect.surfaceScale());
+    fLight->setData(uman, rt, effect.light());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1123,8 +1076,7 @@
 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrProgramStageFactory& factory,
                                             const GrCustomStage& stage)
     : INHERITED(factory, stage)
-    , fKDUni(kInvalidUniformHandle)
-    , fKDLocation(0) {
+    , fKDUni(kInvalidUniformHandle) {
 }
 
 void GrGLDiffuseLightingEffect::setupVariables(GrGLShaderBuilder* builder, int stage) {
@@ -1133,14 +1085,6 @@
                                  stage);
 }
 
-void GrGLDiffuseLightingEffect::initUniforms(const GrGLShaderBuilder* builder,
-                                             const GrGLInterface* gl,
-                                             int programID) {
-    INHERITED::initUniforms(builder, gl, programID);
-    const char* kd = builder->getUniformCStr(fKDUni);
-    GR_GL_CALL_RET(gl, fKDLocation, GetUniformLocation(programID, kd));
-}
-
 void GrGLDiffuseLightingEffect::emitLightFunc(const GrGLShaderBuilder* builder, SkString* funcs) {
     const char* kd = builder->getUniformCStr(fKDUni);
     funcs->appendf("vec4 light(vec3 normal, vec3 surfaceToLight, vec3 lightColor) {\n");
@@ -1149,14 +1093,14 @@
     funcs->appendf("}\n");
 }
 
-void GrGLDiffuseLightingEffect::setData(const GrGLInterface* gl,
+void GrGLDiffuseLightingEffect::setData(const GrGLUniformManager& uman,
                                         const GrCustomStage& data,
                                         const GrRenderTarget* rt,
                                         int stageNum) {
-    INHERITED::setData(gl, data, rt, stageNum);
+    INHERITED::setData(uman, data, rt, stageNum);
     const GrDiffuseLightingEffect& effect =
         static_cast<const GrDiffuseLightingEffect&>(data);
-    GR_GL_CALL(gl, Uniform1f(fKDLocation, effect.kd()));
+    uman.set1f(fKDUni, effect.kd());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1185,9 +1129,7 @@
                                             const GrCustomStage& stage)
     : GrGLLightingEffect(factory, stage)
     , fKSUni(kInvalidUniformHandle)
-    , fKSLocation(0)
-    , fShininessUni(kInvalidUniformHandle)
-    , fShininessLocation(0) {
+    , fShininessUni(kInvalidUniformHandle) {
 }
 
 void GrGLSpecularLightingEffect::setupVariables(GrGLShaderBuilder* builder, int stage) {
@@ -1198,16 +1140,6 @@
                                         kFloat_GrSLType, "uShininess", stage);
 }
 
-void GrGLSpecularLightingEffect::initUniforms(const GrGLShaderBuilder* builder,
-                                              const GrGLInterface* gl,
-                                              int programID) {
-    INHERITED::initUniforms(builder, gl, programID);
-    const char* ks = builder->getUniformCStr(fKSUni);
-    const char* shininess = builder->getUniformCStr(fShininessUni);
-    GR_GL_CALL_RET(gl, fKSLocation, GetUniformLocation(programID, ks));
-    GR_GL_CALL_RET(gl, fShininessLocation, GetUniformLocation(programID, shininess));
-}
-
 void GrGLSpecularLightingEffect::emitLightFunc(const GrGLShaderBuilder* builder, SkString* funcs) {
     funcs->appendf("vec4 light(vec3 normal, vec3 surfaceToLight, vec3 lightColor) {\n");
     funcs->appendf("\tvec3 halfDir = vec3(normalize(surfaceToLight + vec3(0, 0, 1)));\n");
@@ -1219,15 +1151,14 @@
     funcs->appendf("}\n");
 }
 
-void GrGLSpecularLightingEffect::setData(const GrGLInterface* gl,
+void GrGLSpecularLightingEffect::setData(const GrGLUniformManager& uman,
                                          const GrCustomStage& data,
                                          const GrRenderTarget* rt,
                                          int stageNum) {
-    INHERITED::setData(gl, data, rt, stageNum);
-    const GrSpecularLightingEffect& effect =
-        static_cast<const GrSpecularLightingEffect&>(data);
-    GR_GL_CALL(gl, Uniform1f(fKSLocation, effect.ks()));
-    GR_GL_CALL(gl, Uniform1f(fShininessLocation, effect.shininess()));
+    INHERITED::setData(uman, data, rt, stageNum);
+    const GrSpecularLightingEffect& effect = static_cast<const GrSpecularLightingEffect&>(data);
+    uman.set1f(fKSUni, effect.ks());
+    uman.set1f(fShininessUni, effect.shininess());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1244,15 +1175,10 @@
                                     kVec3f_GrSLType, "uLightColor", stage);
 }
 
-void GrGLLight::initUniforms(const GrGLShaderBuilder* builder,
-                             const GrGLInterface* gl,
-                             int programID) {
-    const char* color = builder->getUniformCStr(fColorUni);
-    GR_GL_CALL_RET(gl, fColorLocation, GetUniformLocation(programID, color));
-}
-
-void GrGLLight::setData(const GrGLInterface* gl, const GrRenderTarget* rt, const SkLight* light) const {
-    setUniformPoint3(gl, fColorLocation, light->color() * SkScalarInvert(SkIntToScalar(255)));
+void GrGLLight::setData(const GrGLUniformManager& uman,
+                        const GrRenderTarget* rt,
+                        const SkLight* light) const {
+    setUniformPoint3(uman, fColorUni, light->color() * SkScalarInvert(SkIntToScalar(255)));
 }
 
 GrGLLight* SkDistantLight::createGLLight() const {
@@ -1267,19 +1193,13 @@
                                         "uLightDirection", stage);
 }
 
-void GrGLDistantLight::initUniforms(const GrGLShaderBuilder* builder,
-                                    const GrGLInterface* gl,
-                                    int programID) {
-    INHERITED::initUniforms(builder, gl, programID);
-    const char* dir = builder->getUniformCStr(fDirectionUni);
-    GR_GL_CALL_RET(gl, fDirectionLocation, GetUniformLocation(programID, dir));
-}
-
-void GrGLDistantLight::setData(const GrGLInterface* gl, const GrRenderTarget* rt, const SkLight* light) const {
-    INHERITED::setData(gl, rt, light);
+void GrGLDistantLight::setData(const GrGLUniformManager& uman,
+                               const GrRenderTarget* rt,
+                               const SkLight* light) const {
+    INHERITED::setData(uman, rt, light);
     SkASSERT(light->type() == SkLight::kDistant_LightType);
     const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(light);
-    setUniformNormal3(gl, fDirectionLocation, distantLight->direction());
+    setUniformNormal3(uman, fDirectionUni, distantLight->direction());
 }
 
 void GrGLDistantLight::emitSurfaceToLight(const GrGLShaderBuilder* builder,
@@ -1297,28 +1217,23 @@
                                        "uLightLocation", stage);
 }
 
-void GrGLPointLight::initUniforms(const GrGLShaderBuilder* builder,
-                                  const GrGLInterface* gl,
-                                  int programID) {
-    INHERITED::initUniforms(builder, gl, programID);
-    const char* loc = builder->getUniformCStr(fLocationUni);
-    GR_GL_CALL_RET(gl, fLocationLocation, GetUniformLocation(programID, loc));
-}
-
-void GrGLPointLight::setData(const GrGLInterface* gl, const GrRenderTarget* rt, const SkLight* light) const {
-    INHERITED::setData(gl, rt, light);
+void GrGLPointLight::setData(const GrGLUniformManager& uman,
+                             const GrRenderTarget* rt,
+                             const SkLight* light) const {
+    INHERITED::setData(uman, rt, light);
     SkASSERT(light->type() == SkLight::kPoint_LightType);
     const SkPointLight* pointLight = static_cast<const SkPointLight*>(light);
-    setUniformPoint3FlipY(gl, fLocationLocation, pointLight->location(), rt->height());
+    setUniformPoint3FlipY(uman, fLocationUni, pointLight->location(), rt->height());
 }
 
 void GrGLPointLight::emitVS(SkString* out) const {
 }
 
-void GrGLPointLight::emitSurfaceToLight(const GrGLShaderBuilder* builder, SkString* out, const char* z) const {
+void GrGLPointLight::emitSurfaceToLight(const GrGLShaderBuilder* builder,
+                                        SkString* out,
+                                        const char* z) const {
     const char* loc = builder->getUniformCStr(fLocationUni);
-    out->appendf(
-        "normalize(%s - vec3(gl_FragCoord.xy, %s))", loc, z);
+    out->appendf("normalize(%s - vec3(gl_FragCoord.xy, %s))", loc, z);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1339,32 +1254,18 @@
                               kVec3f_GrSLType, "uS", stage);
 }
 
-void GrGLSpotLight::initUniforms(const GrGLShaderBuilder* builder, const GrGLInterface* gl, int programID) {
-    INHERITED::initUniforms(builder, gl, programID);
-    const char* location = builder->getUniformCStr(fLocationUni);
-    const char* exponent = builder->getUniformCStr(fExponentUni);
-    const char* cosInner = builder->getUniformCStr(fCosInnerConeAngleUni);
-    const char* cosOuter = builder->getUniformCStr(fCosOuterConeAngleUni);
-    const char* coneScale = builder->getUniformCStr(fConeScaleUni);
-    const char* s = builder->getUniformCStr(fSUni);
-    GR_GL_CALL_RET(gl, fLocationLocation, GetUniformLocation(programID, location));
-    GR_GL_CALL_RET(gl, fExponentLocation, GetUniformLocation(programID, exponent));
-    GR_GL_CALL_RET(gl, fCosInnerConeAngleLocation, GetUniformLocation(programID, cosInner));
-    GR_GL_CALL_RET(gl, fCosOuterConeAngleLocation, GetUniformLocation(programID, cosOuter));
-    GR_GL_CALL_RET(gl, fConeScaleLocation, GetUniformLocation(programID, coneScale));
-    GR_GL_CALL_RET(gl, fSLocation, GetUniformLocation(programID, s));
-}
-
-void GrGLSpotLight::setData(const GrGLInterface* gl, const GrRenderTarget* rt, const SkLight* light) const {
-    INHERITED::setData(gl, rt, light);
+void GrGLSpotLight::setData(const GrGLUniformManager& uman,
+                            const GrRenderTarget* rt,
+                            const SkLight* light) const {
+    INHERITED::setData(uman, rt, light);
     SkASSERT(light->type() == SkLight::kSpot_LightType);
     const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light);
-    setUniformPoint3FlipY(gl, fLocationLocation, spotLight->location(), rt->height());
-    GR_GL_CALL(gl, Uniform1f(fExponentLocation, spotLight->specularExponent()));
-    GR_GL_CALL(gl, Uniform1f(fCosInnerConeAngleLocation, spotLight->cosInnerConeAngle()));
-    GR_GL_CALL(gl, Uniform1f(fCosOuterConeAngleLocation, spotLight->cosOuterConeAngle()));
-    GR_GL_CALL(gl, Uniform1f(fConeScaleLocation, spotLight->coneScale()));
-    setUniformNormal3(gl, fSLocation, spotLight->s());
+    setUniformPoint3FlipY(uman, fLocationUni, spotLight->location(), rt->height());
+    uman.set1f(fExponentUni, spotLight->specularExponent());
+    uman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle());
+    uman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle());
+    uman.set1f(fConeScaleUni, spotLight->coneScale());
+    setUniformNormal3(uman, fSUni, spotLight->s());
 }
 
 void GrGLSpotLight::emitVS(SkString* out) const {
diff --git a/src/gpu/effects/GrColorTableEffect.cpp b/src/gpu/effects/GrColorTableEffect.cpp
index 8ea0dbf..f047a3e 100644
--- a/src/gpu/effects/GrColorTableEffect.cpp
+++ b/src/gpu/effects/GrColorTableEffect.cpp
@@ -26,11 +26,7 @@
                         const char* inputColor,
                         const char* samplerName) SK_OVERRIDE;
 
-    virtual void initUniforms(const GrGLShaderBuilder*,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE {}
-
-    virtual void setData(const GrGLInterface*,
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE {}
diff --git a/src/gpu/effects/GrConvolutionEffect.cpp b/src/gpu/effects/GrConvolutionEffect.cpp
index a16313e..f01caa3 100644
--- a/src/gpu/effects/GrConvolutionEffect.cpp
+++ b/src/gpu/effects/GrConvolutionEffect.cpp
@@ -11,9 +11,9 @@
 #include "gl/GrGLTexture.h"
 #include "GrProgramStageFactory.h"
 
-// For brevity, and these definitions are likely to move to a different class soon.
-typedef GrGLShaderBuilder::UniformHandle UniformHandle;
-static const UniformHandle kInvalidUniformHandle = GrGLShaderBuilder::kInvalidUniformHandle;
+// For brevity
+typedef GrGLUniformManager::UniformHandle UniformHandle;
+static const UniformHandle kInvalidUniformHandle = GrGLUniformManager::kInvalidUniformHandle;
 
 class GrGLConvolutionEffect : public GrGLProgramStage {
 public:
@@ -29,11 +29,7 @@
                         const char* inputColor,
                         const char* samplerName) SK_OVERRIDE;
 
-    virtual void initUniforms(const GrGLShaderBuilder*,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-
-    virtual void setData(const GrGLInterface*,
+    virtual void setData(const GrGLUniformManager& uman,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE;
@@ -45,9 +41,7 @@
 
     int             fRadius;
     UniformHandle   fKernelUni;
-    GrGLint         fKernelLocation;
     UniformHandle   fImageIncrementUni;
-    GrGLint         fImageIncrementLocation;
 
     typedef GrGLProgramStage INHERITED;
 };
@@ -56,9 +50,7 @@
                                              const GrCustomStage& stage)
     : GrGLProgramStage(factory)
     , fKernelUni(kInvalidUniformHandle)
-    , fKernelLocation(0)
-    , fImageIncrementUni(kInvalidUniformHandle)
-    , fImageIncrementLocation(0) {
+    , fImageIncrementUni(kInvalidUniformHandle) {
     const GrConvolutionEffect& c =
         static_cast<const GrConvolutionEffect&>(stage);
     fRadius = c.radius();
@@ -71,9 +63,6 @@
                                              kVec2f_GrSLType, "uImageIncrement", stage);
     fKernelUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                      kFloat_GrSLType, "uKernel", stage, this->width());
-
-    fImageIncrementLocation = kUseUniform;
-    fKernelLocation = kUseUniform;
 }
 
 void GrGLConvolutionEffect::emitVS(GrGLShaderBuilder* builder,
@@ -114,16 +103,7 @@
     }
 }
 
-void GrGLConvolutionEffect::initUniforms(const GrGLShaderBuilder* builder,
-                                         const GrGLInterface* gl,
-                                         int programID) {
-    const char* kernel = builder->getUniformCStr(fKernelUni);
-    const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
-    GR_GL_CALL_RET(gl, fImageIncrementLocation, GetUniformLocation(programID, imgInc));
-    GR_GL_CALL_RET(gl, fKernelLocation, GetUniformLocation(programID, kernel));
-}
-
-void GrGLConvolutionEffect::setData(const GrGLInterface* gl,
+void GrGLConvolutionEffect::setData(const GrGLUniformManager& uman,
                                     const GrCustomStage& data,
                                     const GrRenderTarget*,
                                     int stageNum) {
@@ -143,9 +123,8 @@
         default:
             GrCrash("Unknown filter direction.");
     }
-    GR_GL_CALL(gl, Uniform2fv(fImageIncrementLocation, 1, imageIncrement));
-
-    GR_GL_CALL(gl, Uniform1fv(fKernelLocation, this->width(), conv.kernel()));
+    uman.set2fv(fImageIncrementUni, 0, 1, imageIncrement);
+    uman.set1fv(fKernelUni, 0, this->width(), conv.kernel());
 }
 
 GrGLProgramStage::StageKey GrGLConvolutionEffect::GenKey(
diff --git a/src/gpu/effects/GrGradientEffects.cpp b/src/gpu/effects/GrGradientEffects.cpp
index 34bff09..3769e21 100644
--- a/src/gpu/effects/GrGradientEffects.cpp
+++ b/src/gpu/effects/GrGradientEffects.cpp
@@ -202,9 +202,9 @@
 
 /////////////////////////////////////////////////////////////////////
 
-// For brevity, and these definitions are likely to move to a different class soon.
-typedef GrGLShaderBuilder::UniformHandle UniformHandle;
-static const UniformHandle kInvalidUniformHandle = GrGLShaderBuilder::kInvalidUniformHandle;
+// For brevity
+typedef GrGLUniformManager::UniformHandle UniformHandle;
+static const UniformHandle kInvalidUniformHandle = GrGLUniformManager::kInvalidUniformHandle;
 
 class GrGLRadial2Gradient : public GrGLGradientStage {
 
@@ -222,10 +222,7 @@
                         const char* outputColor,
                         const char* inputColor,
                         const char* samplerName) SK_OVERRIDE;
-    virtual void initUniforms(const GrGLShaderBuilder* builder,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface*,
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE;
@@ -237,9 +234,7 @@
 protected:
 
     UniformHandle   fVSParamUni;
-    GrGLint         fVSParamLocation;
     UniformHandle   fFSParamUni;
-    GrGLint         fFSParamLocation;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
@@ -287,9 +282,6 @@
     fFSParamUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                        kFloat_GrSLType, "uRadial2FSParams", stage, 6);
 
-    fVSParamLocation = GrGLProgramStage::kUseUniform;
-    fFSParamLocation = GrGLProgramStage::kUseUniform;
-
     // For radial gradients without perspective we can pass the linear
     // part of the quadratic as a varying.
     if (builder->fVaryingDims == builder->fCoordDims) {
@@ -385,16 +377,7 @@
     this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
 }
 
-void GrGLRadial2Gradient::initUniforms(const GrGLShaderBuilder* builder,
-                                       const GrGLInterface* gl,
-                                       int programID) {
-    const char* vsParam = builder->getUniformCStr(fVSParamUni);
-    const char* fsParam = builder->getUniformCStr(fFSParamUni);
-    GR_GL_CALL_RET(gl, fVSParamLocation, GetUniformLocation(programID, vsParam));
-    GR_GL_CALL_RET(gl, fFSParamLocation, GetUniformLocation(programID, fsParam));
-}
-
-void GrGLRadial2Gradient::setData(const GrGLInterface* gl,
+void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman,
                                   const GrCustomStage& baseData,
                                   const GrRenderTarget*,
                                   int stageNum) {
@@ -423,8 +406,8 @@
             data.isPosRoot() ? 1.f : -1.f
         };
 
-        GR_GL_CALL(gl, Uniform1fv(fVSParamLocation, 6, values));
-        GR_GL_CALL(gl, Uniform1fv(fFSParamLocation, 6, values));
+        uman.set1fv(fVSParamUni, 0, 6, values);
+        uman.set1fv(fFSParamUni, 0, 6, values);
         fCachedCenter = centerX1;
         fCachedRadius = radius0;
         fCachedPosRoot = data.isPosRoot();
@@ -492,10 +475,7 @@
                         const char* outputColor,
                         const char* inputColor,
                         const char* samplerName) SK_OVERRIDE;
-    virtual void initUniforms(const GrGLShaderBuilder* builder,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface*,
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE;
@@ -713,16 +693,7 @@
     }
 }
 
-void GrGLConical2Gradient::initUniforms(const GrGLShaderBuilder* builder,
-                                        const GrGLInterface* gl,
-                                        int programID) {
-    const char* vsParam = builder->getUniformCStr(fVSParamUni);
-    const char* fsParam = builder->getUniformCStr(fFSParamUni);
-    GR_GL_CALL_RET(gl, fVSParamLocation, GetUniformLocation(programID, vsParam));
-    GR_GL_CALL_RET(gl, fFSParamLocation, GetUniformLocation(programID, fsParam));
-}
-
-void GrGLConical2Gradient::setData(const GrGLInterface* gl,
+void GrGLConical2Gradient::setData(const GrGLUniformManager& uman,
                                    const GrCustomStage& baseData,
                                    const GrRenderTarget*,
                                    int stageNum) {
@@ -753,8 +724,8 @@
             GrScalarToFloat(diffRadius)
         };
 
-        GR_GL_CALL(gl, Uniform1fv(fVSParamLocation, 6, values));
-        GR_GL_CALL(gl, Uniform1fv(fFSParamLocation, 6, values));
+        uman.set1fv(fVSParamUni, 0, 6, values);
+        uman.set1fv(fFSParamUni, 0, 6, values);
         fCachedCenter = centerX1;
         fCachedRadius = radius0;
         fCachedDiffRadius = diffRadius;
diff --git a/src/gpu/effects/GrMorphologyEffect.cpp b/src/gpu/effects/GrMorphologyEffect.cpp
index 6699989..22c986a 100644
--- a/src/gpu/effects/GrMorphologyEffect.cpp
+++ b/src/gpu/effects/GrMorphologyEffect.cpp
@@ -29,10 +29,7 @@
 
     static inline StageKey GenKey(const GrCustomStage& s);
 
-    virtual void initUniforms(const GrGLShaderBuilder*,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-    virtual void setData(const GrGLInterface*,
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE;
@@ -40,10 +37,9 @@
 private:
     int width() const { return GrMorphologyEffect::WidthFromRadius(fRadius); }
 
-    int                                fRadius;
-    GrMorphologyEffect::MorphologyType fType;
-    GrGLShaderBuilder::UniformHandle   fImageIncrementUni;
-    GrGLint                            fImageIncrementLocation;
+    int                                 fRadius;
+    GrMorphologyEffect::MorphologyType  fType;
+    GrGLUniformManager::UniformHandle   fImageIncrementUni;
 
     typedef GrGLProgramStage INHERITED;
 };
@@ -51,8 +47,7 @@
 GrGLMorphologyEffect ::GrGLMorphologyEffect(const GrProgramStageFactory& factory,
                                             const GrCustomStage& stage)
     : GrGLProgramStage(factory)
-    , fImageIncrementUni(GrGLShaderBuilder::kInvalidUniformHandle)
-    , fImageIncrementLocation(0) {
+    , fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle) {
     const GrMorphologyEffect& m = static_cast<const GrMorphologyEffect&>(stage);
     fRadius = m.radius();
     fType = m.type();
@@ -71,13 +66,6 @@
     code->appendf("\t\t%s -= vec2(%d, %d) * %s;\n", vertexCoords, fRadius, fRadius, imgInc);
 }
 
-void GrGLMorphologyEffect::initUniforms(const GrGLShaderBuilder* builder,
-                                        const GrGLInterface* gl,
-                                        int programID) {
-    const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
-    GR_GL_CALL_RET(gl, fImageIncrementLocation, GetUniformLocation(programID, imgInc));
-}
-
 void GrGLMorphologyEffect ::emitFS(GrGLShaderBuilder* builder,
                                    const char* outputColor,
                                    const char* inputColor,
@@ -119,7 +107,7 @@
     return key;
 }
 
-void GrGLMorphologyEffect ::setData(const GrGLInterface* gl,
+void GrGLMorphologyEffect ::setData(const GrGLUniformManager& uman,
                                     const GrCustomStage& data,
                                     const GrRenderTarget*,
                                     int stageNum) {
@@ -140,7 +128,7 @@
         default:
             GrCrash("Unknown filter direction.");
     }
-    GR_GL_CALL(gl, Uniform2fv(fImageIncrementLocation, 1, imageIncrement));
+    uman.set2fv(fImageIncrementUni, 0, 1, imageIncrement);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/effects/GrSingleTextureEffect.cpp b/src/gpu/effects/GrSingleTextureEffect.cpp
index d8b90a1..350d9e6 100644
--- a/src/gpu/effects/GrSingleTextureEffect.cpp
+++ b/src/gpu/effects/GrSingleTextureEffect.cpp
@@ -12,10 +12,6 @@
 #include "GrProgramStageFactory.h"
 #include "GrTexture.h"
 
-// For brevity, and these definitions are likely to move to a different class soon.
-typedef GrGLShaderBuilder::UniformHandle UniformHandle;
-static const UniformHandle kInvalidUniformHandle = GrGLShaderBuilder::kInvalidUniformHandle;
-
 class GrGLSingleTextureEffect : public GrGLProgramStage {
 public:
     GrGLSingleTextureEffect(const GrProgramStageFactory& factory,
diff --git a/src/gpu/effects/GrTextureDomainEffect.cpp b/src/gpu/effects/GrTextureDomainEffect.cpp
index e949c4c..ca8561c 100644
--- a/src/gpu/effects/GrTextureDomainEffect.cpp
+++ b/src/gpu/effects/GrTextureDomainEffect.cpp
@@ -9,10 +9,6 @@
 #include "gl/GrGLProgramStage.h"
 #include "GrProgramStageFactory.h"
 
-// For brevity, and these definitions are likely to move to a different class soon.
-typedef GrGLShaderBuilder::UniformHandle UniformHandle;
-static const UniformHandle kInvalidUniformHandle = GrGLShaderBuilder::kInvalidUniformHandle;
-
 class GrGLTextureDomainEffect : public GrGLProgramStage {
 public:
     GrGLTextureDomainEffect(const GrProgramStageFactory& factory,
@@ -27,11 +23,7 @@
                         const char* inputColor,
                         const char* samplerName) SK_OVERRIDE;
 
-    virtual void initUniforms(const GrGLShaderBuilder* builder,
-                              const GrGLInterface*,
-                              int programID) SK_OVERRIDE;
-
-    virtual void setData(const GrGLInterface*,
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage&,
                          const GrRenderTarget*,
                          int stageNum) SK_OVERRIDE;
@@ -39,8 +31,7 @@
     static inline StageKey GenKey(const GrCustomStage&) { return 0; }
 
 private:
-    UniformHandle fNameUni;
-    int           fNameLocation;
+    GrGLUniformManager::UniformHandle fNameUni;
 
     typedef GrGLProgramStage INHERITED;
 };
@@ -48,15 +39,13 @@
 GrGLTextureDomainEffect::GrGLTextureDomainEffect(const GrProgramStageFactory& factory,
                                                  const GrCustomStage& stage)
     : GrGLProgramStage(factory)
-    , fNameUni(kInvalidUniformHandle)
-    , fNameLocation(0) {
+    , fNameUni(GrGLUniformManager::kInvalidUniformHandle) {
 }
 
 void GrGLTextureDomainEffect::setupVariables(GrGLShaderBuilder* builder,
                                              int stage) {
     fNameUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                    kVec4f_GrSLType, "uTexDom", stage);
-    fNameLocation = kUseUniform;
 };
 
 void GrGLTextureDomainEffect::emitFS(GrGLShaderBuilder* builder,
@@ -75,17 +64,10 @@
     builder->emitDefaultFetch(outputColor, samplerName);
 }
 
-void GrGLTextureDomainEffect::initUniforms(const GrGLShaderBuilder* builder,
-                                           const GrGLInterface* gl, int programID) {
-    GR_GL_CALL_RET(gl, fNameLocation,
-                   GetUniformLocation(programID, builder->getUniformCStr(fNameUni)));
-    GrAssert(kUnusedUniform != fNameLocation);
-}
-
-void GrGLTextureDomainEffect::setData(const GrGLInterface* gl,
-                         const GrCustomStage& data,
-                         const GrRenderTarget*,
-                         int stageNum) {
+void GrGLTextureDomainEffect::setData(const GrGLUniformManager& uman,
+                                      const GrCustomStage& data,
+                                      const GrRenderTarget*,
+                                      int stageNum) {
     const GrTextureDomainEffect& effect = static_cast<const GrTextureDomainEffect&>(data);
     const GrRect& domain = effect.domain();
 
@@ -104,8 +86,7 @@
         // of elements so that values = (l, t, r, b).
         SkTSwap(values[1], values[3]);
     }
-
-    GR_GL_CALL(gl, Uniform4fv(fNameLocation, 1, values));
+    uman.set4fv(fNameUni, 0, 1, values);
 }
 
 
@@ -114,7 +95,6 @@
 GrTextureDomainEffect::GrTextureDomainEffect(GrTexture* texture, GrRect domain)
     : GrSingleTextureEffect(texture)
     , fTextureDomain(domain) {
-
 }
 
 GrTextureDomainEffect::~GrTextureDomainEffect() {
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 8c1f4f7..3a39d0c 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -21,16 +21,6 @@
 #define GL_CALL(X) GR_GL_CALL(fContextInfo.interface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(fContextInfo.interface(), R, X)
 
-namespace {
-
-enum {
-    /// Used to mark a StageUniLocation field that should be bound
-    /// to a uniform during getUniformLocationsAndInitCache().
-    kUseUniform = 2000
-};
-
-}  // namespace
-
 #define PRINT_SHADERS 0
 
 typedef GrGLProgram::Desc::StageDesc StageDesc;
@@ -104,15 +94,27 @@
 
 GrGLProgram::GrGLProgram(const GrGLContextInfo& gl,
                          const Desc& desc,
-                         GrCustomStage** customStages) : fContextInfo(gl) {
+                         GrCustomStage** customStages)
+: fContextInfo(gl)
+, fUniformManager(gl) {
     fDesc = desc;
     fVShaderID = 0;
     fGShaderID = 0;
     fFShaderID = 0;
     fProgramID = 0;
+
+    fViewMatrix = GrMatrix::InvalidMatrix();
+    fViewportSize.set(-1, -1);
+    fColor = GrColor_ILLEGAL;
+    fColorFilterColor = GrColor_ILLEGAL;
+
     for (int s = 0; s < GrDrawState::kNumStages; ++s) {
         fProgramStage[s] = NULL;
+        fTextureMatrices[s] = GrMatrix::InvalidMatrix();
+        // this is arbitrary, just initialize to something
+        fTextureOrientation[s] = GrGLTexture::kBottomUp_Orientation;
     }
+
     this->genProgram(customStages);
 }
 
@@ -399,9 +401,8 @@
             *inColor = fsName;
             } break;
         case GrGLProgram::Desc::kUniform_ColorInput:
-            builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                 kVec4f_GrSLType, COL_UNI_NAME);
-            fUniLocations.fColorUni = kUseUniform;
+            fUniforms.fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                                                      kVec4f_GrSLType, COL_UNI_NAME);
             *inColor = COL_UNI_NAME;
             break;
         case GrGLProgram::Desc::kTransBlack_ColorInput:
@@ -416,9 +417,8 @@
 }
 
 void GrGLProgram::genUniformCoverage(GrGLShaderBuilder* builder, SkString* inOutCoverage) {
-    builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                        kVec4f_GrSLType, COV_UNI_NAME);
-    fUniLocations.fCoverageUni = kUseUniform;
+    fUniforms.fCoverageUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                                                 kVec4f_GrSLType, COV_UNI_NAME);
     if (inOutCoverage->size()) {
         builder->fFSCode.appendf("\tvec4 uniCoverage = %s * %s;\n",
                                   COV_UNI_NAME, inOutCoverage->c_str());
@@ -589,15 +589,12 @@
     return true;
 }
 
-
 bool GrGLProgram::genProgram(GrCustomStage** customStages) {
     GrAssert(0 == fProgramID);
 
-    GrGLShaderBuilder builder(fContextInfo);
+    GrGLShaderBuilder builder(fContextInfo, fUniformManager);
     const uint32_t& layout = fDesc.fVertexLayout;
 
-    fUniLocations.reset();
-
 #if GR_GL_EXPERIMENTAL_GS
     builder.fUsesGS = fDesc.fExperimentalGS;
 #endif
@@ -658,9 +655,8 @@
         builder.fFSOutputs.push_back(colorOutput);
     }
 
-    builder.addUniform(GrGLShaderBuilder::kVertex_ShaderType,
-                       kMat33f_GrSLType, VIEW_MATRIX_NAME);
-    fUniLocations.fViewMatrixUni = kUseUniform;
+    fUniforms.fViewMatrixUni = builder.addUniform(GrGLShaderBuilder::kVertex_ShaderType,
+                                                  kMat33f_GrSLType, VIEW_MATRIX_NAME);
 
     builder.fVSAttrs.push_back().set(kVec2f_GrSLType,
                                      GrGLShaderVar::kAttribute_TypeModifier,
@@ -748,9 +744,8 @@
         }
     }
     if (needColorFilterUniform) {
-        builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                           kVec4f_GrSLType, COL_FILTER_UNI_NAME);
-        fUniLocations.fColorFilterUni = kUseUniform;
+        fUniforms.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                                                       kVec4f_GrSLType, COL_FILTER_UNI_NAME);
     }
     bool wroteFragColorZero = false;
     if (SkXfermode::kZero_Coeff == uniformCoeff &&
@@ -768,12 +763,10 @@
         inColor = "filteredColor";
     }
     if (applyColorMatrix) {
-        builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                           kMat44f_GrSLType, COL_MATRIX_UNI_NAME);
-        builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                           kVec4f_GrSLType, COL_MATRIX_VEC_UNI_NAME);
-        fUniLocations.fColorMatrixUni = kUseUniform;
-        fUniLocations.fColorMatrixVecUni = kUseUniform;
+        fUniforms.fColorMatrixUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                                                       kMat44f_GrSLType, COL_MATRIX_UNI_NAME);
+        fUniforms.fColorMatrixVecUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                                                          kVec4f_GrSLType, COL_MATRIX_VEC_UNI_NAME);
         builder.fFSCode.append("\tvec4 matrixedColor;\n");
         const char* color = adjustInColor(inColor);
         addColorMatrix(&builder.fFSCode, "matrixedColor", color);
@@ -927,7 +920,8 @@
         return false;
     }
 
-    this->getUniformLocationsAndInitCache(builder);
+    builder.finished(fProgramID);
+    this->initSamplerUniforms();
 
     return true;
 }
@@ -993,78 +987,14 @@
     return true;
 }
 
-void GrGLProgram::getUniformLocationsAndInitCache(const GrGLShaderBuilder& builder) {
-
-    if (kUseUniform == fUniLocations.fViewMatrixUni) {
-        GL_CALL_RET(fUniLocations.fViewMatrixUni, GetUniformLocation(fProgramID, VIEW_MATRIX_NAME));
-        GrAssert(kUnusedUniform != fUniLocations.fViewMatrixUni);
-    }
-    if (kUseUniform == fUniLocations.fColorUni) {
-        GL_CALL_RET(fUniLocations.fColorUni, GetUniformLocation(fProgramID, COL_UNI_NAME));
-        GrAssert(kUnusedUniform != fUniLocations.fColorUni);
-    }
-    if (kUseUniform == fUniLocations.fColorFilterUni) {
-        GL_CALL_RET(fUniLocations.fColorFilterUni,
-                    GetUniformLocation(fProgramID, COL_FILTER_UNI_NAME));
-        GrAssert(kUnusedUniform != fUniLocations.fColorFilterUni);
-    }
-
-    if (kUseUniform == fUniLocations.fColorMatrixUni) {
-        GL_CALL_RET(fUniLocations.fColorMatrixUni,
-                    GetUniformLocation(fProgramID, COL_MATRIX_UNI_NAME));
-    }
-
-    if (kUseUniform == fUniLocations.fColorMatrixVecUni) {
-        GL_CALL_RET(fUniLocations.fColorMatrixVecUni,
-                    GetUniformLocation(fProgramID, COL_MATRIX_VEC_UNI_NAME));
-    }
-
-    if (kUseUniform == fUniLocations.fCoverageUni) {
-        GL_CALL_RET(fUniLocations.fCoverageUni,GetUniformLocation(fProgramID, COV_UNI_NAME));
-        GrAssert(kUnusedUniform != fUniLocations.fCoverageUni);
-    }
-
-    for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        StageUniLocations& locations = fUniLocations.fStages[s];
-        if (fDesc.fStages[s].isEnabled()) {
-            if (kUseUniform == locations.fTextureMatrixUni) {
-                SkString texMName;
-                tex_matrix_name(s, &texMName);
-                GL_CALL_RET(locations.fTextureMatrixUni,
-                            GetUniformLocation(fProgramID, texMName.c_str()));
-                //color filter table effect does not consumer coords gen'ed by matrix.
-                //GrAssert(kUnusedUniform != locations.fTextureMatrixUni);
-            }
-
-            if (kUseUniform == locations.fSamplerUni) {
-                SkString samplerName;
-                sampler_name(s, &samplerName);
-                GL_CALL_RET(locations.fSamplerUni,
-                            GetUniformLocation(fProgramID,samplerName.c_str()));
-                GrAssert(kUnusedUniform != locations.fSamplerUni);
-            }
-
-            if (NULL != fProgramStage[s]) {
-                fProgramStage[s]->initUniforms(&builder, fContextInfo.interface(), fProgramID);
-            }
-        }
-    }
+void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
-
     // init sampler unis and set bogus values for state tracking
     for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        if (kUnusedUniform != fUniLocations.fStages[s].fSamplerUni) {
-            GL_CALL(Uniform1i(fUniLocations.fStages[s].fSamplerUni, s));
+        if (GrGLUniformManager::kInvalidUniformHandle != fUniforms.fStages[s].fSamplerUni) {
+            fUniformManager.setSampler(fUniforms.fStages[s].fSamplerUni, s);
         }
-        fTextureMatrices[s] = GrMatrix::InvalidMatrix();
-        // this is arbitrary, just initialize to something
-        fTextureOrientation[s] = GrGLTexture::kBottomUp_Orientation;
-        // Must not reset fStageOverride[] here.
     }
-    fViewMatrix = GrMatrix::InvalidMatrix();
-    fViewportSize.set(-1, -1);
-    fColor = GrColor_ILLEGAL;
-    fColorFilterColor = GrColor_ILLEGAL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1078,7 +1008,7 @@
     GrAssert(stageNum >= 0 && stageNum <= GrDrawState::kNumStages);
 
     const GrGLProgram::StageDesc& desc = fDesc.fStages[stageNum];
-    StageUniLocations& locations = fUniLocations.fStages[stageNum];
+    StageUniforms& uniforms = fUniforms.fStages[stageNum];
     GrGLProgramStage* customStage = fProgramStage[stageNum];
 
     GrAssert((desc.fInConfigFlags & StageDesc::kInConfigBitMask) == desc.fInConfigFlags);
@@ -1093,13 +1023,11 @@
     } else {
         SkString texMatName;
         tex_matrix_name(stageNum, &texMatName);
-        GrGLShaderBuilder::UniformHandle m =
-            segments->addUniform(GrGLShaderBuilder::kVertex_ShaderType,
-                                 kMat33f_GrSLType, texMatName.c_str());
-        const GrGLShaderVar& mat = segments->getUniformVariable(m);
+        uniforms.fTextureMatrixUni = segments->addUniform(GrGLShaderBuilder::kVertex_ShaderType,
+                                                          kMat33f_GrSLType, texMatName.c_str());
+        const GrGLShaderVar& mat = segments->getUniformVariable(uniforms.fTextureMatrixUni);
         // Can't use texMatName.c_str() because it's on the stack!
         matName = mat.getName().c_str();
-        locations.fTextureMatrixUni = kUseUniform;
 
         if (desc.fOptFlags & StageDesc::kNoPerspective_OptFlagBit) {
             segments->fVaryingDims = segments->fCoordDims;
@@ -1116,9 +1044,8 @@
 
     SkString samplerName;
     sampler_name(stageNum, &samplerName);
-    segments->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                         kSampler2D_GrSLType, samplerName.c_str());
-    locations.fSamplerUni = kUseUniform;
+    uniforms.fSamplerUni = segments->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                                                kSampler2D_GrSLType, samplerName.c_str());
 
     const char *varyingVSName, *varyingFSName;
     segments->addVarying(GrSLFloatVectorType(segments->fVaryingDims),
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index 6b6454d..02cb6ef 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -13,7 +13,7 @@
 #include "GrGLContextInfo.h"
 #include "GrGLSL.h"
 #include "GrGLTexture.h"
-//#include "GrGpu.h"
+#include "GrGLUniformManager.h"
 
 #include "SkString.h"
 #include "SkXfermode.h"
@@ -75,10 +75,6 @@
         return 7 + GrDrawState::kMaxTexCoords + 3 * stage;
     }
 
-    enum {
-        kUnusedUniform = -1,
-    };
-
     // Parameters that affect code generation
     // These structs should be kept compact; they are the input to an
     // expensive hash key generator.
@@ -259,6 +255,8 @@
 
     void genGeometryShader(GrGLShaderBuilder* segments) const;
 
+    typedef GrGLUniformManager::UniformHandle UniformHandle;
+
     void genUniformCoverage(GrGLShaderBuilder* segments, SkString* inOutCoverage);
 
     // generates code to compute coverage based on edge AA.
@@ -269,42 +267,37 @@
                                           bool bindColorOut,
                                           bool bindDualSrcOut);
 
-    // Binds uniforms; initializes cache to invalid values.
-    void getUniformLocationsAndInitCache(const GrGLShaderBuilder& builder);
+    // Sets the texture units for samplers
+    void initSamplerUniforms();
 
     bool compileShaders(const GrGLShaderBuilder& builder);
 
     const char* adjustInColor(const SkString& inColor) const;
 
-    struct StageUniLocations {
-        GrGLint fTextureMatrixUni;
-        GrGLint fSamplerUni;
-        GrGLint fTexDomUni;
-        void reset() {
-            fTextureMatrixUni = kUnusedUniform;
-            fSamplerUni = kUnusedUniform;
-            fTexDomUni = kUnusedUniform;
+    struct StageUniforms {
+        UniformHandle fTextureMatrixUni;
+        UniformHandle fSamplerUni;
+        StageUniforms() {
+            fTextureMatrixUni = GrGLUniformManager::kInvalidUniformHandle;
+            fSamplerUni = GrGLUniformManager::kInvalidUniformHandle;
         }
     };
 
-    struct UniLocations {
-        GrGLint fViewMatrixUni;
-        GrGLint fColorUni;
-        GrGLint fCoverageUni;
-        GrGLint fColorFilterUni;
-        GrGLint fColorMatrixUni;
-        GrGLint fColorMatrixVecUni;
-        StageUniLocations fStages[GrDrawState::kNumStages];
-        void reset() {
-            fViewMatrixUni = kUnusedUniform;
-            fColorUni = kUnusedUniform;
-            fCoverageUni = kUnusedUniform;
-            fColorFilterUni = kUnusedUniform;
-            fColorMatrixUni = kUnusedUniform;
-            fColorMatrixVecUni = kUnusedUniform;
-            for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-                fStages[s].reset();
-            }
+    struct Uniforms {
+        UniformHandle fViewMatrixUni;
+        UniformHandle fColorUni;
+        UniformHandle fCoverageUni;
+        UniformHandle fColorFilterUni;
+        UniformHandle fColorMatrixUni;
+        UniformHandle fColorMatrixVecUni;
+        StageUniforms fStages[GrDrawState::kNumStages];
+        Uniforms() {
+            fViewMatrixUni = GrGLUniformManager::kInvalidUniformHandle;
+            fColorUni = GrGLUniformManager::kInvalidUniformHandle;
+            fCoverageUni = GrGLUniformManager::kInvalidUniformHandle;
+            fColorFilterUni = GrGLUniformManager::kInvalidUniformHandle;
+            fColorMatrixUni = GrGLUniformManager::kInvalidUniformHandle;
+            fColorMatrixVecUni = GrGLUniformManager::kInvalidUniformHandle;
         }
     };
 
@@ -313,8 +306,6 @@
     GrGLuint    fGShaderID;
     GrGLuint    fFShaderID;
     GrGLuint    fProgramID;
-    // shader uniform locations (-1 if shader doesn't use them)
-    UniLocations fUniLocations;
 
     // The matrix sent to GL is determined by both the client's matrix and
     // the size of the viewport.
@@ -336,6 +327,9 @@
     Desc fDesc;
     const GrGLContextInfo&      fContextInfo;
 
+    GrGLUniformManager          fUniformManager;
+    Uniforms                    fUniforms;
+
     friend class GrGpuGL; // TODO: remove this by adding getters and moving functionality.
 
     typedef GrRefCnt INHERITED;
diff --git a/src/gpu/gl/GrGLProgramStage.cpp b/src/gpu/gl/GrGLProgramStage.cpp
index fe103ad..caf123b 100644
--- a/src/gpu/gl/GrGLProgramStage.cpp
+++ b/src/gpu/gl/GrGLProgramStage.cpp
@@ -21,13 +21,7 @@
 
 }
 
-void GrGLProgramStage::initUniforms(const GrGLShaderBuilder*,
-                                    const GrGLInterface*,
-                                    int progID) {
-
-}
-
-void GrGLProgramStage::setData(const GrGLInterface*,
+void GrGLProgramStage::setData(const GrGLUniformManager&,
                                const GrCustomStage&,
                                const GrRenderTarget*,
                                int stageNum) {
diff --git a/src/gpu/gl/GrGLProgramStage.h b/src/gpu/gl/GrGLProgramStage.h
index 6350ae3..5b2ff50 100644
--- a/src/gpu/gl/GrGLProgramStage.h
+++ b/src/gpu/gl/GrGLProgramStage.h
@@ -73,17 +73,11 @@
                         const char* inputColor,
                         const char* samplerName) = 0;
 
-    /** Binds uniforms; we must have already bound the program and
-        determined its GL program ID. */
-    virtual void initUniforms(const GrGLShaderBuilder* builder,
-                              const GrGLInterface* gl,
-                              int programID);
-
     /** A GrGLCustomStage instance can be reused with any GrCustomStage
         that produces the same stage key; this function reads data from
         a stage and uploads any uniform variables required by the shaders
         created in emit*(). */
-    virtual void setData(const GrGLInterface* gl,
+    virtual void setData(const GrGLUniformManager&,
                          const GrCustomStage& stage,
                          const GrRenderTarget* renderTarget,
                          int stageNum);
diff --git a/src/gpu/gl/GrGLShaderBuilder.cpp b/src/gpu/gl/GrGLShaderBuilder.cpp
index 7fa804a..f56f102 100644
--- a/src/gpu/gl/GrGLShaderBuilder.cpp
+++ b/src/gpu/gl/GrGLShaderBuilder.cpp
@@ -7,6 +7,7 @@
 
 #include "gl/GrGLShaderBuilder.h"
 #include "gl/GrGLProgram.h"
+#include "gl/GrGLUniformHandle.h"
 
 // number of each input/output type in a single allocation block
 static const int kVarsPerBlock = 8;
@@ -17,12 +18,15 @@
 // ES2 FS only guarantees mediump and lowp support
 static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision;
 
+typedef GrGLUniformManager::UniformHandle UniformHandle;
+///////////////////////////////////////////////////////////////////////////////
+
 // Architectural assumption: always 2-d input coords.
 // Likely to become non-constant and non-static, perhaps even
 // varying by stage, if we use 1D textures for gradients!
 //const int GrGLShaderBuilder::fCoordDims = 2;
 
-GrGLShaderBuilder::GrGLShaderBuilder(const GrGLContextInfo& ctx)
+GrGLShaderBuilder::GrGLShaderBuilder(const GrGLContextInfo& ctx, GrGLUniformManager& uniformManager)
     : fUniforms(kVarsPerBlock)
     , fVSAttrs(kVarsPerBlock)
     , fVSOutputs(kVarsPerBlock)
@@ -33,8 +37,8 @@
     , fUsesGS(false)
     , fVaryingDims(0)
     , fComplexCoord(false)
-    , fContext(ctx) {
-
+    , fContext(ctx)
+    , fUniformManager(uniformManager) {
 }
 
 void GrGLShaderBuilder::computeSwizzle(uint32_t configFlags) {
@@ -115,23 +119,23 @@
     fFSCode.appendf("%s%s;\n", fSwizzle.c_str(), fModulate.c_str());
 }
 
-namespace {
-inline int handle_to_index(GrGLShaderBuilder::UniformHandle h) { return ~h; }
-inline GrGLShaderBuilder::UniformHandle index_to_handle(int i) { return ~i; }
-}
-
-GrGLShaderBuilder::UniformHandle GrGLShaderBuilder::addUniform(uint32_t visibility,
-                                                               GrSLType type,
-                                                               const char* name,
-                                                               int stageNum,
-                                                               int count) {
+GrGLUniformManager::UniformHandle GrGLShaderBuilder::addUniform(uint32_t visibility,
+                                                                GrSLType type,
+                                                                const char* name,
+                                                                int stageNum,
+                                                                int count) {
     GrAssert(name && strlen(name));
     static const uint32_t kVisibilityMask = kVertex_ShaderType | kFragment_ShaderType;
     GrAssert(0 == (~kVisibilityMask & visibility));
     GrAssert(0 != visibility);
 
-    Uniform& uni = fUniforms.push_back();
+    BuilderUniform& uni = fUniforms.push_back();
     UniformHandle h = index_to_handle(fUniforms.count() - 1);
+    GR_DEBUGCODE(UniformHandle h2 =)
+    fUniformManager.appendUniform(type, count);
+    // We expect the uniform manager to initially have no uniforms and that all uniforms are added
+    // by this function. Therefore, the handles should match.
+    GrAssert(h2 == h);
     uni.fVariable.setType(type);
     uni.fVariable.setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
     uni.fVariable.setName(name);
@@ -280,3 +284,6 @@
     }
  }
 
+void GrGLShaderBuilder::finished(GrGLuint programID) {
+    fUniformManager.getUniformLocations(programID, fUniforms);
+}
diff --git a/src/gpu/gl/GrGLShaderBuilder.h b/src/gpu/gl/GrGLShaderBuilder.h
index 892fcbe..347bcda 100644
--- a/src/gpu/gl/GrGLShaderBuilder.h
+++ b/src/gpu/gl/GrGLShaderBuilder.h
@@ -11,28 +11,25 @@
 #include "GrAllocator.h"
 #include "gl/GrGLShaderVar.h"
 #include "gl/GrGLSL.h"
+#include "gl/GrGLUniformManager.h"
 
 class GrGLContextInfo;
+
 /**
   Contains all the incremental state of a shader as it is being built,as well as helpers to
   manipulate that state.
-  TODO: migrate CompileShaders() here?
 */
-
 class GrGLShaderBuilder {
 
 public:
 
-    typedef int UniformHandle;
-    static const UniformHandle kInvalidUniformHandle = 0;
-
     enum ShaderType {
         kVertex_ShaderType   = 0x1,
         kGeometry_ShaderType = 0x2,
         kFragment_ShaderType = 0x4,
     };
 
-    GrGLShaderBuilder(const GrGLContextInfo&);
+    GrGLShaderBuilder(const GrGLContextInfo&, GrGLUniformManager&);
 
     void computeSwizzle(uint32_t configFlags);
     void computeModulate(const char* fsInColor);
@@ -64,18 +61,18 @@
         from which shaders the uniform should be accessible. At least one bit must be set. Geometry
         shader uniforms are not supported at this time.
     */
-    UniformHandle addUniform(uint32_t visibility,
-                             GrSLType type,
-                             const char* name,
-                             int stageNum = -1,
-                             int count = GrGLShaderVar::kNonArray);
+    GrGLUniformManager::UniformHandle addUniform(uint32_t visibility,
+                                                 GrSLType type,
+                                                 const char* name,
+                                                 int stageNum = -1,
+                                                 int count = GrGLShaderVar::kNonArray);
 
-    const GrGLShaderVar& getUniformVariable(UniformHandle) const;
+    const GrGLShaderVar& getUniformVariable(GrGLUniformManager::UniformHandle) const;
 
     /**
      * Shorcut for getUniformVariable(u).c_str()
      */
-    const char* getUniformCStr(UniformHandle u) const {
+    const char* getUniformCStr(GrGLUniformManager::UniformHandle u) const {
         return this->getUniformVariable(u).c_str();
     }
 
@@ -99,19 +96,20 @@
     /** Called after building is complete to get the final shader string. */
     void getShader(ShaderType, SkString*) const;
 
+    /**
+     * TODO: Make this do all the compiling, linking, etc. Hide this from the custom stages
+     */
+    void finished(GrGLuint programID);
+
 private:
+
     typedef GrTAllocator<GrGLShaderVar> VarArray;
 
-    struct Uniform {
-        GrGLShaderVar fVariable;
-        uint32_t      fVisibility;
-    };
-
-    typedef GrTAllocator<Uniform> UniformArray;
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderType, SkString*) const;
 
-    UniformArray fUniforms;
+    typedef GrGLUniformManager::BuilderUniform BuilderUniform;
+    GrGLUniformManager::BuilderUniformArray fUniforms;
 
     // TODO: Everything below here private.
 public:
@@ -149,7 +147,8 @@
     //@}
 
 private:
-    const GrGLContextInfo& fContext;
+    const GrGLContextInfo&  fContext;
+    GrGLUniformManager&     fUniformManager;
 };
 
 #endif
diff --git a/src/gpu/gl/GrGLUniformHandle.h b/src/gpu/gl/GrGLUniformHandle.h
new file mode 100644
index 0000000..231dd31
--- /dev/null
+++ b/src/gpu/gl/GrGLUniformHandle.h
@@ -0,0 +1,16 @@
+/*
+ * 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 GrUniformHandle_DEFINED
+#define GrUniformHandle_DEFINED
+
+namespace {
+inline int handle_to_index(GrGLUniformManager::UniformHandle h) { return ~h; }
+inline GrGLUniformManager::UniformHandle index_to_handle(int i) { return ~i; }
+}
+
+#endif
diff --git a/src/gpu/gl/GrGLUniformManager.cpp b/src/gpu/gl/GrGLUniformManager.cpp
new file mode 100644
index 0000000..1625ebb
--- /dev/null
+++ b/src/gpu/gl/GrGLUniformManager.cpp
@@ -0,0 +1,247 @@
+/*
+ * 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 "gl/GrGLShaderBuilder.h"
+#include "gl/GrGLProgram.h"
+#include "gl/GrGLUniformHandle.h"
+
+#define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, OFFSET, COUNT) \
+         GrAssert(offset + arrayCount <= uni.fArrayCount || \
+                  (0 == offset && 1 == arrayCount && GrGLShaderVar::kNonArray == uni.fArrayCount))
+
+GrGLUniformManager::UniformHandle GrGLUniformManager::appendUniform(GrSLType type, int arrayCount) {
+    int idx = fUniforms.count();
+    Uniform& uni = fUniforms.push_back();
+    GrAssert(GrGLShaderVar::kNonArray == arrayCount || arrayCount > 0);
+    uni.fArrayCount = arrayCount;
+    uni.fType = type;
+    uni.fVSLocation = kUnusedUniform;
+    uni.fFSLocation = kUnusedUniform;
+    return index_to_handle(idx);
+}
+
+void GrGLUniformManager::setSampler(UniformHandle u, GrGLint texUnit) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kSampler2D_GrSLType);
+    GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform1i(uni.fFSLocation, texUnit));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform1i(uni.fVSLocation, texUnit));
+    }
+}
+
+void GrGLUniformManager::set1f(UniformHandle u, GrGLfloat v0) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kFloat_GrSLType);
+    GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform1f(uni.fFSLocation, v0));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform1f(uni.fVSLocation, v0));
+    }
+}
+
+void GrGLUniformManager::set1fv(UniformHandle u,
+                                int offset,
+                                int arrayCount,
+                                const GrGLfloat v[]) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kFloat_GrSLType);
+    GrAssert(arrayCount > 0);
+    ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
+    // This assert fires in some instances of the two-pt gradient for its VSParams.
+    // Once the uniform manager is responsible for inserting the duplicate uniform
+    // arrays in VS and FS driver bug workaround, this can be enabled.
+    //GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform1fv(uni.fFSLocation + offset, arrayCount, v));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform1fv(uni.fVSLocation + offset, arrayCount, v));
+    }
+}
+
+void GrGLUniformManager::set2f(UniformHandle u, GrGLfloat v0, GrGLfloat v1) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kVec2f_GrSLType);
+    GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform2f(uni.fFSLocation, v0, v1));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform2f(uni.fVSLocation, v0, v1));
+    }
+}
+
+void GrGLUniformManager::set2fv(UniformHandle u,
+                                int offset,
+                                int arrayCount,
+                                const GrGLfloat v[]) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kVec2f_GrSLType);
+    GrAssert(arrayCount > 0);
+    ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform2fv(uni.fFSLocation + offset, arrayCount, v));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform2fv(uni.fVSLocation + offset, arrayCount, v));
+    }
+}
+
+void GrGLUniformManager::set3f(UniformHandle u, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kVec3f_GrSLType);
+    GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform3f(uni.fFSLocation, v0, v1, v2));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform3f(uni.fVSLocation, v0, v1, v2));
+    }
+}
+
+void GrGLUniformManager::set3fv(UniformHandle u,
+                                int offset,
+                                int arrayCount,
+                                const GrGLfloat v[]) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kVec3f_GrSLType);
+    GrAssert(arrayCount > 0);
+    ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform3fv(uni.fFSLocation + offset, arrayCount, v));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform3fv(uni.fVSLocation + offset, arrayCount, v));
+    }
+}
+
+void GrGLUniformManager::set4f(UniformHandle u,
+                               GrGLfloat v0,
+                               GrGLfloat v1,
+                               GrGLfloat v2,
+                               GrGLfloat v3) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kVec4f_GrSLType);
+    GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform4f(uni.fFSLocation, v0, v1, v2, v3));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform4f(uni.fVSLocation, v0, v1, v2, v3));
+    }
+}
+
+void GrGLUniformManager::set4fv(UniformHandle u,
+                                int offset,
+                                int arrayCount,
+                                const GrGLfloat v[]) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kVec4f_GrSLType);
+    GrAssert(arrayCount > 0);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform4fv(uni.fFSLocation + offset, arrayCount, v));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), Uniform4fv(uni.fVSLocation + offset, arrayCount, v));
+    }
+}
+
+void GrGLUniformManager::setMatrix3f(UniformHandle u, const GrGLfloat matrix[]) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kMat33f_GrSLType);
+    GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), UniformMatrix3fv(uni.fFSLocation, 1, false, matrix));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), UniformMatrix3fv(uni.fVSLocation, 1, false, matrix));
+    }
+}
+
+void GrGLUniformManager::setMatrix4f(UniformHandle u, const GrGLfloat matrix[]) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kMat44f_GrSLType);
+    GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), UniformMatrix4fv(uni.fFSLocation, 1, false, matrix));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(), UniformMatrix4fv(uni.fVSLocation, 1, false, matrix));
+    }
+}
+
+void GrGLUniformManager::setMatrix3fv(UniformHandle u,
+                                      int offset,
+                                      int arrayCount,
+                                      const GrGLfloat matrices[]) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kMat33f_GrSLType);
+    GrAssert(arrayCount > 0);
+    ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(),
+                   UniformMatrix3fv(uni.fFSLocation + offset, arrayCount, false, matrices));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(),
+                   UniformMatrix3fv(uni.fVSLocation + offset, arrayCount, false, matrices));
+    }
+}
+
+void GrGLUniformManager::setMatrix4fv(UniformHandle u,
+                                      int offset,
+                                      int arrayCount,
+                                      const GrGLfloat matrices[]) const {
+    const Uniform& uni = fUniforms[handle_to_index(u)];
+    GrAssert(uni.fType == kMat44f_GrSLType);
+    GrAssert(arrayCount > 0);
+    ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
+    GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+    if (kUnusedUniform != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(),
+                   UniformMatrix4fv(uni.fFSLocation + offset, arrayCount, false, matrices));
+    }
+    if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) {
+        GR_GL_CALL(fContext.interface(),
+                   UniformMatrix4fv(uni.fVSLocation + offset, arrayCount, false, matrices));
+    }
+}
+
+void GrGLUniformManager::getUniformLocations(GrGLuint programID, const BuilderUniformArray& uniforms) {
+    GrAssert(uniforms.count() == fUniforms.count());
+    int count = fUniforms.count();
+    for (int i = 0; i < count; ++i) {
+        GrAssert(uniforms[i].fVariable.getType() == fUniforms[i].fType);
+        GrAssert(uniforms[i].fVariable.getArrayCount() == fUniforms[i].fArrayCount);
+        GrGLint location;
+        // TODO: Move the Xoom uniform array in both FS and VS bug workaround here.
+        GR_GL_CALL_RET(fContext.interface(), location,
+                       GetUniformLocation(programID, uniforms[i].fVariable.c_str()));
+        if (GrGLShaderBuilder::kVertex_ShaderType & uniforms[i].fVisibility) {
+            fUniforms[i].fVSLocation = location;
+        }
+        if (GrGLShaderBuilder::kFragment_ShaderType & uniforms[i].fVisibility) {
+            fUniforms[i].fFSLocation = location;
+        }
+    }
+}
diff --git a/src/gpu/gl/GrGLUniformManager.h b/src/gpu/gl/GrGLUniformManager.h
new file mode 100644
index 0000000..aea96f0
--- /dev/null
+++ b/src/gpu/gl/GrGLUniformManager.h
@@ -0,0 +1,76 @@
+/*
+ * 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 GrGLUniformManager_DEFINED
+#define GrGLUniformManager_DEFINED
+
+#include "gl/GrGLShaderVar.h"
+#include "gl/GrGLSL.h"
+
+#include "SkTArray.h"
+
+class GrGLContextInfo;
+
+/** Manages a program's uniforms.
+*/
+class GrGLUniformManager {
+public:
+    // Opaque handle to a uniform
+    typedef int UniformHandle;
+    static const UniformHandle kInvalidUniformHandle = 0;
+
+    GrGLUniformManager(const GrGLContextInfo& context) : fContext(context) {}
+
+    UniformHandle appendUniform(GrSLType type, int arrayCount = GrGLShaderVar::kNonArray);
+
+    /** Functions for uploading uniform values. The varities ending in v can be used to upload to an
+     *  array of uniforms. offset + arrayCount must be <= the array count of the uniform.
+     */
+    void setSampler(UniformHandle, GrGLint texUnit) const;
+    void set1f(UniformHandle, GrGLfloat v0) const;
+    void set1fv(UniformHandle, int offset, int arrayCount, const GrGLfloat v[]) const;
+    void set2f(UniformHandle, GrGLfloat, GrGLfloat) const;
+    void set2fv(UniformHandle, int offset, int arrayCount, const GrGLfloat v[]) const;
+    void set3f(UniformHandle, GrGLfloat, GrGLfloat, GrGLfloat) const;
+    void set3fv(UniformHandle, int offset, int arrayCount, const GrGLfloat v[]) const;
+    void set4f(UniformHandle, GrGLfloat, GrGLfloat, GrGLfloat, GrGLfloat) const;
+    void set4fv(UniformHandle, int offset, int arrayCount, const GrGLfloat v[]) const;
+    // matrices are column-major, the first three upload a single matrix, the latter three upload
+    // arrayCount matrices into a uniform array.
+    void setMatrix3f(UniformHandle, const GrGLfloat matrix[]) const;
+    void setMatrix4f(UniformHandle, const GrGLfloat matrix[]) const;
+    void setMatrix3fv(UniformHandle, int offset, int arrayCount, const GrGLfloat matrices[]) const;
+    void setMatrix4fv(UniformHandle, int offset, int arrayCount, const GrGLfloat matrices[]) const;
+
+    struct BuilderUniform {
+        GrGLShaderVar fVariable;
+        uint32_t      fVisibility;
+    };
+    typedef SkTArray<BuilderUniform, true> BuilderUniformArray;
+
+    /**
+     * Called by the GrGLShaderBuilder to get GL locations for all uniforms.
+     */
+    void getUniformLocations(GrGLuint programID, const BuilderUniformArray& uniforms);
+
+private:
+    enum {
+        kUnusedUniform = -1,
+    };
+
+    struct Uniform {
+        GrGLint     fVSLocation;
+        GrGLint     fFSLocation;
+        GrSLType    fType;
+        int         fArrayCount;
+    };
+
+    SkTArray<Uniform, true> fUniforms;
+    const GrGLContextInfo&  fContext;
+};
+
+#endif
diff --git a/src/gpu/gl/GrGpuGL.h b/src/gpu/gl/GrGpuGL.h
index fb78ad2..b3e8cf8 100644
--- a/src/gpu/gl/GrGpuGL.h
+++ b/src/gpu/gl/GrGpuGL.h
@@ -219,8 +219,8 @@
     void flushBoundTextureAndParams(int stage);
     void flushBoundTextureAndParams(int stage, GrGLTexture* nextTexture);
 
-    // sets the texture matrix and domain for the currently bound program
-    void flushTextureMatrixAndDomain(int stage);
+    // sets the texture matrix for the currently bound program
+    void flushTextureMatrix(int stage);
 
     // sets the color specified by GrDrawState::setColor()
     void flushColor(GrColor color);
diff --git a/src/gpu/gl/GrGpuGL_program.cpp b/src/gpu/gl/GrGpuGL_program.cpp
index 56a893d..f4044fc 100644
--- a/src/gpu/gl/GrGpuGL_program.cpp
+++ b/src/gpu/gl/GrGpuGL_program.cpp
@@ -11,6 +11,9 @@
 #include "GrGLProgramStage.h"
 #include "GrGpuVertex.h"
 
+typedef GrGLUniformManager::UniformHandle UniformHandle;
+static const UniformHandle kInvalidUniformHandle = GrGLUniformManager::kInvalidUniformHandle;
+
 #define SKIP_CACHE_CHECK    true
 #define GR_UINT32_MAX   static_cast<uint32_t>(-1)
 
@@ -147,11 +150,7 @@
             GrScalarToFloat(m[GrMatrix::kMTransY]),
             GrScalarToFloat(m[GrMatrix::kMPersp2])
         };
-
-        GrAssert(GrGLProgram::kUnusedUniform != 
-                 fCurrentProgram->fUniLocations.fViewMatrixUni);
-        GL_CALL(UniformMatrix3fv(fCurrentProgram->fUniLocations.fViewMatrixUni,
-                                 1, false, mt));
+        fCurrentProgram->fUniformManager.setMatrix3f(fCurrentProgram->fUniforms.fViewMatrixUni, mt);
         fCurrentProgram->fViewMatrix = vm;
         fCurrentProgram->fViewportSize = viewportSize;
     }
@@ -194,7 +193,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGpuGL::flushTextureMatrixAndDomain(int s) {
+void GrGpuGL::flushTextureMatrix(int s) {
     const GrDrawState& drawState = this->getDrawState();
     const GrGLTexture* texture =
         static_cast<const GrGLTexture*>(drawState.getTexture(s));
@@ -203,13 +202,12 @@
         bool orientationChange = fCurrentProgram->fTextureOrientation[s] !=
                                  texture->orientation();
 
-        const GrGLint& matrixUni =
-            fCurrentProgram->fUniLocations.fStages[s].fTextureMatrixUni;
+        UniformHandle matrixUni = fCurrentProgram->fUniforms.fStages[s].fTextureMatrixUni;
 
         const GrMatrix& hwMatrix = fCurrentProgram->fTextureMatrices[s];
         const GrMatrix& samplerMatrix = drawState.getSampler(s).getMatrix();
 
-        if (GrGLProgram::kUnusedUniform != matrixUni &&
+        if (kInvalidUniformHandle != matrixUni &&
             (orientationChange || !hwMatrix.cheapEqualTo(samplerMatrix))) {
 
             GrMatrix m = samplerMatrix;
@@ -229,7 +227,7 @@
                 GrScalarToFloat(m[GrMatrix::kMPersp2])
             };
 
-            GL_CALL(UniformMatrix3fv(matrixUni, 1, false, mt));
+            fCurrentProgram->fUniformManager.setMatrix3f(matrixUni, mt);
             fCurrentProgram->fTextureMatrices[s] = samplerMatrix;
         }
 
@@ -239,10 +237,9 @@
 
 
 void GrGpuGL::flushColorMatrix() {
-    int matrixUni = fCurrentProgram->fUniLocations.fColorMatrixUni;
-    int vecUni = fCurrentProgram->fUniLocations.fColorMatrixVecUni;
-    if (GrGLProgram::kUnusedUniform != matrixUni
-     && GrGLProgram::kUnusedUniform != vecUni) {
+    UniformHandle matrixUni = fCurrentProgram->fUniforms.fColorMatrixUni;
+    UniformHandle vecUni = fCurrentProgram->fUniforms.fColorMatrixVecUni;
+    if (kInvalidUniformHandle != matrixUni && kInvalidUniformHandle != vecUni) {
         const float* m = this->getDrawState().getColorMatrix();
         GrGLfloat mt[]  = {
             m[0], m[5], m[10], m[15],
@@ -254,8 +251,8 @@
         GrGLfloat vec[] = {
             m[4] * scale, m[9] * scale, m[14] * scale, m[19] * scale,
         };
-        GL_CALL(UniformMatrix4fv(matrixUni, 1, false, mt));
-        GL_CALL(Uniform4fv(vecUni, 1, vec));
+        fCurrentProgram->fUniformManager.setMatrix4f(matrixUni, mt);
+        fCurrentProgram->fUniformManager.set4fv(vecUni, 0, 1, vec);
     }
 }
 
@@ -293,9 +290,9 @@
                     // OpenGL ES doesn't support unsigned byte varieties of
                     // glUniform
                     float c[] = GR_COLOR_TO_VEC4(color);
-                    GrAssert(GrGLProgram::kUnusedUniform != 
-                             fCurrentProgram->fUniLocations.fColorUni);
-                    GL_CALL(Uniform4fv(fCurrentProgram->fUniLocations.fColorUni, 1, c));
+                    GrAssert(kInvalidUniformHandle !=  fCurrentProgram->fUniforms.fColorUni);
+                    fCurrentProgram->fUniformManager.set4fv(fCurrentProgram->fUniforms.fColorUni,
+                                                            0, 1, c);
                     fCurrentProgram->fColor = color;
                 }
                 break;
@@ -306,12 +303,11 @@
                 GrCrash("Unknown color type.");
         }
     }
-    if (fCurrentProgram->fUniLocations.fColorFilterUni
-                != GrGLProgram::kUnusedUniform
-            && fCurrentProgram->fColorFilterColor
-                != drawState.getColorFilterColor()) {
+    UniformHandle filterColorUni = fCurrentProgram->fUniforms.fColorFilterUni;
+    if (kInvalidUniformHandle != filterColorUni &&
+        fCurrentProgram->fColorFilterColor != drawState.getColorFilterColor()) {
         float c[] = GR_COLOR_TO_VEC4(drawState.getColorFilterColor());
-        GL_CALL(Uniform4fv(fCurrentProgram->fUniLocations.fColorFilterUni, 1, c));
+        fCurrentProgram->fUniformManager.set4fv(filterColorUni, 0, 1, c);
         fCurrentProgram->fColorFilterColor = drawState.getColorFilterColor();
     }
 }
@@ -342,9 +338,9 @@
                     // OpenGL ES doesn't support unsigned byte varieties of
                     // glUniform
                     float c[] = GR_COLOR_TO_VEC4(coverage);
-                    GrAssert(GrGLProgram::kUnusedUniform != 
-                             fCurrentProgram->fUniLocations.fCoverageUni);
-                    GL_CALL(Uniform4fv(fCurrentProgram->fUniLocations.fCoverageUni, 1, c));
+                    GrAssert(kInvalidUniformHandle !=  fCurrentProgram->fUniforms.fCoverageUni);
+                    fCurrentProgram->fUniformManager.set4fv(fCurrentProgram->fUniforms.fCoverageUni,
+                                                            0, 1, c);
                     fCurrentProgram->fCoverage = coverage;
                 }
                 break;
@@ -418,13 +414,13 @@
 #endif
                 this->flushBoundTextureAndParams(s);
 
-                this->flushTextureMatrixAndDomain(s);
+                this->flushTextureMatrix(s);
 
                 if (NULL != fCurrentProgram->fProgramStage[s]) {
                     const GrSamplerState& sampler = this->getDrawState().getSampler(s);
                     const GrGLTexture* texture = static_cast<const GrGLTexture*>(
                                                     this->getDrawState().getTexture(s));
-                    fCurrentProgram->fProgramStage[s]->setData(this->glInterface(),
+                    fCurrentProgram->fProgramStage[s]->setData(fCurrentProgram->fUniformManager,
                                                                *sampler.getCustomStage(),
                                                                drawState.getRenderTarget(), s);
                 }