Remove backend factories

src/effects/SkLightingImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU
+#include "GrFragmentProcessor.h"
+#include "GrInvariantOutput.h"
 #include "effects/GrSingleTextureEffect.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
-#include "GrFragmentProcessor.h"
-#include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
 
 class GrGLDiffuseLightingEffect;
 class GrGLSpecularLightingEffect;
 
 // For brevity
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 #endif
 
 namespace {
 
@@ skipping 333 matching lines @@
                                        SkScalar surfaceScale,
                                        const SkMatrix& matrix,
                                        SkScalar kd) {
         return SkNEW_ARGS(GrDiffuseLightingEffect, (texture,
                                                     light,
                                                     surfaceScale,
                                                     matrix,
                                                     kd));
     }
 
-    static const char* Name() { return "DiffuseLighting"; }
+    virtual const char* name() const SK_OVERRIDE { return "DiffuseLighting"; }
 
-    typedef GrGLDiffuseLightingEffect GLProcessor;
+    virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
 
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+
+    virtual uint32_t classID() const {
+        static uint32_t id = GenClassID();
+        return id;
+    }
+
     SkScalar kd() const { return fKD; }
 
 private:
     virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
 
     GrDiffuseLightingEffect(GrTexture* texture,
                             const SkLight* light,
                             SkScalar surfaceScale,
                             const SkMatrix& matrix,
                             SkScalar kd);
@@ skipping 11 matching lines @@
                                        const SkMatrix& matrix,
                                        SkScalar ks,
                                        SkScalar shininess) {
         return SkNEW_ARGS(GrSpecularLightingEffect, (texture,
                                                      light,
                                                      surfaceScale,
                                                      matrix,
                                                      ks,
                                                      shininess));
     }
-    static const char* Name() { return "SpecularLighting"; }
 
-    typedef GrGLSpecularLightingEffect GLProcessor;
+    virtual const char* name() const SK_OVERRIDE { return "SpecularLighting"; }
 
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    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;
+    }
+
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
 private:
     virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
 
     GrSpecularLightingEffect(GrTexture* texture,
                              const SkLight* light,
                              SkScalar surfaceScale,
                              const SkMatrix& matrix,
@@ skipping 755 matching lines @@
         default:
             SkFAIL("Unexpected value.");
             return NULL;
     }
 }
 
 }
 
 class GrGLLightingEffect  : public GrGLFragmentProcessor {
 public:
-    GrGLLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+    GrGLLightingEffect(const GrProcessor&);
     virtual ~GrGLLightingEffect();
 
     virtual void emitCode(GrGLFPBuilder*,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b);
@@ skipping 11 matching lines @@
 
     UniformHandle       fImageIncrementUni;
     UniformHandle       fSurfaceScaleUni;
     GrGLLight*          fLight;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDiffuseLightingEffect  : public GrGLLightingEffect {
 public:
-    GrGLDiffuseLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+    GrGLDiffuseLightingEffect(const GrProcessor&);
     virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) SK_OVERRIDE;
     virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKDUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpecularLightingEffect  : public GrGLLightingEffect {
 public:
-    GrGLSpecularLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+    GrGLSpecularLightingEffect(const GrProcessor&);
     virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) SK_OVERRIDE;
     virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKSUni;
     UniformHandle   fShininessUni;
 };
 
@@ skipping 26 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDiffuseLightingEffect::GrDiffuseLightingEffect(GrTexture* texture,
                                                  const SkLight* light,
                                                  SkScalar surfaceScale,
                                                  const SkMatrix& matrix,
                                                  SkScalar kd)
     : INHERITED(texture, light, surfaceScale, matrix), fKD(kd) {
 }
 
-const GrBackendFragmentProcessorFactory& GrDiffuseLightingEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<GrDiffuseLightingEffect>::getInstance();
-}
-
 bool GrDiffuseLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>();
     return INHERITED::onIsEqual(sBase) &&
             this->kd() == s.kd();
 }
 
+void GrDiffuseLightingEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                                GrProcessorKeyBuilder* b) const {
+    GrGLDiffuseLightingEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrDiffuseLightingEffect::createGLInstance() const {
+    return SkNEW_ARGS(GrGLDiffuseLightingEffect, (*this));
+}
+
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect);
 
 GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(SkRandom* random,
                                               GrContext* context,
                                               const GrDrawTargetCaps&,
                                               GrTexture* textures[]) {
     SkScalar surfaceScale = random->nextSScalar1();
     SkScalar kd = random->nextUScalar1();
     SkAutoTUnref<SkLight> light(create_random_light(random));
     SkMatrix matrix;
     for (int i = 0; i < 9; i++) {
         matrix[i] = random->nextUScalar1();
     }
     return GrDiffuseLightingEffect::Create(textures[GrProcessorUnitTest::kAlphaTextureIdx],
                                            light, surfaceScale, matrix, kd);
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrGLLightingEffect::GrGLLightingEffect(const GrBackendProcessorFactory& factory,
-                                       const GrProcessor& fp)
-    : INHERITED(factory) {
+GrGLLightingEffect::GrGLLightingEffect(const GrProcessor& fp) {
     const GrLightingEffect& m = fp.cast<GrLightingEffect>();
     fLight = m.light()->createGLLight();
 }
 
 GrGLLightingEffect::~GrGLLightingEffect() {
     delete fLight;
 }
 
 void GrGLLightingEffect::emitCode(GrGLFPBuilder* builder,
                                   const GrFragmentProcessor&,
@@ skipping 104 matching lines @@
     pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
     pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale());
     SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.filterMatrix()));
     fLight->setData(pdman, transformedLight);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendProcessorFactory& factory,
-                                                     const GrProcessor& proc)
-    : INHERITED(factory, proc) {
+GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrProcessor& proc)
+    : INHERITED(proc) {
 }
 
 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLFPBuilder* builder, SkString* funcName) {
     const char* kd;
     fKDUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                  kFloat_GrSLType,
                                  "KD",
                                  &kd);
 
     static const GrGLShaderVar gLightArgs[] = {
@@ skipping 25 matching lines @@
                                                    const SkLight* light,
                                                    SkScalar surfaceScale,
                                                    const SkMatrix& matrix,
                                                    SkScalar ks,
                                                    SkScalar shininess)
     : INHERITED(texture, light, surfaceScale, matrix),
       fKS(ks),
       fShininess(shininess) {
 }
 
-const GrBackendFragmentProcessorFactory& GrSpecularLightingEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<GrSpecularLightingEffect>::getInstance();
-}
-
 bool GrSpecularLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>();
     return INHERITED::onIsEqual(sBase) &&
            this->ks() == s.ks() &&
            this->shininess() == s.shininess();
 }
 
+void GrSpecularLightingEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                                GrProcessorKeyBuilder* b) const {
+    GrGLSpecularLightingEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrSpecularLightingEffect::createGLInstance() const {
+    return SkNEW_ARGS(GrGLSpecularLightingEffect, (*this));
+}
+
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect);
 
 GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(SkRandom* random,
                                                           GrContext* context,
                                                           const GrDrawTargetCaps&,
                                                           GrTexture* textures[]) {
     SkScalar surfaceScale = random->nextSScalar1();
     SkScalar ks = random->nextUScalar1();
     SkScalar shininess = random->nextUScalar1();
     SkAutoTUnref<SkLight> light(create_random_light(random));
     SkMatrix matrix;
     for (int i = 0; i < 9; i++) {
         matrix[i] = random->nextUScalar1();
     }
     return GrSpecularLightingEffect::Create(textures[GrProcessorUnitTest::kAlphaTextureIdx],
                                             light, surfaceScale, matrix, ks, shininess);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendProcessorFactory& factory,
-                                                       const GrProcessor& proc)
-    : INHERITED(factory, proc) {
+GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrProcessor& proc)
+    : INHERITED(proc) {
 }
 
 void GrGLSpecularLightingEffect::emitLightFunc(GrGLFPBuilder* builder, SkString* funcName) {
     const char* ks;
     const char* shininess;
 
     fKSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                  kFloat_GrSLType, "KS", &ks);
     fShininessUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                         kFloat_GrSLType, "Shininess", &shininess);
@@ skipping 146 matching lines @@
 
     fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END