Remove GrGLProcessor and create GrGLSLTextureSampler class.

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
 
 #include "SkTArray.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/GrGLProgramDesc.h"
 #include "gl/GrGLProgramDataManager.h"
 #include "gl/GrGLTypes.h"
 
 #include <stdarg.h>
 
 class GrGLCaps;
 class GrGLContextInfo;
 class GrGLProgramBuilder;
+class GrGLSLTextureSampler;
 
 /**
   base class for all shaders builders
 */
 class GrGLShaderBuilder {
 public:
-    typedef GrGLProcessor::TransformedCoordsArray TransformedCoordsArray;
-    typedef GrGLProcessor::TextureSampler TextureSampler;
-
     GrGLShaderBuilder(GrGLProgramBuilder* program);
 
     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
      */
     /** Appends a 2D texture sample with projection if necessary. coordType must either be Vec2f or
         Vec3f. The latter is interpreted as projective texture coords. The vec length and swizzle
-        order of the result depends on the GrTextureAccess associated with the TextureSampler. */
+        order of the result depends on the GrTextureAccess associated with the GrGLSLTextureSampler.
+        */
     void appendTextureLookup(SkString* out,
-                             const TextureSampler&,
+                             const GrGLSLTextureSampler&,
                              const char* coordName,
                              GrSLType coordType = kVec2f_GrSLType) const;
 
     /** Version of above that appends the result to the fragment shader code instead.*/
-    void appendTextureLookup(const TextureSampler&,
+    void appendTextureLookup(const GrGLSLTextureSampler&,
                              const char* coordName,
                              GrSLType coordType = kVec2f_GrSLType);
 
 
     /** Does the work of appendTextureLookup and modulates the result by modulation. The result is
-        always a vec4. modulation and the swizzle specified by TextureSampler must both be vec4 or
-        float. If modulation is "" or nullptr it this function acts as though appendTextureLookup were
-        called. */
+        always a vec4. modulation and the swizzle specified by GrGLSLTextureSampler must both be
+        vec4 or float. If modulation is "" or nullptr it this function acts as though
+        appendTextureLookup were called. */
     void appendTextureLookupAndModulate(const char* modulation,
-                                        const TextureSampler&,
+                                        const GrGLSLTextureSampler&,
                                         const char* coordName,
                                         GrSLType coordType = kVec2f_GrSLType);
 
     /** If texture swizzling is available using tex parameters then it is preferred over mangling
         the generated shader code. This potentially allows greater reuse of cached shaders. */
     static const GrGLenum* GetTexParamSwizzle(GrPixelConfig config, const GrGLCaps& caps);
 
     /**
     * Called by GrGLProcessors to add code to one of the shaders.
     */
@@ skipping 125 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