Add constant color GrFP.

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
 
@@ skipping 98 matching lines @@
     void mulByKnownSingleComponent(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));
+                // We don't need to change fIsSingleComponent in this case
             }
         }
     }
 
+    void mulByKnownFourComponents(GrColor color) {
+        if (0 == color) {
+            this->internalSetToTransparentBlack();
+        } else {
+            if (color != 0xffffffff) {
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(GrColorUnpackR(fColor), GrColorUnpackR(color)),
+                    SkMulDiv255Round(GrColorUnpackG(fColor), GrColorUnpackG(color)),
+                    SkMulDiv255Round(GrColorUnpackB(fColor), GrColorUnpackB(color)),
+                    SkMulDiv255Round(GrColorUnpackA(fColor), GrColorUnpackA(color)));
+                    this->updateIsSingleComponent();

[egdaniel, 2015/03/04 15:17:03]

at least with what is in the updateISC function now, I don't think this sets
isSingleComponent correctly.

Think of the case where beforehand we have:
fValidFlags = 0, fIsSingleComponent = true;

If we multiply by a color here where all the components are not equal, we should
end up with something like:
fValidFlags = 0, fIsSingleComponent = false.

In the current thing I think we would end up,
fValidFlags = 0, fIsSingleComponent = true;

[bsalomon, 2015/03/04 19:43:36]

Done.

+            }
+        }
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by color.
+    void mulAlphaByKnownFourComponents(GrColor color) {
+        if (0 == color || 0 == this->hasZeroAlpha()) {
+            this->internalSetToTransparentBlack();
+        } else {
+            if (fValidFlags & kA_GrColorComponentFlag) {
+                GrColor alpha = GrColorUnpackA(fColor);
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(alpha, GrColorUnpackR(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackG(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackB(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackA(color)));
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            } else {
+                fValidFlags = 0;
+            }
+            // If color is single channel then so are we.
+            GrColor a = GrColorUnpackA(color);
+            fIsSingleComponent = a == GrColorUnpackR(color) && a == GrColorUnpackG(color) &&
+                                 a == GrColorUnpackB(color);
+        }
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by the alpha param.
+    void mulAlphaByKnownSingleComponent(uint8_t alpha) {
+        if (0 == alpha || 0 == 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;
+        }
+    }
+
     void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
         fValidFlags &= ~invalidateFlags;
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
     }
 
     void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
@@ skipping 65 matching lines @@
     }
 
     bool isOpaque() const {
         return ((fValidFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(fColor));
     }
 
     bool isSolidWhite() const {
         return (fValidFlags == kRGBA_GrColorComponentFlags && 0xFFFFFFFF == fColor);
     }
 
+    void updateIsSingleComponent() {

[egdaniel, 2015/03/04 15:17:03]

In general I am not a big fan of this function or at least with its given name.
I don't want someone to get confused that calling updateIsSingleComponent will
always update it correctly. This function seems to be written to cover one
specific case.

+        if (kRGBA_GrColorComponentFlags == fValidFlags) {
+            GrColor a = GrColorUnpackA(fColor);
+            fIsSingleComponent = a == GrColorUnpackR(fColor) && a == GrColorUnpackG(fColor) &&
+                                 a == GrColorUnpackB(fColor);
+        }
+
+    }
     bool isSingleComponent() const { return fIsSingleComponent; }
 
     bool willUseInputColor() const { return fWillUseInputColor; }
     void resetWillUseInputColor() { fWillUseInputColor = true; }
 
     bool allStagesMulInput() const { return !fNonMulStageFound; }
     void resetNonMulStageFound() { fNonMulStageFound = false; }
 
     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;
     bool fIsSingleComponent;
     bool fNonMulStageFound;
     bool fWillUseInputColor;
     bool fIsLCDCoverage; // Temorary data member until texture pixel configs are updated
 
 };
 
 #endif