Remove GP from drawstate, revision of invariant output for GP

include/gpu/GrInvariantOutput.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrInvariantOutput_DEFINED
 #define GrInvariantOutput_DEFINED
 
 #include "GrColor.h"
 
+struct GrInitInvariantOutput {
+    GrInitInvariantOutput()
+        : fValidFlags(0)
+        , fColor(0)
+        , fIsSingleComponent(false) {}
+
+    void setKnownComponents(GrColor color) {
+        fColor = color;
+        fValidFlags = kRGBA_GrColorComponentFlags;

[bsalomon, 2014/12/09 20:39:50]

fSingleComponent = (true if all the values the same);

+    }
+
+    void setKnownAlpha(uint8_t alpha) {
+        fColor |= (fColor >> GrColor_SHIFT_A) | alpha;

[bsalomon, 2014/12/09 20:39:50]

fColor = (alpha << SHIFT_A);

right?

+        fValidFlags |= kA_GrColorComponentFlag;

[bsalomon, 2014/12/09 20:39:50]

= not |=, right?

+    }

[bsalomon, 2014/12/09 20:39:50]

fSingleComponent = true;

+
+    void setUnknownAlpha() {
+        fValidFlags &= ~kA_GrColorComponentFlag;

[bsalomon, 2014/12/09 20:39:50]

fValidFlags = 0;
fSingleComponent = true;

+    }
+
+    void setUnknown() {
+        fValidFlags = 0;

[bsalomon, 2014/12/09 20:39:50]

fSingleComponent = false;

Should we make the name of this explicitly 4 channel? e.g. setUnknownComponents
?

+    }
+
+    void setOpaque() {
+        fColor |= (fColor >> GrColor_SHIFT_A) | 0xFF;
+        fValidFlags |= kA_GrColorComponentFlag;

[bsalomon, 2014/12/09 20:39:50]

fSingleComponent = false

+    }
+
+    void setIsSingleComponent() { fIsSingleComponent = true; }

[bsalomon, 2014/12/09 20:39:50]

Do we need this two helpers? seems always implied by the above helpers and the
fields are all public.

+
+    void setHasFourComponents() { fIsSingleComponent = false; }
+
+    uint32_t fValidFlags;
+    GrColor fColor;
+    bool fIsSingleComponent;
+};
+
 class GrInvariantOutput {
 public:
     GrInvariantOutput(GrColor color, GrColorComponentFlags flags, bool isSingleComponent)
         : fColor(color)
         , fValidFlags(flags)
         , fIsSingleComponent(isSingleComponent)
         , fNonMulStageFound(false)
         , fWillUseInputColor(true)
         , fIsLCDCoverage(false) {}
 
+    GrInvariantOutput(const GrInitInvariantOutput& io)
+        : fColor(io.fColor)
+        , fValidFlags(io.fValidFlags)
+        , fIsSingleComponent(io.fIsSingleComponent)
+        , fNonMulStageFound(false)
+        , fWillUseInputColor(false) {}
+
     virtual ~GrInvariantOutput() {}
 
     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(); 
+            this->mulByUnknownColor();
         }
     }
 
     void mulByUnknownColor() {
         if (this->hasZeroAlpha()) {
             this->internalSetToTransparentBlack();
         } else {
             this->internalSetToUnknown();
         }
     }
@@ skipping 67 matching lines @@
     friend class GrProcOptInfo;
 
     void reset(GrColor color, GrColorComponentFlags flags, bool isSingleComponent) {
         fColor = color;
         fValidFlags = flags;
         fIsSingleComponent = isSingleComponent;
         fNonMulStageFound = false;
         fWillUseInputColor = true;
     }
 
+    void reset(const GrInitInvariantOutput& io) {
+        fColor = io.fColor;
+        fValidFlags = io.fValidFlags;
+        fIsSingleComponent = io.fIsSingleComponent;
+        fNonMulStageFound = false;
+        fWillUseInputColor = true;
+    }
+
     void internalSetToTransparentBlack() {
         fValidFlags = kRGBA_GrColorComponentFlags;
         fColor = 0;
         fIsSingleComponent = true;
     }
 
     void internalSetToUnknown() {
         fValidFlags = 0;
         fIsSingleComponent = false;
     }
@@ skipping 29 matching lines @@
     uint32_t fValidFlags;
     bool fIsSingleComponent;
     bool fNonMulStageFound;
     bool fWillUseInputColor;
     bool fIsLCDCoverage; // Temorary data member until texture pixel configs are updated
 
 };
 
 #endif