Remove backend factories

include/gpu/GrFragmentProcessor.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrFragmentProcessor_DEFINED
 #define GrFragmentProcessor_DEFINED
 
 #include "GrProcessor.h"
 
 class GrCoordTransform;
+class GrGLCaps;
+class GrGLFragmentProcessor;
+class GrProcessorKeyBuilder;
 
 /** Provides custom fragment shader code. Fragment processors receive an input color (vec4f) and
     produce an output color. They may reference textures and uniforms. They may use
     GrCoordTransforms to receive a transformation of the local coordinates that map from local space
     to the fragment being processed.
  */
 class GrFragmentProcessor : public GrProcessor {
 public:
     GrFragmentProcessor()
         : INHERITED()
         , fWillReadDstColor(false)
         , fWillUseInputColor(true) {}
 
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const = 0;
+    /** Implemented using GLFragmentProcessor::GenKey as described in this class's comment. */
+    virtual void getGLProcessorKey(const GrGLCaps& caps,
+                                   GrProcessorKeyBuilder* b) const = 0;
+
+    /** Returns a new instance of the appropriate *GL* implementation class
+        for the given GrFragmentProcessor; caller is responsible for deleting
+        the object. */
+    virtual GrGLFragmentProcessor* createGLInstance() const = 0;
+
+    /** Human-meaningful string to identify this GrFragmentProcessor; may be embedded
+        in generated shader code. */
+    virtual const char* name() const = 0;
 
     int numTransforms() const { return fCoordTransforms.count(); }
 
     /** Returns the coordinate transformation at index. index must be valid according to
         numTransforms(). */
     const GrCoordTransform& coordTransform(int index) const { return *fCoordTransforms[index]; }
 
     /** Will this prceossor read the destination pixel value? */
     bool willReadDstColor() const { return fWillReadDstColor; }
 
     /** Will this prceossor read the source color value? */
     bool willUseInputColor() const { return fWillUseInputColor; }
 
-    /** Returns true if this and other prceossor conservatively draw identically. It can only return
-        true when the two prceossor are of the same subclass (i.e. they return the same object from
+    /** Returns true if this and other processor conservatively draw identically. It can only return
+        true when the two processor 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 prceossor would
-        generate the same shader code. To test for identical code generation use the prceossor' keys
-        computed by the GrBackendProcessorFactory. */
+        A return value of true from isEqual() should not be used to test whether the processor would
+        generate the same shader code. To test for identical code generation use getGLProcessorKey*/
     bool isEqual(const GrFragmentProcessor& that) const {
-        if (&this->getFactory() != &that.getFactory() ||
+        if (this->classID() != that.classID() ||
             !this->hasSameTransforms(that) ||
             !this->hasSameTextureAccesses(that)) {
             return false;
         }
         return this->onIsEqual(that);
     }
 
 protected:
     /**
      * Fragment Processor subclasses call this from their constructor to register coordinate
@@ skipping 40 matching lines @@
     bool hasSameTransforms(const GrFragmentProcessor&) const;
 
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
     bool                                         fWillReadDstColor;
     bool                                         fWillUseInputColor;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif