Use GLSLCaps for creating processor keys and GLSL-specific programs

src/effects/gradients/SkTwoPointRadialGradient.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTwoPointRadialGradient.h"
 
@@ skipping 390 matching lines @@
     virtual ~GrGLRadial2Gradient() { }
 
     virtual void emitCode(GrGLFPBuilder*,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) override;
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
-    static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
+    static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
 
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     bool fIsDegenerate;
 
@@ skipping 20 matching lines @@
                                        const SkTwoPointRadialGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm) {
         return SkNEW_ARGS(GrRadial2Gradient, (ctx, shader, matrix, tm));
     }
 
     virtual ~GrRadial2Gradient() { }
 
     const char* name() const override { return "Two-Point Radial Gradient"; }
 
-    virtual void getGLProcessorKey(const GrGLCaps& caps,
+    virtual void getGLProcessorKey(const GrGLSLCaps& caps,
                                    GrProcessorKeyBuilder* b) const override {
         GrGLRadial2Gradient::GenKey(*this, caps, b);
     }
 
     GrGLFragmentProcessor* createGLInstance() const override {
         return SkNEW_ARGS(GrGLRadial2Gradient, (*this));
     }
 
     // The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
     bool isDegenerate() const { return SK_Scalar1 == fCenterX1; }
@@ skipping 199 matching lines @@
         };
 
         pdman.set1fv(fParamUni, 6, values);
         fCachedCenter = centerX1;
         fCachedRadius = radius0;
         fCachedPosRoot = data.isPosRoot();
     }
 }
 
 void GrGLRadial2Gradient::GenKey(const GrProcessor& processor,
-                                 const GrGLCaps&, GrProcessorKeyBuilder* b) {
+                                 const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     uint32_t* key = b->add32n(2);
     key[0] = GenBaseGradientKey(processor);
     key[1] = processor.cast<GrRadial2Gradient>().isDegenerate();
 }
 
 /////////////////////////////////////////////////////////////////////
 
 bool SkTwoPointRadialGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
                                                    const SkMatrix&,
                                                    const SkMatrix* localMatrix, GrColor* paintColor,
@@ skipping 32 matching lines @@
 #else
 
 bool SkTwoPointRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
                                                    const SkMatrix*,
                                                    GrColor*, GrFragmentProcessor**)  const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 
 #endif