Create fragment processor for performing input color blend with child processor

include/gpu/GrInvariantOutput.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 GrInvariantOutput_DEFINED
 #define GrInvariantOutput_DEFINED
 
 #include "GrColor.h"
 
 struct GrInitInvariantOutput {
     GrInitInvariantOutput()
-        : fValidFlags(0)
+        : fValidFlags(kNone_GrColorComponentFlags)
         , fColor(0)
         , fIsSingleComponent(false)
         , fIsLCDCoverage(false) {}
 
     void setKnownFourComponents(GrColor color) {
         fColor = color;
         fValidFlags = kRGBA_GrColorComponentFlags;
         fIsSingleComponent = false;
     }
 
     void setUnknownFourComponents() {
-        fValidFlags = 0;
+        fValidFlags = kNone_GrColorComponentFlags;
         fIsSingleComponent = false;
     }
 
     void setUnknownOpaqueFourComponents() {
         fColor = 0xffU << GrColor_SHIFT_A;
         fValidFlags = kA_GrColorComponentFlag;
         fIsSingleComponent = false;
     }
 
     void setKnownSingleComponent(uint8_t alpha) {
         fColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
         fValidFlags = kRGBA_GrColorComponentFlags;
         fIsSingleComponent = true;
     }
 
     void setUnknownSingleComponent() {
-        fValidFlags = 0;
+        fValidFlags = kNone_GrColorComponentFlags;
         fIsSingleComponent = true;
     }
 
     void setUsingLCDCoverage() { fIsLCDCoverage = true; }
 
-    uint32_t fValidFlags;
-    GrColor fColor;
-    bool fIsSingleComponent;
-    bool fIsLCDCoverage; // Temorary data member until texture pixel configs are updated
+    GrColorComponentFlags   fValidFlags;
+    GrColor                 fColor;
+    bool                    fIsSingleComponent;
+    bool                    fIsLCDCoverage; // Temorary data member until texture pixel configs are
+                                            // updated
 };
 
 class GrInvariantOutput {
 public:
     GrInvariantOutput(GrColor color, GrColorComponentFlags flags, bool isSingleComponent)
         : fColor(color)
         , fValidFlags(flags)
         , fIsSingleComponent(isSingleComponent)
         , fNonMulStageFound(false)
         , fWillUseInputColor(true)
@@ skipping 36 matching lines @@
         }
         SkDEBUGCODE(this->validate());
     }
 
     void mulByUnknownSingleComponent() {
         SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha()) {
             this->internalSetToTransparentBlack();
         } else {
             // We don't need to change fIsSingleComponent in this case
-            fValidFlags = 0;
+            fValidFlags = kNone_GrColorComponentFlags;
         }
         SkDEBUGCODE(this->validate());
     }
 
     void mulByKnownSingleComponent(uint8_t alpha) {
         SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha() || 0 == alpha) {
             this->internalSetToTransparentBlack();
         } else {
             if (alpha != 255) {
@@ skipping 43 matching lines @@
                 fIsSingleComponent = false;
                 fColor = GrColorPackRGBA(
                     SkMulDiv255Round(preAlpha, GrColorUnpackR(color)),
                     SkMulDiv255Round(preAlpha, GrColorUnpackG(color)),
                     SkMulDiv255Round(preAlpha, GrColorUnpackB(color)),
                     SkMulDiv255Round(preAlpha, a));
                 fValidFlags = kRGBA_GrColorComponentFlags;
             }
         } else {
             fIsSingleComponent = false;
-            fValidFlags = 0;
+            fValidFlags = kNone_GrColorComponentFlags;
         }
         SkDEBUGCODE(this->validate());
     }
 
     // Ignores the incoming color's RGB and muls its alpha by the alpha param and sets all channels
     // equal to that value.
     void mulAlphaByKnownSingleComponent(uint8_t alpha) {
         SkDEBUGCODE(this->validate());
         if (0 == alpha || this->hasZeroAlpha()) {
             this->internalSetToTransparentBlack();
         } else {
             if (fValidFlags & kA_GrColorComponentFlag) {
                 GrColor a = GrColorUnpackA(fColor);
                 a = SkMulDiv255Round(alpha, a);
                 fColor = GrColorPackRGBA(a, a, a, a);
                 fValidFlags = kRGBA_GrColorComponentFlags;
             } else {
-                fValidFlags = 0;
+                fValidFlags = kNone_GrColorComponentFlags;
             }
             fIsSingleComponent = true;
         }
         SkDEBUGCODE(this->validate());
     }
 
-    void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
+    void invalidateComponents(GrColorComponentFlags invalidateFlags, ReadInput readsInput) {
         SkDEBUGCODE(this->validate());
-        fValidFlags &= ~invalidateFlags;
+        fValidFlags = (fValidFlags & ~invalidateFlags);
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
         SkDEBUGCODE(this->validate());
     }
 
-    void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
+    void setToOther(GrColorComponentFlags validFlags, GrColor color, ReadInput readsInput) {
         SkDEBUGCODE(this->validate());
         fValidFlags = validFlags;
         fColor = color;
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
         if (kRGBA_GrColorComponentFlags == fValidFlags) {
             uint32_t a;
@@ skipping 19 matching lines @@
         SkDEBUGCODE(this->validate());
     }
 
     // Temporary setter to handle LCD text correctly until we improve texture pixel config queries
     // and thus can rely solely on number of coverage components for RGA vs single channel coverage.
     void setUsingLCDCoverage() {
         fIsLCDCoverage = true;
     }
 
     GrColor color() const { return fColor; }
-    uint8_t validFlags() const { return fValidFlags; }
+    GrColorComponentFlags 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:
     friend class GrProcOptInfo;
 
@@ skipping 21 matching lines @@
         fIsLCDCoverage = io.fIsLCDCoverage;
     }
 
     void internalSetToTransparentBlack() {
         fValidFlags = kRGBA_GrColorComponentFlags;
         fColor = 0;
         fIsSingleComponent = true;
     }
 
     void internalSetToUnknown() {
-        fValidFlags = 0;
+        fValidFlags = kNone_GrColorComponentFlags;
         fIsSingleComponent = false;
     }
 
     bool hasZeroAlpha() const {
         return ((fValidFlags & kA_GrColorComponentFlag) && 0 == GrColorUnpackA(fColor));
     }
 
     bool isOpaque() const {
         return ((fValidFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(fColor));
     }
@@ skipping 12 matching lines @@
 
     bool isLCDCoverage() const { return fIsLCDCoverage; }
 
     SkDEBUGCODE(bool colorComponentsAllEqual() const;)
     /**
      * If alpha is valid, check that any valid R,G,B values are <= A
      */
     SkDEBUGCODE(bool validPreMulColor() const;)
 
     GrColor fColor;
-    uint32_t fValidFlags;
+    GrColorComponentFlags fValidFlags;
     bool fIsSingleComponent;
     bool fNonMulStageFound;
     bool fWillUseInputColor;
     bool fIsLCDCoverage; // Temorary data member until texture pixel configs are updated
 
 };
 
 #endif