Remove backend factories

src/gpu/effects/GrBezierEffect.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 "GrBezierEffect.h"
 
-#include "gl/builders/GrGLProgramBuilder.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLGeometryProcessor.h"
-#include "GrTBackendProcessorFactory.h"
+#include "gl/builders/GrGLProgramBuilder.h"
 
 class GrGLConicEffect : public GrGLGeometryProcessor {
 public:
-    GrGLConicEffect(const GrBackendProcessorFactory&,
-                    const GrGeometryProcessor&,
+    GrGLConicEffect(const GrGeometryProcessor&,
                     const GrBatchTracker&);
 
     virtual void emitCode(const EmitArgs&) SK_OVERRIDE;
 
     static inline void GenKey(const GrGeometryProcessor&,
                               const GrBatchTracker&,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager&,
                          const GrGeometryProcessor&,
                          const GrBatchTracker&) SK_OVERRIDE {}
 
 private:
     GrPrimitiveEdgeType fEdgeType;
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
-GrGLConicEffect::GrGLConicEffect(const GrBackendProcessorFactory& factory,
-                                 const GrGeometryProcessor& processor,
-                                 const GrBatchTracker& bt)
-    : INHERITED (factory) {
+GrGLConicEffect::GrGLConicEffect(const GrGeometryProcessor& processor,
+                                 const GrBatchTracker& bt) {
     const GrConicEffect& ce = processor.cast<GrConicEffect>();
     fEdgeType = ce.getEdgeType();
 }
 
 void GrGLConicEffect::emitCode(const EmitArgs& args) {
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
     const GrConicEffect& gp = args.fGP.cast<GrConicEffect>();
 
     GrGLVertToFrag v(kVec4f_GrSLType);
     args.fPB->addVarying("ConicCoeffs", &v);
@@ skipping 73 matching lines @@
                              GrProcessorKeyBuilder* b) {
     const GrConicEffect& ce = processor.cast<GrConicEffect>();
     uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrConicEffect::~GrConicEffect() {}
 
-const GrBackendGeometryProcessorFactory& GrConicEffect::getFactory() const {
-    return GrTBackendGeometryProcessorFactory<GrConicEffect>::getInstance();
+void GrConicEffect::getGLProcessorKey(const GrBatchTracker& bt,
+                                      const GrGLCaps& caps,
+                                      GrProcessorKeyBuilder* b) const {
+    GrGLConicEffect::GenKey(*this, bt, caps, b);
+}
+
+GrGLGeometryProcessor* GrConicEffect::createGLInstance(const GrBatchTracker& bt) const {
+    return SkNEW_ARGS(GrGLConicEffect, (*this, bt));
 }
 
 GrConicEffect::GrConicEffect(GrPrimitiveEdgeType edgeType)
     : fEdgeType(edgeType) {
+    this->initClassID<GrConicEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInConicCoeffs = &this->addVertexAttrib(GrAttribute("inConicCoeffs",
                                                         kVec4f_GrVertexAttribType));
 }
 
 bool GrConicEffect::onIsEqual(const GrGeometryProcessor& other) const {
     const GrConicEffect& ce = other.cast<GrConicEffect>();
     return (ce.fEdgeType == fEdgeType);
 }
 
@@ skipping 13 matching lines @@
     } while (NULL == gp);
     return gp;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Quad
 //////////////////////////////////////////////////////////////////////////////
 
 class GrGLQuadEffect : public GrGLGeometryProcessor {
 public:
-    GrGLQuadEffect(const GrBackendProcessorFactory&,
-                   const GrGeometryProcessor&,
+    GrGLQuadEffect(const GrGeometryProcessor&,
                    const GrBatchTracker&);
 
     virtual void emitCode(const EmitArgs&) SK_OVERRIDE;
 
     static inline void GenKey(const GrGeometryProcessor&,
                               const GrBatchTracker&,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager&,
                          const GrGeometryProcessor&,
                          const GrBatchTracker&) SK_OVERRIDE {}
 
 private:
     GrPrimitiveEdgeType fEdgeType;
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
-GrGLQuadEffect::GrGLQuadEffect(const GrBackendProcessorFactory& factory,
-                               const GrGeometryProcessor& processor,
-                               const GrBatchTracker& bt)
-    : INHERITED (factory) {
+GrGLQuadEffect::GrGLQuadEffect(const GrGeometryProcessor& processor,
+                               const GrBatchTracker& bt) {
     const GrQuadEffect& ce = processor.cast<GrQuadEffect>();
     fEdgeType = ce.getEdgeType();
 }
 
 void GrGLQuadEffect::emitCode(const EmitArgs& args) {
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
     const GrQuadEffect& gp = args.fGP.cast<GrQuadEffect>();
 
     GrGLVertToFrag v(kVec4f_GrSLType);
     args.fPB->addVarying("HairQuadEdge", &v);
@@ skipping 59 matching lines @@
                             GrProcessorKeyBuilder* b) {
     const GrQuadEffect& ce = processor.cast<GrQuadEffect>();
     uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrQuadEffect::~GrQuadEffect() {}
 
-const GrBackendGeometryProcessorFactory& GrQuadEffect::getFactory() const {
-    return GrTBackendGeometryProcessorFactory<GrQuadEffect>::getInstance();
+void GrQuadEffect::getGLProcessorKey(const GrBatchTracker& bt,
+                                     const GrGLCaps& caps,
+                                     GrProcessorKeyBuilder* b) const {
+    GrGLQuadEffect::GenKey(*this, bt, caps, b);
+}
+
+GrGLGeometryProcessor* GrQuadEffect::createGLInstance(const GrBatchTracker& bt) const {
+    return SkNEW_ARGS(GrGLQuadEffect, (*this, bt));
 }
 
 GrQuadEffect::GrQuadEffect(GrPrimitiveEdgeType edgeType)
     : fEdgeType(edgeType) {
+    this->initClassID<GrQuadEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInHairQuadEdge = &this->addVertexAttrib(GrAttribute("inHairQuadEdge",
                                                         kVec4f_GrVertexAttribType));
 }
 
 bool GrQuadEffect::onIsEqual(const GrGeometryProcessor& other) const {
     const GrQuadEffect& ce = other.cast<GrQuadEffect>();
     return (ce.fEdgeType == fEdgeType);
 }
 
@@ skipping 13 matching lines @@
     } while (NULL == gp);
     return gp;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Cubic
 //////////////////////////////////////////////////////////////////////////////
 
 class GrGLCubicEffect : public GrGLGeometryProcessor {
 public:
-    GrGLCubicEffect(const GrBackendProcessorFactory&,
-                    const GrGeometryProcessor&,
+    GrGLCubicEffect(const GrGeometryProcessor&,
                     const GrBatchTracker&);
 
     virtual void emitCode(const EmitArgs&) SK_OVERRIDE;
 
     static inline void GenKey(const GrGeometryProcessor&,
                               const GrBatchTracker&,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager&,
                          const GrGeometryProcessor&,
                          const GrBatchTracker&) SK_OVERRIDE {}
 
 private:
     GrPrimitiveEdgeType fEdgeType;
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
-GrGLCubicEffect::GrGLCubicEffect(const GrBackendProcessorFactory& factory,
-                                 const GrGeometryProcessor& processor,
-                                 const GrBatchTracker&)
-    : INHERITED (factory) {
+GrGLCubicEffect::GrGLCubicEffect(const GrGeometryProcessor& processor,
+                                 const GrBatchTracker&) {
     const GrCubicEffect& ce = processor.cast<GrCubicEffect>();
     fEdgeType = ce.getEdgeType();
 }
 
 void GrGLCubicEffect::emitCode(const EmitArgs& args) {
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
     const GrCubicEffect& gp = args.fGP.cast<GrCubicEffect>();
 
     GrGLVertToFrag v(kVec4f_GrSLType);
     args.fPB->addVarying("CubicCoeffs", &v, GrGLShaderVar::kHigh_Precision);
@@ skipping 100 matching lines @@
                              GrProcessorKeyBuilder* b) {
     const GrCubicEffect& ce = processor.cast<GrCubicEffect>();
     uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrCubicEffect::~GrCubicEffect() {}
 
-const GrBackendGeometryProcessorFactory& GrCubicEffect::getFactory() const {
-    return GrTBackendGeometryProcessorFactory<GrCubicEffect>::getInstance();
+void GrCubicEffect::getGLProcessorKey(const GrBatchTracker& bt,
+                                      const GrGLCaps& caps,
+                                      GrProcessorKeyBuilder* b) const {
+    GrGLCubicEffect::GenKey(*this, bt, caps, b);
+}
+
+GrGLGeometryProcessor* GrCubicEffect::createGLInstance(const GrBatchTracker& bt) const {
+    return SkNEW_ARGS(GrGLCubicEffect, (*this, bt));
 }
 
 GrCubicEffect::GrCubicEffect(GrPrimitiveEdgeType edgeType)
     : fEdgeType(edgeType) {
+    this->initClassID<GrCubicEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInCubicCoeffs = &this->addVertexAttrib(GrAttribute("inCubicCoeffs",
                                                         kVec4f_GrVertexAttribType));
 }
 
 bool GrCubicEffect::onIsEqual(const GrGeometryProcessor& other) const {
     const GrCubicEffect& ce = other.cast<GrCubicEffect>();
     return (ce.fEdgeType == fEdgeType);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrCubicEffect);
 
 GrGeometryProcessor* GrCubicEffect::TestCreate(SkRandom* random,
                                                GrContext*,
                                                const GrDrawTargetCaps& caps,
                                                GrTexture*[]) {
     GrGeometryProcessor* gp;
     do {
         GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                                                     random->nextULessThan(kGrProcessorEdgeTypeCnt));
         gp = GrCubicEffect::Create(edgeType, caps);
     } while (NULL == gp);
     return gp;
 }