Move GrInvariantOutput out of GrProcessor and into its own class.

This will help with the ability to subclass, add to, etc. GrInvariantOutput. Also it was simply
getting a little too big to be a "supporting" subclass
BUG=skia:

Review URL: https://codereview.chromium.org/699943003

1 files changed, 3 insertions, 140 deletions

diff --git a/include/gpu/GrProcessor.h b/include/gpu/GrProcessor.h
index 96ce288404..20123754e2 100644
--- a/include/gpu/GrProcessor.h
+++ b/include/gpu/GrProcessor.h
@@ -17,6 +17,7 @@
 
 class GrContext;
 class GrCoordTransform;
+class GrInvariantOutput;
 
 /** Provides custom shader code to the Ganesh shading pipeline. GrProcessor objects *must* be
     immutable: after being constructed, their fields may not change.
@@ -31,137 +32,6 @@ public:
 
     virtual ~GrProcessor();
 
-    struct InvariantOutput{
-        InvariantOutput() : fColor(0), fValidFlags(0), fIsSingleComponent(false),
-                            fNonMulStageFound(false), fWillUseInputColor(true) {}
-
-        enum ReadInput {
-            kWill_ReadInput,
-            kWillNot_ReadInput,
-        };
-
-        void mulByUnknownOpaqueColor() {
-            if (this->isOpaque()) {
-                fValidFlags = kA_GrColorComponentFlag;
-                fIsSingleComponent = false;
-            } else {
-                // Since the current state is not opaque we no longer care if the color being
-                // multiplied is opaque.
-                this->mulByUnknownColor(); 
-            }
-        }
-
-        void mulByUnknownColor() {
-            if (this->hasZeroAlpha()) {
-                this->internalSetToTransparentBlack();
-            } else {
-                this->internalSetToUnknown();
-            }
-        }
-
-        void mulByUnknownAlpha() {
-            if (this->hasZeroAlpha()) {
-                this->internalSetToTransparentBlack();
-            } else {
-                // We don't need to change fIsSingleComponent in this case
-                fValidFlags = 0;
-            }
-        }
-
-        void mulByKnownAlpha(uint8_t alpha) {
-            if (this->hasZeroAlpha() || 0 == alpha) {
-                this->internalSetToTransparentBlack();
-            } else {
-                if (alpha != 255) {
-                    // Multiply color by alpha
-                    fColor = GrColorPackRGBA(SkMulDiv255Round(GrColorUnpackR(fColor), alpha),
-                                             SkMulDiv255Round(GrColorUnpackG(fColor), alpha),
-                                             SkMulDiv255Round(GrColorUnpackB(fColor), alpha),
-                                             SkMulDiv255Round(GrColorUnpackA(fColor), alpha));
-                }
-            }
-        }
-
-        void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
-            fValidFlags &= ~invalidateFlags;
-            fIsSingleComponent = false;
-            if (kWillNot_ReadInput == readsInput) {
-                fWillUseInputColor = false;
-            }
-        }
-
-        void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
-            fValidFlags = validFlags;
-            fColor = color;
-            fIsSingleComponent = false;
-            fNonMulStageFound = true;
-            if (kWillNot_ReadInput == readsInput) {
-                fWillUseInputColor = false;
-            }
-        }
-
-        void setToUnknown(ReadInput readsInput) {
-            this->internalSetToUnknown();
-            fNonMulStageFound= true;
-            if (kWillNot_ReadInput == readsInput) {
-                fWillUseInputColor = false;
-            }
-        }
-
-        bool isOpaque() const {
-            return ((fValidFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(fColor));
-        }
-
-        bool isSolidWhite() const {
-            return (fValidFlags == kRGBA_GrColorComponentFlags && 0xFFFFFFFF == fColor);
-        }
-
-        GrColor color() const { return fColor; }
-        uint8_t validFlags() const { return fValidFlags; }
-
-        /**
-         * If isSingleComponent is true, then the flag values for r, g, b, and a must all be the
-         * same. If the flags are all set then all color components must be equal.
-         */
-        SkDEBUGCODE(void validate() const;)
-
-    private:
-        void internalSetToTransparentBlack() {
-            fValidFlags = kRGBA_GrColorComponentFlags;
-            fColor = 0;
-            fIsSingleComponent = true;
-        }
-
-        void internalSetToUnknown() {
-            fValidFlags = 0;
-            fIsSingleComponent = false;
-        }
-
-        bool hasZeroAlpha() const {
-            return ((fValidFlags & kA_GrColorComponentFlag) && 0 == GrColorUnpackA(fColor));
-        }
-
-        SkDEBUGCODE(bool colorComponentsAllEqual() const;)
-        /**
-         * If alpha is valid, check that any valid R,G,B values are <= A
-         */
-        SkDEBUGCODE(bool validPreMulColor() const;)
-
-        // Friended class that have "controller" code which loop over stages calling
-        // computeInvarianteOutput(). These controllers may need to manually adjust the internal
-        // members of InvariantOutput
-        friend class GrDrawState;
-        friend class GrOptDrawState;
-        friend class GrPaint;
-        friend class GrProcessor;
-
-        GrColor fColor;
-        uint32_t fValidFlags;
-        bool fIsSingleComponent;
-        bool fNonMulStageFound;
-        bool fWillUseInputColor;
-    };
-
     /**
      * This function is used to perform optimizations. When called the invarientOuput param
      * indicate whether the input components to this processor in the FS will have known values.
@@ -170,13 +40,7 @@ public:
      * inout to indicate known values of its output. A component of the color member only has
      * meaning if the corresponding bit in validFlags is set.
      */
-    void computeInvariantOutput(InvariantOutput* inout) const {
-        inout->fWillUseInputColor = true;
-        this->onComputeInvariantOutput(inout);
-#ifdef SK_DEBUG
-        inout->validate();
-#endif
-    }
+    void computeInvariantOutput(GrInvariantOutput* inout) const; 
 
     /** This object, besides creating back-end-specific helper objects, is used for run-time-type-
         identification. The factory should be an instance of templated class,
@@ -247,11 +111,10 @@ protected:
     void setWillReadFragmentPosition() { fWillReadFragmentPosition = true; }
 
 private:
-
     /** 
      * Subclass implements this to support getConstantColorComponents(...).
      */
-    virtual void onComputeInvariantOutput(InvariantOutput* inout) const = 0;
+    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
 
     SkSTArray<4, const GrTextureAccess*, true>   fTextureAccesses;
     bool                                         fWillReadFragmentPosition;