Move willUseInputColor check to computeInvariantOutput

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 21 matching lines @@
     effect use the macro GR_CREATE_STATIC_EFFECT declared below.
   */
 class GrProcessor : public GrProgramElement {
 public:
     SK_DECLARE_INST_COUNT(GrProcessor)
 
     virtual ~GrProcessor();
 
     struct InvariantOutput{
         InvariantOutput() : fColor(0), fValidFlags(0), fIsSingleComponent(false),
-                            fNonMulStageFound(false) {}
+                            fNonMulStageFound(false), fWillUseInputColor(true) {}
+
+        enum ReadInput {
+            kWill_ReadInput,
+            kWillNot_ReadInput,
+        };
 
         void mulByUnknownOpaqueColor() {
             if (this->isOpaque()) {
                 fValidFlags = kA_GrColorComponentFlag;
                 fIsSingleComponent = false;
             } else {
                 // Since the current state is not opaque we no longer care if the color being
                 // multiplied is opaque.
                 this->mulByUnknownColor(); 
             }
         }
 
         void mulByUnknownColor() {
             if (this->hasZeroAlpha()) {
                 this->internalSetToTransparentBlack();
             } else {
                 this->internalSetToUnknown();
             }
         }
 
         void mulByUnknownAlpha() {
             if (this->hasZeroAlpha()) {
                 this->internalSetToTransparentBlack();
             } else {
                 // We don't need to change fIsSingleComponent in this case
                 fValidFlags = 0;
             }
         }
 
-        void invalidateComponents(uint8_t invalidateFlags) {
+        void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
             fValidFlags &= ~invalidateFlags;
             fIsSingleComponent = false;
+            if (kWillNot_ReadInput == readsInput) {
+                fWillUseInputColor = false;
+            }
         }
 
-        void setToTransparentBlack() {
+        void setToTransparentBlack(ReadInput readsInput) {

[bsalomon, 2014/10/15 14:52:42]

Does this one need it? Aren't we going to omit the current effect and everyone
before?

[egdaniel, 2014/10/15 18:37:48]

Changed function to be mulByKnownAlpha to clear up any uncertainty this function
may of had

             this->internalSetToTransparentBlack();
             fNonMulStageFound = true;
+            if (kWillNot_ReadInput == readsInput) {
+                fWillUseInputColor = false;
+            }
         }
 
-        void setToOther(uint8_t validFlags, GrColor color) {
+        void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
             fValidFlags = validFlags;
             fColor = color;
             fIsSingleComponent = false;
             fNonMulStageFound = true;
+            if (kWillNot_ReadInput == readsInput) {
+                fWillUseInputColor = false;
+            }
         }
 
-        void setToUnknown() {
+        void setToUnknown(ReadInput readsInput) {
             this->internalSetToUnknown();
             fNonMulStageFound= true;
+            if (kWillNot_ReadInput == readsInput) {
+                fWillUseInputColor = false;
+            }
         }
 
         bool isOpaque() const {
             return ((fValidFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(fColor));
         }
 
         bool isSolidWhite() const {
             return (fValidFlags == kRGBA_GrColorComponentFlags && 0xFFFFFFFF == fColor);
         }
 
@@ skipping 27 matching lines @@
          * If alpha is valid, check that any valid R,G,B values are <= A
          */
         SkDEBUGCODE(bool validPreMulColor() const;)
 
         // Friended class that have "controller" code which loop over stages calling
         // computeInvarianteOutput(). These controllers may need to manually adjust the internal
         // members of InvariantOutput
         friend class GrDrawState;
         friend class GrOptDrawState;
         friend class GrPaint;
+        friend class GrProcessor;
 
         GrColor fColor;
         uint32_t fValidFlags;
         bool fIsSingleComponent;
         bool fNonMulStageFound;
+        bool fWillUseInputColor;
     };
 
     /**
      * 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.
      * 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.
      */
     void computeInvariantOutput(InvariantOutput* inout) const {
+        inout->fWillUseInputColor = true;
         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
@@ skipping 97 matching lines @@
     SkSTArray<4, const GrTextureAccess*, true>   fTextureAccesses;
     bool                                         fWillReadFragmentPosition;
 
     typedef GrProgramElement INHERITED;
 };
 
 class GrFragmentProcessor : public GrProcessor {
 public:
     GrFragmentProcessor()
         : INHERITED()
-        , fWillReadDstColor(false)
-        , fWillUseInputColor(true) {}
+        , fWillReadDstColor(false) {}
 
     virtual const GrBackendFragmentProcessorFactory& getFactory() const = 0;
 
     int numTransforms() const { return fCoordTransforms.count(); }
 
     /** Returns the coordinate transformation at index. index must be valid according to
         numTransforms(). */
     const GrCoordTransform& coordTransform(int index) const { return *fCoordTransforms[index]; }
 
     /** Will this effect read the destination pixel value? */
     bool willReadDstColor() const { return fWillReadDstColor; }
 
-    /** Will this effect read the source color value? */
-    bool willUseInputColor() const { return fWillUseInputColor; }
-
 protected:
     /**
      * Fragment Processor subclasses call this from their constructor to register coordinate
      * transformations. The processor subclass manages the lifetime of the transformations (this
      * function only stores a pointer). The GrCoordTransform is typically a member field of the
      * GrProcessor subclass. When the matrix has perspective, the transformed coordinates will have
      * 3 components. Otherwise they'll have 2. This must only be called from the constructor because
      * GrProcessors are immutable.
      */
     void addCoordTransform(const GrCoordTransform*);
 
     /**
      * If the effect subclass will read the destination pixel value then it must call this function
      * from its constructor. Otherwise, when its generated backend-specific effect class attempts
      * to generate code that reads the destination pixel it will fail.
      */
     void setWillReadDstColor() { fWillReadDstColor = true; }
 
-    /**
-     * If the effect will generate a result that does not depend on the input color value then it
-     * must call this function from its constructor. Otherwise, when its generated backend-specific
-     * code might fail during variable binding due to unused variables.
-     */
-    void setWillNotUseInputColor() { fWillUseInputColor = false; }
-
 private:
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
     bool                                         fWillReadDstColor;
-    bool                                         fWillUseInputColor;
 
     typedef GrProcessor INHERITED;
 };
 
 /**
  * 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