Move GrInvariantOutput out of GrProcessor and into its own class.

src/gpu/GrPaint.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPaint.h"
 
 #include "GrBlend.h"
+#include "GrInvariantOutput.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 void GrPaint::addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
     this->addColorProcessor(GrSimpleTextureEffect::Create(texture, matrix))->unref();
 }
 
 void GrPaint::addCoverageTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
     this->addCoverageProcessor(GrSimpleTextureEffect::Create(texture, matrix))->unref();
 }
 
@@ skipping 23 matching lines @@
         }
     }
     return false;
 }
 
 bool GrPaint::getOpaqueAndKnownColor(GrColor* solidColor,
                                      uint32_t* solidColorKnownComponents) const {
 
     // TODO: Share this implementation with GrDrawState
 
-    GrProcessor::InvariantOutput inout;
-    inout.fColor = 0xFFFFFFFF;
-    inout.fValidFlags = kRGBA_GrColorComponentFlags;
-    inout.fIsSingleComponent = true;
+    GrInvariantOutput inoutCoverage(0xFFFFFFFF,
+                                    kRGBA_GrColorComponentFlags,
+                                    true);
     int count = fCoverageStages.count();
     for (int i = 0; i < count; ++i) {
-        fCoverageStages[i].getProcessor()->computeInvariantOutput(&inout);
+        fCoverageStages[i].getProcessor()->computeInvariantOutput(&inoutCoverage);
     }
-    if (!inout.isSolidWhite()) {
+    if (!inoutCoverage.isSolidWhite()) {
         return false;
     }
 
-    inout.fColor = fColor;
-    inout.fValidFlags = kRGBA_GrColorComponentFlags;
-    inout.fIsSingleComponent = false;
+    GrInvariantOutput inout(fColor, kRGBA_GrColorComponentFlags, false);
     count = fColorStages.count();
     for (int i = 0; i < count; ++i) {
         fColorStages[i].getProcessor()->computeInvariantOutput(&inout);
     }
 
     SkASSERT((NULL == solidColor) == (NULL == solidColorKnownComponents));
 
     GrBlendCoeff srcCoeff = fSrcBlendCoeff;
     GrBlendCoeff dstCoeff = fDstBlendCoeff;
-    GrSimplifyBlend(&srcCoeff, &dstCoeff, inout.fColor, inout.fValidFlags,
+    GrSimplifyBlend(&srcCoeff, &dstCoeff, inout.color(), inout.validFlags(),
                     0, 0, 0);
 
     bool opaque = kZero_GrBlendCoeff == dstCoeff && !GrBlendCoeffRefsDst(srcCoeff);
     if (solidColor) {
         if (opaque) {
             switch (srcCoeff) {
                 case kZero_GrBlendCoeff:
                     *solidColor = 0;
                     *solidColorKnownComponents = kRGBA_GrColorComponentFlags;
                     break;
 
                 case kOne_GrBlendCoeff:
-                    *solidColor = inout.fColor;
-                    *solidColorKnownComponents = inout.fValidFlags;
+                    *solidColor = inout.color();
+                    *solidColorKnownComponents = inout.validFlags();
                     break;
 
                 // The src coeff should never refer to the src and if it refers to dst then opaque
                 // should have been false.
                 case kSC_GrBlendCoeff:
                 case kISC_GrBlendCoeff:
                 case kDC_GrBlendCoeff:
                 case kIDC_GrBlendCoeff:
                 case kSA_GrBlendCoeff:
                 case kISA_GrBlendCoeff:
@@ skipping 10 matching lines @@
                 case kIConstA_GrBlendCoeff:
                     *solidColorKnownComponents = 0;
                     break;
             }
         } else {
             solidColorKnownComponents = 0;
         }
     }
     return opaque;
 }