Remove GrGLProcessor and create GrGLSLTextureSampler class.

src/gpu/gl/builders/GrGLShaderBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLShaderBuilder.h"
 #include "GrGLProgramBuilder.h"
 #include "GrGLShaderStringBuilder.h"
 #include "gl/GrGLCaps.h"
 #include "gl/GrGLContext.h"
 #include "gl/GrGLGpu.h"
 #include "glsl/GrGLSLCaps.h"
 #include "glsl/GrGLSLShaderVar.h"
+#include "glsl/GrGLSLTextureSampler.h"
 
 namespace {
 void append_texture_lookup(SkString* out,
                            GrGLGpu* gpu,
                            const char* samplerName,
                            const char* coordName,
                            uint32_t configComponentMask,
                            const char* swizzle,
                            GrSLType varyingType = kVec2f_GrSLType) {
     SkASSERT(coordName);
@@ skipping 62 matching lines @@
         if (i < argCnt - 1) {
             this->functions().append(", ");
         }
     }
     this->functions().append(") {\n");
     this->functions().append(body);
     this->functions().append("}\n\n");
 }
 
 void GrGLShaderBuilder::appendTextureLookup(SkString* out,
-                                            const TextureSampler& sampler,
+                                            const GrGLSLTextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) const {
     append_texture_lookup(out,
                           fProgramBuilder->gpu(),
                           fProgramBuilder->getUniformCStr(sampler.fSamplerUniform),
                           coordName,
                           sampler.configComponentMask(),
                           sampler.swizzle(),
                           varyingType);
 }
 
-void GrGLShaderBuilder::appendTextureLookup(const TextureSampler& sampler,
+void GrGLShaderBuilder::appendTextureLookup(const GrGLSLTextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) {
     this->appendTextureLookup(&this->code(), sampler, coordName, varyingType);
 }
 
 void GrGLShaderBuilder::appendTextureLookupAndModulate(const char* modulation,
-                                                       const TextureSampler& sampler,
+                                                       const GrGLSLTextureSampler& sampler,
                                                        const char* coordName,
                                                        GrSLType varyingType) {
     SkString lookup;
     this->appendTextureLookup(&lookup, sampler, coordName, varyingType);
     this->codeAppend((GrGLSLExpr4(modulation) * GrGLSLExpr4(lookup)).c_str());
 }
 
 
 const GrGLenum* GrGLShaderBuilder::GetTexParamSwizzle(GrPixelConfig config, const GrGLCaps& caps) {
     if (caps.textureSwizzleSupport() && GrPixelConfigIsAlphaOnly(config)) {
@@ skipping 88 matching lines @@
     fFinalized = true;
 
     if (!shaderId) {
         return false;
     }
 
     *shaderIds->append() = shaderId;
 
     return true;
 }