Remove backend factories

src/gpu/effects/GrDashingEffect.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 "GrDashingEffect.h"
 
 #include "../GrAARectRenderer.h"
 
 #include "GrGeometryProcessor.h"
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTarget.h"
 #include "GrDrawTargetCaps.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
 #include "GrStrokeInfo.h"
-#include "GrTBackendProcessorFactory.h"
 #include "SkGr.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLSL.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns whether or not the gpu can fast path the dash line effect.
 static bool can_fast_path_dash(const SkPoint pts[2], const GrStrokeInfo& strokeInfo,
@@ skipping 424 matching lines @@
 class DashingCircleEffect : public GrGeometryProcessor {
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
     static GrGeometryProcessor* Create(GrPrimitiveEdgeType edgeType,
                                        const DashInfo& info,
                                        SkScalar radius);
 
     virtual ~DashingCircleEffect();
 
-    static const char* Name() { return "DashingCircleEffect"; }
+    virtual const char* name() const SK_OVERRIDE { return "DashingCircleEffect"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
 
     const GrAttribute* inCoord() const { return fInCoord; }
 
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
     SkScalar getRadius() const { return fRadius; }
 
     SkScalar getCenterX() const { return fCenterX; }
 
     SkScalar getIntervalLength() const { return fIntervalLength; }
 
-    typedef GLDashingCircleEffect GLProcessor;
+    virtual void getGLProcessorKey(const GrBatchTracker&,
+                                   const GrGLCaps&,
+                                   GrProcessorKeyBuilder* b) const SK_OVERRIDE;
 
-    virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker&) const SK_OVERRIDE;
 
 private:
     DashingCircleEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info, SkScalar radius);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
 
     GrPrimitiveEdgeType fEdgeType;
     const GrAttribute*  fInPosition;
     const GrAttribute*  fInCoord;
     SkScalar            fIntervalLength;
     SkScalar            fRadius;
     SkScalar            fCenterX;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect : public GrGLGeometryProcessor {
 public:
-    GLDashingCircleEffect(const GrBackendProcessorFactory&,
-                          const GrGeometryProcessor&,
-                          const GrBatchTracker&);
+    GLDashingCircleEffect(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:
     GrGLProgramDataManager::UniformHandle fParamUniform;
     SkScalar                              fPrevRadius;
     SkScalar                              fPrevCenterX;
     SkScalar                              fPrevIntervalLength;
     typedef GrGLGeometryProcessor INHERITED;
 };
 
-GLDashingCircleEffect::GLDashingCircleEffect(const GrBackendProcessorFactory& factory,
-                                             const GrGeometryProcessor&,
-                                             const GrBatchTracker&)
-    : INHERITED (factory) {
+GLDashingCircleEffect::GLDashingCircleEffect(const GrGeometryProcessor&,
+                                             const GrBatchTracker&) {
     fPrevRadius = SK_ScalarMin;
     fPrevCenterX = SK_ScalarMin;
     fPrevIntervalLength = SK_ScalarMax;
 }
 
 void GLDashingCircleEffect::emitCode(const EmitArgs& args) {
     const DashingCircleEffect& dce = args.fGP.cast<DashingCircleEffect>();
     const char *paramName;
     // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x coord, and
     // the total interval length of the dash.
@@ skipping 67 matching lines @@
 
     return SkNEW_ARGS(DashingCircleEffect, (edgeType, info, radius));
 }
 
 DashingCircleEffect::~DashingCircleEffect() {}
 
 void DashingCircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownAlpha();
 }
 
-const GrBackendGeometryProcessorFactory& DashingCircleEffect::getFactory() const {
-    return GrTBackendGeometryProcessorFactory<DashingCircleEffect>::getInstance();
+void DashingCircleEffect::getGLProcessorKey(const GrBatchTracker& bt,
+                                            const GrGLCaps& caps,
+                                            GrProcessorKeyBuilder* b) const {
+    GLDashingCircleEffect::GenKey(*this, bt, caps, b);
+}
+
+GrGLGeometryProcessor* DashingCircleEffect::createGLInstance(const GrBatchTracker& bt) const {
+    return SkNEW_ARGS(GLDashingCircleEffect, (*this, bt));
 }
 
 DashingCircleEffect::DashingCircleEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info,
                                          SkScalar radius)
     : fEdgeType(edgeType) {
+    this->initClassID<DashingCircleEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttribType));
     SkScalar onLen = info.fIntervals[0];
     SkScalar offLen = info.fIntervals[1];
     fIntervalLength = onLen + offLen;
     fRadius = radius;
     fCenterX = SkScalarHalf(offLen);
 }
 
 bool DashingCircleEffect::onIsEqual(const GrGeometryProcessor& other) const {
@@ skipping 40 matching lines @@
 class DashingLineEffect : public GrGeometryProcessor {
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
     static GrGeometryProcessor* Create(GrPrimitiveEdgeType edgeType,
                                        const DashInfo& info,
                                        SkScalar strokeWidth);
 
     virtual ~DashingLineEffect();
 
-    static const char* Name() { return "DashingEffect"; }
+    virtual const char* name() const SK_OVERRIDE { return "DashingEffect"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
 
     const GrAttribute* inCoord() const { return fInCoord; }
 
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
     const SkRect& getRect() const { return fRect; }
 
     SkScalar getIntervalLength() const { return fIntervalLength; }
 
-    typedef GLDashingLineEffect GLProcessor;
+    virtual void getGLProcessorKey(const GrBatchTracker& bt,
+                                   const GrGLCaps& caps,
+                                   GrProcessorKeyBuilder* b) const SK_OVERRIDE;
 
-    virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE;
 
 private:
     DashingLineEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info, SkScalar strokeWidth);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
 
     GrPrimitiveEdgeType fEdgeType;
     const GrAttribute*  fInPosition;
     const GrAttribute*  fInCoord;
     SkRect              fRect;
     SkScalar            fIntervalLength;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingLineEffect : public GrGLGeometryProcessor {
 public:
-    GLDashingLineEffect(const GrBackendProcessorFactory&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&);
+    GLDashingLineEffect(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:
     GrGLProgramDataManager::UniformHandle fRectUniform;
     GrGLProgramDataManager::UniformHandle fIntervalUniform;
     SkRect                                fPrevRect;
     SkScalar                              fPrevIntervalLength;
     typedef GrGLGeometryProcessor INHERITED;
 };
 
-GLDashingLineEffect::GLDashingLineEffect(const GrBackendProcessorFactory& factory,
-                                         const GrGeometryProcessor&,
-                                         const GrBatchTracker&)
-    : INHERITED (factory) {
+GLDashingLineEffect::GLDashingLineEffect(const GrGeometryProcessor&,
+                                         const GrBatchTracker&) {
     fPrevRect.fLeft = SK_ScalarNaN;
     fPrevIntervalLength = SK_ScalarMax;
 }
 
 void GLDashingLineEffect::emitCode(const EmitArgs& args) {
     const DashingLineEffect& de = args.fGP.cast<DashingLineEffect>();
     const char *rectName;
     // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
     // respectively.
     fRectUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
@@ skipping 81 matching lines @@
 
     return SkNEW_ARGS(DashingLineEffect, (edgeType, info, strokeWidth));
 }
 
 DashingLineEffect::~DashingLineEffect() {}
 
 void DashingLineEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownAlpha();
 }
 
-const GrBackendGeometryProcessorFactory& DashingLineEffect::getFactory() const {
-    return GrTBackendGeometryProcessorFactory<DashingLineEffect>::getInstance();
+void DashingLineEffect::getGLProcessorKey(const GrBatchTracker& bt,
+                                          const GrGLCaps& caps,
+                                          GrProcessorKeyBuilder* b) const {
+    GLDashingLineEffect::GenKey(*this, bt, caps, b);
+}
+
+GrGLGeometryProcessor* DashingLineEffect::createGLInstance(const GrBatchTracker& bt) const {
+    return SkNEW_ARGS(GLDashingLineEffect, (*this, bt));
 }
 
 DashingLineEffect::DashingLineEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info,
                                      SkScalar strokeWidth)
     : fEdgeType(edgeType) {
+    this->initClassID<DashingLineEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttribType));
     SkScalar onLen = info.fIntervals[0];
     SkScalar offLen = info.fIntervals[1];
     SkScalar halfOffLen = SkScalarHalf(offLen);
     SkScalar halfStroke = SkScalarHalf(strokeWidth);
     fIntervalLength = onLen + offLen;
     fRect.set(halfOffLen, -halfStroke, halfOffLen + onLen, halfStroke);
 }
 
@@ skipping 33 matching lines @@
     switch (cap) {
         case GrDashingEffect::kRound_DashCap:
             return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(strokeWidth));
         case GrDashingEffect::kNonRound_DashCap:
             return DashingLineEffect::Create(edgeType, info, strokeWidth);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }