Move GrInvariantOutput out of GrProcessor and into its own class.

src/effects/SkTableColorFilter.cpp

 
 #include "SkBitmap.h"
 #include "SkTableColorFilter.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkUnPreMultiply.h"
 #include "SkString.h"
 
 class SkTable_ColorFilter : public SkColorFilter {
@@ skipping 258 matching lines @@
             fBitmap = bmp;
         }
         *table = *fBitmap;
     }
     return true;
 }
 
 #if SK_SUPPORT_GPU
 
 #include "GrFragmentProcessor.h"
+#include "GrInvariantOutput.h"
 #include "GrTBackendProcessorFactory.h"
 #include "SkGr.h"
 #include "effects/GrTextureStripAtlas.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 
 class GLColorTableEffect;
 
 class ColorTableEffect : public GrFragmentProcessor {
 public:
     static GrFragmentProcessor* Create(GrContext* context, SkBitmap bitmap, unsigned flags);
 
     virtual ~ColorTableEffect();
 
     static const char* Name() { return "ColorTable"; }
     virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
 
     typedef GLColorTableEffect GLProcessor;
 
     const GrTextureStripAtlas* atlas() const { return fAtlas; }
     int atlasRow() const { return fRow; }
 
 private:
     virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
 
-    virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
+    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
 
     ColorTableEffect(GrTexture* texture, GrTextureStripAtlas* atlas, int row, unsigned flags);
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     GrTextureAccess         fTextureAccess;
 
     // currently not used in shader code, just to assist onComputeInvariantOutput().
     unsigned                fFlags; 
 
@@ skipping 146 matching lines @@
 bool ColorTableEffect::onIsEqual(const GrFragmentProcessor& other) const {
     // For non-atlased instances, the texture (compared by base class) is sufficient to
     // differentiate different tables. For atlased instances we ensure they are using the
     // same row.
     const ColorTableEffect& that = other.cast<ColorTableEffect>();
     SkASSERT(SkToBool(fAtlas) == SkToBool(that.fAtlas));
     // Ok to always do this comparison since both would be -1 if non-atlased.
     return fRow == that.fRow;
 }
 
-void ColorTableEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
+void ColorTableEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     // If we kept the table in the effect then we could actually run known inputs through the
     // table.
     uint8_t invalidateFlags = 0;
     if (fFlags & SkTable_ColorFilter::kR_Flag) {
         invalidateFlags |= kR_GrColorComponentFlag;
     }
     if (fFlags & SkTable_ColorFilter::kG_Flag) {
         invalidateFlags |= kG_GrColorComponentFlag;
     }
     if (fFlags & SkTable_ColorFilter::kB_Flag) {
         invalidateFlags |= kB_GrColorComponentFlag;
     }
     if (fFlags & SkTable_ColorFilter::kA_Flag) {
         invalidateFlags |= kA_GrColorComponentFlag;
     }
-    inout->invalidateComponents(invalidateFlags, InvariantOutput::kWill_ReadInput);
+    inout->invalidateComponents(invalidateFlags, GrInvariantOutput::kWill_ReadInput);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorTableEffect);
 
 GrFragmentProcessor* ColorTableEffect::TestCreate(SkRandom* random,
                                                   GrContext* context,
                                                   const GrDrawTargetCaps&,
                                                   GrTexture* textures[]) {
@@ skipping 48 matching lines @@
 SkColorFilter* SkTableColorFilter::CreateARGB(const uint8_t tableA[256],
                                               const uint8_t tableR[256],
                                               const uint8_t tableG[256],
                                               const uint8_t tableB[256]) {
     return SkNEW_ARGS(SkTable_ColorFilter, (tableA, tableR, tableG, tableB));
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkTableColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTable_ColorFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END