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

include/gpu/GrPaint.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrPaint_DEFINED
 #define GrPaint_DEFINED
 
 #include "GrColor.h"
-#include "GrStagedProcessor.h"
 #include "GrProcessorDataManager.h"
 #include "GrXferProcessor.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "GrFragmentProcessor.h"
 
 #include "SkRegion.h"
 #include "SkXfermode.h"
 
 /**
  * The paint describes how color and coverage are computed at each pixel by GrContext draw
@@ skipping 12 matching lines @@
  *
  * setXPFactory is used to control blending between the output color and dest. It also implements
  * the application of fractional coverage from the coverage pipeline.
  */
 class GrPaint {
 public:
     GrPaint();
 
     GrPaint(const GrPaint& paint) { *this = paint; }
 
-    ~GrPaint() {}
+    ~GrPaint() { this->resetFragmentProcessors();  }
 
     /**
      * The initial color of the drawn primitive. Defaults to solid white.
      */
     void setColor(GrColor color) { fColor = color; }
     GrColor getColor() const { return fColor; }
 
     /**
      * Should primitives be anti-aliased or not. Defaults to false.
      */
@@ skipping 13 matching lines @@
 
     void setPorterDuffXPFactory(SkXfermode::Mode mode) {
         fXPFactory.reset(GrPorterDuffXPFactory::Create(mode));
     }
 
     void setCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage = false); 
 
     /**
      * Appends an additional color processor to the color computation.
      */
-    const GrFragmentProcessor* addColorProcessor(const GrFragmentProcessor* fp) {
+    const GrFragmentProcessor* addColorFragmentProcessor(const GrFragmentProcessor* fp) {
         SkASSERT(fp);
-        SkNEW_APPEND_TO_TARRAY(&fColorStages, GrFragmentStage, (fp));
+        fColorFragmentProcessors.push_back(SkRef(fp));
         return fp;
     }
 
     /**
      * Appends an additional coverage processor to the coverage computation.
      */
-    const GrFragmentProcessor* addCoverageProcessor(const GrFragmentProcessor* fp) {
+    const GrFragmentProcessor* addCoverageFragmentProcessor(const GrFragmentProcessor* fp) {
         SkASSERT(fp);
-        SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrFragmentStage, (fp));
+        fCoverageFragmentProcessors.push_back(SkRef(fp));
         return fp;
     }
 
     /**
      * Helpers for adding color or coverage effects that sample a texture. The matrix is applied
      * to the src space position to compute texture coordinates.
      */
     void addColorTextureProcessor(GrTexture*, const SkMatrix&);
     void addCoverageTextureProcessor(GrTexture*, const SkMatrix&);
     void addColorTextureProcessor(GrTexture*, const SkMatrix&, const GrTextureParams&);
     void addCoverageTextureProcessor(GrTexture*, const SkMatrix&, const GrTextureParams&);
 
-    int numColorStages() const { return fColorStages.count(); }
-    int numCoverageStages() const { return fCoverageStages.count(); }
-    int numTotalStages() const { return this->numColorStages() + this->numCoverageStages(); }
+    int numColorFragmentProcessors() const { return fColorFragmentProcessors.count(); }
+    int numCoverageFragmentProcessors() const { return fCoverageFragmentProcessors.count(); }
+    int numTotalFragmentProcessors() const { return this->numColorFragmentProcessors() +
+                                              this->numCoverageFragmentProcessors(); }
 
     const GrXPFactory* getXPFactory() const {
         if (!fXPFactory) {
             fXPFactory.reset(GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode));
         }
         return fXPFactory.get();
     }
 
-    const GrFragmentStage& getColorStage(int s) const { return fColorStages[s]; }
-    const GrFragmentStage& getCoverageStage(int s) const { return fCoverageStages[s]; }
+    const GrFragmentProcessor* getColorFragmentProcessor(int i) const {
+        return fColorFragmentProcessors[i];
+    }
+    const GrFragmentProcessor* getCoverageFragmentProcessor(int i) const {
+        return fCoverageFragmentProcessors[i];
+    }
 
     GrPaint& operator=(const GrPaint& paint) {
         fAntiAlias = paint.fAntiAlias;
         fDither = paint.fDither;
 
         fColor = paint.fColor;
-
-        fColorStages = paint.fColorStages;
-        fCoverageStages = paint.fCoverageStages;
+        this->resetFragmentProcessors();
+        fColorFragmentProcessors = paint.fColorFragmentProcessors;
+        fCoverageFragmentProcessors = paint.fCoverageFragmentProcessors;
+        for (int i = 0; i < fColorFragmentProcessors.count(); ++i) {
+            fColorFragmentProcessors[i]->ref();
+        }
+        for (int i = 0; i < fCoverageFragmentProcessors.count(); ++i) {
+            fCoverageFragmentProcessors[i]->ref();
+        }
 
         fXPFactory.reset(SkRef(paint.getXPFactory()));
         fProcDataManager.reset(new GrProcessorDataManager(*paint.processorDataManager()));
 
         return *this;
     }
 
     /**
      * Returns true if the paint's output color will be constant after blending. If the result is
      * true, constantColor will be updated to contain the constant color. Note that we can conflate
      * coverage and color, so the actual values written to pixels with partial coverage may still
      * not seem constant, even if this function returns true.
      */
     bool isConstantBlendedColor(GrColor* constantColor) const;
 
     GrProcessorDataManager* getProcessorDataManager() { return fProcDataManager.get(); }
 
     const GrProcessorDataManager* processorDataManager() const { return fProcDataManager.get(); }
 
 private:
-    mutable SkAutoTUnref<const GrXPFactory> fXPFactory;
-    SkSTArray<4, GrFragmentStage>        fColorStages;
-    SkSTArray<2, GrFragmentStage>        fCoverageStages;
+    void resetFragmentProcessors() {
+        for (int i = 0; i < fColorFragmentProcessors.count(); ++i) {
+            fColorFragmentProcessors[i]->unref();
+        }
+        for (int i = 0; i < fCoverageFragmentProcessors.count(); ++i) {
+            fCoverageFragmentProcessors[i]->unref();
+        }
+        fColorFragmentProcessors.reset();
+        fCoverageFragmentProcessors.reset();
+    }
 
-    bool                                 fAntiAlias;
-    bool                                 fDither;
+    mutable SkAutoTUnref<const GrXPFactory>         fXPFactory;
+    SkSTArray<4, const GrFragmentProcessor*, true>  fColorFragmentProcessors;
+    SkSTArray<2, const GrFragmentProcessor*, true>  fCoverageFragmentProcessors;
 
-    GrColor                              fColor;
-    SkAutoTUnref<GrProcessorDataManager> fProcDataManager;
+    bool                                            fAntiAlias;
+    bool                                            fDither;
+
+    GrColor                                         fColor;
+    SkAutoTUnref<GrProcessorDataManager>            fProcDataManager;
 };
 
 #endif