Remove backend factories

src/gpu/effects/GrConvolutionEffect.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "gl/builders/GrGLProgramBuilder.h"
 #include "GrConvolutionEffect.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLTexture.h"
-#include "GrTBackendProcessorFactory.h"
+#include "gl/builders/GrGLProgramBuilder.h"
 
 // For brevity
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
 class GrGLConvolutionEffect : public GrGLFragmentProcessor {
 public:
-    GrGLConvolutionEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+    GrGLConvolutionEffect(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& pdman, const GrProcessor&) SK_OVERRIDE;
 
     static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
 
 private:
     int width() const { return Gr1DKernelEffect::WidthFromRadius(fRadius); }
     bool useBounds() const { return fUseBounds; }
     Gr1DKernelEffect::Direction direction() const { return fDirection; }
 
     int                 fRadius;
     bool                fUseBounds;
     Gr1DKernelEffect::Direction    fDirection;
     UniformHandle       fKernelUni;
     UniformHandle       fImageIncrementUni;
     UniformHandle       fBoundsUni;
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
-GrGLConvolutionEffect::GrGLConvolutionEffect(const GrBackendProcessorFactory& factory,
-                                             const GrProcessor& processor)
-    : INHERITED(factory) {
+GrGLConvolutionEffect::GrGLConvolutionEffect(const GrProcessor& processor) {
     const GrConvolutionEffect& c = processor.cast<GrConvolutionEffect>();
     fRadius = c.radius();
     fUseBounds = c.useBounds();
     fDirection = c.direction();
 }
 
 void GrGLConvolutionEffect::emitCode(GrGLFPBuilder* builder,
                                      const GrFragmentProcessor&,
                                      const char* outputColor,
                                      const char* inputColor,
@@ skipping 87 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrConvolutionEffect::GrConvolutionEffect(GrTexture* texture,
                                          Direction direction,
                                          int radius,
                                          const float* kernel,
                                          bool useBounds,
                                          float bounds[2])
     : Gr1DKernelEffect(texture, direction, radius), fUseBounds(useBounds) {
+    this->initClassID<GrConvolutionEffect>();
     SkASSERT(radius <= kMaxKernelRadius);
     SkASSERT(kernel);
     int width = this->width();
     for (int i = 0; i < width; i++) {
         fKernel[i] = kernel[i];
     }
     memcpy(fBounds, bounds, sizeof(fBounds));
 }
 
 GrConvolutionEffect::GrConvolutionEffect(GrTexture* texture,
                                          Direction direction,
                                          int radius,
                                          float gaussianSigma,
                                          bool useBounds,
                                          float bounds[2])
     : Gr1DKernelEffect(texture, direction, radius), fUseBounds(useBounds) {
+    this->initClassID<GrConvolutionEffect>();
     SkASSERT(radius <= kMaxKernelRadius);
     int width = this->width();
 
     float sum = 0.0f;
     float denom = 1.0f / (2.0f * gaussianSigma * gaussianSigma);
     for (int i = 0; i < width; ++i) {
         float x = static_cast<float>(i - this->radius());
         // Note that the constant term (1/(sqrt(2*pi*sigma^2)) of the Gaussian
         // is dropped here, since we renormalize the kernel below.
         fKernel[i] = sk_float_exp(- x * x * denom);
         sum += fKernel[i];
     }
     // Normalize the kernel
     float scale = 1.0f / sum;
     for (int i = 0; i < width; ++i) {
         fKernel[i] *= scale;
     }
     memcpy(fBounds, bounds, sizeof(fBounds));
 }
 
 GrConvolutionEffect::~GrConvolutionEffect() {
 }
 
-const GrBackendFragmentProcessorFactory& GrConvolutionEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<GrConvolutionEffect>::getInstance();
+void GrConvolutionEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                        GrProcessorKeyBuilder* b) const {
+    GrGLConvolutionEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrConvolutionEffect::createGLInstance() const  {
+    return SkNEW_ARGS(GrGLConvolutionEffect, (*this));
 }
 
 bool GrConvolutionEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrConvolutionEffect& s = sBase.cast<GrConvolutionEffect>();
     return (this->radius() == s.radius() &&
             this->direction() == s.direction() &&
             this->useBounds() == s.useBounds() &&
             0 == memcmp(fBounds, s.fBounds, sizeof(fBounds)) &&
             0 == memcmp(fKernel, s.fKernel, this->width() * sizeof(float)));
 }
@@ skipping 20 matching lines @@
     }
 
     bool useBounds = random->nextBool();
     return GrConvolutionEffect::Create(textures[texIdx],
                                        dir,
                                        radius,
                                        kernel,
                                        useBounds,
                                        bounds);
 }