Move GrGLShaderVar to GrGLSL

src/gpu/gl/builders/GrGLShaderBuilder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
@@ skipping 12 matching lines @@
 /**
   base class for all shaders builders
 */
 class GrGLShaderBuilder {
 public:
     typedef GrGLProcessor::TransformedCoordsArray TransformedCoordsArray;
     typedef GrGLProcessor::TextureSampler TextureSampler;
 
     GrGLShaderBuilder(GrGLProgramBuilder* program);
 
-    void addInput(GrGLShaderVar i) { fInputs.push_back(i); }
-    void addOutput(GrGLShaderVar i) { fOutputs.push_back(i); }
+    void addInput(const GrGLSLShaderVar& input) { fInputs.push_back(input); }
+    void addOutput(const GrGLSLShaderVar& output) { fOutputs.push_back(output); }
 
     /*
      * We put texture lookups in the base class because it is TECHNICALLY possible to do texture
      * lookups in any kind of shader.  However, for the time being using these calls on non-fragment
      * shaders will result in a shader compilation error as texture sampler uniforms are only
      * visible to the fragment shader.  It would not be hard to change this behavior, if someone
      * actually wants to do texture lookups in a non-fragment shader
      *
      * TODO if append texture lookup is used on a non-fragment shader, sampler uniforms should be
      * made visible to that shaders
@@ skipping 40 matching lines @@
     void codePrependf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
        va_list args;
        va_start(args, format);
        this->code().prependVAList(format, args);
        va_end(args);
     }
 
     /**
      * Appends a variable declaration to one of the shaders
      */
-    void declAppend(const GrGLShaderVar& var);
+    void declAppend(const GrGLSLShaderVar& var);
 
     /** Emits a helper function outside of main() in the fragment shader. */
     void emitFunction(GrSLType returnType,
                       const char* name,
                       int argCnt,
-                      const GrGLShaderVar* args,
+                      const GrGLSLShaderVar* args,
                       const char* body,
                       SkString* outName);
 
     /*
      * Get parent builder for adding uniforms
      */
     GrGLProgramBuilder* getProgramBuilder() { return fProgramBuilder; }
 
     /**
      * Helper for begining and ending a block in the shader code.
      */
     class ShaderBlock {
     public:
         ShaderBlock(GrGLShaderBuilder* builder) : fBuilder(builder) {
             SkASSERT(builder);
             fBuilder->codeAppend("{");
         }
 
         ~ShaderBlock() {
             fBuilder->codeAppend("}");
         }
     private:
         GrGLShaderBuilder* fBuilder;
     };
 
 protected:
-    typedef GrTAllocator<GrGLShaderVar> VarArray;
+    typedef GrTAllocator<GrGLSLShaderVar> VarArray;
     void appendDecls(const VarArray& vars, SkString* out) const;
 
     /*
      * this super low level function is just for use internally to builders
      */
     void appendTextureLookup(const char* samplerName,
                              const char* coordName,
                              uint32_t configComponentMask,
                              const char* swizzle);
 
@@ skipping 62 matching lines @@
     VarArray fOutputs;
     uint32_t fFeaturesAddedMask;
     SkSTArray<1, SkString> fLayoutParams[kLastInterfaceQualifier + 1];
     int fCodeIndex;
     bool fFinalized;
 
     friend class GrGLProgramBuilder;
     friend class GrGLPathProgramBuilder; // to access fInputs.
 };
 #endif