Revert of Add constant color GrFP. (patchset #10 id:180001 of https://codereview.chromium.org/978713002/)

Reason for revert:
Revert while investigating assertions.

Original issue's description:
> Add constant color GrFP.
>
> Committed: https://skia.googlesource.com/skia/+/dfbbec436cbcacc3270d4b28357c8393e67d6494

TBR=egdaniel@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

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

3 files changed, 2 insertions, 164 deletions

diff --git a/include/gpu/GrInvariantOutput.h b/include/gpu/GrInvariantOutput.h
index fd0a7f8eb5..4977333de4 100644
--- a/include/gpu/GrInvariantOutput.h
+++ b/include/gpu/GrInvariantOutput.h
@@ -79,7 +79,6 @@ public:
     };
 
     void mulByUnknownOpaqueFourComponents() {
-        SkDEBUGCODE(this->validate());
         if (this->isOpaque()) {
             fValidFlags = kA_GrColorComponentFlag;
             fIsSingleComponent = false;
@@ -88,32 +87,26 @@ public:
             // 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 @@ public:
                                          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 @@ public:
         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
@@ -255,13 +165,6 @@ public:
 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;
         fValidFlags = flags;
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index 026b25685e..7cb614dd4c 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -78,9 +78,8 @@ GrTexture* GrRefCachedBitmapTexture(GrContext*, const SkBitmap&, const GrTexture
 // Sets the color of GrPaint to the value of the parameter paintColor
 // Callers may subsequently modify the GrPaint. Setting constantColor indicates
 // that the final paint will draw the same color at every pixel. This allows
-// an optimization where the color filter can be applied to the SkPaint's
-// color once while converting to GrPaint and then ignored. TODO: Remove this
-// bool and use the invariant info to automatically apply the color filter.
+// an optimization where the the color filter can be applied to the SkPaint's
+// color once while converting to GrPaint and then ignored.
 void SkPaint2GrPaintNoShader(GrContext* context, GrRenderTarget*, const SkPaint& skPaint,
                              GrColor paintColor, bool constantColor, GrPaint* grPaint);
 
diff --git a/include/gpu/effects/GrConstColorProcessor.h b/include/gpu/effects/GrConstColorProcessor.h
deleted file mode 100644
index 27ee0dfd08..0000000000
--- a/include/gpu/effects/GrConstColorProcessor.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrColorProcessor_DEFINED
-#define GrColorProcessor_DEFINED
-
-#include "GrFragmentProcessor.h"
-
-class GrInvariantOutput;
-
-/**
- * This is a simple GrFragmentProcessor that outputs a constant color. It may do one of the
- * following with its input color: ignore it, or multiply it by the constant color, multiply its
- * alpha by the constant color and ignore the input color's r, g, and b.
- */
-class GrConstColorProcessor : public GrFragmentProcessor {
-public:
-    enum InputMode {
-        kIgnore_InputMode,
-        kModulateRGBA_InputMode,
-        kModulateA_InputMode,
-
-        kLastInputMode = kModulateA_InputMode
-    };
-    static const int kInputModeCnt = kLastInputMode + 1;
-
-    static GrFragmentProcessor* Create(GrColor color, InputMode mode) {
-        return SkNEW_ARGS(GrConstColorProcessor, (color, mode));
-    }
-
-    ~GrConstColorProcessor() override {}
-
-    const char* name() const override { return "Color"; }
-
-    void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
-
-    GrGLFragmentProcessor* createGLInstance() const override;
-
-    GrColor color() const { return fColor; }
-
-    InputMode inputMode() const { return fMode; }
-
-private:
-    GrConstColorProcessor(GrColor color, InputMode mode) : fColor(color), fMode(mode) {
-        this->initClassID<GrConstColorProcessor>();
-    }
-
-    bool onIsEqual(const GrFragmentProcessor&) const override;
-
-    void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
-
-    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
-
-    GrColor     fColor;
-    InputMode   fMode;
-
-    typedef GrFragmentProcessor INHERITED;
-};
-
-#endif