Remove backend factories

src/gpu/effects/GrRRectEffect.cpp

Index: src/gpu/effects/GrRRectEffect.cpp
diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index 7e58c1fe287a58b95e6c7084d2e18959687758a3..11899ed37e58e4a2c9f8107faa19ea6c6d397446 100644
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -5,25 +5,22 @@
  * found in the LICENSE file.
  */
 
-#include "gl/builders/GrGLProgramBuilder.h"
 #include "GrRRectEffect.h"
 
-#include "gl/GrGLProcessor.h"
-#include "gl/GrGLSL.h"
 #include "GrConvexPolyEffect.h"
+#include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrOvalEffect.h"
-#include "GrTBackendProcessorFactory.h"
-
 #include "SkRRect.h"
+#include "gl/GrGLProcessor.h"
+#include "gl/GrGLSL.h"
+#include "gl/builders/GrGLProgramBuilder.h"
 
 // The effects defined here only handle rrect radii >= kRadiusMin.
 static const SkScalar kRadiusMin = SK_ScalarHalf;
 
 //////////////////////////////////////////////////////////////////////////////
 
-class GLCircularRRectEffect;
-
 class CircularRRectEffect : public GrFragmentProcessor {
 public:
 
@@ -50,7 +47,17 @@ public:
                                        const SkRRect&);
 
     virtual ~CircularRRectEffect() {};
-    static const char* Name() { return "CircularRRect"; }
+
+    virtual const char* name() const SK_OVERRIDE { return "CircularRRect"; }
+
+    virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+
+    virtual uint32_t classID() const {
+        static uint32_t id = GenClassID();
+        return id;
+    }
 
     const SkRRect& getRRect() const { return fRRect; }
 
@@ -58,10 +65,6 @@ public:
 
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
-    typedef GLCircularRRectEffect GLProcessor;
-
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
-
 private:
     CircularRRectEffect(GrPrimitiveEdgeType, uint32_t circularCornerFlags, const SkRRect&);
 
@@ -91,10 +94,6 @@ void CircularRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) con
     inout->mulByUnknownAlpha();
 }
 
-const GrBackendFragmentProcessorFactory& CircularRRectEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<CircularRRectEffect>::getInstance();
-}
-
 CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t circularCornerFlags,
                                          const SkRRect& rrect)
     : fRRect(rrect)
@@ -135,7 +134,7 @@ GrFragmentProcessor* CircularRRectEffect::TestCreate(SkRandom* random,
 
 class GLCircularRRectEffect : public GrGLFragmentProcessor {
 public:
-    GLCircularRRectEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+    GLCircularRRectEffect(const GrProcessor&);
 
     virtual void emitCode(GrGLFPBuilder* builder,
                           const GrFragmentProcessor& fp,
@@ -155,9 +154,7 @@ private:
     typedef GrGLFragmentProcessor INHERITED;
 };
 
-GLCircularRRectEffect::GLCircularRRectEffect(const GrBackendProcessorFactory& factory,
-                                             const GrProcessor& )
-    : INHERITED (factory) {
+GLCircularRRectEffect::GLCircularRRectEffect(const GrProcessor& ) {
     fPrevRRect.setEmpty();
 }
 
@@ -380,25 +377,39 @@ void GLCircularRRectEffect::setData(const GrGLProgramDataManager& pdman,
     }
 }
 
-//////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
-class GLEllipticalRRectEffect;
+void CircularRRectEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                            GrProcessorKeyBuilder* b) const {
+    GLCircularRRectEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* CircularRRectEffect::createGLInstance() const  {
+    return SkNEW_ARGS(GLCircularRRectEffect, (*this));
+}
+
+//////////////////////////////////////////////////////////////////////////////
 
 class EllipticalRRectEffect : public GrFragmentProcessor {
 public:
     static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRRect&);
 
     virtual ~EllipticalRRectEffect() {};
-    static const char* Name() { return "EllipticalRRect"; }
 
-    const SkRRect& getRRect() const { return fRRect; }
+    virtual const char* name() const SK_OVERRIDE { return "EllipticalRRect"; }
 
+    virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
 
-    GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+
+    virtual uint32_t classID() const {
+        static uint32_t id = GenClassID();
+        return id;
+    }
 
-    typedef GLEllipticalRRectEffect GLProcessor;
+    const SkRRect& getRRect() const { return fRRect; }
 
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
 private:
     EllipticalRRectEffect(GrPrimitiveEdgeType, const SkRRect&);
@@ -427,10 +438,6 @@ void EllipticalRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) c
     inout->mulByUnknownAlpha();
 }
 
-const GrBackendFragmentProcessorFactory& EllipticalRRectEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<EllipticalRRectEffect>::getInstance();
-}
-
 EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const SkRRect& rrect)
     : fRRect(rrect)
     , fEdgeType(edgeType){
@@ -488,7 +495,7 @@ GrFragmentProcessor* EllipticalRRectEffect::TestCreate(SkRandom* random,
 
 class GLEllipticalRRectEffect : public GrGLFragmentProcessor {
 public:
-    GLEllipticalRRectEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+    GLEllipticalRRectEffect(const GrProcessor&);
 
     virtual void emitCode(GrGLFPBuilder* builder,
                           const GrFragmentProcessor& effect,
@@ -508,9 +515,7 @@ private:
     typedef GrGLFragmentProcessor INHERITED;
 };
 
-GLEllipticalRRectEffect::GLEllipticalRRectEffect(const GrBackendProcessorFactory& factory,
-                             const GrProcessor& effect)
-    : INHERITED (factory) {
+GLEllipticalRRectEffect::GLEllipticalRRectEffect(const GrProcessor& effect) {
     fPrevRRect.setEmpty();
 }
 
@@ -634,6 +639,17 @@ void GLEllipticalRRectEffect::setData(const GrGLProgramDataManager& pdman,
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void EllipticalRRectEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                              GrProcessorKeyBuilder* b) const {
+    GLEllipticalRRectEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* EllipticalRRectEffect::createGLInstance() const  {
+    return SkNEW_ARGS(GLEllipticalRRectEffect, (*this));
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 GrFragmentProcessor* GrRRectEffect::Create(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {