Revert of Add constant color GrFP.

include/gpu/GrInvariantOutput.h

Index: include/gpu/GrInvariantOutput.h
diff --git a/include/gpu/GrInvariantOutput.h b/include/gpu/GrInvariantOutput.h
index fd0a7f8eb56552528cb2e2279d997d9b9cf81eda..4977333de4e80779432c0eb20289ad5065f47ae3 100644
--- a/include/gpu/GrInvariantOutput.h
+++ b/include/gpu/GrInvariantOutput.h
@@ -79,7 +79,6 @@
     };
 
     void mulByUnknownOpaqueFourComponents() {
-        SkDEBUGCODE(this->validate());
         if (this->isOpaque()) {
             fValidFlags = kA_GrColorComponentFlag;
             fIsSingleComponent = false;
@@ -88,32 +87,26 @@
             // multiplied is opaque.
             this->mulByUnknownFourComponents();
         }
-        SkDEBUGCODE(this->validate());
     }
 
     void mulByUnknownFourComponents() {
-        SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha()) {
             this->internalSetToTransparentBlack();
         } else {
             this->internalSetToUnknown();
         }
-        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;
         }
-        SkDEBUGCODE(this->validate());
     }
 
     void mulByKnownSingleComponent(uint8_t alpha) {
-        SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha() || 0 == alpha) {
             this->internalSetToTransparentBlack();
         } else {
@@ -123,89 +116,20 @@
                                          SkMulDiv255Round(GrColorUnpackG(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackB(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackA(fColor), alpha));
-                // We don't need to change fIsSingleComponent in this case
             }
         }
-        SkDEBUGCODE(this->validate());
-    }
-
-    void mulByKnownFourComponents(GrColor color) {
-        SkDEBUGCODE(this->validate());
-        uint32_t a;
-        if (GetAlphaAndCheckSingleChannel(color, &a)) {
-            this->mulByKnownSingleComponent(a);
-        } else {
-            if (color != 0xffffffff) {
-                fColor = GrColorPackRGBA(
-                    SkMulDiv255Round(GrColorUnpackR(fColor), GrColorUnpackR(color)),
-                    SkMulDiv255Round(GrColorUnpackG(fColor), GrColorUnpackG(color)),
-                    SkMulDiv255Round(GrColorUnpackB(fColor), GrColorUnpackB(color)),
-                    SkMulDiv255Round(GrColorUnpackA(fColor), a));
-                if (kRGBA_GrColorComponentFlags == fValidFlags) {
-                    fIsSingleComponent = GetAlphaAndCheckSingleChannel(fColor, &a);
-                }
-            }
-        }
-        SkDEBUGCODE(this->validate());
-    }
-
-    // Ignores the incoming color's RGB and muls its alpha by color.
-    void mulAlphaByKnownFourComponents(GrColor color) {
-        SkDEBUGCODE(this->validate());
-        uint32_t a;
-        if (GetAlphaAndCheckSingleChannel(color, &a)) {
-            this->mulAlphaByKnownSingleComponent(a);
-        } else if (fValidFlags & kA_GrColorComponentFlag) {
-            GrColor preAlpha = GrColorUnpackA(fColor);
-            if (0 == preAlpha) {
-                this->internalSetToTransparentBlack();
-            } else {
-                fColor = GrColorPackRGBA(
-                    SkMulDiv255Round(preAlpha, GrColorUnpackR(color)),
-                    SkMulDiv255Round(preAlpha, GrColorUnpackG(color)),
-                    SkMulDiv255Round(preAlpha, GrColorUnpackB(color)),
-                    SkMulDiv255Round(preAlpha, a));
-                fValidFlags = kRGBA_GrColorComponentFlags;
-            }
-        } else {
-            fValidFlags = 0;
-        }
-        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;
-            }
-            fIsSingleComponent = true;
-        }
-        SkDEBUGCODE(this->validate());
     }
 
     void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
-        SkDEBUGCODE(this->validate());
         fValidFlags &= ~invalidateFlags;
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
-        SkDEBUGCODE(this->validate());
     }
 
     void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
-        SkDEBUGCODE(this->validate());
         fValidFlags = validFlags;
         fColor = color;
         fIsSingleComponent = false;
@@ -213,28 +137,14 @@
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
-        if (kRGBA_GrColorComponentFlags == fValidFlags) {
-            uint32_t a;
-            if (GetAlphaAndCheckSingleChannel(color, &a)) {
-                fIsSingleComponent = true;
-            }
-        } else if (kA_GrColorComponentFlag & fValidFlags) {
-            // Assuming fColor is premul means if a is 0 the color must be all 0s.
-            if (!GrColorUnpackA(fColor)) {
-                this->internalSetToTransparentBlack();
-            }
-        }
-        SkDEBUGCODE(this->validate());
     }
 
     void setToUnknown(ReadInput readsInput) {
-        SkDEBUGCODE(this->validate());
         this->internalSetToUnknown();
         fNonMulStageFound= true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
-        SkDEBUGCODE(this->validate());
     }
 
     // Temporary setter to handle LCD text correctly until we improve texture pixel config queries
@@ -254,13 +164,6 @@
 
 private:
     friend class GrProcOptInfo;
-
-    /** Extracts the alpha channel and returns true if r,g,b == a. */
-    static bool GetAlphaAndCheckSingleChannel(GrColor color, uint32_t* alpha) {
-        *alpha = GrColorUnpackA(color);
-        return *alpha == GrColorUnpackR(color) && *alpha == GrColorUnpackG(color) &&
-               *alpha == GrColorUnpackB(color);
-    }
 
     void reset(GrColor color, GrColorComponentFlags flags, bool isSingleComponent) {
         fColor = color;