Move GrInvariantOutput out of GrProcessor and into its own class.

src/effects/SkColorFilters.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlitRow.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
@@ skipping 106 matching lines @@
 SkFlattenable* SkModeColorFilter::CreateProc(SkReadBuffer& buffer) {
     SkColor color = buffer.readColor();
     SkXfermode::Mode mode = (SkXfermode::Mode)buffer.readUInt();
     return SkColorFilter::CreateModeFilter(color, mode);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if SK_SUPPORT_GPU
 #include "GrBlend.h"
 #include "GrFragmentProcessor.h"
+#include "GrInvariantOutput.h"
 #include "GrProcessorUnitTest.h"
 #include "GrTBackendProcessorFactory.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #include "SkGr.h"
 
 namespace {
 /**
  * A definition of blend equation for one coefficient. Generates a
  * blend_coeff * value "expression".
@@ skipping 137 matching lines @@
 private:
     ModeColorFilterEffect(GrColor color, SkXfermode::Mode mode)
         : fMode(mode),
           fColor(color) {}
 
     virtual bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE {
         const ModeColorFilterEffect& s = other.cast<ModeColorFilterEffect>();
         return fMode == s.fMode && fColor == s.fColor;
     }
 
-    virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
+    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
 
     SkXfermode::Mode fMode;
     GrColor fColor;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 namespace {
 
 /** Function color_component_to_int tries to reproduce the GLSL rounding. The spec doesn't specify
@@ skipping 70 matching lines @@
     uint32_t getValidComponents() const  { return fFlags; }
 
     typedef MaskedColorExpr AExpr;
 private:
     float fColor[4];
     uint32_t fFlags;
 };
 
 }
 
-void ModeColorFilterEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
+void ModeColorFilterEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     float inputColor[4];
     GrColorToRGBAFloat(inout->color(), inputColor);
     float filterColor[4];
     GrColorToRGBAFloat(fColor, filterColor);
     MaskedColorExpr result =
         color_filter_expression(fMode,
                                 MaskedColorExpr(filterColor, kRGBA_GrColorComponentFlags),
                                 MaskedColorExpr(inputColor, inout->validFlags()));
 
     // Check if we will use the input color
     SkXfermode::Coeff dstCoeff;
     SkXfermode::Coeff srcCoeff;
     SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff));
-    InvariantOutput::ReadInput readInput = InvariantOutput::kWill_ReadInput;
+    GrInvariantOutput::ReadInput readInput = GrInvariantOutput::kWill_ReadInput;
     // These could be calculated from the blend equation with template trickery..
     if (SkXfermode::kZero_Coeff == dstCoeff &&
         !GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff))) {
-        readInput = InvariantOutput::kWillNot_ReadInput;
+        readInput = GrInvariantOutput::kWillNot_ReadInput;
     }
     inout->setToOther(result.getValidComponents(), result.getColor(), readInput);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ModeColorFilterEffect);
 GrFragmentProcessor* ModeColorFilterEffect::TestCreate(SkRandom* rand,
                                                        GrContext*,
                                                        const GrDrawTargetCaps&,
                                                        GrTexture*[]) {
     SkXfermode::Mode mode = SkXfermode::kDst_Mode;
@@ skipping 146 matching lines @@
     matrix.postTranslate(SkIntToScalar(SkColorGetR(add)),
                          SkIntToScalar(SkColorGetG(add)),
                          SkIntToScalar(SkColorGetB(add)),
                          0);
     return SkColorMatrixFilter::Create(matrix);
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkModeColorFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END