Remove backend factories

tests/GLProgramsTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This is a GPU-backend specific test. It relies on static intializers to work
 
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
 
 #include "GrContextFactory.h"
 #include "GrInvariantOutput.h"
 #include "GrOptDrawState.h"
-#include "GrTBackendProcessorFactory.h"
 #include "GrTest.h"
 #include "SkChecksum.h"
 #include "SkRandom.h"
 #include "Test.h"
 #include "effects/GrConfigConversionEffect.h"
 #include "gl/GrGLPathRendering.h"
 #include "gl/GrGpuGL.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 /*
  * A dummy processor which just tries to insert a massive key and verify that it can retrieve the
  * whole thing correctly
  */
 static const uint32_t kMaxKeySize = 1024;
 
-class GLBigKeyProcessor;
+class GLBigKeyProcessor : public GrGLFragmentProcessor {
+public:
+    GLBigKeyProcessor(const GrProcessor&) {}
+
+    virtual void emitCode(GrGLFPBuilder* builder,
+                          const GrFragmentProcessor& fp,
+                          const char* outputColor,
+                          const char* inputColor,
+                          const TransformedCoordsArray&,
+                          const TextureSamplerArray&) {}
+
+    static void GenKey(const GrProcessor& processor, const GrGLCaps&, GrProcessorKeyBuilder* b) {
+        for (uint32_t i = 0; i < kMaxKeySize; i++) {
+            b->add32(i);
+        }
+    }
+
+private:
+    typedef GrGLFragmentProcessor INHERITED;
+};
 
 class BigKeyProcessor : public GrFragmentProcessor {
 public:
     static GrFragmentProcessor* Create() {
         GR_CREATE_STATIC_PROCESSOR(gBigKeyProcessor, BigKeyProcessor, ())
         return SkRef(gBigKeyProcessor);
     }
 
-    static const char* Name() { return "Big ol' Key"; }
+    virtual const char* name() const SK_OVERRIDE { return "Big Ole Key"; }
 
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
-        return GrTBackendFragmentProcessorFactory<BigKeyProcessor>::getInstance();
+    virtual void getGLProcessorKey(const GrGLCaps& caps,
+                                   GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+        GLBigKeyProcessor::GenKey(*this, caps, b);
     }
 
-    typedef GLBigKeyProcessor GLProcessor;
+    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+        return SkNEW_ARGS(GLBigKeyProcessor, (*this));
+    }
 
 private:
-    BigKeyProcessor() { }
+    BigKeyProcessor() {
+        this->initClassID<BigKeyProcessor>();
+    }
     virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE { }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(BigKeyProcessor);
 
 GrFragmentProcessor* BigKeyProcessor::TestCreate(SkRandom*,
                                                  GrContext*,
                                                  const GrDrawTargetCaps&,
                                                  GrTexture*[]) {
     return BigKeyProcessor::Create();
 }
 
-class GLBigKeyProcessor : public GrGLFragmentProcessor {
-public:
-    GLBigKeyProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&)
-        : INHERITED(factory) {}
-
-    virtual void emitCode(GrGLFPBuilder* builder,
-                          const GrFragmentProcessor& fp,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) {}
-
-    static void GenKey(const GrProcessor& processor, const GrGLCaps&, GrProcessorKeyBuilder* b) {
-        for (uint32_t i = 0; i < kMaxKeySize; i++) {
-            b->add32(i);
-        }
-    }
-
-private:
-    typedef GrGLFragmentProcessor INHERITED;
-};
-
 /*
  * Begin test code
  */
 static const int kRenderTargetHeight = 1;
 static const int kRenderTargetWidth = 1;
 
 static GrRenderTarget* random_render_target(GrContext* context,
                                             const GrCacheID& cacheId,
                                             SkRandom* random) {
     // setup render target
@@ skipping 328 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
         }
     }
 }
 
 #endif