Remove backend factories

src/gpu/GrGeometryProcessor.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGeometryProcessor_DEFINED
 #define GrGeometryProcessor_DEFINED
 
@@ skipping 16 matching lines @@
         SkASSERT(sizeof(T) <= kMaxSize);
         return reinterpret_cast<T*>(fData);
     }
 
     static const size_t kMaxSize = 32;
 
 private:
     uint8_t fData[kMaxSize];
 };
 
+class GrGLCaps;
+class GrGLGeometryProcessor;
 class GrOptDrawState;
 
 /**
  * A GrGeometryProcessor is used to perform computation in the vertex shader and
  * add support for custom vertex attributes. A GrGemeotryProcessor is typically
  * tied to the code that does a specific type of high-level primitive rendering
  * (e.g. anti-aliased circle rendering). The GrGeometryProcessor used for a draw is
  * specified using GrDrawState. There can only be one geometry processor active for
  * a draw. The custom vertex attributes required by the geometry processor must be
  * added to the vertex attribute array specified on the GrDrawState.
  * GrGeometryProcessor subclasses should be immutable after construction.
  */
 class GrGeometryProcessor : public GrProcessor {
 public:
     GrGeometryProcessor()
         : fVertexStride(0)
         , fWillUseGeoShader(false)
         , fHasVertexColor(false)
         , fHasVertexCoverage(false)
         , fHasLocalCoords(false) {}
 
-    virtual const GrBackendGeometryProcessorFactory& getFactory() const = 0;
+    virtual const char* name() const = 0;
+
+    /** Implemented using GLProcessor::GenKey as described in this class's comment. */
+    virtual void getGLProcessorKey(const GrBatchTracker& bt,
+                                   const GrGLCaps& caps,
+                                   GrProcessorKeyBuilder* b) const = 0;
+
+
+    /** Returns a new instance of the appropriate *GL* implementation class
+        for the given GrProcessor; caller is responsible for deleting
+        the object. */
+    virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const = 0;
 
     /*
      * This is a safeguard to prevent GPs from going beyond platform specific attribute limits.
      * This number can almost certainly be raised if required.
      */
     static const int kMaxVertexAttribs = 6;
 
     struct GrAttribute {
         GrAttribute(const char* name, GrVertexAttribType type)
             : fName(name)
@@ skipping 15 matching lines @@
 
     bool willUseGeoShader() const { return fWillUseGeoShader; }
 
     /** Returns true if this and other processor conservatively draw identically. It can only return
         true when the two prcoessors are of the same subclass (i.e. they return the same object from
         from getFactory()).
         A return value of true from isEqual() should not be used to test whether the processors
         would generate the same shader code. To test for identical code generation use the
         processors' keys computed by the GrBackendEffectFactory. */
     bool isEqual(const GrGeometryProcessor& that) const {
-        if (&this->getFactory() != &that.getFactory() || !this->hasSameTextureAccesses(that)) {
+        if (this->classID() != that.classID() || !this->hasSameTextureAccesses(that)) {
             return false;
         }
         return this->onIsEqual(that);
     }
 
     struct InitBT {
         bool fOutputColor;
         bool fOutputCoverage;
         GrColor fColor;
         GrColor fCoverage;
@@ skipping 31 matching lines @@
 
     SkSTArray<kMaxVertexAttribs, GrAttribute, true> fAttribs;
     size_t fVertexStride;
     bool fWillUseGeoShader;
     bool fHasVertexColor;
     bool fHasVertexCoverage;
     bool fHasLocalCoords;
 
     typedef GrProcessor INHERITED;
 };
-
 #endif