Remove GrStagedProcessor, remove the word Stage as it applies to FPs

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)
         , fNumTexturesExclChildren(0)
         , fNumTransformsExclChildren(0) {}
 
+    ~GrFragmentProcessor() override;
+
     GrGLFragmentProcessor* createGLInstance() const;
 
     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);
+            fChildProcessors[i]->getGLProcessorKey(caps, b);
         }
     }
 
     int numTexturesExclChildren() const { return fNumTexturesExclChildren; }
 
     int numTransformsExclChildren() const { return fNumTransformsExclChildren; }
 
     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]; }
 
     const SkTArray<const GrCoordTransform*, true>& coordTransforms() const {
         return fCoordTransforms;
     }
 
     void gatherCoordTransforms(SkTArray<const GrCoordTransform*, true>* outTransforms) const {
         if (!fCoordTransforms.empty()) {
             outTransforms->push_back_n(fCoordTransforms.count(), fCoordTransforms.begin());
         }
     }
 
     int numChildProcessors() const { return fChildProcessors.count(); }
 
-    const GrFragmentProcessor& childProcessor(int index) const {
-        return *fChildProcessors[index].processor();
-    }
+    const GrFragmentProcessor& childProcessor(int index) const { return *fChildProcessors[index]; }
 
     /** Do any of the coordtransforms for this processor require local coords? */
     bool usesLocalCoords() const { return fUsesLocalCoords; }
 
     /** 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 processor would
         generate the same shader code. To test for identical code generation use getGLProcessorKey*/
@@ skipping 93 matching lines @@
      *                      (C)          (E)          (F)
      *                     [c1]      [e1,e2,e3]      [f1,f2]
      *
      * The same goes for fTextureAccesses with textures.
      */
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
 
     int                                          fNumTexturesExclChildren;
     int                                          fNumTransformsExclChildren;
 
-    SkTArray<GrFragmentStage, false>             fChildProcessors;
+    // TODO: These must convert their processors to pending-execution refs when the parent is
+    // converted (do this automatically in GrProgramElement?).
+    SkTArray<const GrFragmentProcessor*, true>   fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif