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

src/gpu/GrPipeline.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPipeline_DEFINED
 #define GrPipeline_DEFINED
 
 #include "GrColor.h"
+#include "GrFragmentProcessor.h"
 #include "GrGpu.h"
 #include "GrNonAtomicRef.h"
-#include "GrPendingFragmentStage.h"
+#include "GrPendingProgramElement.h"
 #include "GrPrimitiveProcessor.h"
 #include "GrProgramDesc.h"
 #include "GrStencil.h"
 #include "GrTypesPriv.h"
 #include "SkMatrix.h"
 #include "SkRefCnt.h"
 
 class GrBatch;
 class GrDeviceCoordTexture;
 class GrPipelineBuilder;
@@ skipping 52 matching lines @@
         }
         return true;
     }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name GrFragmentProcessors
 
 
-    int numColorFragmentStages() const { return fNumColorStages; }
-    int numCoverageFragmentStages() const { return fFragmentStages.count() - fNumColorStages; }
-    int numFragmentStages() const { return fFragmentStages.count(); }
+    int numColorFragmentProcessors() const { return fNumColorProcessors; }
+    int numCoverageFragmentProcessors() const {
+        return fFragmentProcessors.count() - fNumColorProcessors;
+    }
+    int numFragmentProcessors() const { return fFragmentProcessors.count(); }
 
     const GrXferProcessor* getXferProcessor() const { return fXferProcessor.get(); }
 
-    const GrPendingFragmentStage& getColorStage(int idx) const {
-        SkASSERT(idx < this->numColorFragmentStages());
-        return fFragmentStages[idx];
+    const GrFragmentProcessor& getColorFragmentProcessor(int idx) const {
+        SkASSERT(idx < this->numColorFragmentProcessors());
+        return *fFragmentProcessors[idx].get();
     }
-    const GrPendingFragmentStage& getCoverageStage(int idx) const {
-        SkASSERT(idx < this->numCoverageFragmentStages());
-        return fFragmentStages[fNumColorStages + idx];
+
+    const GrFragmentProcessor& getCoverageFragmentProcessor(int idx) const {
+        SkASSERT(idx < this->numCoverageFragmentProcessors());
+        return *fFragmentProcessors[fNumColorProcessors + idx].get();
     }
-    const GrPendingFragmentStage& getFragmentStage(int idx) const {
-        return fFragmentStages[idx];
+
+    const GrFragmentProcessor& getFragmentProcessor(int idx) const {
+        return *fFragmentProcessors[idx].get();
     }
 
     /// @}
 
     /**
      * Retrieves the currently set render-target.
      *
      * @return    The currently set render target.
      */
     GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
@@ skipping 29 matching lines @@
 private:
     GrPipeline() { /** Initialized in factory function*/ }
 
     /**
      * Alter the program desc and inputs (attribs and processors) based on the blend optimization.
      */
     void adjustProgramFromOptimizations(const GrPipelineBuilder& ds,
                                         GrXferProcessor::OptFlags,
                                         const GrProcOptInfo& colorPOI,
                                         const GrProcOptInfo& coveragePOI,
-                                        int* firstColorStageIdx,
-                                        int* firstCoverageStageIdx);
+                                        int* firstColorProcessorIdx,
+                                        int* firstCoverageProcessorIdx);
 
     /**
      * Calculates the primary and secondary output types of the shader. For certain output types
      * the function may adjust the blend coefficients. After this function is called the src and dst
      * blend coeffs will represent those used by backend API.
      */
     void setOutputStateInfo(const GrPipelineBuilder& ds, GrXferProcessor::OptFlags,
                             const GrCaps&);
 
     enum Flags {
         kDither_Flag            = 0x1,
         kHWAA_Flag              = 0x2,
         kSnapVertices_Flag      = 0x4,
     };
 
     typedef GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> RenderTarget;
-    typedef SkSTArray<8, GrPendingFragmentStage> FragmentStageArray;
+    typedef GrPendingProgramElement<const GrFragmentProcessor> PendingFragmentProcessor;
+    typedef SkAutoSTArray<8, PendingFragmentProcessor> FragmentProcessorArray;
     typedef GrPendingProgramElement<const GrXferProcessor> ProgramXferProcessor;
     RenderTarget                        fRenderTarget;
     GrScissorState                      fScissorState;
     GrStencilSettings                   fStencilSettings;
     GrPipelineBuilder::DrawFace         fDrawFace;
     uint32_t                            fFlags;
     ProgramXferProcessor                fXferProcessor;
-    FragmentStageArray                  fFragmentStages;
+    FragmentProcessorArray              fFragmentProcessors;
     bool                                fReadsFragPosition;
 
-    // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
-    int                                 fNumColorStages;
+    // This value is also the index in fFragmentProcessors where coverage processors begin.
+    int                                 fNumColorProcessors;
 
     SkSTArray<8, const GrCoordTransform*, true> fCoordTransforms;
     GrProgramDesc                       fDesc;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif