diff --git a/include/core/SkImageFilter.h b/include/core/SkImageFilter.h
index 4c75019..c5f6a3b 100644
--- a/include/core/SkImageFilter.h
+++ b/include/core/SkImageFilter.h
@@ -86,11 +86,11 @@
      *  GrEffect, used to process this filter on the GPU, or false if
      *  not.
      *
-     *  If stage is non-NULL, a new GrEffect instance is stored
+     *  If effect is non-NULL, a new GrEffect instance is stored
      *  in it.  The caller assumes ownership of the stage, and it is up to the
      *  caller to unref it.
      */
-    virtual bool asNewEffect(GrEffect** stage, GrTexture*) const;
+    virtual bool asNewEffect(GrEffect** effect, GrTexture*) const;
 
     /**
      *  Returns true if the filter can be processed on the GPU.  This is most
diff --git a/include/effects/SkMagnifierImageFilter.h b/include/effects/SkMagnifierImageFilter.h
index 21ab894..400a010 100644
--- a/include/effects/SkMagnifierImageFilter.h
+++ b/include/effects/SkMagnifierImageFilter.h
@@ -16,7 +16,7 @@
 public:
     SkMagnifierImageFilter(SkRect srcRect, SkScalar inset);
 
-    virtual bool asNewEffect(GrEffect** stage,
+    virtual bool asNewEffect(GrEffect** effect,
                              GrTexture* texture) const SK_OVERRIDE;
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMagnifierImageFilter)
diff --git a/include/effects/SkMatrixConvolutionImageFilter.h b/include/effects/SkMatrixConvolutionImageFilter.h
index c0a5fd7..f4d2c8e 100644
--- a/include/effects/SkMatrixConvolutionImageFilter.h
+++ b/include/effects/SkMatrixConvolutionImageFilter.h
@@ -62,7 +62,7 @@
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
 
 #if SK_SUPPORT_GPU
-    virtual bool asNewEffect(GrEffect** stage, GrTexture*) const SK_OVERRIDE;
+    virtual bool asNewEffect(GrEffect**, GrTexture*) const SK_OVERRIDE;
 #endif
 
 private:
diff --git a/include/gpu/GrEffect.h b/include/gpu/GrEffect.h
index 7574958..4eb8f2a 100644
--- a/include/gpu/GrEffect.h
+++ b/include/gpu/GrEffect.h
@@ -39,7 +39,7 @@
     virtual ~GrEffect();
 
     /** If given an input texture that is/is not opaque, is this
-        stage guaranteed to produce an opaque output? */
+        effect guaranteed to produce an opaque output? */
     virtual bool isOpaque(bool inputTextureIsOpaque) const;
 
     /** This object, besides creating back-end-specific helper
diff --git a/include/gpu/GrProgramStageFactory.h b/include/gpu/GrProgramStageFactory.h
index 1a4f078..5779862 100644
--- a/include/gpu/GrProgramStageFactory.h
+++ b/include/gpu/GrProgramStageFactory.h
@@ -13,7 +13,7 @@
 #include "GrNoncopyable.h"
 
 /** Given a GrEffect of a particular type, creates the corresponding
-    graphics-backend-specific GrProgramStage. Also tracks equivalence
+    graphics-backend-specific GrGLProgramStage. Also tracks equivalence
     of shaders generated via a key.
  */
 
@@ -29,13 +29,11 @@
         kTexturingStageKeyBits = 6
     };
 
-    virtual StageKey glStageKey(const GrEffect& stage,
-                                const GrGLCaps& caps ) const = 0;
-    virtual GrGLProgramStage* createGLInstance(
-        const GrEffect& stage) const = 0;
+    virtual StageKey glStageKey(const GrEffect&, const GrGLCaps&) const = 0;
+    virtual GrGLProgramStage* createGLInstance(const GrEffect&) const = 0;
 
     bool operator ==(const GrProgramStageFactory& b) const {
-        return fStageClassID == b.fStageClassID;
+        return fEffectClassID == b.fEffectClassID;
     }
     bool operator !=(const GrProgramStageFactory& b) const {
         return !(*this == b);
@@ -45,67 +43,64 @@
 
 protected:
     enum {
-        kIllegalStageClassID = 0,
+        kIllegalEffectClassID = 0,
     };
 
     GrProgramStageFactory() {
-        fStageClassID = kIllegalStageClassID;
+        fEffectClassID = kIllegalEffectClassID;
     }
 
     static StageKey GenID() {
-        // fCurrStageClassID has been initialized to kIllegalStageClassID. The
+        // fCurrEffectClassID has been initialized to kIllegalEffectClassID. The
         // atomic inc returns the old value not the incremented value. So we add
         // 1 to the returned value.
-        int32_t id = sk_atomic_inc(&fCurrStageClassID) + 1;
+        int32_t id = sk_atomic_inc(&fCurrEffectClassID) + 1;
         GrAssert(id < (1 << (8 * sizeof(StageKey) - kProgramStageKeyBits)));
         return id;
     }
 
-    StageKey fStageClassID;
+    StageKey fEffectClassID;
 
 private:
-    static int32_t fCurrStageClassID;
+    static int32_t fCurrEffectClassID;
 };
 
-template <typename StageClass>
+template <typename EffectClass>
 class GrTProgramStageFactory : public GrProgramStageFactory {
 
 public:
-    typedef typename StageClass::GLProgramStage GLProgramStage;
+    typedef typename EffectClass::GLProgramStage GLProgramStage;
 
     /** Returns a human-readable name that is accessible via GrEffect or
         GrGLProgramStage and is consistent between the two of them.
      */
-    virtual const char* name() const SK_OVERRIDE { return StageClass::Name(); }
+    virtual const char* name() const SK_OVERRIDE { return EffectClass::Name(); }
 
-    /** Returns a value that idenitifes the GLSL shader code generated by
+    /** Returns a value that identifies the GLSL shader code generated by
         a GrEffect. This enables caching of generated shaders. Part of the
         id identifies the GrEffect subclass. The remainder is based
         on the aspects of the GrEffect object's configuration that affect
         GLSL code generation. */
-    virtual StageKey glStageKey(const GrEffect& stage,
-                                const GrGLCaps& caps) const SK_OVERRIDE {
-        GrAssert(kIllegalStageClassID != fStageClassID);
-        StageKey stageID = GLProgramStage::GenKey(stage, caps);
-        StageKey textureKey = GLProgramStage::GenTextureKey(stage, caps);
+    virtual StageKey glStageKey(const GrEffect& effect, const GrGLCaps& caps) const SK_OVERRIDE {
+        GrAssert(kIllegalEffectClassID != fEffectClassID);
+        StageKey stageID = GLProgramStage::GenKey(effect, caps);
+        StageKey textureKey = GLProgramStage::GenTextureKey(effect, caps);
 #if GR_DEBUG
-        static const StageKey kIllegalIDMask =
-            (uint16_t) (~((1U << kProgramStageKeyBits) - 1));
+        static const StageKey kIllegalIDMask = (uint16_t) (~((1U << kProgramStageKeyBits) - 1));
         GrAssert(!(kIllegalIDMask & stageID));
 
         static const StageKey kIllegalTextureKeyMask =
             (uint16_t) (~((1U << kTexturingStageKeyBits) - 1));
         GrAssert(!(kIllegalTextureKeyMask & textureKey));
 #endif
-        return fStageClassID | (textureKey << kProgramStageKeyBits) | stageID;
+        return fEffectClassID | (textureKey << kProgramStageKeyBits) | stageID;
     }
 
     /** Returns a new instance of the appropriate *GL* implementation class
         for the given GrEffect; caller is responsible for deleting
         the object. */
-    virtual GLProgramStage* createGLInstance(
-                        const GrEffect& stage) const SK_OVERRIDE {
-        return SkNEW_ARGS(GLProgramStage, (*this, stage));
+    virtual GLProgramStage* createGLInstance(const GrEffect& effect) const SK_OVERRIDE {
+        return SkNEW_ARGS(GLProgramStage, (*this, effect));
     }
 
     /** This class is a singleton. This function returns the single instance.
@@ -122,7 +117,7 @@
 
 protected:
     GrTProgramStageFactory() {
-        fStageClassID = GenID() << (kProgramStageKeyBits + kTexturingStageKeyBits) ;
+        fEffectClassID = GenID() << (kProgramStageKeyBits + kTexturingStageKeyBits) ;
     }
 };
 
diff --git a/src/effects/SkBlendImageFilter.cpp b/src/effects/SkBlendImageFilter.cpp
index fcda114..e2dde8b 100644
--- a/src/effects/SkBlendImageFilter.cpp
+++ b/src/effects/SkBlendImageFilter.cpp
@@ -113,7 +113,7 @@
 class GrGLBlendEffect  : public GrGLLegacyProgramStage {
 public:
     GrGLBlendEffect(const GrProgramStageFactory& factory,
-                    const GrEffect& stage);
+                    const GrEffect& effect);
     virtual ~GrGLBlendEffect();
 
     virtual void emitFS(GrGLShaderBuilder* builder,
@@ -237,9 +237,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLBlendEffect::GrGLBlendEffect(const GrProgramStageFactory& factory,
-                                 const GrEffect& stage)
+                                 const GrEffect& effect)
     : INHERITED(factory),
-      fMode(static_cast<const GrBlendEffect&>(stage).mode()) {
+      fMode(static_cast<const GrBlendEffect&>(effect).mode()) {
 }
 
 GrGLBlendEffect::~GrGLBlendEffect() {
diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp
index be766f2..226aed7 100644
--- a/src/effects/SkColorMatrixFilter.cpp
+++ b/src/effects/SkColorMatrixFilter.cpp
@@ -345,7 +345,7 @@
         static StageKey GenKey(const GrEffect& s, const GrGLCaps&) { return 0; }
 
         GLProgramStage(const GrProgramStageFactory& factory,
-                       const GrEffect& stage)
+                       const GrEffect& effect)
         : INHERITED(factory)
         , fMatrixHandle(GrGLUniformManager::kInvalidUniformHandle)
         , fVectorHandle(GrGLUniformManager::kInvalidUniformHandle) {
@@ -383,8 +383,8 @@
         }
 
         virtual void setData(const GrGLUniformManager& uniManager,
-                             const GrEffect& stage) SK_OVERRIDE {
-            const ColorMatrixEffect& cme = static_cast<const ColorMatrixEffect&>(stage);
+                             const GrEffect& effect) SK_OVERRIDE {
+            const ColorMatrixEffect& cme = static_cast<const ColorMatrixEffect&>(effect);
             const float* m = cme.fMatrix.fMat;
             // The GL matrix is transposed from SkColorMatrix.
             GrGLfloat mt[]  = {
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 702fb12..4402bde 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -264,7 +264,7 @@
                                  SkScalar kd, SkImageFilter* input);
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter)
 
-    virtual bool asNewEffect(GrEffect** stage, GrTexture*) const SK_OVERRIDE;
+    virtual bool asNewEffect(GrEffect** effect, GrTexture*) const SK_OVERRIDE;
     SkScalar kd() const { return fKD; }
 
 protected:
@@ -284,7 +284,7 @@
     SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input);
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter)
 
-    virtual bool asNewEffect(GrEffect** stage, GrTexture*) const SK_OVERRIDE;
+    virtual bool asNewEffect(GrEffect** effect, GrTexture*) const SK_OVERRIDE;
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
@@ -821,12 +821,12 @@
     return true;
 }
 
-bool SkDiffuseLightingImageFilter::asNewEffect(GrEffect** stage,
+bool SkDiffuseLightingImageFilter::asNewEffect(GrEffect** effect,
                                                GrTexture* texture) const {
 #if SK_SUPPORT_GPU
-    if (stage) {
+    if (effect) {
         SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
-        *stage = SkNEW_ARGS(GrDiffuseLightingEffect, (texture, light(), scale, kd()));
+        *effect = SkNEW_ARGS(GrDiffuseLightingEffect, (texture, light(), scale, kd()));
     }
     return true;
 #else
@@ -890,12 +890,12 @@
     return true;
 }
 
-bool SkSpecularLightingImageFilter::asNewEffect(GrEffect** stage,
+bool SkSpecularLightingImageFilter::asNewEffect(GrEffect** effect,
                                                 GrTexture* texture) const {
 #if SK_SUPPORT_GPU
-    if (stage) {
+    if (effect) {
         SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
-        *stage = SkNEW_ARGS(GrSpecularLightingEffect, (texture, light(), scale, ks(), shininess()));
+        *effect = SkNEW_ARGS(GrSpecularLightingEffect, (texture, light(), scale, ks(), shininess()));
     }
     return true;
 #else
@@ -942,7 +942,7 @@
 class GrGLLightingEffect  : public GrGLLegacyProgramStage {
 public:
     GrGLLightingEffect(const GrProgramStageFactory& factory,
-                       const GrEffect& stage);
+                       const GrEffect& effect);
     virtual ~GrGLLightingEffect();
 
     virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
@@ -972,7 +972,7 @@
 class GrGLDiffuseLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLDiffuseLightingEffect(const GrProgramStageFactory& factory,
-                              const GrEffect& stage);
+                              const GrEffect& effect);
     virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
     virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRIDE;
     virtual void setData(const GrGLUniformManager&, const GrEffect&) SK_OVERRIDE;
@@ -988,7 +988,7 @@
 class GrGLSpecularLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLSpecularLightingEffect(const GrProgramStageFactory& factory,
-                               const GrEffect& stage);
+                               const GrEffect& effect);
     virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
     virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRIDE;
     virtual void setData(const GrGLUniformManager&, const GrEffect&) SK_OVERRIDE;
@@ -1054,11 +1054,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLLightingEffect::GrGLLightingEffect(const GrProgramStageFactory& factory,
-                                       const GrEffect& stage)
+                                       const GrEffect& effect)
     : INHERITED(factory)
     , fImageIncrementUni(kInvalidUniformHandle)
     , fSurfaceScaleUni(kInvalidUniformHandle) {
-    const GrLightingEffect& m = static_cast<const GrLightingEffect&>(stage);
+    const GrLightingEffect& m = static_cast<const GrLightingEffect&>(effect);
     fLight = m.light()->createGLLight();
 }
 
@@ -1188,8 +1188,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrProgramStageFactory& factory,
-                                            const GrEffect& stage)
-    : INHERITED(factory, stage)
+                                            const GrEffect& effect)
+    : INHERITED(factory, effect)
     , fKDUni(kInvalidUniformHandle) {
 }
 
@@ -1260,8 +1260,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrProgramStageFactory& factory,
-                                            const GrEffect& stage)
-    : GrGLLightingEffect(factory, stage)
+                                            const GrEffect& effect)
+    : GrGLLightingEffect(factory, effect)
     , fKSUni(kInvalidUniformHandle)
     , fShininessUni(kInvalidUniformHandle) {
 }
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index 5a81465..9f5a675 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -75,7 +75,7 @@
 class GrGLMagnifierEffect : public GrGLLegacyProgramStage {
 public:
     GrGLMagnifierEffect(const GrProgramStageFactory& factory,
-                        const GrEffect& stage);
+                        const GrEffect& effect);
 
     virtual void setupVariables(GrGLShaderBuilder* state) SK_OVERRIDE;
     virtual void emitVS(GrGLShaderBuilder* state,
@@ -100,7 +100,7 @@
 };
 
 GrGLMagnifierEffect::GrGLMagnifierEffect(const GrProgramStageFactory& factory,
-                                         const GrEffect& stage)
+                                         const GrEffect& effect)
     : INHERITED(factory)
     , fOffsetVar(GrGLUniformManager::kInvalidUniformHandle)
     , fZoomVar(GrGLUniformManager::kInvalidUniformHandle)
@@ -201,10 +201,10 @@
                                  SkIntToScalar(width), SkIntToScalar(height)),
                 inset));
     GrSamplerState sampler;
-    GrEffect* stage;
-    filter->asNewEffect(&stage, textures[0]);
-    GrAssert(NULL != stage);
-    return stage;
+    GrEffect* effect;
+    filter->asNewEffect(&effect, textures[0]);
+    GrAssert(NULL != effect);
+    return effect;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -243,18 +243,17 @@
     SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0);
 }
 
-bool SkMagnifierImageFilter::asNewEffect(GrEffect** stage,
+bool SkMagnifierImageFilter::asNewEffect(GrEffect** effect,
                                          GrTexture* texture) const {
 #if SK_SUPPORT_GPU
-    if (stage) {
-      *stage =
-          SkNEW_ARGS(GrMagnifierEffect, (texture,
-                                         fSrcRect.x() / texture->width(),
-                                         fSrcRect.y() / texture->height(),
-                                         texture->width() / fSrcRect.width(),
-                                         texture->height() / fSrcRect.height(),
-                                         fInset / texture->width(),
-                                         fInset / texture->height()));
+    if (effect) {
+      *effect = SkNEW_ARGS(GrMagnifierEffect, (texture,
+                                               fSrcRect.x() / texture->width(),
+                                               fSrcRect.y() / texture->height(),
+                                               texture->width() / fSrcRect.width(),
+                                               texture->height() / fSrcRect.height(),
+                                               fInset / texture->width(),
+                                               fInset / texture->height()));
     }
     return true;
 #else
diff --git a/src/effects/SkMatrixConvolutionImageFilter.cpp b/src/effects/SkMatrixConvolutionImageFilter.cpp
index ae16aef..eeb61a7 100644
--- a/src/effects/SkMatrixConvolutionImageFilter.cpp
+++ b/src/effects/SkMatrixConvolutionImageFilter.cpp
@@ -282,7 +282,7 @@
 class GrGLMatrixConvolutionEffect : public GrGLLegacyProgramStage {
 public:
     GrGLMatrixConvolutionEffect(const GrProgramStageFactory& factory,
-                                const GrEffect& stage);
+                                const GrEffect& effect);
     virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
     virtual void emitVS(GrGLShaderBuilder* state,
                         const char* vertexCoords) SK_OVERRIDE {}
@@ -312,14 +312,14 @@
 };
 
 GrGLMatrixConvolutionEffect::GrGLMatrixConvolutionEffect(const GrProgramStageFactory& factory,
-                                           const GrEffect& stage)
+                                           const GrEffect& effect)
     : INHERITED(factory)
     , fKernelUni(GrGLUniformManager::kInvalidUniformHandle)
     , fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle)
     , fTargetUni(GrGLUniformManager::kInvalidUniformHandle)
     , fGainUni(GrGLUniformManager::kInvalidUniformHandle)
     , fBiasUni(GrGLUniformManager::kInvalidUniformHandle) {
-    const GrMatrixConvolutionEffect& m = static_cast<const GrMatrixConvolutionEffect&>(stage);
+    const GrMatrixConvolutionEffect& m = static_cast<const GrMatrixConvolutionEffect&>(effect);
     fKernelSize = m.kernelSize();
     fTileMode = m.tileMode();
     fConvolveAlpha = m.convolveAlpha();
@@ -521,18 +521,18 @@
 
 }
 
-bool SkMatrixConvolutionImageFilter::asNewEffect(GrEffect** stage,
+bool SkMatrixConvolutionImageFilter::asNewEffect(GrEffect** effect,
                                                  GrTexture* texture) const {
     bool ok = fKernelSize.width() * fKernelSize.height() <= MAX_KERNEL_SIZE;
-    if (ok && stage) {
-        *stage = SkNEW_ARGS(GrMatrixConvolutionEffect, (texture,
-                                                        fKernelSize,
-                                                        fKernel,
-                                                        fGain,
-                                                        fBias,
-                                                        fTarget,
-                                                        fTileMode,
-                                                        fConvolveAlpha));
+    if (ok && effect) {
+        *effect = SkNEW_ARGS(GrMatrixConvolutionEffect, (texture,
+                                                         fKernelSize,
+                                                         fKernel,
+                                                         fGain,
+                                                         fBias,
+                                                         fTarget,
+                                                         fTileMode,
+                                                         fConvolveAlpha));
     }
     return ok;
 }
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index 8df5def..2348815 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -269,7 +269,7 @@
 class GrGLMorphologyEffect  : public GrGLLegacyProgramStage {
 public:
     GrGLMorphologyEffect (const GrProgramStageFactory& factory,
-                          const GrEffect& stage);
+                          const GrEffect& effect);
 
     virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
     virtual void emitVS(GrGLShaderBuilder* state,
@@ -294,10 +294,10 @@
 };
 
 GrGLMorphologyEffect::GrGLMorphologyEffect(const GrProgramStageFactory& factory,
-                                           const GrEffect& stage)
+                                           const GrEffect& effect)
     : INHERITED(factory)
     , fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle) {
-    const GrMorphologyEffect& m = static_cast<const GrMorphologyEffect&>(stage);
+    const GrMorphologyEffect& m = static_cast<const GrMorphologyEffect&>(effect);
     fRadius = m.radius();
     fType = m.type();
 }
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 1e7a8b6..076db5d 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -247,7 +247,7 @@
 class GLColorTableEffect : public GrGLLegacyProgramStage {
 public:
     GLColorTableEffect(const GrProgramStageFactory& factory,
-                         const GrEffect& stage);
+                         const GrEffect& effect);
 
     virtual void setupVariables(GrGLShaderBuilder* state) SK_OVERRIDE {}
     virtual void emitVS(GrGLShaderBuilder* state,
@@ -267,7 +267,7 @@
 };
 
 GLColorTableEffect::GLColorTableEffect(
-    const GrProgramStageFactory& factory, const GrEffect& stage)
+    const GrProgramStageFactory& factory, const GrEffect& effect)
     : INHERITED(factory) {
  }
 
@@ -355,13 +355,13 @@
     this->asComponentTable(&bitmap);
     // passing NULL because this effect does no tiling or filtering.
     GrTexture* texture = GrLockCachedBitmapTexture(context, bitmap, NULL);
-    GrEffect* stage = SkNEW_ARGS(ColorTableEffect, (texture));
+    GrEffect* effect = SkNEW_ARGS(ColorTableEffect, (texture));
 
     // Unlock immediately, this is not great, but we don't have a way of
     // knowing when else to unlock it currently. TODO: Remove this when
     // unref becomes the unlock replacement for all types of textures.
     GrUnlockCachedBitmapTexture(texture);
-    return stage;
+    return effect;
 }
 
 #endif // SK_SUPPORT_GPU
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index e6d1596..079623a 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -687,8 +687,8 @@
                                   kFloat_GrSLType, "GradientYCoordFS");
 }
 
-void GrGLGradientStage::setData(const GrGLUniformManager& uman, const GrEffect& stage) {
-    GrScalar yCoord = static_cast<const GrGradientEffect&>(stage).getYCoord();
+void GrGLGradientStage::setData(const GrGLUniformManager& uman, const GrEffect& effect) {
+    GrScalar yCoord = static_cast<const GrGradientEffect&>(effect).getYCoord();
     if (yCoord != fCachedYCoord) {
         uman.set1f(fFSYUni, yCoord);
         fCachedYCoord = yCoord;
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index a1b3776..36550cd 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -237,9 +237,9 @@
     bool useAtlas() const { return SkToBool(-1 != fRow); }
     GrScalar getYCoord() const { return fYCoord; };
 
-    virtual bool isEqual(const GrEffect& stage) const SK_OVERRIDE {
-        const GrGradientEffect& s = static_cast<const GrGradientEffect&>(stage);
-        return INHERITED::isEqual(stage) && this->useAtlas() == s.useAtlas() &&
+    virtual bool isEqual(const GrEffect& effect) const SK_OVERRIDE {
+        const GrGradientEffect& s = static_cast<const GrGradientEffect&>(effect);
+        return INHERITED::isEqual(effect) && this->useAtlas() == s.useAtlas() &&
                fYCoord == s.getYCoord();
     }
 
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 8219388..019dcbc 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -562,7 +562,7 @@
 bool SkLinearGradient::asNewEffect(GrContext* context, GrSamplerState* sampler) const {
     SkASSERT(NULL != context && NULL != sampler);
 
-    SkAutoTUnref<GrEffect> stage(SkNEW_ARGS(GrLinearGradient, (context, *this, fTileMode)));
+    SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrLinearGradient, (context, *this, fTileMode)));
 
     SkMatrix matrix;
     if (this->getLocalMatrix(&matrix)) {
@@ -570,9 +570,9 @@
             return false;
         }
         matrix.postConcat(fPtsToUnit);
-        sampler->setEffect(stage, matrix);
+        sampler->setEffect(effect, matrix);
     } else {
-        sampler->setEffect(stage, fPtsToUnit);
+        sampler->setEffect(effect, fPtsToUnit);
     }
 
     return true;
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index 1008c87..04deeba 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -560,7 +560,7 @@
 
 bool SkRadialGradient::asNewEffect(GrContext* context, GrSamplerState* sampler) const {
     SkASSERT(NULL != context && NULL != sampler);
-    SkAutoTUnref<GrEffect> stage(SkNEW_ARGS(GrRadialGradient, (context, *this, fTileMode)));
+    SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrRadialGradient, (context, *this, fTileMode)));
 
     SkMatrix matrix;
     if (this->getLocalMatrix(&matrix)) {
@@ -568,9 +568,9 @@
             return false;
         }
         matrix.postConcat(fPtsToUnit);
-        sampler->setEffect(stage, matrix);
+        sampler->setEffect(effect, matrix);
     } else {
-        sampler->setEffect(stage, fPtsToUnit);
+        sampler->setEffect(effect, fPtsToUnit);
     }
 
     return true;
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index 0678f3b..4f63f64 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -466,8 +466,7 @@
 /////////////////////////////////////////////////////////////////////
 
 bool SkSweepGradient::asNewEffect(GrContext* context, GrSamplerState* sampler) const {
-    SkAutoTUnref<GrEffect> stage(SkNEW_ARGS(GrSweepGradient, (context, *this)));
-
+    SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrSweepGradient, (context, *this)));
 
     SkMatrix matrix;
     if (this->getLocalMatrix(&matrix)) {
@@ -475,9 +474,9 @@
             return false;
         }
         matrix.postConcat(fPtsToUnit);
-        sampler->setEffect(stage, matrix);
+        sampler->setEffect(effect, matrix);
     } else {
-        sampler->setEffect(stage, fPtsToUnit);
+        sampler->setEffect(effect, fPtsToUnit);
     }
 
     return true;
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index e6d5b4c..858242b 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -1317,16 +1317,16 @@
         ast.set(this, desc, match);
         GrTexture* texture = ast.texture();
         if (texture) {
-            SkAutoTUnref<GrEffect> stage;
+            SkAutoTUnref<GrEffect> effect;
             if (unpremul) {
-                stage.reset(this->createPMToUPMEffect(src, swapRAndB));
+                effect.reset(this->createPMToUPMEffect(src, swapRAndB));
             }
             // If we failed to create a PM->UPM effect and have no other conversions to perform then
             // there is no longer any point to using the scratch.
-            if (NULL != stage || flipY || swapRAndB) {
-                if (NULL == stage) {
-                    stage.reset(GrConfigConversionEffect::Create(src, swapRAndB));
-                    GrAssert(NULL != stage);
+            if (NULL != effect || flipY || swapRAndB) {
+                if (NULL == effect) {
+                    effect.reset(GrConfigConversionEffect::Create(src, swapRAndB));
+                    GrAssert(NULL != effect);
                 } else {
                     unpremul = false; // we will handle the UPM conversion in the draw
                 }
@@ -1345,7 +1345,7 @@
                     matrix.setTranslate(SK_Scalar1 *left, SK_Scalar1 *top);
                 }
                 matrix.postIDiv(src->width(), src->height());
-                drawState->sampler(0)->setEffect(stage, matrix);
+                drawState->sampler(0)->setEffect(effect, matrix);
                 GrRect rect = GrRect::MakeWH(GrIntToScalar(width), GrIntToScalar(height));
                 fGpu->drawSimpleRect(rect, NULL);
                 // we want to read back from the scratch's origin
@@ -1490,7 +1490,7 @@
         return;
     }
 #endif
-    SkAutoTUnref<GrEffect> stage;
+    SkAutoTUnref<GrEffect> effect;
     bool swapRAndB = (fGpu->preferredReadPixelsConfig(config) == GrPixelConfigSwapRAndB(config));
 
     GrPixelConfig textureConfig;
@@ -1516,8 +1516,8 @@
         if (kRGBA_8888_GrPixelConfig != config && kBGRA_8888_GrPixelConfig != config) {
             return;
         }
-        stage.reset(this->createUPMToPMEffect(texture, swapRAndB));
-        if (NULL == stage) {
+        effect.reset(this->createUPMToPMEffect(texture, swapRAndB));
+        if (NULL == effect) {
             SkCanvas::Config8888 srcConfig8888, dstConfig8888;
             GR_DEBUGCODE(bool success = )
             grconfig_to_config8888(config, true, &srcConfig8888);
@@ -1534,9 +1534,9 @@
             rowBytes = 4 * width;
         }
     }
-    if (NULL == stage) {
-        stage.reset(GrConfigConversionEffect::Create(texture, swapRAndB));
-        GrAssert(NULL != stage);
+    if (NULL == effect) {
+        effect.reset(GrConfigConversionEffect::Create(texture, swapRAndB));
+        GrAssert(NULL != effect);
     }
 
     this->writeTexturePixels(texture,
@@ -1553,7 +1553,7 @@
     drawState->setRenderTarget(target);
 
     matrix.setIDiv(texture->width(), texture->height());
-    drawState->sampler(0)->setEffect(stage, matrix);
+    drawState->sampler(0)->setEffect(effect, matrix);
 
     fGpu->drawSimpleRect(GrRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)), NULL);
 }
diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h
index 330ae66..54f2179 100644
--- a/src/gpu/GrDrawState.h
+++ b/src/gpu/GrDrawState.h
@@ -26,7 +26,7 @@
     SK_DECLARE_INST_COUNT(GrDrawState)
 
     /**
-     * Number of texture stages. Each stage takes as input a color and
+     * Number of effect stages. Each stage takes as input a color and
      * 2D texture coordinates. The color input to the first enabled stage is the
      * per-vertex color or the constant color (setColor/setAlpha) if there are
      * no per-vertex colors. For subsequent stages the input color is the output
@@ -190,8 +190,7 @@
      */
     void createTextureEffect(int stage, GrTexture* texture) {
         GrAssert(!this->getSampler(stage).getEffect());
-        this->sampler(stage)->setEffect(
-            SkNEW_ARGS(GrSingleTextureEffect, (texture)))->unref();
+        this->sampler(stage)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (texture)))->unref();
     }
     void createTextureEffect(int stage, GrTexture* texture, const GrMatrix& matrix) {
         GrAssert(!this->getSampler(stage).getEffect());
diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrDrawTarget.cpp
index d365a89..dbb04a6 100644
--- a/src/gpu/GrDrawTarget.cpp
+++ b/src/gpu/GrDrawTarget.cpp
@@ -748,10 +748,10 @@
     GrAssert(NULL != drawState.getRenderTarget());
     for (int s = 0; s < GrDrawState::kNumStages; ++s) {
         if (drawState.isStageEnabled(s)) {
-            const GrEffect* stage = drawState.getSampler(s).getEffect();
-            int numTextures = stage->numTextures();
+            const GrEffect* effect = drawState.getSampler(s).getEffect();
+            int numTextures = effect->numTextures();
             for (int t = 0; t < numTextures; ++t) {
-                GrTexture* texture = stage->texture(t);
+                GrTexture* texture = effect->texture(t);
                 GrAssert(texture->asRenderTarget() != drawState.getRenderTarget());
             }
         }
@@ -831,11 +831,11 @@
     // Check if a color stage could create a partial alpha
     for (int s = 0; s < drawState.getFirstCoverageStage(); ++s) {
         if (this->isStageEnabled(s)) {
-            const GrEffect* stage = drawState.getSampler(s).getEffect();
-            // FIXME: The param indicates whether the texture is opaque or not. However, the stage
+            const GrEffect* effect = drawState.getSampler(s).getEffect();
+            // FIXME: The param indicates whether the texture is opaque or not. However, the effect
             // already controls its textures. It really needs to know whether the incoming color
             // (from a uni, per-vertex colors, or previous stage) is opaque or not.
-            if (!stage->isOpaque(true)) {
+            if (!effect->isOpaque(true)) {
                 return false;
             }
         }
@@ -913,7 +913,7 @@
     }
 
     // check for coverage due to constant coverage, per-vertex coverage,
-    // edge aa or coverage texture stage
+    // edge aa or coverage stage
     bool hasCoverage = forceCoverage ||
                        0xffffffff != drawState.getCoverage() ||
                        (layout & kCoverage_VertexLayoutBit) ||
diff --git a/src/gpu/GrEffect.cpp b/src/gpu/GrEffect.cpp
index 352d43c..396f5d1 100644
--- a/src/gpu/GrEffect.cpp
+++ b/src/gpu/GrEffect.cpp
@@ -35,8 +35,7 @@
     }
 };
 
-int32_t GrProgramStageFactory::fCurrStageClassID =
-                                    GrProgramStageFactory::kIllegalStageClassID;
+int32_t GrProgramStageFactory::fCurrEffectClassID = GrProgramStageFactory::kIllegalEffectClassID;
 
 GrEffect::GrEffect(int numTextures)
     : fNumTextures(numTextures) {
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 5cdecdb..b7de9ad 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -512,9 +512,9 @@
             SkColor filtered = colorFilter->filterColor(skPaint.getColor());
             grPaint->setColor(SkColor2GrColor(filtered));
         } else {
-            SkAutoTUnref<GrEffect> stage(colorFilter->asNewEffect(dev->context()));
-            if (NULL != stage.get()) {
-                grPaint->colorSampler(kColorFilterTextureIdx)->setEffect(stage);
+            SkAutoTUnref<GrEffect> effect(colorFilter->asNewEffect(dev->context()));
+            if (NULL != effect.get()) {
+                grPaint->colorSampler(kColorFilterTextureIdx)->setEffect(effect);
             } else {
                 // TODO: rewrite this using asNewEffect()
                 SkColor color;
@@ -1415,7 +1415,7 @@
     }
 
     GrRect textureDomain = GrRect::MakeEmpty();
-    SkAutoTUnref<GrEffect> stage;
+    SkAutoTUnref<GrEffect> effect;
     if (needsTextureDomain) {
         // Use a constrained texture domain to avoid color bleeding
         GrScalar left, top, right, bottom;
@@ -1434,11 +1434,11 @@
             top = bottom = GrScalarHalf(paintRect.top() + paintRect.bottom());
         }
         textureDomain.setLTRB(left, top, right, bottom);
-        stage.reset(SkNEW_ARGS(GrTextureDomainEffect, (texture, textureDomain, params)));
+        effect.reset(SkNEW_ARGS(GrTextureDomainEffect, (texture, textureDomain, params)));
     } else {
-        stage.reset(SkNEW_ARGS(GrSingleTextureEffect, (texture, params)));
+        effect.reset(SkNEW_ARGS(GrSingleTextureEffect, (texture, params)));
     }
-    grPaint->colorSampler(kBitmapTextureIdx)->setEffect(stage);
+    grPaint->colorSampler(kBitmapTextureIdx)->setEffect(effect);
     fContext->drawRectToRect(*grPaint, dstRect, paintRect, &m);
 }
 
@@ -1475,18 +1475,18 @@
     desc.fWidth = SkScalarCeilToInt(rect.width());
     desc.fHeight = SkScalarCeilToInt(rect.height());
     desc.fConfig = kRGBA_8888_GrPixelConfig;
-    GrEffect* stage;
+    GrEffect* effect;
 
     if (filter->canFilterImageGPU()) {
         // Save the render target and set it to NULL, so we don't accidentally draw to it in the
         // filter.  Also set the clip wide open and the matrix to identity.
         GrContext::AutoWideOpenIdentityDraw awo(context, NULL);
         texture = filter->onFilterImageGPU(&proxy, texture, rect);
-    } else if (filter->asNewEffect(&stage, texture)) {
+    } else if (filter->asNewEffect(&effect, texture)) {
         GrAutoScratchTexture dst(context, desc);
-        apply_effect(context, texture, dst.texture(), rect, stage);
+        apply_effect(context, texture, dst.texture(), rect, effect);
         texture = dst.detach();
-        stage->unref();
+        effect->unref();
     }
     return texture;
 }
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index beb6107..7bc203b 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -12,9 +12,9 @@
 public:
     GrGLConfigConversionEffect(const GrProgramStageFactory& factory,
                                const GrEffect& s) : INHERITED (factory) {
-        const GrConfigConversionEffect& stage = static_cast<const GrConfigConversionEffect&>(s);
-        fSwapRedAndBlue = stage.swapsRedAndBlue();
-        fPMConversion = stage.pmConversion();
+        const GrConfigConversionEffect& effect = static_cast<const GrConfigConversionEffect&>(s);
+        fSwapRedAndBlue = effect.swapsRedAndBlue();
+        fPMConversion = effect.pmConversion();
     }
 
     virtual void emitVS(GrGLShaderBuilder* builder,
@@ -59,8 +59,8 @@
     }
 
     static inline StageKey GenKey(const GrEffect& s, const GrGLCaps&) {
-        const GrConfigConversionEffect& stage = static_cast<const GrConfigConversionEffect&>(s);
-        return static_cast<int>(stage.swapsRedAndBlue()) | (stage.pmConversion() << 1);
+        const GrConfigConversionEffect& effect = static_cast<const GrConfigConversionEffect&>(s);
+        return static_cast<int>(effect.swapsRedAndBlue()) | (effect.pmConversion() << 1);
     }
 
 private:
@@ -177,24 +177,24 @@
 
         GrPaint paint;
 
-        SkAutoTUnref<GrEffect> pmToUPMStage1(SkNEW_ARGS(GrConfigConversionEffect,
+        SkAutoTUnref<GrEffect> pmToUPMEffect1(SkNEW_ARGS(GrConfigConversionEffect,
                                                         (dataTex, false, *pmToUPMRule)));
-        SkAutoTUnref<GrEffect> upmToPMStage(SkNEW_ARGS(GrConfigConversionEffect,
+        SkAutoTUnref<GrEffect> upmToPMEffect(SkNEW_ARGS(GrConfigConversionEffect,
                                                        (readTex, false, *upmToPMRule)));
-        SkAutoTUnref<GrEffect> pmToUPMStage2(SkNEW_ARGS(GrConfigConversionEffect,
+        SkAutoTUnref<GrEffect> pmToUPMEffect2(SkNEW_ARGS(GrConfigConversionEffect,
                                                         (tempTex, false, *pmToUPMRule)));
 
         context->setRenderTarget(readTex->asRenderTarget());
-        paint.colorSampler(0)->setEffect(pmToUPMStage1);
+        paint.colorSampler(0)->setEffect(pmToUPMEffect1);
         context->drawRectToRect(paint, kDstRect, kSrcRect);
 
         readTex->readPixels(0, 0, 256, 256, kRGBA_8888_GrPixelConfig, firstRead);
 
         context->setRenderTarget(tempTex->asRenderTarget());
-        paint.colorSampler(0)->setEffect(upmToPMStage);
+        paint.colorSampler(0)->setEffect(upmToPMEffect);
         context->drawRectToRect(paint, kDstRect, kSrcRect);
         context->setRenderTarget(readTex->asRenderTarget());
-        paint.colorSampler(0)->setEffect(pmToUPMStage2);
+        paint.colorSampler(0)->setEffect(pmToUPMEffect2);
         context->drawRectToRect(paint, kDstRect, kSrcRect);
 
         readTex->readPixels(0, 0, 256, 256, kRGBA_8888_GrPixelConfig, secondRead);
diff --git a/src/gpu/effects/GrConvolutionEffect.cpp b/src/gpu/effects/GrConvolutionEffect.cpp
index 32086ca..e49302e 100644
--- a/src/gpu/effects/GrConvolutionEffect.cpp
+++ b/src/gpu/effects/GrConvolutionEffect.cpp
@@ -17,8 +17,7 @@
 
 class GrGLConvolutionEffect : public GrGLLegacyProgramStage {
 public:
-    GrGLConvolutionEffect(const GrProgramStageFactory& factory,
-                          const GrEffect& stage);
+    GrGLConvolutionEffect(const GrProgramStageFactory&, const GrEffect&);
 
     virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
     virtual void emitVS(GrGLShaderBuilder* builder,
@@ -43,12 +42,12 @@
 };
 
 GrGLConvolutionEffect::GrGLConvolutionEffect(const GrProgramStageFactory& factory,
-                                             const GrEffect& stage)
+                                             const GrEffect& effect)
     : INHERITED(factory)
     , fKernelUni(kInvalidUniformHandle)
     , fImageIncrementUni(kInvalidUniformHandle) {
     const GrConvolutionEffect& c =
-        static_cast<const GrConvolutionEffect&>(stage);
+        static_cast<const GrConvolutionEffect&>(effect);
     fRadius = c.radius();
 }
 
diff --git a/src/gpu/effects/GrSingleTextureEffect.cpp b/src/gpu/effects/GrSingleTextureEffect.cpp
index 7717f6a..47e26e5 100644
--- a/src/gpu/effects/GrSingleTextureEffect.cpp
+++ b/src/gpu/effects/GrSingleTextureEffect.cpp
@@ -14,8 +14,9 @@
 
 class GrGLSingleTextureEffect : public GrGLLegacyProgramStage {
 public:
-    GrGLSingleTextureEffect(const GrProgramStageFactory& factory,
-                            const GrEffect& stage) : INHERITED (factory) { }
+    GrGLSingleTextureEffect(const GrProgramStageFactory& factory, const GrEffect&)
+    : INHERITED (factory) {
+    }
 
     virtual void emitVS(GrGLShaderBuilder* builder,
                         const char* vertexCoords) SK_OVERRIDE { }
diff --git a/src/gpu/effects/GrTextureDomainEffect.cpp b/src/gpu/effects/GrTextureDomainEffect.cpp
index fb0bcff..1203392 100644
--- a/src/gpu/effects/GrTextureDomainEffect.cpp
+++ b/src/gpu/effects/GrTextureDomainEffect.cpp
@@ -11,8 +11,7 @@
 
 class GrGLTextureDomainEffect : public GrGLLegacyProgramStage {
 public:
-    GrGLTextureDomainEffect(const GrProgramStageFactory& factory,
-                            const GrEffect& stage);
+    GrGLTextureDomainEffect(const GrProgramStageFactory&, const GrEffect&);
 
     virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
     virtual void emitVS(GrGLShaderBuilder* builder,
@@ -33,7 +32,7 @@
 };
 
 GrGLTextureDomainEffect::GrGLTextureDomainEffect(const GrProgramStageFactory& factory,
-                                                 const GrEffect& stage)
+                                                 const GrEffect&)
     : INHERITED(factory)
     , fNameUni(GrGLUniformManager::kInvalidUniformHandle) {
 }
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 5549e58..ae957e9 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -896,7 +896,7 @@
 // Stage code generation
 
 // TODO: Move this function to GrGLShaderBuilder
-GrGLProgramStage* GrGLProgram::GenStageCode(const GrEffect* stage,
+GrGLProgramStage* GrGLProgram::GenStageCode(const GrEffect* effect,
                                             const StageDesc& desc,
                                             StageUniforms* uniforms,
                                             const char* fsInColor, // NULL means no incoming color
@@ -904,7 +904,7 @@
                                             const char* vsInCoord,
                                             GrGLShaderBuilder* builder) {
 
-    GrGLProgramStage* glStage = stage->getFactory().createGLInstance(*stage);
+    GrGLProgramStage* glStage = effect->getFactory().createGLInstance(*effect);
 
     /// Vertex Shader Stuff
 
@@ -932,13 +932,13 @@
                         &varyingFSName);
     builder->setupTextureAccess(varyingFSName, texCoordVaryingType);
 
-    int numTextures = stage->numTextures();
+    int numTextures = effect->numTextures();
     SkSTArray<8, GrGLShaderBuilder::TextureSampler> textureSamplers;
 
     textureSamplers.push_back_n(numTextures);
 
     for (int i = 0; i < numTextures; ++i) {
-        textureSamplers[i].init(builder, &stage->textureAccess(i));
+        textureSamplers[i].init(builder, &effect->textureAccess(i));
         uniforms->fSamplerUniforms.push_back(textureSamplers[i].fSamplerUniform);
     }
 
@@ -956,7 +956,7 @@
     builder->fVSCode.appendf("\t{ // %s\n", glStage->name());
     builder->fFSCode.appendf("\t{ // %s \n", glStage->name());
     glStage->emitCode(builder,
-                      *stage,
+                      *effect,
                       desc.fCustomStageKey,
                       varyingVSName,
                       fsOutColor,
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index f6760a9..056b7ed 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -175,7 +175,7 @@
 
     void genInputColor(GrGLShaderBuilder* builder, SkString* inColor);
 
-    static GrGLProgramStage* GenStageCode(const GrEffect* stage,
+    static GrGLProgramStage* GenStageCode(const GrEffect* effect,
                                           const StageDesc& desc, // TODO: Eliminate this
                                           StageUniforms* stageUniforms, // TODO: Eliminate this
                                           const char* fsInColor, // NULL means no incoming color
diff --git a/src/gpu/gl/GrGLProgramStage.cpp b/src/gpu/gl/GrGLProgramStage.cpp
index 8cbb7c3..cc4cc91 100644
--- a/src/gpu/gl/GrGLProgramStage.cpp
+++ b/src/gpu/gl/GrGLProgramStage.cpp
@@ -20,11 +20,11 @@
 void GrGLProgramStage::setData(const GrGLUniformManager&, const GrEffect&) {
 }
 
-GrGLProgramStage::StageKey GrGLProgramStage::GenTextureKey(const GrEffect& stage,
+GrGLProgramStage::StageKey GrGLProgramStage::GenTextureKey(const GrEffect& effect,
                                                            const GrGLCaps& caps) {
     StageKey key = 0;
-    for (int index = 0; index < stage.numTextures(); ++index) {
-        const GrTextureAccess& access = stage.textureAccess(index);
+    for (int index = 0; index < effect.numTextures(); ++index) {
+        const GrTextureAccess& access = effect.textureAccess(index);
         StageKey value = GrGLShaderBuilder::KeyForTextureAccess(access, caps) << index;
         GrAssert(0 == (value & key)); // keys for each access ought not to overlap
         key |= value;
diff --git a/src/gpu/gl/GrGLProgramStage.h b/src/gpu/gl/GrGLProgramStage.h
index 300e6f1..190ea8a6 100644
--- a/src/gpu/gl/GrGLProgramStage.h
+++ b/src/gpu/gl/GrGLProgramStage.h
@@ -77,7 +77,7 @@
     /** A GrGLProgramStage instance can be reused with any GrEffect that produces the same stage
         key; this function reads data from a stage and uploads any uniform variables required
         by the shaders created in emitCode(). */
-    virtual void setData(const GrGLUniformManager&, const GrEffect& stage);
+    virtual void setData(const GrGLUniformManager&, const GrEffect&);
 
     const char* name() const { return fFactory.name(); }
 
diff --git a/src/gpu/gl/GrGpuGL_program.cpp b/src/gpu/gl/GrGpuGL_program.cpp
index 9f78aa4..5bc84f8 100644
--- a/src/gpu/gl/GrGpuGL_program.cpp
+++ b/src/gpu/gl/GrGpuGL_program.cpp
@@ -199,11 +199,11 @@
     const GrDrawState& drawState = this->getDrawState();
 
     // FIXME: Still assuming only a single texture per effect
-    const GrEffect* stage = drawState.getSampler(s).getEffect();
-    if (0 == stage->numTextures()) {
+    const GrEffect* effect = drawState.getSampler(s).getEffect();
+    if (0 == effect->numTextures()) {
         return;
     }
-    const GrGLTexture* texture = static_cast<const GrGLTexture*>(stage->texture(0));
+    const GrGLTexture* texture = static_cast<const GrGLTexture*>(effect->texture(0));
     if (NULL != texture) {
 
         bool orientationChange = fCurrentProgram->fTextureOrientation[s] !=
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 355cade..252288b 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -44,9 +44,9 @@
     // TODO: Remove GrRandom.
     SkRandom sk_random;
     sk_random.setSeed(random->nextU());
-    GrEffect* stage = GrEffectTestFactory::CreateStage(&sk_random, context, dummyTextures);
-    GrAssert(stage);
-    return stage;
+    GrEffect* effect = GrEffectTestFactory::CreateStage(&sk_random, context, dummyTextures);
+    GrAssert(effect);
+    return effect;
 }
 }