Remove backend factories

src/effects/SkMagnifierImageFilter.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 "SkBitmap.h"
 #include "SkMagnifierImageFilter.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkValidationUtils.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 #if SK_SUPPORT_GPU
+#include "GrInvariantOutput.h"
 #include "effects/GrSingleTextureEffect.h"
 #include "gl/GrGLProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLTexture.h"
-#include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
-
-class GrGLMagnifierEffect;
+#include "gl/builders/GrGLProgramBuilder.h"
 
 class GrMagnifierEffect : public GrSingleTextureEffect {
 
 public:
     static GrFragmentProcessor* Create(GrTexture* texture,
                                        float xOffset,
                                        float yOffset,
                                        float xInvZoom,
                                        float yInvZoom,
                                        float xInvInset,
                                        float yInvInset) {
         return SkNEW_ARGS(GrMagnifierEffect, (texture,
                                               xOffset,
                                               yOffset,
                                               xInvZoom,
                                               yInvZoom,
                                               xInvInset,
                                               yInvInset));
     }
 
     virtual ~GrMagnifierEffect() {};
 
-    static const char* Name() { return "Magnifier"; }
+    virtual const char* name() const SK_OVERRIDE { return "Magnifier"; }
 
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+    virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+
     float x_offset() const { return fXOffset; }
     float y_offset() const { return fYOffset; }
     float x_inv_zoom() const { return fXInvZoom; }
     float y_inv_zoom() const { return fYInvZoom; }
     float x_inv_inset() const { return fXInvInset; }
     float y_inv_inset() const { return fYInvInset; }
 
-    typedef GrGLMagnifierEffect GLProcessor;
-
 private:
     GrMagnifierEffect(GrTexture* texture,
                       float xOffset,
                       float yOffset,
                       float xInvZoom,
                       float yInvZoom,
                       float xInvInset,
                       float yInvInset)
         : GrSingleTextureEffect(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture))
         , fXOffset(xOffset)
         , fYOffset(yOffset)
         , fXInvZoom(xInvZoom)
         , fYInvZoom(yInvZoom)
         , fXInvInset(xInvInset)
-        , fYInvInset(yInvInset) {}
+        , fYInvInset(yInvInset) {
+        this->initClassID<GrMagnifierEffect>();
+    }
 
     virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
 
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     float fXOffset;
     float fYOffset;
     float fXInvZoom;
     float fYInvZoom;
     float fXInvInset;
     float fYInvInset;
 
     typedef GrSingleTextureEffect INHERITED;
 };
 
 // For brevity
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
 class GrGLMagnifierEffect : public GrGLFragmentProcessor {
 public:
-    GrGLMagnifierEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+    GrGLMagnifierEffect(const GrProcessor&);
 
     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;
 
 private:
     UniformHandle       fOffsetVar;
     UniformHandle       fInvZoomVar;
     UniformHandle       fInvInsetVar;
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
-GrGLMagnifierEffect::GrGLMagnifierEffect(const GrBackendProcessorFactory& factory,
-                                         const GrProcessor&)
-    : INHERITED(factory) {
+GrGLMagnifierEffect::GrGLMagnifierEffect(const GrProcessor&) {
 }
 
 void GrGLMagnifierEffect::emitCode(GrGLFPBuilder* builder,
                                    const GrFragmentProcessor&,
                                    const char* outputColor,
                                    const char* inputColor,
                                    const TransformedCoordsArray& coords,
                                    const TextureSamplerArray& samplers) {
     fOffsetVar = builder->addUniform(
         GrGLProgramBuilder::kFragment_Visibility |
@@ skipping 45 matching lines @@
 void GrGLMagnifierEffect::setData(const GrGLProgramDataManager& pdman,
                                   const GrProcessor& effect) {
     const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>();
     pdman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset());
     pdman.set2f(fInvZoomVar, zoom.x_inv_zoom(), zoom.y_inv_zoom());
     pdman.set2f(fInvInsetVar, zoom.x_inv_inset(), zoom.y_inv_inset());
 }
 
 /////////////////////////////////////////////////////////////////////
 
+void GrMagnifierEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                          GrProcessorKeyBuilder* b) const {
+    GrGLMagnifierEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrMagnifierEffect::createGLInstance() const {
+    return SkNEW_ARGS(GrGLMagnifierEffect, (*this));
+}
+
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect);
 
 GrFragmentProcessor* GrMagnifierEffect::TestCreate(SkRandom* random,
                                                    GrContext* context,
                                                    const GrDrawTargetCaps&,
                                                    GrTexture** textures) {
     GrTexture* texture = textures[0];
     const int kMaxWidth = 200;
     const int kMaxHeight = 200;
     const int kMaxInset = 20;
@@ skipping 10 matching lines @@
         texture->width() / (float) x,
         texture->height() / (float) y,
         (float) inset / texture->width(),
         (float) inset / texture->height());
     SkASSERT(effect);
     return effect;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-const GrBackendFragmentProcessorFactory& GrMagnifierEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<GrMagnifierEffect>::getInstance();
-}
-
 bool GrMagnifierEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrMagnifierEffect& s = sBase.cast<GrMagnifierEffect>();
     return (this->fXOffset == s.fXOffset &&
             this->fYOffset == s.fYOffset &&
             this->fXInvZoom == s.fXInvZoom &&
             this->fYInvZoom == s.fYInvZoom &&
             this->fXInvInset == s.fXInvInset &&
             this->fYInvInset == s.fYInvInset);
 }
 
@@ skipping 119 matching lines @@
 
             int x_val = SkPin32(SkScalarFloorToInt(x_interp), 0, width - 1);
             int y_val = SkPin32(SkScalarFloorToInt(y_interp), 0, height - 1);
 
             *dptr = sptr[y_val * width + x_val];
             dptr++;
         }
     }
     return true;
 }