Refactor various gradient effect classes

src/effects/gradients/SkTwoPointConicalGradient_gpu.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 "SkTwoPointConicalGradient_gpu.h"
 
 #include "SkTwoPointConicalGradient.h"
@@ skipping 42 matching lines @@
         SkScalar invDiffLen = SkScalarInvert(diffLen);
         SkMatrix rot;
         rot.setSinCos(-SkScalarMul(invDiffLen, diff.fY),
                        SkScalarMul(invDiffLen, diff.fX));
         invLMatrix->postConcat(rot);
     }
 }
 
 class Edge2PtConicalEffect : public GrGradientEffect {
 public:
+    class GLSLEdge2PtConicalProcessor;
 
     static sk_sp<GrFragmentProcessor> Make(GrContext* ctx,
                                            const SkTwoPointConicalGradient& shader,
                                            const SkMatrix& matrix,
                                            SkShader::TileMode tm) {
         return sk_sp<GrFragmentProcessor>(new Edge2PtConicalEffect(ctx, shader, matrix, tm));
     }
 
     virtual ~Edge2PtConicalEffect() {}
 
@@ skipping 60 matching lines @@
     GrCoordTransform fBTransform;
     SkScalar         fCenterX1;
     SkScalar         fRadius0;
     SkScalar         fDiffRadius;
 
     // @}
 
     typedef GrGradientEffect INHERITED;
 };
 
-class GLEdge2PtConicalEffect : public GrGLGradientEffect {
+class Edge2PtConicalEffect::GLSLEdge2PtConicalProcessor : public GrGradientEffect::GLSLProcessor {
 public:
-    GLEdge2PtConicalEffect(const GrProcessor&);
-    virtual ~GLEdge2PtConicalEffect() { }
+    GLSLEdge2PtConicalProcessor(const GrProcessor&);
+    virtual ~GLSLEdge2PtConicalProcessor() { }
 
     virtual void emitCode(EmitArgs&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedRadius;
     SkScalar fCachedDiffRadius;
 
     // @}
 
 private:
-    typedef GrGLGradientEffect INHERITED;
+    typedef GrGradientEffect::GLSLProcessor INHERITED;
 
 };
 
 void Edge2PtConicalEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                                  GrProcessorKeyBuilder* b) const {
-    GLEdge2PtConicalEffect::GenKey(*this, caps, b);
+    Edge2PtConicalEffect::GLSLEdge2PtConicalProcessor::GenKey(*this, caps, b);
 }
 
 GrGLSLFragmentProcessor* Edge2PtConicalEffect::onCreateGLSLInstance() const {
-    return new GLEdge2PtConicalEffect(*this);
+    return new Edge2PtConicalEffect::GLSLEdge2PtConicalProcessor(*this);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 sk_sp<GrFragmentProcessor> Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = d->fRandom->nextUScalar1();
@@ skipping 19 matching lines @@
     auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2,
                                                         colors, stops, colorCount, tm);
     SkMatrix viewMatrix = GrTest::TestMatrix(d->fRandom);
     sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(SkShader::AsFPArgs(
         d->fContext, &viewMatrix, NULL, kNone_SkFilterQuality, nullptr,
         SkSourceGammaTreatment::kRespect));
     GrAlwaysAssert(fp);
     return fp;
 }
 
-GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrProcessor&)
+Edge2PtConicalEffect::GLSLEdge2PtConicalProcessor::GLSLEdge2PtConicalProcessor(const GrProcessor&)
     : fVSVaryingName(nullptr)
     , fFSVaryingName(nullptr)
     , fCachedRadius(-SK_ScalarMax)
     , fCachedDiffRadius(-SK_ScalarMax) {}
 
-void GLEdge2PtConicalEffect::emitCode(EmitArgs& args) {
+void Edge2PtConicalEffect::GLSLEdge2PtConicalProcessor::emitCode(EmitArgs& args) {
     const Edge2PtConicalEffect& ge = args.fFp.cast<Edge2PtConicalEffect>();
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     this->emitUniforms(uniformHandler, ge);
     fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                            kVec3f_GrSLType, kDefault_GrSLPrecision,
                                            "Conical2FSParams");
 
     SkString cName("c");
     SkString tName("t");
     SkString p0; // start radius
@@ skipping 41 matching lines @@
                     uniformHandler,
                     args.fGLSLCaps,
                     ge,
                     tName.c_str(),
                     args.fOutputColor,
                     args.fInputColor,
                     args.fTexSamplers);
     fragBuilder->codeAppend("\t}\n");
 }
 
-void GLEdge2PtConicalEffect::onSetData(const GrGLSLProgramDataManager& pdman,
+void Edge2PtConicalEffect::GLSLEdge2PtConicalProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
                                        const GrProcessor& processor) {
     INHERITED::onSetData(pdman, processor);
     const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();
     SkScalar radius0 = data.radius();
     SkScalar diffRadius = data.diffRadius();
 
     if (fCachedRadius != radius0 ||
         fCachedDiffRadius != diffRadius) {
 
         pdman.set3f(fParamUni, SkScalarToFloat(radius0),
                     SkScalarToFloat(SkScalarMul(radius0, radius0)), SkScalarToFloat(diffRadius));
         fCachedRadius = radius0;
         fCachedDiffRadius = diffRadius;
     }
 }
 
-void GLEdge2PtConicalEffect::GenKey(const GrProcessor& processor,
+void Edge2PtConicalEffect::GLSLEdge2PtConicalProcessor::GenKey(const GrProcessor& processor,
                                     const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     b->add32(GenBaseGradientKey(processor));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Focal Conical Gradients
 //////////////////////////////////////////////////////////////////////////////
 
 static ConicalType set_matrix_focal_conical(const SkTwoPointConicalGradient& shader,
                                             SkMatrix* invLMatrix, SkScalar* focalX) {
@@ skipping 48 matching lines @@
 
     invLMatrix->postConcat(matrix);
 
     return conicalType;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class FocalOutside2PtConicalEffect : public GrGradientEffect {
 public:
+    class GLSLFocalOutside2PtConicalProcessor;
 
     static sk_sp<GrFragmentProcessor> Make(GrContext* ctx,
                                            const SkTwoPointConicalGradient& shader,
                                            const SkMatrix& matrix,
                                            SkShader::TileMode tm,
                                            SkScalar focalX) {
         return sk_sp<GrFragmentProcessor>(
             new FocalOutside2PtConicalEffect(ctx, shader, matrix, tm, focalX));
     }
 
@@ skipping 30 matching lines @@
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     SkScalar         fFocalX;
     bool             fIsFlipped;
 
     typedef GrGradientEffect INHERITED;
 };
 
-class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
+class FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor : public GrGradientEffect::GLSLProcessor {
 public:
-    GLFocalOutside2PtConicalEffect(const GrProcessor&);
-    virtual ~GLFocalOutside2PtConicalEffect() { }
+    GLSLFocalOutside2PtConicalProcessor(const GrProcessor&);
+    virtual ~GLSLFocalOutside2PtConicalProcessor() { }
 
     virtual void emitCode(EmitArgs&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     bool fIsFlipped;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedFocal;
 
     // @}
 
 private:
-    typedef GrGLGradientEffect INHERITED;
+    typedef GrGradientEffect::GLSLProcessor INHERITED;
 
 };
 
 void FocalOutside2PtConicalEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                                          GrProcessorKeyBuilder* b) const {
-    GLFocalOutside2PtConicalEffect::GenKey(*this, caps, b);
+    FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor::GenKey(*this, caps, b);
 }
 
 GrGLSLFragmentProcessor* FocalOutside2PtConicalEffect::onCreateGLSLInstance() const {
-    return new GLFocalOutside2PtConicalEffect(*this);
+    return new FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor(*this);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 sk_sp<GrFragmentProcessor> FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = 0.f;
@@ skipping 16 matching lines @@
     auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2,
                                                         colors, stops, colorCount, tm);
     SkMatrix viewMatrix = GrTest::TestMatrix(d->fRandom);
     sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(SkShader::AsFPArgs(
         d->fContext, &viewMatrix, NULL, kNone_SkFilterQuality, nullptr,
         SkSourceGammaTreatment::kRespect));
     GrAlwaysAssert(fp);
     return fp;
 }
 
-GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrProcessor& processor)
+FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor::GLSLFocalOutside2PtConicalProcessor(const GrProcessor& processor)
     : fVSVaryingName(nullptr)
     , fFSVaryingName(nullptr)
     , fCachedFocal(SK_ScalarMax) {
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
 }
 
-void GLFocalOutside2PtConicalEffect::emitCode(EmitArgs& args) {
+void FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor::emitCode(EmitArgs& args) {
     const FocalOutside2PtConicalEffect& ge = args.fFp.cast<FocalOutside2PtConicalEffect>();
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     this->emitUniforms(uniformHandler, ge);
     fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                            kVec2f_GrSLType, kDefault_GrSLPrecision,
                                            "Conical2FSParams");
     SkString tName("t");
     SkString p0; // focalX
     SkString p1; // 1 - focalX * focalX
 
@@ skipping 31 matching lines @@
                     uniformHandler,
                     args.fGLSLCaps,
                     ge,
                     tName.c_str(),
                     args.fOutputColor,
                     args.fInputColor,
                     args.fTexSamplers);
     fragBuilder->codeAppend("\t}\n");
 }
 
-void GLFocalOutside2PtConicalEffect::onSetData(const GrGLSLProgramDataManager& pdman,
+void FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
                                                const GrProcessor& processor) {
     INHERITED::onSetData(pdman, processor);
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
         SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal);
 
         pdman.set2f(fParamUni, SkScalarToFloat(focal), SkScalarToFloat(oneMinus2F));
         fCachedFocal = focal;
     }
 }
 
-void GLFocalOutside2PtConicalEffect::GenKey(const GrProcessor& processor,
+void FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor::GenKey(const GrProcessor& processor,
                                             const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     uint32_t* key = b->add32n(2);
     key[0] = GenBaseGradientKey(processor);
     key[1] = processor.cast<FocalOutside2PtConicalEffect>().isFlipped();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-class GLFocalInside2PtConicalEffect;
-
 class FocalInside2PtConicalEffect : public GrGradientEffect {
 public:
+    class GLSLFocalInside2PtConicalProcessor;
 
     static sk_sp<GrFragmentProcessor> Make(GrContext* ctx,
                                            const SkTwoPointConicalGradient& shader,
                                            const SkMatrix& matrix,
                                            SkShader::TileMode tm,
                                            SkScalar focalX) {
         return sk_sp<GrFragmentProcessor>(
             new FocalInside2PtConicalEffect(ctx, shader, matrix, tm, focalX));
     }
 
     virtual ~FocalInside2PtConicalEffect() {}
 
     const char* name() const override {
         return "Two-Point Conical Gradient Focal Inside";
     }
 
     SkScalar focal() const { return fFocalX; }
 
-    typedef GLFocalInside2PtConicalEffect GLSLProcessor;
+    typedef FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor GLSLProcessor;
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
     void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
         const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fFocalX == s.fFocalX);
     }
 
     FocalInside2PtConicalEffect(GrContext* ctx,
                                 const SkTwoPointConicalGradient& shader,
                                 const SkMatrix& matrix,
                                 SkShader::TileMode tm,
                                 SkScalar focalX)
         : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {
         this->initClassID<FocalInside2PtConicalEffect>();
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     SkScalar         fFocalX;
 
     typedef GrGradientEffect INHERITED;
 };
 
-class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
+class FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor : public GrGradientEffect::GLSLProcessor {
 public:
-    GLFocalInside2PtConicalEffect(const GrProcessor&);
-    virtual ~GLFocalInside2PtConicalEffect() {}
+    GLSLFocalInside2PtConicalProcessor(const GrProcessor&);
+    virtual ~GLSLFocalInside2PtConicalProcessor() {}
 
     virtual void emitCode(EmitArgs&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
     UniformHandle fFocalUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedFocal;
 
     // @}
 
 private:
-    typedef GrGLGradientEffect INHERITED;
+    typedef GrGradientEffect::GLSLProcessor INHERITED;
 
 };
 
 void FocalInside2PtConicalEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                                         GrProcessorKeyBuilder* b) const {
-    GLFocalInside2PtConicalEffect::GenKey(*this, caps, b);
+    FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor::GenKey(*this, caps, b);
 }
 
 GrGLSLFragmentProcessor* FocalInside2PtConicalEffect::onCreateGLSLInstance() const {
-    return new GLFocalInside2PtConicalEffect(*this);
+    return new FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor(*this);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 sk_sp<GrFragmentProcessor> FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = 0.f;
@@ skipping 18 matching lines @@
     auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2,
                                                         colors, stops, colorCount, tm);
     SkMatrix viewMatrix = GrTest::TestMatrix(d->fRandom);
     sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(SkShader::AsFPArgs(
         d->fContext, &viewMatrix, NULL, kNone_SkFilterQuality, nullptr,
         SkSourceGammaTreatment::kRespect));
     GrAlwaysAssert(fp);
     return fp;
 }
 
-GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrProcessor&)
+FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor::GLSLFocalInside2PtConicalProcessor(const GrProcessor&)
     : fVSVaryingName(nullptr)
     , fFSVaryingName(nullptr)
     , fCachedFocal(SK_ScalarMax) {}
 
-void GLFocalInside2PtConicalEffect::emitCode(EmitArgs& args) {
+void FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor::emitCode(EmitArgs& args) {
     const FocalInside2PtConicalEffect& ge = args.fFp.cast<FocalInside2PtConicalEffect>();
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     this->emitUniforms(uniformHandler, ge);
     fFocalUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                            kFloat_GrSLType, kDefault_GrSLPrecision,
                                            "Conical2FSParams");
     SkString tName("t");
 
     // this is the distance along x-axis from the end center to focal point in
     // transformed coordinates
@@ skipping 11 matching lines @@
     this->emitColor(fragBuilder,
                     uniformHandler,
                     args.fGLSLCaps,
                     ge,
                     tName.c_str(),
                     args.fOutputColor,
                     args.fInputColor,
                     args.fTexSamplers);
 }
 
-void GLFocalInside2PtConicalEffect::onSetData(const GrGLSLProgramDataManager& pdman,
+void FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
                                               const GrProcessor& processor) {
     INHERITED::onSetData(pdman, processor);
     const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConicalEffect>();
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
         pdman.set1f(fFocalUni, SkScalarToFloat(focal));
         fCachedFocal = focal;
     }
 }
 
-void GLFocalInside2PtConicalEffect::GenKey(const GrProcessor& processor,
+void FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor::GenKey(const GrProcessor& processor,
                                            const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     b->add32(GenBaseGradientKey(processor));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Circle Conical Gradients
 //////////////////////////////////////////////////////////////////////////////
 
 struct CircleConicalInfo {
     SkPoint fCenterEnd;
@@ skipping 50 matching lines @@
 
     // if A ends up being negative, the start circle is contained completely inside the end cirlce
     if (A < 0.f) {
         return kInside_ConicalType;
     }
     return kOutside_ConicalType;
 }
 
 class CircleInside2PtConicalEffect : public GrGradientEffect {
 public:
+    class GLSLCircleInside2PtConicalProcessor;
 
     static sk_sp<GrFragmentProcessor> Make(GrContext* ctx,
                                            const SkTwoPointConicalGradient& shader,
                                            const SkMatrix& matrix,
                                            SkShader::TileMode tm,
                                            const CircleConicalInfo& info) {
         return sk_sp<GrFragmentProcessor>(
             new CircleInside2PtConicalEffect(ctx, shader, matrix, tm, info));
     }
 
@@ skipping 31 matching lines @@
         this->initClassID<CircleInside2PtConicalEffect>();
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     const CircleConicalInfo fInfo;
 
     typedef GrGradientEffect INHERITED;
 };
 
-class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
+class CircleInside2PtConicalEffect::GLSLCircleInside2PtConicalProcessor : public GrGradientEffect::GLSLProcessor {
 public:
-    GLCircleInside2PtConicalEffect(const GrProcessor&);
-    virtual ~GLCircleInside2PtConicalEffect() {}
+    GLSLCircleInside2PtConicalProcessor(const GrProcessor&);
+    virtual ~GLSLCircleInside2PtConicalProcessor() {}
 
     virtual void emitCode(EmitArgs&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
     UniformHandle fCenterUni;
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedCenterX;
     SkScalar fCachedCenterY;
     SkScalar fCachedA;
     SkScalar fCachedB;
     SkScalar fCachedC;
 
     // @}
 
 private:
-    typedef GrGLGradientEffect INHERITED;
+    typedef GrGradientEffect::GLSLProcessor INHERITED;
 
 };
 
 void CircleInside2PtConicalEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                                          GrProcessorKeyBuilder* b) const {
-    GLCircleInside2PtConicalEffect::GenKey(*this, caps, b);
+    CircleInside2PtConicalEffect::GLSLCircleInside2PtConicalProcessor::GenKey(*this, caps, b);
 }
 
 GrGLSLFragmentProcessor* CircleInside2PtConicalEffect::onCreateGLSLInstance() const {
-    return new GLCircleInside2PtConicalEffect(*this);
+    return new CircleInside2PtConicalEffect::GLSLCircleInside2PtConicalProcessor(*this);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 sk_sp<GrFragmentProcessor> CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = d->fRandom->nextUScalar1() + 0.0001f; // make sure radius1 != 0
@@ skipping 17 matching lines @@
     auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2,
                                                         colors, stops, colorCount, tm);
     SkMatrix viewMatrix = GrTest::TestMatrix(d->fRandom);
     sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(SkShader::AsFPArgs(
         d->fContext, &viewMatrix, NULL, kNone_SkFilterQuality, nullptr,
         SkSourceGammaTreatment::kRespect));
     GrAlwaysAssert(fp);
     return fp;
 }
 
-GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrProcessor& processor)
+CircleInside2PtConicalEffect::GLSLCircleInside2PtConicalProcessor::GLSLCircleInside2PtConicalProcessor(const GrProcessor& processor)
     : fVSVaryingName(nullptr)
     , fFSVaryingName(nullptr)
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
     , fCachedC(SK_ScalarMax) {}
 
-void GLCircleInside2PtConicalEffect::emitCode(EmitArgs& args) {
+void CircleInside2PtConicalEffect::GLSLCircleInside2PtConicalProcessor::emitCode(EmitArgs& args) {
     const CircleInside2PtConicalEffect& ge = args.fFp.cast<CircleInside2PtConicalEffect>();
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     this->emitUniforms(uniformHandler, ge);
     fCenterUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
                                             "Conical2FSCenter");
     fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                            kVec3f_GrSLType, kDefault_GrSLPrecision,
                                            "Conical2FSParams");
     SkString tName("t");
@@ skipping 26 matching lines @@
     this->emitColor(fragBuilder,
                     uniformHandler,
                     args.fGLSLCaps,
                     ge,
                     tName.c_str(),
                     args.fOutputColor,
                     args.fInputColor,
                     args.fTexSamplers);
 }
 
-void GLCircleInside2PtConicalEffect::onSetData(const GrGLSLProgramDataManager& pdman,
+void CircleInside2PtConicalEffect::GLSLCircleInside2PtConicalProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
                                                const GrProcessor& processor) {
     INHERITED::onSetData(pdman, processor);
     const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtConicalEffect>();
     SkScalar centerX = data.centerX();
     SkScalar centerY = data.centerY();
     SkScalar A = data.A();
     SkScalar B = data.B();
     SkScalar C = data.C();
 
     if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
         fCachedA != A || fCachedB != B || fCachedC != C) {
 
         pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY));
         pdman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarToFloat(C));
 
         fCachedCenterX = centerX;
         fCachedCenterY = centerY;
         fCachedA = A;
         fCachedB = B;
         fCachedC = C;
     }
 }
 
-void GLCircleInside2PtConicalEffect::GenKey(const GrProcessor& processor,
+void CircleInside2PtConicalEffect::GLSLCircleInside2PtConicalProcessor::GenKey(const GrProcessor& processor,
                                             const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     b->add32(GenBaseGradientKey(processor));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class CircleOutside2PtConicalEffect : public GrGradientEffect {
 public:
+    class GLSLCircleOutside2PtConicalProcessor;
 
     static sk_sp<GrFragmentProcessor> Make(GrContext* ctx,
                                            const SkTwoPointConicalGradient& shader,
                                            const SkMatrix& matrix,
                                            SkShader::TileMode tm,
                                            const CircleConicalInfo& info) {
         return sk_sp<GrFragmentProcessor>(
             new CircleOutside2PtConicalEffect(ctx, shader, matrix, tm, info));
     }
 
@@ skipping 43 matching lines @@
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     const CircleConicalInfo fInfo;
     SkScalar fTLimit;
     bool fIsFlipped;
 
     typedef GrGradientEffect INHERITED;
 };
 
-class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
+class CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor : public GrGradientEffect::GLSLProcessor {
 public:
-    GLCircleOutside2PtConicalEffect(const GrProcessor&);
-    virtual ~GLCircleOutside2PtConicalEffect() {}
+    GLSLCircleOutside2PtConicalProcessor(const GrProcessor&);
+    virtual ~GLSLCircleOutside2PtConicalProcessor() {}
 
     virtual void emitCode(EmitArgs&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
     UniformHandle fCenterUni;
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     bool fIsFlipped;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedCenterX;
     SkScalar fCachedCenterY;
     SkScalar fCachedA;
     SkScalar fCachedB;
     SkScalar fCachedC;
     SkScalar fCachedTLimit;
 
     // @}
 
 private:
-    typedef GrGLGradientEffect INHERITED;
+    typedef GrGradientEffect::GLSLProcessor INHERITED;
 
 };
 
 void CircleOutside2PtConicalEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                                           GrProcessorKeyBuilder* b) const {
-    GLCircleOutside2PtConicalEffect::GenKey(*this, caps, b);
+    CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor::GenKey(*this, caps, b);
 }
 
 GrGLSLFragmentProcessor* CircleOutside2PtConicalEffect::onCreateGLSLInstance() const {
-    return new GLCircleOutside2PtConicalEffect(*this);
+    return new CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor(*this);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 sk_sp<GrFragmentProcessor> CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = d->fRandom->nextUScalar1() + 0.0001f; // make sure radius1 != 0
@@ skipping 18 matching lines @@
     auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2,
                                                         colors, stops, colorCount, tm);
     SkMatrix viewMatrix = GrTest::TestMatrix(d->fRandom);
     sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(SkShader::AsFPArgs(
         d->fContext, &viewMatrix, NULL, kNone_SkFilterQuality, nullptr,
         SkSourceGammaTreatment::kRespect));
     GrAlwaysAssert(fp);
     return fp;
 }
 
-GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrProcessor& processor)
+CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor::GLSLCircleOutside2PtConicalProcessor(const GrProcessor& processor)
     : fVSVaryingName(nullptr)
     , fFSVaryingName(nullptr)
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
     , fCachedC(SK_ScalarMax)
     , fCachedTLimit(SK_ScalarMax) {
     const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
     }
 
-void GLCircleOutside2PtConicalEffect::emitCode(EmitArgs& args) {
+void CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor::emitCode(EmitArgs& args) {
     const CircleOutside2PtConicalEffect& ge = args.fFp.cast<CircleOutside2PtConicalEffect>();
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     this->emitUniforms(uniformHandler, ge);
     fCenterUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
                                             "Conical2FSCenter");
     fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                            kVec4f_GrSLType, kDefault_GrSLPrecision,
                                            "Conical2FSParams");
     SkString tName("t");
@@ skipping 43 matching lines @@
                     uniformHandler,
                     args.fGLSLCaps,
                     ge,
                     tName.c_str(),
                     args.fOutputColor,
                     args.fInputColor,
                     args.fTexSamplers);
     fragBuilder->codeAppend("\t}\n");
 }
 
-void GLCircleOutside2PtConicalEffect::onSetData(const GrGLSLProgramDataManager& pdman,
+void CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
                                                 const GrProcessor& processor) {
     INHERITED::onSetData(pdman, processor);
     const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar centerX = data.centerX();
     SkScalar centerY = data.centerY();
     SkScalar A = data.A();
     SkScalar B = data.B();
     SkScalar C = data.C();
     SkScalar tLimit = data.tLimit();
 
     if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
         fCachedA != A || fCachedB != B || fCachedC != C || fCachedTLimit != tLimit) {
 
         pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY));
         pdman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarToFloat(C),
                    SkScalarToFloat(tLimit));
 
         fCachedCenterX = centerX;
         fCachedCenterY = centerY;
         fCachedA = A;
         fCachedB = B;
         fCachedC = C;
         fCachedTLimit = tLimit;
     }
 }
 
-void GLCircleOutside2PtConicalEffect::GenKey(const GrProcessor& processor,
+void CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor::GenKey(const GrProcessor& processor,
                                              const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     uint32_t* key = b->add32n(2);
     key[0] = GenBaseGradientKey(processor);
     key[1] = processor.cast<CircleOutside2PtConicalEffect>().isFlipped();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 sk_sp<GrFragmentProcessor> Gr2PtConicalGradientEffect::Make(GrContext* ctx,
                                                             const SkTwoPointConicalGradient& shader,
@@ skipping 31 matching lines @@
         return CircleInside2PtConicalEffect::Make(ctx, shader, matrix, tm, info);
     } else if (type == kEdge_ConicalType) {
         set_matrix_edge_conical(shader, &matrix);
         return Edge2PtConicalEffect::Make(ctx, shader, matrix, tm);
     } else {
         return CircleOutside2PtConicalEffect::Make(ctx, shader, matrix, tm, info);
     }
 }
 
 #endif