Remove backend factories

src/gpu/effects/GrConfigConversionEffect.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 "GrConfigConversionEffect.h"
 #include "GrContext.h"
 #include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
 #include "GrSimpleTextureEffect.h"
+#include "SkMatrix.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
-#include "SkMatrix.h"
 
 class GrGLConfigConversionEffect : public GrGLFragmentProcessor {
 public:
-    GrGLConfigConversionEffect(const GrBackendProcessorFactory& factory,
-                               const GrProcessor& processor)
-    : INHERITED (factory) {
+    GrGLConfigConversionEffect(const GrProcessor& processor) {
         const GrConfigConversionEffect& configConversionEffect =
                 processor.cast<GrConfigConversionEffect>();
         fSwapRedAndBlue = configConversionEffect.swapsRedAndBlue();
         fPMConversion = configConversionEffect.pmConversion();
     }
 
     virtual void emitCode(GrGLFPBuilder* builder,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
@@ skipping 76 matching lines @@
                                                    const SkMatrix& matrix)
     : GrSingleTextureEffect(texture, matrix)
     , fSwapRedAndBlue(swapRedAndBlue)
     , fPMConversion(pmConversion) {
     SkASSERT(kRGBA_8888_GrPixelConfig == texture->config() ||
              kBGRA_8888_GrPixelConfig == texture->config());
     // Why did we pollute our texture cache instead of using a GrSingleTextureEffect?
     SkASSERT(swapRedAndBlue || kNone_PMConversion != pmConversion);
 }
 
-const GrBackendFragmentProcessorFactory& GrConfigConversionEffect::getFactory() const {
-    return GrTBackendFragmentProcessorFactory<GrConfigConversionEffect>::getInstance();
-}
-
 bool GrConfigConversionEffect::onIsEqual(const GrFragmentProcessor& s) const {
     const GrConfigConversionEffect& other = s.cast<GrConfigConversionEffect>();
     return other.fSwapRedAndBlue == fSwapRedAndBlue &&
            other.fPMConversion == fPMConversion;
 }
 
 void GrConfigConversionEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     this->updateInvariantOutputForModulation(inout);
 }
 
@@ skipping 13 matching lines @@
         swapRB = random->nextBool();
     }
     return SkNEW_ARGS(GrConfigConversionEffect,
                                       (textures[GrProcessorUnitTest::kSkiaPMTextureIdx],
                                        swapRB,
                                        pmConv,
                                        GrProcessorUnitTest::TestMatrix(random)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+
+void GrConfigConversionEffect::getGLProcessorKey(const GrGLCaps& caps,
+                                                 GrProcessorKeyBuilder* b) const {
+    GrGLConfigConversionEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrConfigConversionEffect::createGLInstance() const {
+    return SkNEW_ARGS(GrGLConfigConversionEffect, (*this));
+}
+
 void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context,
                                                               PMConversion* pmToUPMRule,
                                                               PMConversion* upmToPMRule) {
     *pmToUPMRule = kNone_PMConversion;
     *upmToPMRule = kNone_PMConversion;
     SkAutoTMalloc<uint32_t> data(256 * 256 * 3);
     uint32_t* srcData = data.get();
     uint32_t* firstRead = data.get() + 256 * 256;
     uint32_t* secondRead = data.get() + 2 * 256 * 256;
 
@@ skipping 109 matching lines @@
             kNone_PMConversion != pmConversion) {
             // The PM conversions assume colors are 0..255
             return NULL;
         }
         return SkNEW_ARGS(GrConfigConversionEffect, (texture,
                                                      swapRedAndBlue,
                                                      pmConversion,
                                                      matrix));
     }
 }