Revert of removing GrDrawEffect

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 200 matching lines @@
         return GrTBackendEffectFactory<ModeColorFilterEffect>::getInstance();
     }
 
     static const char* Name() { return "ModeColorFilterEffect"; }
 
     SkXfermode::Mode mode() const { return fMode; }
     GrColor color() const { return fColor; }
 
     class GLEffect : public GrGLEffect {
     public:
-        GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
             : INHERITED(factory) {
         }
 
         virtual void emitCode(GrGLProgramBuilder* builder,
-                              const GrEffect& effect,
+                              const GrDrawEffect& drawEffect,
                               const GrEffectKey& key,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray& coords,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
-            SkXfermode::Mode mode = effect.cast<ModeColorFilterEffect>().mode();
+            SkXfermode::Mode mode = drawEffect.castEffect<ModeColorFilterEffect>().mode();
 
             SkASSERT(SkXfermode::kDst_Mode != mode);
             const char* colorFilterColorUniName = NULL;
-            if (effect.cast<ModeColorFilterEffect>().willUseFilterColor()) {
+            if (drawEffect.castEffect<ModeColorFilterEffect>().willUseFilterColor()) {
                 fFilterColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                       kVec4f_GrSLType, "FilterColor",
                                                       &colorFilterColorUniName);
             }
 
             GrGLSLExpr4 filter =
-                color_filter_expression(mode, GrGLSLExpr4(colorFilterColorUniName),
-                                        GrGLSLExpr4(inputColor));
+                color_filter_expression(mode, GrGLSLExpr4(colorFilterColorUniName), GrGLSLExpr4(inputColor));
 
             builder->getFragmentShaderBuilder()->
                     codeAppendf("\t%s = %s;\n", outputColor, filter.c_str());
         }
 
-        static void GenKey(const GrEffect& effect, const GrGLCaps&,
+        static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
                            GrEffectKeyBuilder* b) {
-            const ModeColorFilterEffect& colorModeFilter = effect.cast<ModeColorFilterEffect>();
+            const ModeColorFilterEffect& colorModeFilter = drawEffect.castEffect<ModeColorFilterEffect>();
             // The SL code does not depend on filter color at the moment, so no need to represent it
             // in the key.
             b->add32(colorModeFilter.mode());
         }
 
-        virtual void setData(const GrGLProgramDataManager& pdman,
-                             const GrEffect& effect) SK_OVERRIDE {
+        virtual void setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) SK_OVERRIDE {
             if (fFilterColorUni.isValid()) {
-                const ModeColorFilterEffect& colorModeFilter = effect.cast<ModeColorFilterEffect>();
+                const ModeColorFilterEffect& colorModeFilter = drawEffect.castEffect<ModeColorFilterEffect>();
                 GrGLfloat c[4];
                 GrColorToRGBAFloat(colorModeFilter.color(), c);
                 pdman.set4fv(fFilterColorUni, 1, c);
             }
         }
 
     private:
 
         GrGLProgramDataManager::UniformHandle fFilterColorUni;
         typedef GrGLEffect INHERITED;
     };
 
     GR_DECLARE_EFFECT_TEST;
 
 private:
     ModeColorFilterEffect(GrColor color, SkXfermode::Mode mode)
         : fMode(mode),
           fColor(color) {
 
         SkXfermode::Coeff dstCoeff;
         SkXfermode::Coeff srcCoeff;
         SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff));
         // These could be calculated from the blend equation with template trickery..
-        if (SkXfermode::kZero_Coeff == dstCoeff &&
-                !GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff))) {
+        if (SkXfermode::kZero_Coeff == dstCoeff && !GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff))) {
             this->setWillNotUseInputColor();
         }
     }
 
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
-        const ModeColorFilterEffect& s = other.cast<ModeColorFilterEffect>();
+        const ModeColorFilterEffect& s = CastEffect<ModeColorFilterEffect>(other);
         return fMode == s.fMode && fColor == s.fColor;
     }
 
     SkXfermode::Mode fMode;
     GrColor fColor;
 
     typedef GrEffect INHERITED;
 };
 
 namespace {
@@ skipping 242 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