Add isSingleComponent bool to getConstantColorComponent

include/gpu/GrProcessor.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrProcessor_DEFINED
 #define GrProcessor_DEFINED
 
@@ skipping 19 matching lines @@
     Dynamically allocated GrProcessors are managed by a per-thread memory pool. The ref count of an
     effect must reach 0 before the thread terminates and the pool is destroyed. To create a static
     effect use the macro GR_CREATE_STATIC_EFFECT declared below.
   */
 class GrProcessor : public GrProgramElement {
 public:
     SK_DECLARE_INST_COUNT(GrProcessor)
 
     virtual ~GrProcessor();
 
+    struct InvarientOutput{

[bsalomon, 2014/09/30 00:41:01]

"Invariant" (gulp)

There might be some more useful helpers for modifying this here:

e.g.:

void mulByUnknownOpaqueColor() {
    if (this->isOpaque()) {
        fValidFlags = kA_GrCCF;
    } else {
        fValidFlags = 0;
    }
    fIsSingleComponent = false;
}

void mulByUnknownColor() {
    // really any mulBy should have this "if"
    if (kA_GrCC && 0 == GrColorUnpackAlpha(fColor)) {
        fValidFlags = kRGBA_GrCCF;
        fColor = 0;
        fIsSingleComponent = true;
    } else {
        fValidFlags = 0;
        fIsSingleComponent = false;
    }
}

void mulByUnknownAlpha() {
   // fIsSingleComponent stays the same
   fValidFlags = 0;
}

void mulByKnownColor(GrColor color)

(I didn't think these through all that thoroughly)

There are probably very few effects that wouldn't be able to share a common
implementation using helpers.

[egdaniel, 2014/10/02 14:58:33]

Fixed speeling
Will work on adding helpers in follow up cl(s)

+        GrColor color;
+        uint32_t validFlags;

[bsalomon, 2014/09/30 00:41:01]

fColor, fValidFlags, fIsSingleComponent

[egdaniel, 2014/10/02 14:58:33]

Done.

+        bool isSingleComponent;
+
+        bool hasOpaqueAlpha() const {

[bsalomon, 2014/09/30 00:41:01]

isOpaque?

[egdaniel, 2014/10/02 14:58:33]

Done.

+            return ((validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(color));
+        }
+
+        bool hasOpaqueColor() const {
+            return (validFlags == kRGBA_GrColorComponentFlags &&

[bsalomon, 2014/09/30 00:41:01]

isSolidWhite?

[egdaniel, 2014/10/02 14:58:33]

Done.

+                    0xFFFFFFFF == GrColorUnpackA(color));
+        }
+
+        /**
+         * 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:
+        SkDEBUGCODE(bool colorComponentsAllEqual() const;)
+    };
+
     /**
-     * This function is used to perform optimizations. When called the color and validFlags params
+     * This function is used to perform optimizations. When called the invarientOuput param
      * indicate whether the input components to this effect in the FS will have known values.
-     * validFlags is a bitfield of GrColorComponentFlags. The function updates both params to
-     * indicate known values of its output. A component of the color param only has meaning if the
-     * corresponding bit in validFlags is set.
+     * In invarientOutput the validFlags member is a bitfield of GrColorComponentFlags. The
+     * isSingleComponent member indicates whether the input will be 1 or 4 bytes. The function
+     * updates the members of invarientOutput to indicate known values of its output. A component
+     * of the color member only has meaning if the corresponding bit in validFlags is set.
      */
-    virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const = 0;
+    void computeInvarientOutput(InvarientOutput* invarientOutput) const {

[bsalomon, 2014/09/30 00:41:01]

Because the param is inout it feels weird to call it the param invariantOutput. 
"inout"? ...

[egdaniel, 2014/10/02 14:58:33]

Done.

+        this->onComputeInvarientOutput(invarientOutput);
+#ifdef SK_DEBUG
+        invarientOutput->validate();
+#endif
+    }
 
     /** 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,
         GrTBackendEffectFactory. It is templated on the subclass of GrProcessor. The subclass must
         have a nested type (or typedef) named GLProcessor which will be the subclass of
         GrGLProcessor created by the factory.
 
         Example:
         class MyCustomEffect : public GrProcessor {
         ...
@@ skipping 93 matching lines @@
     void setWillReadFragmentPosition() { fWillReadFragmentPosition = true; }
 
 private:
     SkDEBUGCODE(void assertEquality(const GrProcessor& other) const;)
 
     /** Subclass implements this to support isEqual(). It will only be called if it is known that
         the two effects are of the same subclass (i.e. they return the same object from
         getFactory()).*/
     virtual bool onIsEqual(const GrProcessor& other) const = 0;
 
+    /** 
+     * Subclass implements this to support getConstantColorComponents(...).
+     */
+    virtual void onComputeInvarientOutput(InvarientOutput* invarientOutput) const = 0;
     friend class GrGeometryProcessor; // to set fRequiresVertexShader and build fVertexAttribTypes.
 
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
     SkSTArray<4, const GrTextureAccess*, true>   fTextureAccesses;
     bool                                         fWillReadFragmentPosition;
 
     typedef GrProgramElement INHERITED;
 };
 
 class GrFragmentProcessor : public GrProcessor {
@@ skipping 37 matching lines @@
  * This creates an effect outside of the effect memory pool. The effect's destructor will be called
  * at global destruction time. NAME will be the name of the created GrProcessor.
  */
 #define GR_CREATE_STATIC_FRAGMENT_PROCESSOR(NAME, EFFECT_CLASS, ARGS)                             \
 static SkAlignedSStorage<sizeof(EFFECT_CLASS)> g_##NAME##_Storage;                                \
 static GrFragmentProcessor*                                                                       \
 NAME SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS);                          \
 static SkAutoTDestroy<GrFragmentProcessor> NAME##_ad(NAME);
 
 #endif