Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

src/gpu/gl/GrGLEffectMatrix.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLEffectMatrix.h"
 #include "GrDrawEffect.h"
 #include "GrTexture.h"
@@ skipping 66 matching lines @@
     SkString suffixedUniName;
     if (NULL != suffix) {
         suffixedUniName.append(uniName);
         suffixedUniName.append(suffix);
         uniName = suffixedUniName.c_str();
     }
     if (kVoid_GrSLType != fUniType) {
         fUni = builder->addUniform(GrGLShaderBuilder::kVertex_ShaderType,
                                    fUniType,
                                    uniName,
-                                   &uniName);
+                                   &uniName)->glUniform();
     }
 
     const char* varyingName = "MatrixCoord";
     SkString suffixedVaryingName;
     if (NULL != suffix) {
         suffixedVaryingName.append(varyingName);
         suffixedVaryingName.append(suffix);
         varyingName = suffixedVaryingName.c_str();
     }
     const char* vsVaryingName;
@@ skipping 80 matching lines @@
             *fsCoordName = coordName;
         }
     } else if(NULL != fsCoordName) {
         *fsCoordName = fsVaryingName;
     }
     if (NULL != vsVaryingType) {
         *vsVaryingType = varyingType;
     }
 }
 
-void GrGLEffectMatrix::setData(const GrGLUniformManager& uniformManager,
+void GrGLEffectMatrix::setData(const GrGLContext& context,
                                const SkMatrix& matrix,
                                const GrDrawEffect& drawEffect,
                                const GrTexture* texture) {
-    GrAssert((GrGLUniformManager::kInvalidUniformHandle == fUni) ==
-             (kVoid_GrSLType == fUniType));
+    GrAssert((NULL != fUni) != (kVoid_GrSLType == fUniType));
     const SkMatrix& coordChangeMatrix = GrEffect::kLocal_CoordsType == fCoordsType ?
                                             drawEffect.getCoordChangeMatrix() :
                                             SkMatrix::I();
     switch (fUniType) {
         case kVoid_GrSLType:
             GrAssert(matrix.isIdentity());
             GrAssert(coordChangeMatrix.isIdentity());
             GrAssert(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
             return;
         case kVec2f_GrSLType: {
             GrAssert(SkMatrix::kTranslate_Mask == (matrix.getType() | coordChangeMatrix.getType()));
             GrAssert(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
             SkScalar tx = matrix[SkMatrix::kMTransX] + (coordChangeMatrix)[SkMatrix::kMTransX];
             SkScalar ty = matrix[SkMatrix::kMTransY] + (coordChangeMatrix)[SkMatrix::kMTransY];
             if (fPrevMatrix.get(SkMatrix::kMTransX) != tx ||
                 fPrevMatrix.get(SkMatrix::kMTransY) != ty) {
-                uniformManager.set2f(fUni, tx, ty);
+                fUni->set2f(context, tx, ty);
                 fPrevMatrix.set(SkMatrix::kMTransX, tx);
                 fPrevMatrix.set(SkMatrix::kMTransY, ty);
             }
             break;
         }
         case kMat33f_GrSLType: {
             SkMatrix combined;
             combined.setConcat(matrix, coordChangeMatrix);
             if (NULL != texture && kBottomLeft_GrSurfaceOrigin == texture->origin()) {
                 // combined.postScale(1,-1);
                 // combined.postTranslate(0,1);
                 combined.set(SkMatrix::kMSkewY,
                     combined[SkMatrix::kMPersp0] - combined[SkMatrix::kMSkewY]);
                 combined.set(SkMatrix::kMScaleY,
                     combined[SkMatrix::kMPersp1] - combined[SkMatrix::kMScaleY]);
                 combined.set(SkMatrix::kMTransY,
                     combined[SkMatrix::kMPersp2] - combined[SkMatrix::kMTransY]);
             }
             if (!fPrevMatrix.cheapEqualTo(combined)) {
-                uniformManager.setSkMatrix(fUni, combined);
+                fUni->setSkMatrix(context, combined);
                 fPrevMatrix = combined;
             }
             break;
         }
         default:
             GrCrash("Unexpected uniform type.");
     }
 }