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 22 matching lines @@
   */
 class GrProcessor : public GrProgramElement {
 public:
     SK_DECLARE_INST_COUNT(GrProcessor)
 
     virtual ~GrProcessor();
 
     /**
      * This function is used to perform optimizations. When called the color and validFlags params
      * 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.
+     * validFlags is a bitfield of GrColorComponentFlags. The isSingleComponent param indicates
+     * whether the input will be 1 or 4 bytes. The function updates all 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. If an effect sets isSingleComponent to true, then validFlags must
+     * be all 1's or all 0's. If it is all 1's then all color components must be equal.

[bsalomon, 2014/09/29 15:28:04]

all 1's isn't quit right (since this is a uint32_t).

"...then the flag value for r,g,b, and a must all be the same. If the flags are
set then ..."?

[egdaniel, 2014/09/29 15:50:20]

Done.

      */
-    virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const = 0;
+    void getConstantColorComponents(GrColor* color, uint32_t* validFlags,
+                                    bool* isSingleComponent) const {
+        this->onGetConstantColorComponents(color, validFlags, isSingleComponent);
+#ifdef SK_DEBUG
+        this->validateComponents(*color, *validFlags, *isSingleComponent);
+#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 88 matching lines @@
     /**
      * If the effect will generate a backend-specific effect that will read the fragment position
      * in the FS then it must call this method from its constructor. Otherwise, the request to
      * access the fragment position will be denied.
      */
     void setWillReadFragmentPosition() { fWillReadFragmentPosition = true; }
 
 private:
     SkDEBUGCODE(void assertEquality(const GrProcessor& other) const;)
 
+    SkDEBUGCODE(void validateComponents(GrColor color, uint32_t validFlags,
+                                        bool isSingleComponent) 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 onGetConstantColorComponents(GrColor* color, uint32_t* validFlags,
+                                              bool* isSingleComponent) 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