Create GLSL base class for ProgramDataManager

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 "gl/GrGLFragmentProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
+#include "glsl/GrGLSLProgramDataManager.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 47 matching lines @@
     typedef GrFragmentProcessor INHERITED;
 };
 
 class GrGLAlphaThresholdEffect : public GrGLFragmentProcessor {
 public:
     GrGLAlphaThresholdEffect(const GrFragmentProcessor&) {}
 
     virtual void emitCode(EmitArgs&) override;
 
 protected:
-    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+    void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
 
-    GrGLProgramDataManager::UniformHandle fInnerThresholdVar;
-    GrGLProgramDataManager::UniformHandle fOuterThresholdVar;
+    GrGLSLProgramDataManager::UniformHandle fInnerThresholdVar;
+    GrGLSLProgramDataManager::UniformHandle fOuterThresholdVar;
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 void GrGLAlphaThresholdEffect::emitCode(EmitArgs& args) {
     fInnerThresholdVar = args.fBuilder->addUniform(
         GrGLProgramBuilder::kFragment_Visibility,
         kFloat_GrSLType, kDefault_GrSLPrecision,
         "inner_threshold");
     fOuterThresholdVar = args.fBuilder->addUniform(
@@ skipping 30 matching lines @@
                           "\t\t} else if (color.a < inner_thresh) {\n"
                           "\t\t\tfloat scale = inner_thresh / max(0.001, color.a);\n"
                           "\t\t\tcolor.rgb *= scale;\n"
                           "\t\t\tcolor.a = inner_thresh;\n"
                           "\t\t}\n");
 
     fsBuilder->codeAppendf("%s = %s;\n", args.fOutputColor,
                            (GrGLSLExpr4(args.fInputColor) * GrGLSLExpr4("color")).c_str());
 }
 
-void GrGLAlphaThresholdEffect::onSetData(const GrGLProgramDataManager& pdman,
+void GrGLAlphaThresholdEffect::onSetData(const GrGLSLProgramDataManager& pdman,
                                        const GrProcessor& proc) {
     const AlphaThresholdEffect& alpha_threshold = proc.cast<AlphaThresholdEffect>();
     pdman.set1f(fInnerThresholdVar, alpha_threshold.innerThreshold());
     pdman.set1f(fOuterThresholdVar, alpha_threshold.outerThreshold());
 }
 
 /////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AlphaThresholdEffect);
 
@@ skipping 174 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