Added tree structure to GrGLFragmentProcessor, i.e. GL instances

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"
 #include "GrStagedProcessor.h"
 
 class GrCoordTransform;
 class GrGLSLCaps;
 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()
         , fUsesLocalCoords(false) {}
 
-    /** 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;
+    GrGLFragmentProcessor* createGLInstance() const;
 
     /** Human-meaningful string to identify this GrFragmentProcessor; may be embedded
         in generated shader code. */
     virtual const char* name() const = 0;
 
     void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
         this->onGetGLProcessorKey(caps, b);
         for (int i = 0; i < fChildProcessors.count(); ++i) {
             fChildProcessors[i].processor()->getGLProcessorKey(caps, b);
         }
@@ skipping 74 matching lines @@
 
     /**
      * Subclass implements this to support getConstantColorComponents(...).
      *
      * Note: it's up to the subclass implementation to do any recursive call to compute the child
      * procs' output invariants; computeInvariantOutput will not be recursive.
      */
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
 
 private:
+    /** Returns a new instance of the appropriate *GL* implementation class
+        for the given GrFragmentProcessor; caller is responsible for deleting
+        the object. */
+    virtual GrGLFragmentProcessor* onCreateGLInstance() const = 0;
+
     /** Implemented using GLFragmentProcessor::GenKey as described in this class's comment. */
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const = 0;
 
     /**
      * Subclass implements this to support isEqual(). It will only be called if it is known that
      * the two processors are of the same subclass (i.e. they return the same object from
      * getFactory()). The processor subclass should not compare its coord transforms as that will
      * be performed automatically in the non-virtual isEqual().
      */
@@ skipping 27 matching lines @@
      * The same goes for fTextureAccesses with textures.
      */
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
 
     SkTArray<GrFragmentStage, false>             fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif