Revert of Add isSingleComponent bool to getConstantColorComponent

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 177 matching lines @@
         // TODO: Make the effect take the coeffs rather than mode since we already do the
         // conversion here.
         SkXfermode::Coeff srcCoeff, dstCoeff;
         if (!SkXfermode::ModeAsCoeff(mode, &srcCoeff, &dstCoeff)) {
             SkDebugf("Failing to create color filter for mode %d\n", mode);
             return NULL;
         }
         return SkNEW_ARGS(ModeColorFilterEffect, (c, mode));
     }
 
+    virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
+
     bool willUseFilterColor() const {
         SkXfermode::Coeff dstCoeff;
         SkXfermode::Coeff srcCoeff;
         SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff));
         if (SkXfermode::kZero_Coeff == srcCoeff) {
             return GrBlendCoeffRefsSrc(sk_blend_to_grblend(dstCoeff));
         }
         return true;
     }
 
@@ skipping 76 matching lines @@
                 !GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff))) {
             this->setWillNotUseInputColor();
         }
     }
 
     virtual bool onIsEqual(const GrProcessor& 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;
-
     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
  * to which direction the 0.5 goes.
@@ skipping 69 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::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     float inputColor[4];
-    GrColorToRGBAFloat(inout->fColor, inputColor);
+    GrColorToRGBAFloat(*color, inputColor);
     float filterColor[4];
     GrColorToRGBAFloat(fColor, filterColor);
     MaskedColorExpr result =
         color_filter_expression(fMode,
                                 MaskedColorExpr(filterColor, kRGBA_GrColorComponentFlags),
-                                MaskedColorExpr(inputColor, inout->fValidFlags));
+                                MaskedColorExpr(inputColor, *validFlags));
 
-    inout->fColor = result.getColor();
-    inout->fValidFlags = result.getValidComponents();
-    inout->fIsSingleComponent = false;
+    *color = result.getColor();
+    *validFlags = result.getValidComponents();
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ModeColorFilterEffect);
 GrFragmentProcessor* ModeColorFilterEffect::TestCreate(SkRandom* rand,
                                                        GrContext*,
                                                        const GrDrawTargetCaps&,
                                                        GrTexture*[]) {
     SkXfermode::Mode mode = SkXfermode::kDst_Mode;
     while (SkXfermode::kDst_Mode == mode) {
         mode = static_cast<SkXfermode::Mode>(rand->nextRangeU(0, SkXfermode::kLastCoeffMode));
@@ skipping 138 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