Solo gp

src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTwoPointConicalGradient_gpu.h"
 
 #include "SkTwoPointConicalGradient.h"
 
 #if SK_SUPPORT_GPU
-#include "GrTBackendEffectFactory.h"
+#include "GrTBackendProcessorFactory.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 // For brevity
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
 static const SkScalar kErrorTol = 0.00001f;
 static const SkScalar kEdgeErrorTol = 5.f * kErrorTol;
 
 /**
  * We have three general cases for 2pt conical gradients. First we always assume that
  * the start radius <= end radius. Our first case (kInside_) is when the start circle
@@ skipping 28 matching lines @@
                        SkScalarMul(invDiffLen, diff.fX));
         invLMatrix->postConcat(rot);
     }
 }
 
 class GLEdge2PtConicalEffect;
 
 class Edge2PtConicalEffect : public GrGradientEffect {
 public:
 
-    static GrEffect* Create(GrContext* ctx,
-                            const SkTwoPointConicalGradient& shader,
-                            const SkMatrix& matrix,
-                            SkShader::TileMode tm) {
+    static GrFragmentProcessor* Create(GrContext* ctx,
+                                       const SkTwoPointConicalGradient& shader,
+                                       const SkMatrix& matrix,
+                                       SkShader::TileMode tm) {
         return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shader, matrix, tm));
     }
 
     virtual ~Edge2PtConicalEffect() {}
 
     static const char* Name() { return "Two-Point Conical Gradient Edge Touching"; }
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
 
     // The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
     SkScalar center() const { return fCenterX1; }
     SkScalar diffRadius() const { return fDiffRadius; }
     SkScalar radius() const { return fRadius0; }
 
-    typedef GLEdge2PtConicalEffect GLEffect;
+    typedef GLEdge2PtConicalEffect GLProcessor;
 
 private:
-    virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
+    virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {
         const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fCenterX1 == s.fCenterX1 &&
                 this->fRadius0 == s.fRadius0 &&
                 this->fDiffRadius == s.fDiffRadius);
     }
 
     Edge2PtConicalEffect(GrContext* ctx,
                          const SkTwoPointConicalGradient& shader,
                          const SkMatrix& matrix,
@@ skipping 15 matching lines @@
         SkScalar r0dr = SkScalarMul(fRadius0, fDiffRadius);
         bMatrix[SkMatrix::kMScaleX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMScaleX]) +
                                             SkScalarMul(r0dr, bMatrix[SkMatrix::kMPersp0]));
         bMatrix[SkMatrix::kMSkewX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMSkewX]) +
                                            SkScalarMul(r0dr, bMatrix[SkMatrix::kMPersp1]));
         bMatrix[SkMatrix::kMTransX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMTransX]) +
                                             SkScalarMul(r0dr, bMatrix[SkMatrix::kMPersp2]));
         this->addCoordTransform(&fBTransform);
     }
 
-    GR_DECLARE_EFFECT_TEST;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     // @{
     // Cache of values - these can change arbitrarily, EXCEPT
     // we shouldn't change between degenerate and non-degenerate?!
 
     GrCoordTransform fBTransform;
     SkScalar         fCenterX1;
     SkScalar         fRadius0;
     SkScalar         fDiffRadius;
 
     // @}
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLEdge2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+    GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
     virtual ~GLEdge2PtConicalEffect() { }
 
     virtual void emitCode(GrGLProgramBuilder*,
-                          const GrEffect&,
-                          const GrEffectKey&,
+                          const GrFragmentProcessor&,
+                          const GrProcessorKey&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
-    virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
-    static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+    static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedRadius;
     SkScalar fCachedDiffRadius;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendEffectFactory& Edge2PtConicalEffect::getFactory() const {
-    return GrTBackendEffectFactory<Edge2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& Edge2PtConicalEffect::getFactory() const {
+    return GrTBackendFragmentProcessorFactory<Edge2PtConicalEffect>::getInstance();
 }
 
-GR_DEFINE_EFFECT_TEST(Edge2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect);
 
-GrEffect* Edge2PtConicalEffect::TestCreate(SkRandom* random,
-                                           GrContext* context,
-                                           const GrDrawTargetCaps&,
-                                           GrTexture**) {
+GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(SkRandom* random,
+                                                      GrContext* context,
+                                                      const GrDrawTargetCaps&,
+                                                      GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = random->nextUScalar1();
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // If the circles are identical the factory will give us an empty shader.
         // This will happen if we pick identical centers
     } while (center1 == center2);
 
     // Below makes sure that circle one is contained within circle two
     // and both circles are touching on an edge
     SkPoint diff = center2 - center1;
     SkScalar diffLen = diff.length();
     radius2 = radius1 + diffLen;
 
     SkColor colors[kMaxRandomGradientColors];
     SkScalar stopsArray[kMaxRandomGradientColors];
     SkScalar* stops = stopsArray;
     SkShader::TileMode tm;
     int colorCount = RandomGradientParams(random, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
-    GrEffect* effect;
+    GrFragmentProcessor* fp;
     GrColor paintColor;
-    SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));
-    return effect;
+    SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));
+    return fp;
 }
 
-GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory,
-                                               const GrEffect& effect)
+GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory,
+                                               const GrProcessor&)
     : INHERITED(factory)
     , fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedRadius(-SK_ScalarMax)
     , fCachedDiffRadius(-SK_ScalarMax) {}
 
 void GLEdge2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
-                                      const GrEffect&,
-                                      const GrEffectKey& key,
+                                      const GrFragmentProcessor&,
+                                      const GrProcessorKey& key,
                                       const char* outputColor,
                                       const char* inputColor,
                                       const TransformedCoordsArray& coords,
                                       const TextureSamplerArray& samplers) {
     uint32_t baseKey = key.get32(0);
     this->emitUniforms(builder, baseKey);
     fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType, "Conical2FSParams", 3);
 
     SkString cName("c");
@@ skipping 36 matching lines @@
 
     // if r(t) > 0, then t will be the x coordinate
     fsBuilder->codeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
                            p2.c_str(), p0.c_str());
     fsBuilder->codeAppend("\t");
     this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
 void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
-                                     const GrEffect& effect) {
-    INHERITED::setData(pdman, effect);
-    const Edge2PtConicalEffect& data = effect.cast<Edge2PtConicalEffect>();
+                                     const GrProcessor& processor) {
+    INHERITED::setData(pdman, processor);
+    const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();
     SkScalar radius0 = data.radius();
     SkScalar diffRadius = data.diffRadius();
 
     if (fCachedRadius != radius0 ||
         fCachedDiffRadius != diffRadius) {
 
         float values[3] = {
             SkScalarToFloat(radius0),
             SkScalarToFloat(SkScalarMul(radius0, radius0)),
             SkScalarToFloat(diffRadius)
         };
 
         pdman.set1fv(fParamUni, 3, values);
         fCachedRadius = radius0;
         fCachedDiffRadius = diffRadius;
     }
 }
 
-void GLEdge2PtConicalEffect::GenKey(const GrEffect& effect,
-                                    const GrGLCaps&, GrEffectKeyBuilder* b) {
-    b->add32(GenBaseGradientKey(effect));
+void GLEdge2PtConicalEffect::GenKey(const GrProcessor& processor,
+                                    const GrGLCaps&, GrProcessorKeyBuilder* b) {
+    b->add32(GenBaseGradientKey(processor));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Focal Conical Gradients
 //////////////////////////////////////////////////////////////////////////////
 
 static ConicalType set_matrix_focal_conical(const SkTwoPointConicalGradient& shader,
                                             SkMatrix* invLMatrix, SkScalar* focalX) {
     // Inverse of the current local matrix is passed in then,
     // translate, scale, and rotate such that endCircle is unit circle on x-axis,
@@ skipping 49 matching lines @@
     return conicalType;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLFocalOutside2PtConicalEffect;
 
 class FocalOutside2PtConicalEffect : public GrGradientEffect {
 public:
 
-    static GrEffect* Create(GrContext* ctx,
-                            const SkTwoPointConicalGradient& shader,
-                            const SkMatrix& matrix,
-                            SkShader::TileMode tm,
-                            SkScalar focalX) {
+    static GrFragmentProcessor* Create(GrContext* ctx,
+                                       const SkTwoPointConicalGradient& shader,
+                                       const SkMatrix& matrix,
+                                       SkShader::TileMode tm,
+                                       SkScalar focalX) {
         return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));
     }
 
     virtual ~FocalOutside2PtConicalEffect() { }
 
     static const char* Name() { return "Two-Point Conical Gradient Focal Outside"; }
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
 
     bool isFlipped() const { return fIsFlipped; }
     SkScalar focal() const { return fFocalX; }
 
-    typedef GLFocalOutside2PtConicalEffect GLEffect;
+    typedef GLFocalOutside2PtConicalEffect GLProcessor;
 
 private:
-    virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
+    virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {
         const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fFocalX == s.fFocalX &&
                 this->fIsFlipped == s.fIsFlipped);
     }
 
     FocalOutside2PtConicalEffect(GrContext* ctx,
                                  const SkTwoPointConicalGradient& shader,
                                  const SkMatrix& matrix,
                                  SkShader::TileMode tm,
                                  SkScalar focalX)
     : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isFlippedGrad()) {}
 
-    GR_DECLARE_EFFECT_TEST;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     SkScalar         fFocalX;
     bool             fIsFlipped;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+    GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
     virtual ~GLFocalOutside2PtConicalEffect() { }
 
     virtual void emitCode(GrGLProgramBuilder*,
-                          const GrEffect&,
-                          const GrEffectKey&,
+                          const GrFragmentProcessor&,
+                          const GrProcessorKey&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
-    virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
-    static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+    static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     bool fIsFlipped;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedFocal;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendEffectFactory& FocalOutside2PtConicalEffect::getFactory() const {
-    return GrTBackendEffectFactory<FocalOutside2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& FocalOutside2PtConicalEffect::getFactory() const {
+    return GrTBackendFragmentProcessorFactory<FocalOutside2PtConicalEffect>::getInstance();
 }
 
-GR_DEFINE_EFFECT_TEST(FocalOutside2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect);
 
-GrEffect* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,
-                                                   GrContext* context,
-                                                   const GrDrawTargetCaps&,
-                                                   GrTexture**) {
+GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,
+                                                              GrContext* context,
+                                                              const GrDrawTargetCaps&,
+                                                              GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = 0.f;
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // Need to make sure the centers are not the same or else focal point will be inside
     } while (center1 == center2);
         SkPoint diff = center2 - center1;
         SkScalar diffLen = diff.length();
         // Below makes sure that the focal point is not contained within circle two
         radius2 = random->nextRangeF(0.f, diffLen);
 
     SkColor colors[kMaxRandomGradientColors];
     SkScalar stopsArray[kMaxRandomGradientColors];
     SkScalar* stops = stopsArray;
     SkShader::TileMode tm;
     int colorCount = RandomGradientParams(random, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
-    GrEffect* effect;
+    GrFragmentProcessor* effect;
     GrColor paintColor;
-    SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));
+    SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &effect));
     return effect;
 }
 
-GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory,
-                                                               const GrEffect& effect)
+GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,
+                                                               const GrProcessor& processor)
     : INHERITED(factory)
     , fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedFocal(SK_ScalarMax) {
-    const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConicalEffect>();
+    const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
 }
 
 void GLFocalOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
-                                              const GrEffect&,
-                                              const GrEffectKey& key,
+                                              const GrFragmentProcessor&,
+                                              const GrProcessorKey& key,
                                               const char* outputColor,
                                               const char* inputColor,
                                               const TransformedCoordsArray& coords,
                                               const TextureSamplerArray& samplers) {
     uint32_t baseKey = key.get32(0);
     this->emitUniforms(builder, baseKey);
     fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType, "Conical2FSParams", 2);
     SkString tName("t");
     SkString p0; // focalX
@@ skipping 27 matching lines @@
                                coords2D, p0.c_str());
     }
 
     fsBuilder->codeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str());
     fsBuilder->codeAppend("\t\t");
     this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
 void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
-                                             const GrEffect& effect) {
-    INHERITED::setData(pdman, effect);
-    const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConicalEffect>();
+                                             const GrProcessor& processor) {
+    INHERITED::setData(pdman, processor);
+    const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
         SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal);
 
         float values[2] = {
             SkScalarToFloat(focal),
             SkScalarToFloat(oneMinus2F),
         };
 
         pdman.set1fv(fParamUni, 2, values);
         fCachedFocal = focal;
     }
 }
 
-void GLFocalOutside2PtConicalEffect::GenKey(const GrEffect& effect,
-                                            const GrGLCaps&, GrEffectKeyBuilder* b) {
+void GLFocalOutside2PtConicalEffect::GenKey(const GrProcessor& processor,
+                                            const GrGLCaps&, GrProcessorKeyBuilder* b) {
     uint32_t* key = b->add32n(2);
-    key[0] = GenBaseGradientKey(effect);
-    key[1] = effect.cast<FocalOutside2PtConicalEffect>().isFlipped();
+    key[0] = GenBaseGradientKey(processor);
+    key[1] = processor.cast<FocalOutside2PtConicalEffect>().isFlipped();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLFocalInside2PtConicalEffect;
 
 class FocalInside2PtConicalEffect : public GrGradientEffect {
 public:
 
-    static GrEffect* Create(GrContext* ctx,
-                            const SkTwoPointConicalGradient& shader,
-                            const SkMatrix& matrix,
-                            SkShader::TileMode tm,
-                            SkScalar focalX) {
+    static GrFragmentProcessor* Create(GrContext* ctx,
+                                       const SkTwoPointConicalGradient& shader,
+                                       const SkMatrix& matrix,
+                                       SkShader::TileMode tm,
+                                       SkScalar focalX) {
         return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));
     }
 
     virtual ~FocalInside2PtConicalEffect() {}
 
     static const char* Name() { return "Two-Point Conical Gradient Focal Inside"; }
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
 
     SkScalar focal() const { return fFocalX; }
 
-    typedef GLFocalInside2PtConicalEffect GLEffect;
+    typedef GLFocalInside2PtConicalEffect GLProcessor;
 
 private:
-    virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
+    virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {
         const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fFocalX == s.fFocalX);
     }
 
     FocalInside2PtConicalEffect(GrContext* ctx,
                                 const SkTwoPointConicalGradient& shader,
                                 const SkMatrix& matrix,
                                 SkShader::TileMode tm,
                                 SkScalar focalX)
         : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {}
 
-    GR_DECLARE_EFFECT_TEST;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     SkScalar         fFocalX;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+    GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
     virtual ~GLFocalInside2PtConicalEffect() {}
 
     virtual void emitCode(GrGLProgramBuilder*,
-                          const GrEffect&,
-                          const GrEffectKey&,
+                          const GrFragmentProcessor&,
+                          const GrProcessorKey&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
-    virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
-    static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+    static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fFocalUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedFocal;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendEffectFactory& FocalInside2PtConicalEffect::getFactory() const {
-    return GrTBackendEffectFactory<FocalInside2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& FocalInside2PtConicalEffect::getFactory() const {
+    return GrTBackendFragmentProcessorFactory<FocalInside2PtConicalEffect>::getInstance();
 }
 
-GR_DEFINE_EFFECT_TEST(FocalInside2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect);
 
-GrEffect* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,
-                                                  GrContext* context,
-                                                  const GrDrawTargetCaps&,
-                                                  GrTexture**) {
+GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,
+                                                             GrContext* context,
+                                                             const GrDrawTargetCaps&,
+                                                             GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = 0.f;
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // Below makes sure radius2 is larger enouch such that the focal point
         // is inside the end circle
         SkScalar increase = random->nextUScalar1();
         SkPoint diff = center2 - center1;
         SkScalar diffLen = diff.length();
         radius2 = diffLen + increase;
         // If the circles are identical the factory will give us an empty shader.
     } while (radius1 == radius2 && center1 == center2);
 
     SkColor colors[kMaxRandomGradientColors];
     SkScalar stopsArray[kMaxRandomGradientColors];
     SkScalar* stops = stopsArray;
     SkShader::TileMode tm;
     int colorCount = RandomGradientParams(random, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
-    GrEffect* effect;
-    SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));
-    return effect;
+    GrFragmentProcessor* fp;
+    SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));
+    return fp;
 }
 
-GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory,
-                                                             const GrEffect& effect)
+GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory,
+                                                             const GrProcessor&)
     : INHERITED(factory)
     , fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedFocal(SK_ScalarMax) {}
 
 void GLFocalInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
-                                             const GrEffect&,
-                                             const GrEffectKey& key,
+                                             const GrFragmentProcessor&,
+                                             const GrProcessorKey& key,
                                              const char* outputColor,
                                              const char* inputColor,
                                              const TransformedCoordsArray& coords,
                                              const TextureSamplerArray& samplers) {
     uint32_t baseKey = key.get32(0);
     this->emitUniforms(builder, baseKey);
     fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kFloat_GrSLType, "Conical2FSParams");
     SkString tName("t");
 
     // this is the distance along x-axis from the end center to focal point in
     // transformed coordinates
     GrGLShaderVar focal = builder->getUniformVariable(fFocalUni);
 
     // if we have a vec3 from being in perspective, convert it to a vec2 first
     GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
     const char* coords2D = coords2DString.c_str();
 
     // t = p.x * focalX + length(p)
     fsBuilder->codeAppendf("\tfloat %s = %s.x * %s  + length(%s);\n", tName.c_str(),
                            coords2D, focal.c_str(), coords2D);
 
     this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
 }
 
 void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
-                                            const GrEffect& effect) {
-    INHERITED::setData(pdman, effect);
-    const FocalInside2PtConicalEffect& data = effect.cast<FocalInside2PtConicalEffect>();
+                                            const GrProcessor& processor) {
+    INHERITED::setData(pdman, processor);
+    const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConicalEffect>();
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
         pdman.set1f(fFocalUni, SkScalarToFloat(focal));
         fCachedFocal = focal;
     }
 }
 
-void GLFocalInside2PtConicalEffect::GenKey(const GrEffect& effect,
-                                           const GrGLCaps&, GrEffectKeyBuilder* b) {
-    b->add32(GenBaseGradientKey(effect));
+void GLFocalInside2PtConicalEffect::GenKey(const GrProcessor& processor,
+                                           const GrGLCaps&, GrProcessorKeyBuilder* b) {
+    b->add32(GenBaseGradientKey(processor));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Circle Conical Gradients
 //////////////////////////////////////////////////////////////////////////////
 
 struct CircleConicalInfo {
     SkPoint fCenterEnd;
     SkScalar fA;
     SkScalar fB;
@@ skipping 51 matching lines @@
         return kInside_ConicalType;
     }
     return kOutside_ConicalType;
 }
 
 class GLCircleInside2PtConicalEffect;
 
 class CircleInside2PtConicalEffect : public GrGradientEffect {
 public:
 
-    static GrEffect* Create(GrContext* ctx,
-                            const SkTwoPointConicalGradient& shader,
-                            const SkMatrix& matrix,
-                            SkShader::TileMode tm,
-                            const CircleConicalInfo& info) {
+    static GrFragmentProcessor* Create(GrContext* ctx,
+                                       const SkTwoPointConicalGradient& shader,
+                                       const SkMatrix& matrix,
+                                       SkShader::TileMode tm,
+                                       const CircleConicalInfo& info) {
         return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, shader, matrix, tm, info));
     }
 
     virtual ~CircleInside2PtConicalEffect() {}
 
     static const char* Name() { return "Two-Point Conical Gradient Inside"; }
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
 
     SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
     SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
     SkScalar A() const { return fInfo.fA; }
     SkScalar B() const { return fInfo.fB; }
     SkScalar C() const { return fInfo.fC; }
 
-    typedef GLCircleInside2PtConicalEffect GLEffect;
+    typedef GLCircleInside2PtConicalEffect GLProcessor;
 
 private:
-    virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
+    virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {
         const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
                 this->fInfo.fA == s.fInfo.fA &&
                 this->fInfo.fB == s.fInfo.fB &&
                 this->fInfo.fC == s.fInfo.fC);
     }
 
     CircleInside2PtConicalEffect(GrContext* ctx,
                                  const SkTwoPointConicalGradient& shader,
                                  const SkMatrix& matrix,
                                  SkShader::TileMode tm,
                                  const CircleConicalInfo& info)
         : INHERITED(ctx, shader, matrix, tm), fInfo(info) {}
 
-    GR_DECLARE_EFFECT_TEST;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     const CircleConicalInfo fInfo;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+    GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
     virtual ~GLCircleInside2PtConicalEffect() {}
 
     virtual void emitCode(GrGLProgramBuilder*,
-                          const GrEffect&,
-                          const GrEffectKey&,
+                          const GrFragmentProcessor&,
+                          const GrProcessorKey&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
-    virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
-    static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+    static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fCenterUni;
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedCenterX;
     SkScalar fCachedCenterY;
     SkScalar fCachedA;
     SkScalar fCachedB;
     SkScalar fCachedC;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendEffectFactory& CircleInside2PtConicalEffect::getFactory() const {
-    return GrTBackendEffectFactory<CircleInside2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& CircleInside2PtConicalEffect::getFactory() const {
+    return GrTBackendFragmentProcessorFactory<CircleInside2PtConicalEffect>::getInstance();
 }
 
-GR_DEFINE_EFFECT_TEST(CircleInside2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect);
 
-GrEffect* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,
-                                                   GrContext* context,
-                                                   const GrDrawTargetCaps&,
-                                                   GrTexture**) {
+GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,
+                                                              GrContext* context,
+                                                              const GrDrawTargetCaps&,
+                                                              GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0
     SkPoint center2;
     SkScalar radius2;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // Below makes sure that circle one is contained within circle two
         SkScalar increase = random->nextUScalar1();
         SkPoint diff = center2 - center1;
         SkScalar diffLen = diff.length();
         radius2 = radius1 + diffLen + increase;
         // If the circles are identical the factory will give us an empty shader.
     } while (radius1 == radius2 && center1 == center2);
 
     SkColor colors[kMaxRandomGradientColors];
     SkScalar stopsArray[kMaxRandomGradientColors];
     SkScalar* stops = stopsArray;
     SkShader::TileMode tm;
     int colorCount = RandomGradientParams(random, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
-    GrEffect* effect;
-    SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));
-    return effect;
+    GrFragmentProcessor* processor;
+    SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &processor));
+    return processor;
 }
 
-GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory,
-                                                               const GrEffect& effect)
+GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory,
+                                                               const GrProcessor& processor)
     : INHERITED(factory)
     , fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
     , fCachedC(SK_ScalarMax) {}
 
 void GLCircleInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
-                                              const GrEffect&,
-                                              const GrEffectKey& key,
+                                              const GrFragmentProcessor&,
+                                              const GrProcessorKey& key,
                                               const char* outputColor,
                                               const char* inputColor,
                                               const TransformedCoordsArray& coords,
                                               const TextureSamplerArray& samplers) {
     uint32_t baseKey = key.get32(0);
     this->emitUniforms(builder, baseKey);
     fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                      kVec2f_GrSLType, "Conical2FSCenter");
     fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kVec3f_GrSLType, "Conical2FSParams");
@@ skipping 21 matching lines @@
     fsBuilder->codeAppendf("\tfloat pDotp = dot(%s,  %s);\n", coords2D, coords2D);
     fsBuilder->codeAppendf("\tfloat d = dot(%s,  %s) + %s.y;\n", coords2D, center.c_str(),
                            params.c_str());
     fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\n",
                            tName.c_str(), params.c_str(), params.c_str());
 
     this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
 }
 
 void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
-                                             const GrEffect& effect) {
-    INHERITED::setData(pdman, effect);
-    const CircleInside2PtConicalEffect& data = effect.cast<CircleInside2PtConicalEffect>();
+                                             const GrProcessor& processor) {
+    INHERITED::setData(pdman, processor);
+    const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtConicalEffect>();
     SkScalar centerX = data.centerX();
     SkScalar centerY = data.centerY();
     SkScalar A = data.A();
     SkScalar B = data.B();
     SkScalar C = data.C();
 
     if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
         fCachedA != A || fCachedB != B || fCachedC != C) {
 
         pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY));
         pdman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarToFloat(C));
 
         fCachedCenterX = centerX;
         fCachedCenterY = centerY;
         fCachedA = A;
         fCachedB = B;
         fCachedC = C;
     }
 }
 
-void GLCircleInside2PtConicalEffect::GenKey(const GrEffect& effect,
-                                            const GrGLCaps&, GrEffectKeyBuilder* b) {
-    b->add32(GenBaseGradientKey(effect));
+void GLCircleInside2PtConicalEffect::GenKey(const GrProcessor& processor,
+                                            const GrGLCaps&, GrProcessorKeyBuilder* b) {
+    b->add32(GenBaseGradientKey(processor));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLCircleOutside2PtConicalEffect;
 
 class CircleOutside2PtConicalEffect : public GrGradientEffect {
 public:
 
-    static GrEffect* Create(GrContext* ctx,
-                            const SkTwoPointConicalGradient& shader,
-                            const SkMatrix& matrix,
-                            SkShader::TileMode tm,
-                            const CircleConicalInfo& info) {
+    static GrFragmentProcessor* Create(GrContext* ctx,
+                                       const SkTwoPointConicalGradient& shader,
+                                       const SkMatrix& matrix,
+                                       SkShader::TileMode tm,
+                                       const CircleConicalInfo& info) {
         return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, shader, matrix, tm, info));
     }
 
     virtual ~CircleOutside2PtConicalEffect() {}
 
     static const char* Name() { return "Two-Point Conical Gradient Outside"; }
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+    virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
 
     SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
     SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
     SkScalar A() const { return fInfo.fA; }
     SkScalar B() const { return fInfo.fB; }
     SkScalar C() const { return fInfo.fC; }
     SkScalar tLimit() const { return fTLimit; }
     bool isFlipped() const { return fIsFlipped; }
 
-    typedef GLCircleOutside2PtConicalEffect GLEffect;
+    typedef GLCircleOutside2PtConicalEffect GLProcessor;
 
 private:
-    virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
+    virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {
         const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
                 this->fInfo.fA == s.fInfo.fA &&
                 this->fInfo.fB == s.fInfo.fB &&
                 this->fInfo.fC == s.fInfo.fC &&
                 this->fTLimit == s.fTLimit &&
                 this->fIsFlipped == s.fIsFlipped);
     }
 
     CircleOutside2PtConicalEffect(GrContext* ctx,
                                   const SkTwoPointConicalGradient& shader,
                                   const SkMatrix& matrix,
                                   SkShader::TileMode tm,
                                   const CircleConicalInfo& info)
         : INHERITED(ctx, shader, matrix, tm), fInfo(info) {
         if (shader.getStartRadius() != shader.getEndRadius()) {
             fTLimit = SkScalarDiv(shader.getStartRadius(),
                                   (shader.getStartRadius() - shader.getEndRadius()));
         } else {
             fTLimit = SK_ScalarMin;
         }
 
         fIsFlipped = shader.isFlippedGrad();
     }
 
-    GR_DECLARE_EFFECT_TEST;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     const CircleConicalInfo fInfo;
     SkScalar fTLimit;
     bool fIsFlipped;
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
 public:
-    GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+    GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory&, const GrProcessor&);
     virtual ~GLCircleOutside2PtConicalEffect() {}
 
     virtual void emitCode(GrGLProgramBuilder*,
-                          const GrEffect&,
-                          const GrEffectKey&,
+                          const GrFragmentProcessor&,
+                          const GrProcessorKey&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
-    virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
-    static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+    static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
     UniformHandle fCenterUni;
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     bool fIsFlipped;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedCenterX;
     SkScalar fCachedCenterY;
     SkScalar fCachedA;
     SkScalar fCachedB;
     SkScalar fCachedC;
     SkScalar fCachedTLimit;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
-const GrBackendEffectFactory& CircleOutside2PtConicalEffect::getFactory() const {
-    return GrTBackendEffectFactory<CircleOutside2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& CircleOutside2PtConicalEffect::getFactory() const {
+    return GrTBackendFragmentProcessorFactory<CircleOutside2PtConicalEffect>::getInstance();
 }
 
-GR_DEFINE_EFFECT_TEST(CircleOutside2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect);
 
-GrEffect* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,
-                                                    GrContext* context,
-                                                    const GrDrawTargetCaps&,
-                                                    GrTexture**) {
+GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,
+                                                               GrContext* context,
+                                                               const GrDrawTargetCaps&,
+                                                               GrTexture**) {
     SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
     SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0
     SkPoint center2;
     SkScalar radius2;
     SkScalar diffLen;
     do {
         center2.set(random->nextUScalar1(), random->nextUScalar1());
         // If the circles share a center than we can't be in the outside case
     } while (center1 == center2);
         SkPoint diff = center2 - center1;
         diffLen = diff.length();
         // Below makes sure that circle one is not contained within circle two
         // and have radius2 >= radius to match sorting on cpu side
         radius2 = radius1 + random->nextRangeF(0.f, diffLen);
 
     SkColor colors[kMaxRandomGradientColors];
     SkScalar stopsArray[kMaxRandomGradientColors];
     SkScalar* stops = stopsArray;
     SkShader::TileMode tm;
     int colorCount = RandomGradientParams(random, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
-    GrEffect* effect;
-    SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));
-    return effect;
+    GrFragmentProcessor* processor;
+    SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &processor));
+    return processor;
 }
 
-GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory,
-                                                                 const GrEffect& effect)
+GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,
+                                                                 const GrProcessor& processor)
     : INHERITED(factory)
     , fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
     , fCachedC(SK_ScalarMax)
     , fCachedTLimit(SK_ScalarMax) {
-    const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConicalEffect>();
+    const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
     }
 
 void GLCircleOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
-                                               const GrEffect&,
-                                               const GrEffectKey& key,
+                                               const GrFragmentProcessor&,
+                                               const GrProcessorKey& key,
                                                const char* outputColor,
                                                const char* inputColor,
                                                const TransformedCoordsArray& coords,
                                                const TextureSamplerArray& samplers) {
     uint32_t baseKey = key.get32(0);
     this->emitUniforms(builder, baseKey);
     fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                      kVec2f_GrSLType, "Conical2FSCenter");
     fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kVec4f_GrSLType, "Conical2FSParams");
@@ skipping 37 matching lines @@
         fsBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str());
     }
 
     fsBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str(), params.c_str());
     fsBuilder->codeAppend("\t\t");
     this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
 void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
-                                              const GrEffect& effect) {
-    INHERITED::setData(pdman, effect);
-    const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConicalEffect>();
+                                              const GrProcessor& processor) {
+    INHERITED::setData(pdman, processor);
+    const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar centerX = data.centerX();
     SkScalar centerY = data.centerY();
     SkScalar A = data.A();
     SkScalar B = data.B();
     SkScalar C = data.C();
     SkScalar tLimit = data.tLimit();
 
     if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
         fCachedA != A || fCachedB != B || fCachedC != C || fCachedTLimit != tLimit) {
 
         pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY));
         pdman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarToFloat(C),
                    SkScalarToFloat(tLimit));
 
         fCachedCenterX = centerX;
         fCachedCenterY = centerY;
         fCachedA = A;
         fCachedB = B;
         fCachedC = C;
         fCachedTLimit = tLimit;
     }
 }
 
-void GLCircleOutside2PtConicalEffect::GenKey(const GrEffect& effect,
-                                             const GrGLCaps&, GrEffectKeyBuilder* b) {
+void GLCircleOutside2PtConicalEffect::GenKey(const GrProcessor& processor,
+                                             const GrGLCaps&, GrProcessorKeyBuilder* b) {
     uint32_t* key = b->add32n(2);
-    key[0] = GenBaseGradientKey(effect);
-    key[1] = effect.cast<CircleOutside2PtConicalEffect>().isFlipped();
+    key[0] = GenBaseGradientKey(processor);
+    key[1] = processor.cast<CircleOutside2PtConicalEffect>().isFlipped();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrEffect* Gr2PtConicalGradientEffect::Create(GrContext* ctx,
-                                             const SkTwoPointConicalGradient& shader,
-                                             SkShader::TileMode tm,
-                                             const SkMatrix* localMatrix) {
+GrFragmentProcessor* Gr2PtConicalGradientEffect::Create(GrContext* ctx,
+                                                        const SkTwoPointConicalGradient& shader,
+                                                        SkShader::TileMode tm,
+                                                        const SkMatrix* localMatrix) {
     SkMatrix matrix;
     if (!shader.getLocalMatrix().invert(&matrix)) {
         return NULL;
     }
     if (localMatrix) {
         SkMatrix inv;
         if (!localMatrix->invert(&inv)) {
             return NULL;
         }
         matrix.postConcat(inv);
@@ skipping 19 matching lines @@
         return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, info);
     } else if (type == kEdge_ConicalType) {
         set_matrix_edge_conical(shader, &matrix);
         return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm);
     } else {
         return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, info);
     }
 }
 
 #endif