Create GLSLUniformHandler class for gpu backend

src/gpu/glsl/GrGLSLGeometryProcessor.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLSLGeometryProcessor_DEFINED
 #define GrGLSLGeometryProcessor_DEFINED
 
@@ skipping 24 matching lines @@
     void setTransformDataHelper(const GrPrimitiveProcessor& primProc,
                                 const GrGLSLProgramDataManager& pdman,
                                 int index,
                                 const SkTArray<const GrCoordTransform*, true>& transforms) {
         const GeometryProcessor& gp = primProc.cast<GeometryProcessor>();
         this->setTransformDataMatrix(gp.localMatrix(), pdman, index, transforms);
     }
 
 protected:
     // Emit a uniform matrix for each coord transform.
-    void emitTransforms(GrGLSLGPBuilder* gp,
-                        GrGLSLVertexBuilder* vb,
+    void emitTransforms(GrGLSLVertexBuilder* vb,
                         GrGLSLVaryingHandler* varyingHandler,
+                        GrGLSLUniformHandler* uniformHandler,
                         const GrShaderVar& posVar,
                         const char* localCoords,
                         const TransformsIn& tin,
                         TransformsOut* tout) {
-        this->emitTransforms(gp, vb, varyingHandler, posVar, localCoords, SkMatrix::I(), tin, tout);
+        this->emitTransforms(vb, varyingHandler, uniformHandler,
+                             posVar, localCoords, SkMatrix::I(), tin, tout);
     }
 
     // Emit pre-transformed coords as a vertex attribute per coord-transform.
-    void emitTransforms(GrGLSLGPBuilder*,
-                        GrGLSLVertexBuilder*,
+    void emitTransforms(GrGLSLVertexBuilder*,
                         GrGLSLVaryingHandler*,
+                        GrGLSLUniformHandler*,
                         const GrShaderVar& posVar,
                         const char* localCoords,
                         const SkMatrix& localMatrix,
                         const TransformsIn&,
                         TransformsOut*);
 
     // caller has emitted transforms via attributes
-    void emitTransforms(GrGLSLGPBuilder*,
-                        GrGLSLVertexBuilder*,
+    void emitTransforms(GrGLSLVertexBuilder*,
                         GrGLSLVaryingHandler*,
                         const char* localCoords,
                         const TransformsIn& tin,
                         TransformsOut* tout);
 
     struct GrGPArgs {
         // The variable used by a GP to store its position. It can be
         // either a vec2 or a vec3 depending on the presence of perspective.
         GrShaderVar fPositionVar;
     };
 
     // Create the correct type of position variable given the CTM
-    void setupPosition(GrGLSLGPBuilder*, GrGLSLVertexBuilder*, GrGPArgs*, const char* posName);
-    void setupPosition(GrGLSLGPBuilder*,
-                       GrGLSLVertexBuilder*,
+    void setupPosition(GrGLSLVertexBuilder*, GrGPArgs*, const char* posName);
+    void setupPosition(GrGLSLVertexBuilder*,
+                       GrGLSLUniformHandler* uniformHandler,
                        GrGPArgs*,
                        const char* posName,
                        const SkMatrix& mat,
                        UniformHandle* viewMatrixUniform);
 
     static uint32_t ComputePosKey(const SkMatrix& mat) {
         if (mat.isIdentity()) {
             return 0x0;
         } else if (!mat.hasPerspective()) {
             return 0x01;
@@ skipping 18 matching lines @@
             }
         }
     }
 
     virtual void onEmitCode(EmitArgs&, GrGPArgs*) = 0;
 
     typedef GrGLSLPrimitiveProcessor INHERITED;
 };
 
 #endif