Remove backend factories

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"
 
 #if SK_SUPPORT_GPU
-#include "GrTBackendProcessorFactory.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 // For brevity
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
 static const SkScalar kErrorTol = 0.00001f;
 static const SkScalar kEdgeErrorTol = 5.f * kErrorTol;
 
 /**
  * We have three general cases for 2pt conical gradients. First we always assume that
  * the start radius <= end radius. Our first case (kInside_) is when the start circle
@@ skipping 23 matching lines @@
     SkScalar diffLen = diff.length();
     if (0 != diffLen) {
         SkScalar invDiffLen = SkScalarInvert(diffLen);
         SkMatrix rot;
         rot.setSinCos(-SkScalarMul(invDiffLen, diff.fY),
                        SkScalarMul(invDiffLen, diff.fX));
         invLMatrix->postConcat(rot);
     }
 }
 
-class GLEdge2PtConicalEffect;
-
 class Edge2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm) {
         return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shader, matrix, tm));
     }
 
     virtual ~Edge2PtConicalEffect() {}
 
-    static const char* Name() { return "Two-Point Conical Gradient Edge Touching"; }
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual const char* name() const SK_OVERRIDE {
+        return "Two-Point Conical Gradient Edge Touching";
+    }
+
+    virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
 
     // The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
     SkScalar center() const { return fCenterX1; }
     SkScalar diffRadius() const { return fDiffRadius; }
     SkScalar radius() const { return fRadius0; }
 
-    typedef GLEdge2PtConicalEffect GLProcessor;
-
 private:
     virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
         const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fCenterX1 == s.fCenterX1 &&
                 this->fRadius0 == s.fRadius0 &&
                 this->fDiffRadius == s.fDiffRadius);
     }
 
     Edge2PtConicalEffect(GrContext* ctx,
                          const SkTwoPointConicalGradient& shader,
                          const SkMatrix& matrix,
                          SkShader::TileMode tm)
         : INHERITED(ctx, shader, matrix, tm),
         fCenterX1(shader.getCenterX1()),
         fRadius0(shader.getStartRadius()),
         fDiffRadius(shader.getDiffRadius()){
+        this->initClassID<Edge2PtConicalEffect>();
         // We should only be calling this shader if we are degenerate case with touching circles
         // When deciding if we are in edge case, we scaled by the end radius for cases when the
         // start radius was close to zero, otherwise we scaled by the start radius.  In addition
         // Our test for the edge case in set_matrix_circle_conical has a higher tolerance so we
         // need the sqrt value below
         SkASSERT(SkScalarAbs(SkScalarAbs(fDiffRadius) - fCenterX1) <
                  (fRadius0 < kErrorTol ? shader.getEndRadius() * kEdgeErrorTol :
                                          fRadius0 * sqrt(kEdgeErrorTol)));
 
         // We pass the linear part of the quadratic as a varying.
@@ skipping 21 matching lines @@
     SkScalar         fRadius0;
     SkScalar         fDiffRadius;
 
     // @}
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLEdge2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
+    GLEdge2PtConicalEffect(const GrProcessor&);
     virtual ~GLEdge2PtConicalEffect() { }
 
     virtual void emitCode(GrGLFPBuilder*,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
     virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
@@ skipping 11 matching lines @@
     SkScalar fCachedRadius;
     SkScalar fCachedDiffRadius;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendFragmentProcessorFactory& Edge2PtConicalEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<Edge2PtConicalEffect>::getInstance();
+void Edge2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                             GrProcessorKeyBuilder* b) const {
+    GLEdge2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* Edge2PtConicalEffect::createGLInstance() const {
+    return SkNEW_ARGS(GLEdge2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(SkRandom* random,
                                                       GrContext* context,
                                                       const GrDrawTargetCaps&,
@@ skipping 23 matching lines @@
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrFragmentProcessor* fp;
     GrColor paintColor;
     SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));
     return fp;
 }
 
-GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory,
-                                               const GrProcessor&)
-    : INHERITED(factory)
-    , fVSVaryingName(NULL)
+GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrProcessor&)
+    : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedRadius(-SK_ScalarMax)
     , fCachedDiffRadius(-SK_ScalarMax) {}
 
 void GLEdge2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
                                       const GrFragmentProcessor& fp,
                                       const char* outputColor,
                                       const char* inputColor,
                                       const TransformedCoordsArray& coords,
                                       const TextureSamplerArray& samplers) {
-    const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+    const Edge2PtConicalEffect& ge = fp.cast<Edge2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType, "Conical2FSParams", 3);
 
     SkString cName("c");
     SkString tName("t");
     SkString p0; // start radius
     SkString p1; // start radius squared
     SkString p2; // difference in radii (r1 - r0)
 
@@ skipping 119 matching lines @@
         matrix.postScale(s, s);
     }
 
     invLMatrix->postConcat(matrix);
 
     return conicalType;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-class GLFocalOutside2PtConicalEffect;
-
 class FocalOutside2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm,
                                        SkScalar focalX) {
         return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));
     }
 
     virtual ~FocalOutside2PtConicalEffect() { }
 
-    static const char* Name() { return "Two-Point Conical Gradient Focal Outside"; }
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual const char* name() const SK_OVERRIDE {
+        return "Two-Point Conical Gradient Focal Outside";
+    }
+
+    virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
 
     bool isFlipped() const { return fIsFlipped; }
     SkScalar focal() const { return fFocalX; }
 
-    typedef GLFocalOutside2PtConicalEffect GLProcessor;
-
 private:
     virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
         const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fFocalX == s.fFocalX &&
                 this->fIsFlipped == s.fIsFlipped);
     }
 
     FocalOutside2PtConicalEffect(GrContext* ctx,
                                  const SkTwoPointConicalGradient& shader,
                                  const SkMatrix& matrix,
                                  SkShader::TileMode tm,
                                  SkScalar focalX)
-    : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isFlippedGrad()) {}
+    : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isFlippedGrad()) {
+        this->initClassID<FocalOutside2PtConicalEffect>();
+    }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     SkScalar         fFocalX;
     bool             fIsFlipped;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
+    GLFocalOutside2PtConicalEffect(const GrProcessor&);
     virtual ~GLFocalOutside2PtConicalEffect() { }
 
     virtual void emitCode(GrGLFPBuilder*,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
     virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
@@ skipping 12 matching lines @@
 
     SkScalar fCachedFocal;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendFragmentProcessorFactory& FocalOutside2PtConicalEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<FocalOutside2PtConicalEffect>::getInstance();
+void FocalOutside2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                                     GrProcessorKeyBuilder* b) const {
+    GLFocalOutside2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* FocalOutside2PtConicalEffect::createGLInstance() const {
+    return SkNEW_ARGS(GLFocalOutside2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,
                                                               GrContext* context,
                                                               const GrDrawTargetCaps&,
@@ skipping 20 matching lines @@
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrFragmentProcessor* effect;
     GrColor paintColor;
     SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &effect));
     return effect;
 }
 
-GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,
-                                                               const GrProcessor& processor)
-    : INHERITED(factory)
-    , fVSVaryingName(NULL)
+GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrProcessor& processor)
+    : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedFocal(SK_ScalarMax) {
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
 }
 
 void GLFocalOutside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
                                               const GrFragmentProcessor& fp,
                                               const char* outputColor,
                                               const char* inputColor,
                                               const TransformedCoordsArray& coords,
                                               const TextureSamplerArray& samplers) {
-    const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+    const FocalOutside2PtConicalEffect& ge = fp.cast<FocalOutside2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType, "Conical2FSParams", 2);
     SkString tName("t");
     SkString p0; // focalX
     SkString p1; // 1 - focalX * focalX
 
     builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
     builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
 
@@ skipping 65 matching lines @@
     static GrFragmentProcessor* Create(GrContext* ctx,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm,
                                        SkScalar focalX) {
         return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));
     }
 
     virtual ~FocalInside2PtConicalEffect() {}
 
-    static const char* Name() { return "Two-Point Conical Gradient Focal Inside"; }
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual const char* name() const SK_OVERRIDE {
+        return "Two-Point Conical Gradient Focal Inside";
+    }
+
+    virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
 
     SkScalar focal() const { return fFocalX; }
 
     typedef GLFocalInside2PtConicalEffect GLProcessor;
 
 private:
     virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_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) {}
+        : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {
+        this->initClassID<FocalInside2PtConicalEffect>();
+    }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     SkScalar         fFocalX;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
+    GLFocalInside2PtConicalEffect(const GrProcessor&);
     virtual ~GLFocalInside2PtConicalEffect() {}
 
     virtual void emitCode(GrGLFPBuilder*,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
     virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
@@ skipping 10 matching lines @@
 
     SkScalar fCachedFocal;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendFragmentProcessorFactory& FocalInside2PtConicalEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<FocalInside2PtConicalEffect>::getInstance();
+void FocalInside2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+                               GrProcessorKeyBuilder* b) const {
+    GLFocalInside2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* FocalInside2PtConicalEffect::createGLInstance() const {
+    return SkNEW_ARGS(GLFocalInside2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,
                                                              GrContext* context,
                                                              const GrDrawTargetCaps&,
@@ skipping 22 matching lines @@
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
     GrFragmentProcessor* fp;
     SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));
     return fp;
 }
 
-GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory,
-                                                             const GrProcessor&)
-    : INHERITED(factory)
-    , fVSVaryingName(NULL)
+GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrProcessor&)
+    : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedFocal(SK_ScalarMax) {}
 
 void GLFocalInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
                                              const GrFragmentProcessor& fp,
                                              const char* outputColor,
                                              const char* inputColor,
                                              const TransformedCoordsArray& coords,
                                              const TextureSamplerArray& samplers) {
-    const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+    const FocalInside2PtConicalEffect& ge = fp.cast<FocalInside2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kFloat_GrSLType, "Conical2FSParams");
     SkString tName("t");
 
     // this is the distance along x-axis from the end center to focal point in
     // transformed coordinates
     GrGLShaderVar focal = builder->getUniformVariable(fFocalUni);
 
     // if we have a vec3 from being in perspective, convert it to a vec2 first
@@ skipping 82 matching lines @@
     info->fB = B;
     info->fC = C;
 
     // 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 GLCircleInside2PtConicalEffect;
-
 class CircleInside2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm,
                                        const CircleConicalInfo& info) {
         return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, shader, matrix, tm, info));
     }
 
     virtual ~CircleInside2PtConicalEffect() {}
 
-    static const char* Name() { return "Two-Point Conical Gradient Inside"; }
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual const char* name() const SK_OVERRIDE { return "Two-Point Conical Gradient Inside"; }
+
+    virtual void getGLProcessorKey(const GrGLCaps& caps,
+                                   GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
 
     SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
     SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
     SkScalar A() const { return fInfo.fA; }
     SkScalar B() const { return fInfo.fB; }
     SkScalar C() const { return fInfo.fC; }
 
-    typedef GLCircleInside2PtConicalEffect GLProcessor;
-
 private:
     virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
         const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
                 this->fInfo.fA == s.fInfo.fA &&
                 this->fInfo.fB == s.fInfo.fB &&
                 this->fInfo.fC == s.fInfo.fC);
     }
 
     CircleInside2PtConicalEffect(GrContext* ctx,
                                  const SkTwoPointConicalGradient& shader,
                                  const SkMatrix& matrix,
                                  SkShader::TileMode tm,
                                  const CircleConicalInfo& info)
-        : INHERITED(ctx, shader, matrix, tm), fInfo(info) {}
+        : INHERITED(ctx, shader, matrix, tm), fInfo(info) {
+        this->initClassID<CircleInside2PtConicalEffect>();
+    }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     const CircleConicalInfo fInfo;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
+    GLCircleInside2PtConicalEffect(const GrProcessor&);
     virtual ~GLCircleInside2PtConicalEffect() {}
 
     virtual void emitCode(GrGLFPBuilder*,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
     virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
@@ skipping 15 matching lines @@
     SkScalar fCachedB;
     SkScalar fCachedC;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendFragmentProcessorFactory& CircleInside2PtConicalEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<CircleInside2PtConicalEffect>::getInstance();
+void CircleInside2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                                     GrProcessorKeyBuilder* b) const {
+    GLCircleInside2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* CircleInside2PtConicalEffect::createGLInstance() const {
+    return SkNEW_ARGS(GLCircleInside2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,
                                                               GrContext* context,
                                                               const GrDrawTargetCaps&,
@@ skipping 21 matching lines @@
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
     GrFragmentProcessor* processor;
     SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &processor));
     return processor;
 }
 
-GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory,
-                                                               const GrProcessor& processor)
-    : INHERITED(factory)
-    , fVSVaryingName(NULL)
+GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrProcessor& processor)
+    : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
     , fCachedC(SK_ScalarMax) {}
 
 void GLCircleInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
                                               const GrFragmentProcessor& fp,
                                               const char* outputColor,
                                               const char* inputColor,
                                               const TransformedCoordsArray& coords,
                                               const TextureSamplerArray& samplers) {
-    const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+    const CircleInside2PtConicalEffect& ge = fp.cast<CircleInside2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                      kVec2f_GrSLType, "Conical2FSCenter");
     fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kVec3f_GrSLType, "Conical2FSParams");
     SkString tName("t");
 
     GrGLShaderVar center = builder->getUniformVariable(fCenterUni);
     // params.x = A
     // params.y = B
@@ skipping 46 matching lines @@
     }
 }
 
 void GLCircleInside2PtConicalEffect::GenKey(const GrProcessor& processor,
                                             const GrGLCaps&, GrProcessorKeyBuilder* b) {
     b->add32(GenBaseGradientKey(processor));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-class GLCircleOutside2PtConicalEffect;
-
 class CircleOutside2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm,
                                        const CircleConicalInfo& info) {
         return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, shader, matrix, tm, info));
     }
 
     virtual ~CircleOutside2PtConicalEffect() {}
 
-    static const char* Name() { return "Two-Point Conical Gradient Outside"; }
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual const char* name() const SK_OVERRIDE { return "Two-Point Conical Gradient Outside"; }
+
+    virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
 
     SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
     SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
     SkScalar A() const { return fInfo.fA; }
     SkScalar B() const { return fInfo.fB; }
     SkScalar C() const { return fInfo.fC; }
     SkScalar tLimit() const { return fTLimit; }
     bool isFlipped() const { return fIsFlipped; }
 
-    typedef GLCircleOutside2PtConicalEffect GLProcessor;
-
 private:
     virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
         const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
                 this->fInfo.fA == s.fInfo.fA &&
                 this->fInfo.fB == s.fInfo.fB &&
                 this->fInfo.fC == s.fInfo.fC &&
                 this->fTLimit == s.fTLimit &&
                 this->fIsFlipped == s.fIsFlipped);
     }
 
     CircleOutside2PtConicalEffect(GrContext* ctx,
                                   const SkTwoPointConicalGradient& shader,
                                   const SkMatrix& matrix,
                                   SkShader::TileMode tm,
                                   const CircleConicalInfo& info)
         : INHERITED(ctx, shader, matrix, tm), fInfo(info) {
+        this->initClassID<CircleOutside2PtConicalEffect>();
         if (shader.getStartRadius() != shader.getEndRadius()) {
             fTLimit = SkScalarDiv(shader.getStartRadius(),
                                   (shader.getStartRadius() - shader.getEndRadius()));
         } else {
             fTLimit = SK_ScalarMin;
         }
 
         fIsFlipped = shader.isFlippedGrad();
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     const CircleConicalInfo fInfo;
     SkScalar fTLimit;
     bool fIsFlipped;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+    GLCircleOutside2PtConicalEffect(const GrProcessor&);
     virtual ~GLCircleOutside2PtConicalEffect() {}
 
     virtual void emitCode(GrGLFPBuilder*,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
     virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
@@ skipping 18 matching lines @@
     SkScalar fCachedC;
     SkScalar fCachedTLimit;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendFragmentProcessorFactory& CircleOutside2PtConicalEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<CircleOutside2PtConicalEffect>::getInstance();
+void CircleOutside2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                                      GrProcessorKeyBuilder* b) const {
+    GLCircleOutside2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* CircleOutside2PtConicalEffect::createGLInstance() const {
+    return SkNEW_ARGS(GLCircleOutside2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,
                                                                GrContext* context,
                                                                const GrDrawTargetCaps&,
@@ skipping 22 matching lines @@
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
     GrFragmentProcessor* processor;
     SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &processor));
     return processor;
 }
 
-GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,
-                                                                 const GrProcessor& processor)
-    : INHERITED(factory)
-    , fVSVaryingName(NULL)
+GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrProcessor& processor)
+    : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , 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(GrGLFPBuilder* builder,
                                                const GrFragmentProcessor& fp,
                                                const char* outputColor,
                                                const char* inputColor,
                                                const TransformedCoordsArray& coords,
                                                const TextureSamplerArray& samplers) {
-    const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+    const CircleOutside2PtConicalEffect& ge = fp.cast<CircleOutside2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                      kVec2f_GrSLType, "Conical2FSCenter");
     fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kVec4f_GrSLType, "Conical2FSParams");
     SkString tName("t");
 
     GrGLShaderVar center = builder->getUniformVariable(fCenterUni);
     // params.x = A
     // params.y = B
@@ skipping 111 matching lines @@
         return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, info);
     } else if (type == kEdge_ConicalType) {
         set_matrix_edge_conical(shader, &matrix);
         return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm);
     } else {
         return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, info);
     }
 }
 
 #endif