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 InvariantOutput{
+        GrColor fColor;
+        uint32_t fValidFlags;
+        bool fIsSingleComponent;
+
+        bool isOpaque() const {
+            return ((fValidFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(fColor));
+        }
+
+        bool isSolidWhite() const {
+            return (fValidFlags == kRGBA_GrColorComponentFlags && 0xFFFFFFFF == fColor);
+        }
+
+        /**
+         * 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;)
+
+        /**
+         * If alpha is valid, check that any valid R,G,B values are <= A
+         */
+        SkDEBUGCODE(bool validPreMulColor() 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 inout 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
+     * inout 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 computeInvariantOutput(InvariantOutput* inout) const {
+        this->onComputeInvariantOutput(inout);
+#ifdef SK_DEBUG
+        inout->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 onComputeInvariantOutput(InvariantOutput* inout) 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