Create GLSLUniformHandler class for gpu backend

src/effects/SkMagnifierImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkMagnifierImageFilter.h"
 #include "SkColorPriv.h"
 #include "SkDevice.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkValidationUtils.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 #if SK_SUPPORT_GPU
 #include "GrInvariantOutput.h"
 #include "effects/GrSingleTextureEffect.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
-#include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
+#include "glsl/GrGLSLUniformHandler.h"
 
 class GrMagnifierEffect : public GrSingleTextureEffect {
 
 public:
     static GrFragmentProcessor* Create(GrTexture* texture,
                                        const SkRect& bounds,
                                        float xOffset,
                                        float yOffset,
                                        float xInvZoom,
                                        float yInvZoom,
@@ skipping 79 matching lines @@
     UniformHandle       fInvInsetVar;
     UniformHandle       fBoundsVar;
 
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 GrGLMagnifierEffect::GrGLMagnifierEffect(const GrProcessor&) {
 }
 
 void GrGLMagnifierEffect::emitCode(EmitArgs& args) {
-    fOffsetVar = args.fBuilder->addUniform(
-        GrGLSLProgramBuilder::kFragment_Visibility,
-        kVec2f_GrSLType, kDefault_GrSLPrecision, "Offset");
-    fInvZoomVar = args.fBuilder->addUniform(
-        GrGLSLProgramBuilder::kFragment_Visibility,
-        kVec2f_GrSLType, kDefault_GrSLPrecision, "InvZoom");
-    fInvInsetVar = args.fBuilder->addUniform(
-        GrGLSLProgramBuilder::kFragment_Visibility,
-        kVec2f_GrSLType, kDefault_GrSLPrecision, "InvInset");
-    fBoundsVar = args.fBuilder->addUniform(
-        GrGLSLProgramBuilder::kFragment_Visibility,
-        kVec4f_GrSLType, kDefault_GrSLPrecision, "Bounds");
+    GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
+    fOffsetVar = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                            kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                            "Offset");
+    fInvZoomVar = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                             "InvZoom");
+    fInvInsetVar = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                              kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                              "InvInset");
+    fBoundsVar = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                            kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                            "Bounds");
 
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString coords2D = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
     fragBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str());
     fragBuilder->codeAppendf("\t\tvec2 zoom_coord = %s + %s * %s;\n",
-                             args.fBuilder->getUniformCStr(fOffsetVar),
+                             uniformHandler->getUniformCStr(fOffsetVar),
                              coords2D.c_str(),
-                             args.fBuilder->getUniformCStr(fInvZoomVar));
-    const char* bounds = args.fBuilder->getUniformCStr(fBoundsVar);
+                             uniformHandler->getUniformCStr(fInvZoomVar));
+    const char* bounds = uniformHandler->getUniformCStr(fBoundsVar);
     fragBuilder->codeAppendf("\t\tvec2 delta = (coord - %s.xy) * %s.zw;\n", bounds, bounds);
     fragBuilder->codeAppendf("\t\tdelta = min(delta, vec2(1.0, 1.0) - delta);\n");
     fragBuilder->codeAppendf("\t\tdelta = delta * %s;\n",
-                             args.fBuilder->getUniformCStr(fInvInsetVar));
+                             uniformHandler->getUniformCStr(fInvInsetVar));
 
     fragBuilder->codeAppend("\t\tfloat weight = 0.0;\n");
     fragBuilder->codeAppend("\t\tif (delta.s < 2.0 && delta.t < 2.0) {\n");
     fragBuilder->codeAppend("\t\t\tdelta = vec2(2.0, 2.0) - delta;\n");
     fragBuilder->codeAppend("\t\t\tfloat dist = length(delta);\n");
     fragBuilder->codeAppend("\t\t\tdist = max(2.0 - dist, 0.0);\n");
     fragBuilder->codeAppend("\t\t\tweight = min(dist * dist, 1.0);\n");
     fragBuilder->codeAppend("\t\t} else {\n");
     fragBuilder->codeAppend("\t\t\tvec2 delta_squared = delta * delta;\n");
     fragBuilder->codeAppend("\t\t\tweight = min(min(delta_squared.x, delta_squared.y), 1.0);\n");
@@ skipping 211 matching lines @@
 
 #ifndef SK_IGNORE_TO_STRING
 void SkMagnifierImageFilter::toString(SkString* str) const {
     str->appendf("SkMagnifierImageFilter: (");
     str->appendf("src: (%f,%f,%f,%f) ",
                  fSrcRect.fLeft, fSrcRect.fTop, fSrcRect.fRight, fSrcRect.fBottom);
     str->appendf("inset: %f", fInset);
     str->append(")");
 }
 #endif