Create helper functions to use in computeInvariantOutput calls

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 20 matching lines @@
     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;
+        InvariantOutput() : fColor(0), fValidFlags(0), fIsSingleComponent(false) {}
 
-        InvariantOutput() : fColor(0), fValidFlags(0), fIsSingleComponent(false) {}
+        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->setToTransparentBlack();
+            } else {
+                this->setToUnknown();
+            }
+        }
+
+        void mulByUnknownAlpha() {
+            if (this->hasZeroAlpha()) {
+                this->setToTransparentBlack();
+            } else {
+                // We don't need to change fIsSingleComponent in this case
+                fValidFlags = 0;
+            }
+        }
+
+        void invalidateComponents(uint8_t invalidateFlags) {
+            fValidFlags &= ~invalidateFlags;
+            fIsSingleComponent = false;
+        }
+
+        void setToTransparentBlack() {
+            fValidFlags = kRGBA_GrColorComponentFlags;
+            fColor = 0;
+            fIsSingleComponent = true;
+        }
+
+        void setToOther(uint8_t validFlags, GrColor color) {
+            fValidFlags = validFlags;
+            fColor = color;
+            fIsSingleComponent = false;
+        }
+
+        void setToUnknown() {
+            fValidFlags = 0;
+            fIsSingleComponent = false;
+        }
 
         bool isOpaque() const {
             return ((fValidFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(fColor));
         }
 
         bool isSolidWhite() const {
             return (fValidFlags == kRGBA_GrColorComponentFlags && 0xFFFFFFFF == fColor);
         }
 
+        GrColor color() const { return fColor; }
+        uint8_t validFlags() const { return fValidFlags; }
+
         /**
          * 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:
+        bool hasZeroAlpha() const {
+            return ((fValidFlags & kA_GrColorComponentFlag) && 0 == GrColorUnpackA(fColor));
+        }
+
         SkDEBUGCODE(bool colorComponentsAllEqual() const;)
-
         /**
          * 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;
+
+        GrColor fColor;
+        uint32_t fValidFlags;
+        bool fIsSingleComponent;
     };
 
     /**
      * 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.
      */
@@ skipping 170 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