Create GLSLUniformHandler class for gpu backend

src/effects/SkAlphaThresholdFilter.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAlphaThresholdFilter.h"
 #include "SkBitmap.h"
 #include "SkDevice.h"
@@ skipping 41 matching lines @@
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrTextureAccess.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 
 #include "SkGr.h"
 
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
-#include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
+#include "glsl/GrGLSLUniformHandler.h"
 
 class AlphaThresholdEffect : public GrFragmentProcessor {
 
 public:
     static GrFragmentProcessor* Create(GrTexture* texture,
                                        GrTexture* maskTexture,
                                        float innerThreshold,
                                        float outerThreshold) {
         return new AlphaThresholdEffect(texture, maskTexture, innerThreshold, outerThreshold);
     }
@@ skipping 58 matching lines @@
 
 private:
 
     GrGLSLProgramDataManager::UniformHandle fInnerThresholdVar;
     GrGLSLProgramDataManager::UniformHandle fOuterThresholdVar;
 
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 void GrGLAlphaThresholdEffect::emitCode(EmitArgs& args) {
-    fInnerThresholdVar = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
-                                                   kFloat_GrSLType, kDefault_GrSLPrecision,
-                                                   "inner_threshold");
-    fOuterThresholdVar = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
-                                                   kFloat_GrSLType, kDefault_GrSLPrecision,
-                                                   "outer_threshold");
+    GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
+    fInnerThresholdVar = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                                    kFloat_GrSLType, kDefault_GrSLPrecision,
+                                                    "inner_threshold");
+    fOuterThresholdVar = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                                    kFloat_GrSLType, kDefault_GrSLPrecision,
+                                                    "outer_threshold");
 
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString coords2D = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
     SkString maskCoords2D = fragBuilder->ensureFSCoords2D(args.fCoords, 1);
 
     fragBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str());
     fragBuilder->codeAppendf("\t\tvec2 mask_coord = %s;\n", maskCoords2D.c_str());
     fragBuilder->codeAppend("\t\tvec4 input_color = ");
     fragBuilder->appendTextureLookup(args.fSamplers[0], "coord");
     fragBuilder->codeAppend(";\n");
     fragBuilder->codeAppend("\t\tvec4 mask_color = ");
     fragBuilder->appendTextureLookup(args.fSamplers[1], "mask_coord");
     fragBuilder->codeAppend(";\n");
 
     fragBuilder->codeAppendf("\t\tfloat inner_thresh = %s;\n",
-                             args.fBuilder->getUniformCStr(fInnerThresholdVar));
+                             uniformHandler->getUniformCStr(fInnerThresholdVar));
     fragBuilder->codeAppendf("\t\tfloat outer_thresh = %s;\n",
-                             args.fBuilder->getUniformCStr(fOuterThresholdVar));
+                             uniformHandler->getUniformCStr(fOuterThresholdVar));
     fragBuilder->codeAppend("\t\tfloat mask = mask_color.a;\n");
 
     fragBuilder->codeAppend("vec4 color = input_color;\n");
     fragBuilder->codeAppend("\t\tif (mask < 0.5) {\n"
                             "\t\t\tif (color.a > outer_thresh) {\n"
                             "\t\t\t\tfloat scale = outer_thresh / color.a;\n"
                             "\t\t\t\tcolor.rgb *= scale;\n"
                             "\t\t\t\tcolor.a = outer_thresh;\n"
                             "\t\t\t}\n"
                             "\t\t} else if (color.a < inner_thresh) {\n"
@@ skipping 194 matching lines @@
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkAlphaThresholdFilterImpl::toString(SkString* str) const {
     str->appendf("SkAlphaThresholdImageFilter: (");
     str->appendf("inner: %f outer: %f", fInnerThreshold, fOuterThreshold);
     str->append(")");
 }
 #endif