Make GrDrawState and GrPaint take GrEffect* instead of GrEffectRef*.

Make Sk-effect virtuals produce GrEffect* rather than GrEffectRef*

Make GrEffectRef a typedef for GrEffect.

Committed: https://skia.googlesource.com/skia/+/2011fe9cdfa63b83489a146cea6a724cede352c8

R=robertphillips@google.com

Author: bsalomon@google.com

Review URL: https://codereview.chromium.org/377503004

54 files changed, 140 insertions, 277 deletions

diff --git a/include/core/SkColorFilter.h b/include/core/SkColorFilter.h
index c26bc075c9..25e6bbe746 100644
--- a/include/core/SkColorFilter.h
+++ b/include/core/SkColorFilter.h
@@ -15,7 +15,7 @@
 #include "SkXfermode.h"
 
 class SkBitmap;
-class GrEffectRef;
+class GrEffect;
 class GrContext;
 
 /**
@@ -126,7 +126,7 @@ public:
     /** A subclass may implement this factory function to work with the GPU backend. If the return
         is non-NULL then the caller owns a ref on the returned object.
      */
-    virtual GrEffectRef* asNewEffect(GrContext*) const;
+    virtual GrEffect* asNewEffect(GrContext*) const;
 
     SK_TO_STRING_PUREVIRT()
 
diff --git a/include/core/SkColorShader.h b/include/core/SkColorShader.h
index 8603577a0b..ba17f6c4bc 100644
--- a/include/core/SkColorShader.h
+++ b/include/core/SkColorShader.h
@@ -58,7 +58,7 @@ public:
 
     virtual bool asNewEffect(GrContext* context, const SkPaint& paint,
                              const SkMatrix* localMatrix, GrColor* grColor,
-                             GrEffectRef** grEffect) const SK_OVERRIDE;
+                             GrEffect** grEffect) const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorShader)
diff --git a/include/core/SkImageFilter.h b/include/core/SkImageFilter.h
index 15e9a2f0c9..012a7f728f 100644
--- a/include/core/SkImageFilter.h
+++ b/include/core/SkImageFilter.h
@@ -16,7 +16,7 @@ class SkBitmap;
 class SkColorFilter;
 class SkBaseDevice;
 struct SkIPoint;
-class GrEffectRef;
+class GrEffect;
 class GrTexture;
 
 /**
@@ -282,7 +282,7 @@ protected:
      *  will be called with (NULL, NULL, SkMatrix::I()) to query for support,
      *  so returning "true" indicates support for all possible matrices.
      */
-    virtual bool asNewEffect(GrEffectRef** effect,
+    virtual bool asNewEffect(GrEffect** effect,
                              GrTexture*,
                              const SkMatrix& matrix,
                              const SkIRect& bounds) const;
diff --git a/include/core/SkMaskFilter.h b/include/core/SkMaskFilter.h
index 72f20af21f..39925129a7 100644
--- a/include/core/SkMaskFilter.h
+++ b/include/core/SkMaskFilter.h
@@ -72,7 +72,7 @@ public:
      * If effect is non-NULL, a new GrEffect instance is stored in it. The caller assumes ownership
      * of the effect and must unref it.
      */
-    virtual bool asNewEffect(GrEffectRef** effect,
+    virtual bool asNewEffect(GrEffect** effect,
                              GrTexture*,
                              const SkMatrix& ctm) const;
 
diff --git a/include/core/SkShader.h b/include/core/SkShader.h
index 31f57cc3a6..2ed91f87b1 100644
--- a/include/core/SkShader.h
+++ b/include/core/SkShader.h
@@ -20,7 +20,7 @@ class SkPath;
 class SkPicture;
 class SkXfermode;
 class GrContext;
-class GrEffectRef;
+class GrEffect;
 
 /** \class SkShader
  *
@@ -384,7 +384,7 @@ public:
      */
     virtual bool asNewEffect(GrContext* context, const SkPaint& paint,
                              const SkMatrix* localMatrixOrNull, GrColor* grColor,
-                             GrEffectRef** grEffect) const;
+                             GrEffect** grEffect) const;
 
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     /**
diff --git a/include/core/SkXfermode.h b/include/core/SkXfermode.h
index c0a6572ec7..74fd9f85f7 100644
--- a/include/core/SkXfermode.h
+++ b/include/core/SkXfermode.h
@@ -13,7 +13,7 @@
 #include "SkFlattenable.h"
 #include "SkColor.h"
 
-class GrEffectRef;
+class GrEffect;
 class GrTexture;
 class SkString;
 
@@ -198,7 +198,7 @@ public:
         fragment shader. If NULL, the effect should request access to destination color
         (setWillReadDstColor()), and use that in the fragment shader (builder->dstColor()).
      */
-    virtual bool asNewEffect(GrEffectRef** effect, GrTexture* background = NULL) const;
+    virtual bool asNewEffect(GrEffect** effect, GrTexture* background = NULL) const;
 
     /** Returns true if the xfermode can be expressed as coeffs (src, dst), or as an effect
         (effect). This helper calls the asCoeff() and asNewEffect() virtuals. If the xfermode is
@@ -206,7 +206,7 @@ public:
         simply test the return value.  effect, src, and dst must all be NULL or all non-NULL.
      */
     static bool AsNewEffectOrCoeff(SkXfermode*,
-                                   GrEffectRef** effect,
+                                   GrEffect** effect,
                                    Coeff* src,
                                    Coeff* dst,
                                    GrTexture* background = NULL);
diff --git a/include/effects/SkColorMatrixFilter.h b/include/effects/SkColorMatrixFilter.h
index 5cfa46896b..edbe07dd77 100644
--- a/include/effects/SkColorMatrixFilter.h
+++ b/include/effects/SkColorMatrixFilter.h
@@ -26,7 +26,7 @@ public:
     virtual uint32_t getFlags() const SK_OVERRIDE;
     virtual bool asColorMatrix(SkScalar matrix[20]) const SK_OVERRIDE;
 #if SK_SUPPORT_GPU
-    virtual GrEffectRef* asNewEffect(GrContext*) const SK_OVERRIDE;
+    virtual GrEffect* asNewEffect(GrContext*) const SK_OVERRIDE;
 #endif
 
     struct State {
diff --git a/include/effects/SkLumaColorFilter.h b/include/effects/SkLumaColorFilter.h
index f2cee294c3..06eb01a1ff 100644
--- a/include/effects/SkLumaColorFilter.h
+++ b/include/effects/SkLumaColorFilter.h
@@ -28,7 +28,7 @@ public:
     virtual void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const SK_OVERRIDE;
 
 #if SK_SUPPORT_GPU
-    virtual GrEffectRef* asNewEffect(GrContext*) const SK_OVERRIDE;
+    virtual GrEffect* asNewEffect(GrContext*) const SK_OVERRIDE;
 #endif
 
     SK_TO_STRING_OVERRIDE()
diff --git a/include/effects/SkMagnifierImageFilter.h b/include/effects/SkMagnifierImageFilter.h
index 9d8a9b6cb0..b992e282b6 100644
--- a/include/effects/SkMagnifierImageFilter.h
+++ b/include/effects/SkMagnifierImageFilter.h
@@ -28,7 +28,8 @@ protected:
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
                                SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
 #if SK_SUPPORT_GPU
-    virtual bool asNewEffect(GrEffectRef** effect, GrTexture* texture, const SkMatrix& matrix, const SkIRect& bounds) const SK_OVERRIDE;
+    virtual bool asNewEffect(GrEffect** effect, GrTexture* texture, const SkMatrix& matrix,
+                             const SkIRect& bounds) const SK_OVERRIDE;
 #endif
 
 private:
diff --git a/include/effects/SkMatrixConvolutionImageFilter.h b/include/effects/SkMatrixConvolutionImageFilter.h
index 606de570bd..6d4c826038 100644
--- a/include/effects/SkMatrixConvolutionImageFilter.h
+++ b/include/effects/SkMatrixConvolutionImageFilter.h
@@ -86,7 +86,7 @@ protected:
 
 
 #if SK_SUPPORT_GPU
-    virtual bool asNewEffect(GrEffectRef** effect,
+    virtual bool asNewEffect(GrEffect** effect,
                              GrTexture*,
                              const SkMatrix& ctm,
                              const SkIRect& bounds) const SK_OVERRIDE;
diff --git a/include/effects/SkPerlinNoiseShader.h b/include/effects/SkPerlinNoiseShader.h
index 2d9dfdd69a..33559256e1 100644
--- a/include/effects/SkPerlinNoiseShader.h
+++ b/include/effects/SkPerlinNoiseShader.h
@@ -97,7 +97,7 @@ public:
     };
 
     virtual bool asNewEffect(GrContext* context, const SkPaint&, const SkMatrix*, GrColor*,
-                             GrEffectRef**) const SK_OVERRIDE;
+                             GrEffect**) const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPerlinNoiseShader)
diff --git a/include/gpu/GrBackendEffectFactory.h b/include/gpu/GrBackendEffectFactory.h
index 0fc981cbe9..af8d5c76c5 100644
--- a/include/gpu/GrBackendEffectFactory.h
+++ b/include/gpu/GrBackendEffectFactory.h
@@ -23,7 +23,6 @@
     of GrGLEffect.
  */
 
-class GrEffectRef;
 class GrGLEffect;
 class GrGLCaps;
 class GrDrawEffect;
diff --git a/include/gpu/GrEffect.h b/include/gpu/GrEffect.h
index 5fed5329fb..978ad3a6a6 100644
--- a/include/gpu/GrEffect.h
+++ b/include/gpu/GrEffect.h
@@ -21,66 +21,17 @@ class GrEffect;
 class GrVertexEffect;
 class SkString;
 
-/**
- * A Wrapper class for GrEffect. Its ref-count will track owners that may use effects to enqueue
- * new draw operations separately from ownership within a deferred drawing queue. When the
- * GrEffectRef ref count reaches zero the scratch GrResources owned by the effect can be recycled
- * in service of later draws. However, the deferred draw queue may still own direct references to
- * the underlying GrEffect.
- *
- * GrEffectRefs created by new are placed in a per-thread managed pool. The pool is destroyed when
- * the thread ends. Therefore, all dynamically allocated GrEffectRefs must be unreffed before thread
- * termination.
- */
-class GrEffectRef : public SkRefCnt {
-public:
-    SK_DECLARE_INST_COUNT(GrEffectRef);
-    virtual ~GrEffectRef();
-
-    GrEffect* get() { return fEffect; }
-    const GrEffect* get() const { return fEffect; }
-
-    const GrEffect* operator-> () { return fEffect; }
-    const GrEffect* operator-> () const { return fEffect; }
-
-    void* operator new(size_t size);
-    void operator delete(void* target);
-
-    void* operator new(size_t size, void* placement) {
-        return ::operator new(size, placement);
-    }
-    void operator delete(void* target, void* placement) {
-        ::operator delete(target, placement);
-    }
-
-private:
-    friend class GrEffect; // to construct these
-
-    explicit GrEffectRef(GrEffect* effect);
-
-    GrEffect* fEffect;
-
-    typedef SkRefCnt INHERITED;
-};
-
 /** Provides custom vertex shader, fragment shader, uniform data for a particular stage of the
     Ganesh shading pipeline.
     Subclasses must have a function that produces a human-readable name:
         static const char* Name();
     GrEffect objects *must* be immutable: after being constructed, their fields may not change.
 
-    GrEffect subclass objects should be created by factory functions that return GrEffectRef.
-    There is no public way to wrap a GrEffect in a GrEffectRef. Thus, a factory should be a static
-    member function of a GrEffect subclass.
-
-    Because almost no code should ever handle a GrEffect directly outside of a GrEffectRef, we
-    privately inherit from SkRefCnt to help prevent accidental direct ref'ing/unref'ing of effects.
-
-    Dynamically allocated GrEffects and their corresponding GrEffectRefs are managed by a per-thread
-    memory pool. The ref count of an effect must reach 0 before the thread terminates and the pool
-    is destroyed. To create a static effect use the macro GR_CREATE_STATIC_EFFECT declared below.
+    Dynamically allocated GrEffects are managed by a per-thread memory pool. The ref count of an
+    effect must reach 0 before the thread terminates and the pool is destroyed. To create a static
+    effect use the macro GR_CREATE_STATIC_EFFECT declared below.
   */
-class GrEffect : private SkRefCnt {
+class GrEffect : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrEffect)
 
@@ -124,8 +75,17 @@ public:
         computed by the GrBackendEffectFactory:
             effectA.getFactory().glEffectKey(effectA) == effectB.getFactory().glEffectKey(effectB).
      */
-    bool isEqual(const GrEffectRef& other) const {
-        return this->isEqual(*other.get());
+    bool isEqual(const GrEffect& other) const {
+        if (&this->getFactory() != &other.getFactory()) {
+            return false;
+        }
+        bool result = this->onIsEqual(other);
+#ifdef SK_DEBUG
+        if (result) {
+            this->assertEquality(other);
+        }
+#endif
+        return result;
     }
 
     /** Human-meaningful string to identify this effect; may be embedded
@@ -185,24 +145,6 @@ public:
         ::operator delete(target, placement);
     }
 
-    /** These functions are used when recording effects into a deferred drawing queue. The inc call
-        keeps the effect alive outside of GrEffectRef while allowing any resources owned by the
-        effect to be returned to the cache for reuse. The dec call must balance the inc call. */
-    void incDeferredRefCounts() const {
-        this->ref();
-        int count = fTextureAccesses.count();
-        for (int t = 0; t < count; ++t) {
-            fTextureAccesses[t]->getTexture()->incDeferredRefCount();
-        }
-    }
-    void decDeferredRefCounts() const {
-        int count = fTextureAccesses.count();
-        for (int t = 0; t < count; ++t) {
-            fTextureAccesses[t]->getTexture()->decDeferredRefCount();
-        }
-        this->unref();
-    }
-
 protected:
     /**
      * Subclasses call this from their constructor to register coordinate transformations. The
@@ -225,32 +167,18 @@ protected:
         : fWillReadDstColor(false)
         , fWillReadFragmentPosition(false)
         , fWillUseInputColor(true)
-        , fHasVertexCode(false)
-        , fEffectRef(NULL) {}
+        , fHasVertexCode(false) {}
 
     /** This should be called by GrEffect subclass factories. See the comment on AutoEffectUnref for
         an example factory function. */
-    static GrEffectRef* CreateEffectRef(GrEffect* effect) {
-        if (NULL == effect->fEffectRef) {
-            effect->fEffectRef = SkNEW_ARGS(GrEffectRef, (effect));
-        } else {
-            effect->fEffectRef->ref();
-        }
-        return effect->fEffectRef;
+    static GrEffect* CreateEffectRef(GrEffect* effect) {
+        return SkRef(effect);
     }
 
-    static const GrEffectRef* CreateEffectRef(const GrEffect* effect) {
+    static const GrEffect* CreateEffectRef(const GrEffect* effect) {
         return CreateEffectRef(const_cast<GrEffect*>(effect));
     }
 
-    /** Used by GR_CREATE_STATIC_EFFECT below */
-    static GrEffectRef* CreateStaticEffectRef(void* refStorage, GrEffect* effect) {
-        SkASSERT(NULL == effect->fEffectRef);
-        effect->fEffectRef = SkNEW_PLACEMENT_ARGS(refStorage, GrEffectRef, (effect));
-        return effect->fEffectRef;
-    }
-
-
     /** Helper used in subclass factory functions to unref the effect after it has been wrapped in a
         GrEffectRef. E.g.:
 
@@ -261,14 +189,7 @@ protected:
                 return CreateEffectRef(effect);
             }
      */
-    class AutoEffectUnref {
-    public:
-        AutoEffectUnref(GrEffect* effect) : fEffect(effect) { }
-        ~AutoEffectUnref() { fEffect->unref(); }
-        operator GrEffect*() { return fEffect; }
-    private:
-        GrEffect* fEffect;
-    };
+    typedef SkAutoTUnref<GrEffect> AutoEffectUnref;
 
     /** Helper for getting the GrEffect out of a GrEffectRef and down-casting to a GrEffect subclass
       */
@@ -299,19 +220,6 @@ protected:
     void setWillNotUseInputColor() { fWillUseInputColor = false; }
 
 private:
-    bool isEqual(const GrEffect& other) const {
-        if (&this->getFactory() != &other.getFactory()) {
-            return false;
-        }
-        bool result = this->onIsEqual(other);
-#ifdef SK_DEBUG
-        if (result) {
-            this->assertEquality(other);
-        }
-#endif
-        return result;
-    }
-
     SkDEBUGCODE(void assertEquality(const GrEffect& other) const;)
 
     /** Subclass implements this to support isEqual(). It will only be called if it is known that
@@ -319,12 +227,6 @@ private:
         getFactory()).*/
     virtual bool onIsEqual(const GrEffect& other) const = 0;
 
-    void EffectRefDestroyed() { fEffectRef = NULL; }
-
-    friend class GrEffectRef;    // to call EffectRefDestroyed()
-    friend class GrEffectStage;  // to rewrap GrEffect in GrEffectRef when restoring an effect-stage
-                                 // from deferred state, to call isEqual on naked GrEffects, and
-                                 // to inc/dec deferred ref counts.
     friend class GrVertexEffect; // to set fHasVertexCode and build fVertexAttribTypes.
 
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
@@ -334,32 +236,20 @@ private:
     bool                                         fWillReadFragmentPosition;
     bool                                         fWillUseInputColor;
     bool                                         fHasVertexCode;
-    GrEffectRef*                                 fEffectRef;
 
     typedef SkRefCnt INHERITED;
 };
 
-inline GrEffectRef::GrEffectRef(GrEffect* effect) {
-    SkASSERT(NULL != effect);
-    effect->ref();
-    fEffect = effect;
-}
+typedef GrEffect GrEffectRef;
 
 /**
  * This creates an effect outside of the effect memory pool. The effect's destructor will be called
- * at global destruction time. NAME will be the name of the created GrEffectRef.
+ * at global destruction time. NAME will be the name of the created GrEffect.
  */
 #define GR_CREATE_STATIC_EFFECT(NAME, EFFECT_CLASS, ARGS)                                         \
-enum {                                                                                            \
-    k_##NAME##_EffectRefOffset = GR_CT_ALIGN_UP(sizeof(EFFECT_CLASS), 8),                         \
-    k_##NAME##_StorageSize = k_##NAME##_EffectRefOffset + sizeof(GrEffectRef)                     \
-};                                                                                                \
-static SkAlignedSStorage<k_##NAME##_StorageSize> g_##NAME##_Storage;                              \
-static void* NAME##_RefLocation = (char*)g_##NAME##_Storage.get() + k_##NAME##_EffectRefOffset;   \
-static GrEffect* NAME##_Effect SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS);\
-static SkAutoTDestroy<GrEffect> NAME##_ad(NAME##_Effect);                                         \
-static GrEffectRef* NAME(GrEffect::CreateStaticEffectRef(NAME##_RefLocation, NAME##_Effect));     \
-static SkAutoTDestroy<GrEffectRef> NAME##_Ref_ad(NAME)
+static SkAlignedSStorage<sizeof(EFFECT_CLASS)> g_##NAME##_Storage;                                \
+static GrEffect* NAME SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS);         \
+static SkAutoTDestroy<GrEffect> NAME##_ad(NAME);
 
 
 #endif
diff --git a/include/gpu/GrEffectStage.h b/include/gpu/GrEffectStage.h
index 84ccbbf091..fb0620d6e6 100644
--- a/include/gpu/GrEffectStage.h
+++ b/include/gpu/GrEffectStage.h
@@ -20,8 +20,8 @@
 
 class GrEffectStage {
 public:
-    explicit GrEffectStage(const GrEffectRef* effectRef, int attrIndex0 = -1, int attrIndex1 = -1)
-    : fEffectRef(SkRef(effectRef)) {
+    explicit GrEffectStage(const GrEffect* effect, int attrIndex0 = -1, int attrIndex1 = -1)
+    : fEffect(SkRef(effect)) {
         fCoordChangeMatrixSet = false;
         fVertexAttribIndices[0] = attrIndex0;
         fVertexAttribIndices[1] = attrIndex1;
@@ -36,14 +36,14 @@ public:
         if (other.fCoordChangeMatrixSet) {
             fCoordChangeMatrix = other.fCoordChangeMatrix;
         }
-        fEffectRef.reset(SkRef(other.fEffectRef.get()));
+        fEffect.reset(SkRef(other.fEffect.get()));
         memcpy(fVertexAttribIndices, other.fVertexAttribIndices, sizeof(fVertexAttribIndices));
         return *this;
     }
 
     bool operator== (const GrEffectStage& other) const {
-        SkASSERT(NULL != fEffectRef.get());
-        SkASSERT(NULL != other.fEffectRef.get());
+        SkASSERT(NULL != fEffect.get());
+        SkASSERT(NULL != other.fEffect.get());
 
         if (!this->getEffect()->isEqual(*other.getEffect())) {
             return false;
@@ -81,7 +81,7 @@ public:
     private:
         bool fCoordChangeMatrixSet;
         SkMatrix fCoordChangeMatrix;
-        SkDEBUGCODE(mutable SkAutoTUnref<const GrEffectRef> fEffectRef;)
+        SkDEBUGCODE(mutable SkAutoTUnref<const GrEffect> fEffect;)
 
         friend class GrEffectStage;
     };
@@ -97,9 +97,9 @@ public:
         if (fCoordChangeMatrixSet) {
             savedCoordChange->fCoordChangeMatrix = fCoordChangeMatrix;
         }
-        SkASSERT(NULL == savedCoordChange->fEffectRef.get());
-        SkDEBUGCODE(SkRef(fEffectRef.get());)
-        SkDEBUGCODE(savedCoordChange->fEffectRef.reset(fEffectRef.get());)
+        SkASSERT(NULL == savedCoordChange->fEffect.get());
+        SkDEBUGCODE(SkRef(fEffect.get());)
+        SkDEBUGCODE(savedCoordChange->fEffect.reset(fEffect.get());)
     }
 
     /**
@@ -110,8 +110,8 @@ public:
         if (fCoordChangeMatrixSet) {
             fCoordChangeMatrix = savedCoordChange.fCoordChangeMatrix;
         }
-        SkASSERT(savedCoordChange.fEffectRef.get() == fEffectRef);
-        SkDEBUGCODE(savedCoordChange.fEffectRef.reset(NULL);)
+        SkASSERT(savedCoordChange.fEffect.get() == fEffect);
+        SkDEBUGCODE(savedCoordChange.fEffect.reset(NULL);)
     }
 
     /**
@@ -126,15 +126,15 @@ public:
         }
     }
 
-    const GrEffect* getEffect() const { return fEffectRef.get()->get(); }
+    const GrEffect* getEffect() const { return fEffect.get(); }
 
     const int* getVertexAttribIndices() const { return fVertexAttribIndices; }
-    int getVertexAttribIndexCount() const { return fEffectRef->get()->numVertexAttribs(); }
+    int getVertexAttribIndexCount() const { return fEffect->numVertexAttribs(); }
 
 private:
     bool                                fCoordChangeMatrixSet;
     SkMatrix                            fCoordChangeMatrix;
-    SkAutoTUnref<const GrEffectRef>     fEffectRef;
+    SkAutoTUnref<const GrEffect>        fEffect;
     int                                 fVertexAttribIndices[2];
 };
 
diff --git a/include/gpu/GrEffectUnitTest.h b/include/gpu/GrEffectUnitTest.h
index f71ab54e7e..ffc64f2b82 100644
--- a/include/gpu/GrEffectUnitTest.h
+++ b/include/gpu/GrEffectUnitTest.h
@@ -32,26 +32,26 @@ const SkMatrix& TestMatrix(SkRandom*);
 #if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
 
 class GrContext;
-class GrEffectRef;
+class GrEffect;
 class GrTexture;
 
 class GrEffectTestFactory : SkNoncopyable {
 public:
 
-    typedef GrEffectRef* (*CreateProc)(SkRandom*,
-                                       GrContext*,
-                                       const GrDrawTargetCaps& caps,
-                                       GrTexture* dummyTextures[]);
+    typedef GrEffect* (*CreateProc)(SkRandom*,
+                                    GrContext*,
+                                    const GrDrawTargetCaps& caps,
+                                    GrTexture* dummyTextures[]);
 
     GrEffectTestFactory(CreateProc createProc) {
         fCreateProc = createProc;
         GetFactories()->push_back(this);
     }
 
-    static GrEffectRef* CreateStage(SkRandom* random,
-                                    GrContext* context,
-                                    const GrDrawTargetCaps& caps,
-                                    GrTexture* dummyTextures[]) {
+    static GrEffect* CreateStage(SkRandom* random,
+                                 GrContext* context,
+                                 const GrDrawTargetCaps& caps,
+                                 GrTexture* dummyTextures[]) {
         uint32_t idx = random->nextRangeU(0, GetFactories()->count() - 1);
         GrEffectTestFactory* factory = (*GetFactories())[idx];
         return factory->fCreateProc(random, context, caps, dummyTextures);
@@ -67,10 +67,10 @@ private:
  */
 #define GR_DECLARE_EFFECT_TEST                                                      \
     static GrEffectTestFactory gTestFactory;                                        \
-    static GrEffectRef* TestCreate(SkRandom*,                                       \
-                                   GrContext*,                                      \
-                                   const GrDrawTargetCaps&,                         \
-                                   GrTexture* dummyTextures[2])
+    static GrEffect* TestCreate(SkRandom*,                                          \
+                                GrContext*,                                         \
+                                const GrDrawTargetCaps&,                            \
+                                GrTexture* dummyTextures[2])
 
 /** GrEffect subclasses should insert this macro in their implementation file. They must then
  *  also implement this static function:
@@ -91,10 +91,10 @@ private:
 // The unit test relies on static initializers. Just declare the TestCreate function so that
 // its definitions will compile.
 #define GR_DECLARE_EFFECT_TEST                                                      \
-    static GrEffectRef* TestCreate(SkRandom*,                                       \
-                                   GrContext*,                                      \
-                                   const GrDrawTargetCaps&,                         \
-                                   GrTexture* dummyTextures[2])
+    static GrEffect* TestCreate(SkRandom*,                                          \
+                                GrContext*,                                         \
+                                const GrDrawTargetCaps&,                            \
+                                GrTexture* dummyTextures[2])
 #define GR_DEFINE_EFFECT_TEST(X)
 
 #endif // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
diff --git a/include/gpu/GrPaint.h b/include/gpu/GrPaint.h
index db9b8cc2a6..20dec35b5b 100644
--- a/include/gpu/GrPaint.h
+++ b/include/gpu/GrPaint.h
@@ -87,9 +87,9 @@ public:
     /**
      * Appends an additional color effect to the color computation.
      */
-    const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+    const GrEffect* addColorEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
         SkASSERT(NULL != effect);
-        if (!(*effect)->willUseInputColor()) {
+        if (!effect->willUseInputColor()) {
             fColorStages.reset();
         }
         SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
@@ -99,9 +99,9 @@ public:
     /**
      * Appends an additional coverage effect to the coverage computation.
      */
-    const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+    const GrEffect* addCoverageEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
         SkASSERT(NULL != effect);
-        if (!(*effect)->willUseInputColor()) {
+        if (!effect->willUseInputColor()) {
             fCoverageStages.reset();
         }
         SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp
index 8e03a80427..37ba5403c4 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -471,7 +471,7 @@ bool SkBitmapProcShader::asNewEffect(GrContext* context, const SkPaint& paint,
 
 bool SkBitmapProcShader::asNewEffect(GrContext* context, const SkPaint& paint,
                                      const SkMatrix* localMatrix, GrColor* grColor,
-                                     GrEffectRef** grEffect) const {
+                                     GrEffect** grEffect) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index 08e8397a73..550d1d257a 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -31,7 +31,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBitmapProcShader)
 
 
-    bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffectRef**)
+    bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffect**)
             const SK_OVERRIDE;
 
     class BitmapProcShaderContext : public SkShader::Context {
diff --git a/src/core/SkColorFilter.cpp b/src/core/SkColorFilter.cpp
index 8cf9fc010a..a686f4c412 100644
--- a/src/core/SkColorFilter.cpp
+++ b/src/core/SkColorFilter.cpp
@@ -40,6 +40,6 @@ SkColor SkColorFilter::filterColor(SkColor c) const {
     return SkUnPreMultiply::PMColorToColor(dst);
 }
 
-GrEffectRef* SkColorFilter::asNewEffect(GrContext*) const {
+GrEffect* SkColorFilter::asNewEffect(GrContext*) const {
     return NULL;
 }
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index b67fbe01e7..dfe74cb74b 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -204,9 +204,8 @@ bool SkImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, const Cont
     matrix.postTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
     this->asNewEffect(&effect, srcTexture, matrix, bounds);
     SkASSERT(effect);
-    SkAutoUnref effectRef(effect);
     GrPaint paint;
-    paint.addColorEffect(effect);
+    paint.addColorEffect(effect)->unref();
     context->drawRectToRect(paint, dstRect, srcRect);
 
     SkAutoTUnref<GrTexture> resultTex(dst.detach());
@@ -299,7 +298,7 @@ bool SkImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
     return true;
 }
 
-bool SkImageFilter::asNewEffect(GrEffectRef**, GrTexture*, const SkMatrix&, const SkIRect&) const {
+bool SkImageFilter::asNewEffect(GrEffect**, GrTexture*, const SkMatrix&, const SkIRect&) const {
     return false;
 }
 
diff --git a/src/core/SkLocalMatrixShader.h b/src/core/SkLocalMatrixShader.h
index 1143f062d3..b56cd4726f 100644
--- a/src/core/SkLocalMatrixShader.h
+++ b/src/core/SkLocalMatrixShader.h
@@ -35,7 +35,7 @@ public:
 #if SK_SUPPORT_GPU
     
     virtual bool asNewEffect(GrContext* context, const SkPaint& paint, const SkMatrix* localMatrix,
-                             GrColor* grColor, GrEffectRef** grEffect) const SK_OVERRIDE {
+                             GrColor* grColor, GrEffect** grEffect) const SK_OVERRIDE {
         SkMatrix tmp = fProxyLocalMatrix;
         if (localMatrix) {
             tmp.preConcat(*localMatrix);
@@ -46,7 +46,7 @@ public:
 #else 
     
     virtual bool asNewEffect(GrContext* context, const SkPaint& paint, const SkMatrix* localMatrix,
-                             GrColor* grColor, GrEffectRef** grEffect) const SK_OVERRIDE {
+                             GrColor* grColor, GrEffect** grEffect) const SK_OVERRIDE {
         SkDEBUGFAIL("Should not call in GPU-less build");
         return false;
     }
diff --git a/src/core/SkMaskFilter.cpp b/src/core/SkMaskFilter.cpp
index 2ab2843641..a2adc7c327 100644
--- a/src/core/SkMaskFilter.cpp
+++ b/src/core/SkMaskFilter.cpp
@@ -298,7 +298,7 @@ SkMaskFilter::filterRectsToNine(const SkRect[], int count, const SkMatrix&,
 }
 
 #if SK_SUPPORT_GPU
-bool SkMaskFilter::asNewEffect(GrEffectRef** effect, GrTexture*, const SkMatrix&) const {
+bool SkMaskFilter::asNewEffect(GrEffect** effect, GrTexture*, const SkMatrix&) const {
     return false;
 }
 
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index 2de8d4d4cb..e154131dcb 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -200,7 +200,7 @@ bool SkPictureShader::asNewEffect(GrContext* context, const SkPaint& paint,
 #else
 bool SkPictureShader::asNewEffect(GrContext* context, const SkPaint& paint,
                                   const SkMatrix* localMatrix, GrColor* grColor,
-                                  GrEffectRef** grEffect) const {
+                                  GrEffect** grEffect) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/core/SkPictureShader.h b/src/core/SkPictureShader.h
index 294ffcd6b9..4995d268f3 100644
--- a/src/core/SkPictureShader.h
+++ b/src/core/SkPictureShader.h
@@ -29,7 +29,7 @@ public:
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureShader)
 
-    bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffectRef**)
+    bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffect**)
         const SK_OVERRIDE;
 
 protected:
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 18fb0d2584..71781ee0d8 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -210,7 +210,7 @@ SkShader::GradientType SkShader::asAGradient(GradientInfo* info) const {
 
 bool SkShader::asNewEffect(GrContext* context, const SkPaint& paint,
                            const SkMatrix* localMatrixOrNull, GrColor* grColor,
-                           GrEffectRef** grEffect)  const {
+                           GrEffect** grEffect)  const {
     return false;
 }
 
@@ -361,7 +361,7 @@ bool SkColorShader::asNewEffect(GrContext* context, const SkPaint& paint,
 
 bool SkColorShader::asNewEffect(GrContext* context, const SkPaint& paint,
                                      const SkMatrix* localMatrix, GrColor* grColor,
-                                     GrEffectRef** grEffect) const {
+                                     GrEffect** grEffect) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index d62602e334..b3e2ed16bf 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -676,12 +676,12 @@ bool SkXfermode::asMode(Mode* mode) const {
     return false;
 }
 
-bool SkXfermode::asNewEffect(GrEffectRef** effect, GrTexture* background) const {
+bool SkXfermode::asNewEffect(GrEffect** effect, GrTexture* background) const {
     return false;
 }
 
 bool SkXfermode::AsNewEffectOrCoeff(SkXfermode* xfermode,
-                                    GrEffectRef** effect,
+                                    GrEffect** effect,
                                     Coeff* src,
                                     Coeff* dst,
                                     GrTexture* background) {
diff --git a/src/core/SkXfermode_proccoeff.h b/src/core/SkXfermode_proccoeff.h
index 7edf6654a4..b777f62b5c 100644
--- a/src/core/SkXfermode_proccoeff.h
+++ b/src/core/SkXfermode_proccoeff.h
@@ -31,7 +31,7 @@ public:
     virtual bool asCoeff(Coeff* sc, Coeff* dc) const SK_OVERRIDE;
 
 #if SK_SUPPORT_GPU
-    virtual bool asNewEffect(GrEffectRef** effect,
+    virtual bool asNewEffect(GrEffect** effect,
                              GrTexture* background) const SK_OVERRIDE;
 #endif
 
diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index 6fcd2b4351..0bc906dae9 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -24,7 +24,7 @@ protected:
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
                                SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
 #if SK_SUPPORT_GPU
-    virtual bool asNewEffect(GrEffectRef** effect, GrTexture* texture,
+    virtual bool asNewEffect(GrEffect** effect, GrTexture* texture,
                              const SkMatrix& matrix, const SkIRect& bounds) const SK_OVERRIDE;
 #endif
 
@@ -248,7 +248,7 @@ SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(const SkRegion& region,
 }
 
 #if SK_SUPPORT_GPU
-bool SkAlphaThresholdFilterImpl::asNewEffect(GrEffectRef** effect, GrTexture* texture,
+bool SkAlphaThresholdFilterImpl::asNewEffect(GrEffect** effect, GrTexture* texture,
                                              const SkMatrix& in_matrix, const SkIRect&) const {
     if (effect) {
         GrContext* context = texture->getContext();
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index 81d70a7ff9..bee3a50f3b 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -87,7 +87,7 @@ public:
 #endif
 
 #if SK_SUPPORT_GPU
-    virtual GrEffectRef* asNewEffect(GrContext*) const SK_OVERRIDE;
+    virtual GrEffect* asNewEffect(GrContext*) const SK_OVERRIDE;
 #endif
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter)
 
@@ -409,7 +409,7 @@ GrEffectRef* ModeColorFilterEffect::TestCreate(SkRandom* rand,
     return ModeColorFilterEffect::Create(color, mode);
 }
 
-GrEffectRef* SkModeColorFilter::asNewEffect(GrContext*) const {
+GrEffect* SkModeColorFilter::asNewEffect(GrContext*) const {
     if (SkXfermode::kDst_Mode != fMode) {
         return ModeColorFilterEffect::Create(SkColor2GrColor(fColor), fMode);
     }
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index ae8b905645..4c90f3d4f4 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -121,7 +121,7 @@ private:
     }
 };
 
-GrEffectRef* SkLumaColorFilter::asNewEffect(GrContext*) const {
+GrEffect* SkLumaColorFilter::asNewEffect(GrContext*) const {
     return LumaColorFilterEffect::Create();
 }
 #endif
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index 7f0127ea5a..502cc0764b 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -946,7 +946,7 @@ void GrGLPerlinNoise::setData(const GrGLUniformManager& uman, const GrDrawEffect
 
 bool SkPerlinNoiseShader::asNewEffect(GrContext* context, const SkPaint& paint,
                                       const SkMatrix* externalLocalMatrix, GrColor* grColor,
-                                      GrEffectRef** grEffect) const {
+                                      GrEffect** grEffect) const {
     SkASSERT(NULL != context);
     
     *grColor = SkColor2GrColorJustAlpha(paint.getColor());
@@ -1011,7 +1011,7 @@ bool SkPerlinNoiseShader::asNewEffect(GrContext* context, const SkPaint& paint,
 
 bool SkPerlinNoiseShader::asNewEffect(GrContext* context, const SkPaint& paint,
                                       const SkMatrix* externalLocalMatrix, GrColor* grColor,
-                                      GrEffectRef** grEffect) const {
+                                      GrEffect** grEffect) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 6a9ab10795..771d2fa0d3 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -43,7 +43,7 @@ public:
     virtual bool asComponentTable(SkBitmap* table) const SK_OVERRIDE;
 
 #if SK_SUPPORT_GPU
-    virtual GrEffectRef* asNewEffect(GrContext* context) const SK_OVERRIDE;
+    virtual GrEffect* asNewEffect(GrContext* context) const SK_OVERRIDE;
 #endif
 
     virtual void filterSpan(const SkPMColor src[], int count,
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 72b9d4792f..768623a2b0 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -579,7 +579,7 @@ bool SkLinearGradient::asNewEffect(GrContext* context, const SkPaint& paint,
 
 bool SkLinearGradient::asNewEffect(GrContext* context, const SkPaint& paint,
                                    const SkMatrix* localMatrix, GrColor* grColor,
-                                   GrEffectRef** grEffect)  const {
+                                   GrEffect** grEffect)  const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/effects/gradients/SkLinearGradient.h b/src/effects/gradients/SkLinearGradient.h
index f412a6897d..bb64188251 100644
--- a/src/effects/gradients/SkLinearGradient.h
+++ b/src/effects/gradients/SkLinearGradient.h
@@ -31,7 +31,7 @@ public:
     virtual BitmapType asABitmap(SkBitmap*, SkMatrix*, TileMode*) const SK_OVERRIDE;
     virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
     virtual bool asNewEffect(GrContext* context, const SkPaint& paint, const SkMatrix* localMatrix,
-                             GrColor* grColor, GrEffectRef** grEffect) const SK_OVERRIDE;
+                             GrColor* grColor, GrEffect** grEffect) const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLinearGradient)
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index f0cb1612b0..38e6f33b38 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -591,7 +591,7 @@ bool SkRadialGradient::asNewEffect(GrContext* context, const SkPaint& paint,
 
 bool SkRadialGradient::asNewEffect(GrContext* context, const SkPaint& paint,
                                    const SkMatrix* localMatrix, GrColor* grColor,
-                                   GrEffectRef** grEffect) const {
+                                   GrEffect** grEffect) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/effects/gradients/SkRadialGradient.h b/src/effects/gradients/SkRadialGradient.h
index 197c967f4d..ac79a57d52 100644
--- a/src/effects/gradients/SkRadialGradient.h
+++ b/src/effects/gradients/SkRadialGradient.h
@@ -33,7 +33,7 @@ public:
                                  SkMatrix* matrix,
                                  TileMode* xy) const SK_OVERRIDE;
     virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
-    virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffectRef**) const SK_OVERRIDE;
+    virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffect**) const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRadialGradient)
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index 154e3a2f13..3b54ac8ae9 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -310,7 +310,7 @@ bool SkSweepGradient::asNewEffect(GrContext* context, const SkPaint& paint,
 
 bool SkSweepGradient::asNewEffect(GrContext* context, const SkPaint& paint,
                                   const SkMatrix* localMatrix, GrColor* grColor,
-                                  GrEffectRef** grEffect)  const {
+                                  GrEffect** grEffect)  const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/effects/gradients/SkSweepGradient.h b/src/effects/gradients/SkSweepGradient.h
index 0b12e718ea..7404ac7436 100644
--- a/src/effects/gradients/SkSweepGradient.h
+++ b/src/effects/gradients/SkSweepGradient.h
@@ -35,7 +35,7 @@ public:
 
     virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
 
-    virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffectRef**)
+    virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffect**)
         const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index 4421b90a3a..6678000c90 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -396,7 +396,7 @@ bool SkTwoPointConicalGradient::asNewEffect(GrContext* context, const SkPaint& p
 
 bool SkTwoPointConicalGradient::asNewEffect(GrContext* context, const SkPaint& paint,
                                             const SkMatrix* localMatrix, GrColor* grColor,
-                                            GrEffectRef** grEffect)  const {
+                                            GrEffect** grEffect)  const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.h b/src/effects/gradients/SkTwoPointConicalGradient.h
index f345d08e31..bff377ee79 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.h
+++ b/src/effects/gradients/SkTwoPointConicalGradient.h
@@ -66,7 +66,7 @@ public:
                                  TileMode* xy) const;
     virtual SkShader::GradientType asAGradient(GradientInfo* info) const  SK_OVERRIDE;
     virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor* grColor,
-                             GrEffectRef**) const SK_OVERRIDE;
+                             GrEffect**) const SK_OVERRIDE;
     virtual bool isOpaque() const SK_OVERRIDE;
 
     SkScalar getCenterX1() const { return SkPoint::Distance(fCenter1, fCenter2); }
diff --git a/src/effects/gradients/SkTwoPointConicalGradient_gpu.h b/src/effects/gradients/SkTwoPointConicalGradient_gpu.h
index 2b0f0612d7..4471ffc89c 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.h
+++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.h
@@ -10,7 +10,7 @@
 
 #include "SkGradientShaderPriv.h"
 
-class GrEffectRef;
+class GrEffect;
 class SkTwoPointConicalGradient;
 
 namespace Gr2PtConicalGradientEffect {
@@ -18,8 +18,8 @@ namespace Gr2PtConicalGradientEffect {
      * Creates an effect that produces a two point conical gradient based on the
      * shader passed in.
      */
-    GrEffectRef* Create(GrContext* ctx, const SkTwoPointConicalGradient& shader,
-                        SkShader::TileMode tm, const SkMatrix* localMatrix);
+    GrEffect* Create(GrContext* ctx, const SkTwoPointConicalGradient& shader,
+                     SkShader::TileMode tm, const SkMatrix* localMatrix);
 };
 
 #endif
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp
index e3d89960c6..3507c891c0 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.cpp
+++ b/src/effects/gradients/SkTwoPointRadialGradient.cpp
@@ -712,7 +712,7 @@ bool SkTwoPointRadialGradient::asNewEffect(GrContext* context, const SkPaint& pa
 
 bool SkTwoPointRadialGradient::asNewEffect(GrContext* context, const SkPaint& paint,
                                            const SkMatrix* localMatrix, GrColor* grColor,
-                                           GrEffectRef** grEffect)  const {
+                                           GrEffect** grEffect)  const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.h b/src/effects/gradients/SkTwoPointRadialGradient.h
index 8916754062..dc3a1553a1 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.h
+++ b/src/effects/gradients/SkTwoPointRadialGradient.h
@@ -22,7 +22,7 @@ public:
                                  TileMode* xy) const SK_OVERRIDE;
     virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
     virtual bool asNewEffect(GrContext* context, const SkPaint&, const SkMatrix*, GrColor*,
-                             GrEffectRef**)  const SK_OVERRIDE;
+                             GrEffect**)  const SK_OVERRIDE;
 
     virtual size_t contextSize() const SK_OVERRIDE;
 
diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h
index d2c60ea072..de14763a05 100644
--- a/src/gpu/GrDrawState.h
+++ b/src/gpu/GrDrawState.h
@@ -340,13 +340,13 @@ public:
     /// the color / coverage distinction.
     ////
 
-    const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+    const GrEffect* addColorEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
         SkASSERT(NULL != effect);
         SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
         return effect;
     }
 
-    const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+    const GrEffect* addCoverageEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
         SkASSERT(NULL != effect);
         SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
         return effect;
@@ -356,27 +356,23 @@ public:
      * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
      */
     void addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
-        GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
-        this->addColorEffect(effect)->unref();
+        this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
     }
 
     void addCoverageTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
-        GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
-        this->addCoverageEffect(effect)->unref();
+        this->addCoverageEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
     }
 
     void addColorTextureEffect(GrTexture* texture,
                                const SkMatrix& matrix,
                                const GrTextureParams& params) {
-        GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
-        this->addColorEffect(effect)->unref();
+        this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
     }
 
     void addCoverageTextureEffect(GrTexture* texture,
                                   const SkMatrix& matrix,
                                   const GrTextureParams& params) {
-        GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
-        this->addCoverageEffect(effect)->unref();
+        this->addCoverageEffect(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
     }
 
     /**
diff --git a/src/gpu/GrEffect.cpp b/src/gpu/GrEffect.cpp
index 986e80a57e..f952483562 100644
--- a/src/gpu/GrEffect.cpp
+++ b/src/gpu/GrEffect.cpp
@@ -59,25 +59,7 @@ int32_t GrBackendEffectFactory::fCurrEffectClassID = GrBackendEffectFactory::kIl
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrEffectRef::~GrEffectRef() {
-    SkASSERT(this->unique());
-    fEffect->EffectRefDestroyed();
-    fEffect->unref();
-}
-
-void* GrEffectRef::operator new(size_t size) {
-    return GrEffect_Globals::GetTLS()->allocate(size);
-}
-
-void GrEffectRef::operator delete(void* target) {
-    GrEffect_Globals::GetTLS()->release(target);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-GrEffect::~GrEffect() {
-    SkASSERT(NULL == fEffectRef);
-}
+GrEffect::~GrEffect() {}
 
 const char* GrEffect::name() const {
     return this->getFactory().name();
diff --git a/src/gpu/GrPaint.cpp b/src/gpu/GrPaint.cpp
index ddce0ef175..328484bd2d 100644
--- a/src/gpu/GrPaint.cpp
+++ b/src/gpu/GrPaint.cpp
@@ -12,27 +12,23 @@
 #include "effects/GrSimpleTextureEffect.h"
 
 void GrPaint::addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
-    GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
-    this->addColorEffect(effect)->unref();
+    this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
 }
 
 void GrPaint::addCoverageTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
-    GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
-    this->addCoverageEffect(effect)->unref();
+    this->addCoverageEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
 }
 
 void GrPaint::addColorTextureEffect(GrTexture* texture,
                                     const SkMatrix& matrix,
                                     const GrTextureParams& params) {
-    GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
-    this->addColorEffect(effect)->unref();
+    this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
 }
 
 void GrPaint::addCoverageTextureEffect(GrTexture* texture,
                                        const SkMatrix& matrix,
                                        const GrTextureParams& params) {
-    GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
-    this->addCoverageEffect(effect)->unref();
+    this->addCoverageEffect(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
 }
 
 bool GrPaint::isOpaque() const {
diff --git a/src/gpu/effects/GrDashingEffect.h b/src/gpu/effects/GrDashingEffect.h
index ced967127f..1a51e89ac8 100644
--- a/src/gpu/effects/GrDashingEffect.h
+++ b/src/gpu/effects/GrDashingEffect.h
@@ -35,8 +35,8 @@ namespace GrDashingEffect {
      * Bounding geometry is rendered and the effect computes coverage based on the fragment's
      * position relative to the dashed line.
      */
-    GrEffectRef* Create(GrEffectEdgeType edgeType, const SkPathEffect::DashInfo& info,
-                        SkScalar strokeWidth, DashCap cap);
+    GrEffect* Create(GrEffectEdgeType edgeType, const SkPathEffect::DashInfo& info,
+                     SkScalar strokeWidth, DashCap cap);
 }
 
 #endif
diff --git a/src/gpu/effects/GrDitherEffect.h b/src/gpu/effects/GrDitherEffect.h
index 63036c0c7f..88e0a27ae1 100644
--- a/src/gpu/effects/GrDitherEffect.h
+++ b/src/gpu/effects/GrDitherEffect.h
@@ -11,13 +11,13 @@
 #include "GrTypes.h"
 #include "GrTypesPriv.h"
 
-class GrEffectRef;
+class GrEffect;
 
 namespace GrDitherEffect {
     /**
      * Creates an effect that dithers the resulting color to an RGBA8 framebuffer
      */
-    GrEffectRef* Create();
+    GrEffect* Create();
 };
 
 #endif
diff --git a/src/gpu/effects/GrOvalEffect.h b/src/gpu/effects/GrOvalEffect.h
index 796ee5befb..37574ec58c 100644
--- a/src/gpu/effects/GrOvalEffect.h
+++ b/src/gpu/effects/GrOvalEffect.h
@@ -11,14 +11,14 @@
 #include "GrTypes.h"
 #include "GrTypesPriv.h"
 
-class GrEffectRef;
+class GrEffect;
 struct SkRect;
 
 namespace GrOvalEffect {
     /**
      * Creates an effect that performs clipping against an oval.
      */
-    GrEffectRef* Create(GrEffectEdgeType, const SkRect&);
+    GrEffect* Create(GrEffectEdgeType, const SkRect&);
 };
 
 #endif
diff --git a/src/gpu/effects/GrRRectEffect.h b/src/gpu/effects/GrRRectEffect.h
index 45ac5f43cf..bcf4884ddd 100644
--- a/src/gpu/effects/GrRRectEffect.h
+++ b/src/gpu/effects/GrRRectEffect.h
@@ -11,7 +11,7 @@
 #include "GrTypes.h"
 #include "GrTypesPriv.h"
 
-class GrEffectRef;
+class GrEffect;
 class SkRRect;
 
 namespace GrRRectEffect {
@@ -19,7 +19,7 @@ namespace GrRRectEffect {
      * Creates an effect that performs anti-aliased clipping against a SkRRect. It doesn't support
      * all varieties of SkRRect so the caller must check for a NULL return.
      */
-    GrEffectRef* Create(GrEffectEdgeType, const SkRRect&);
+    GrEffect* Create(GrEffectEdgeType, const SkRRect&);
 };
 
 #endif
diff --git a/src/gpu/effects/GrYUVtoRGBEffect.cpp b/src/gpu/effects/GrYUVtoRGBEffect.cpp
index 1e3810f619..866f4a66b5 100644
--- a/src/gpu/effects/GrYUVtoRGBEffect.cpp
+++ b/src/gpu/effects/GrYUVtoRGBEffect.cpp
@@ -16,7 +16,7 @@ namespace {
 
 class YUVtoRGBEffect : public GrEffect {
 public:
-    static GrEffectRef* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture) {
+    static GrEffect* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture) {
         AutoEffectUnref effect(SkNEW_ARGS(YUVtoRGBEffect, (yTexture, uTexture, vTexture)));
         return CreateEffectRef(effect);
     }
diff --git a/src/gpu/effects/GrYUVtoRGBEffect.h b/src/gpu/effects/GrYUVtoRGBEffect.h
index cc86af7662..150acd5a90 100644
--- a/src/gpu/effects/GrYUVtoRGBEffect.h
+++ b/src/gpu/effects/GrYUVtoRGBEffect.h
@@ -8,14 +8,14 @@
 #ifndef GrYUVtoRGBEffect_DEFINED
 #define GrYUVtoRGBEffect_DEFINED
 
-class GrEffectRef;
+class GrEffect;
 class GrTexture;
 
 namespace GrYUVtoRGBEffect {
     /**
      * Creates an effect that performs color conversion from YUV to RGB
      */
-    GrEffectRef* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture);
+    GrEffect* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture);
 };
 
 #endif
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 64c8559196..8ead5b8bca 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -172,7 +172,7 @@ bool GrGpuGL::programUnitTest(int maxStages) {
                                                                             *this->caps(),
                                                                             dummyTextures));
             SkASSERT(effect);
-            int numAttribs = (*effect)->numVertexAttribs();
+            int numAttribs = effect->numVertexAttribs();
 
             // If adding this effect would exceed the max attrib count then generate a
             // new random effect.
@@ -183,15 +183,15 @@ bool GrGpuGL::programUnitTest(int maxStages) {
 
             // If adding this effect would exceed the max texture coord set count then generate a
             // new random effect.
-            if (useFixedFunctionTexturing && !(*effect)->hasVertexCode()) {
-                int numTransforms = (*effect)->numTransforms();
+            if (useFixedFunctionTexturing && !effect->hasVertexCode()) {
+                int numTransforms = effect->numTransforms();
                 if (currTextureCoordSet + numTransforms > this->glCaps().maxFixedFunctionTextureCoords()) {
                     continue;
                 }
                 currTextureCoordSet += numTransforms;
             }
 
-            useFixedFunctionTexturing = useFixedFunctionTexturing && !(*effect)->hasVertexCode();
+            useFixedFunctionTexturing = useFixedFunctionTexturing && !effect->hasVertexCode();
 
             for (int i = 0; i < numAttribs; ++i) {
                 attribIndices[i] = currAttribIndex++;
diff --git a/tests/GpuColorFilterTest.cpp b/tests/GpuColorFilterTest.cpp
index 9ba9431939..cdb5ef3cdd 100644
--- a/tests/GpuColorFilterTest.cpp
+++ b/tests/GpuColorFilterTest.cpp
@@ -101,7 +101,7 @@ static void test_getConstantColorComponents(skiatest::Reporter* reporter, GrCont
         SkAutoTUnref<GrEffectRef> grEffect(cf->asNewEffect(grContext));
         GrColor color = test.inputColor;
         uint32_t components = test.inputComponents;
-        grEffect->get()->getConstantColorComponents(&color, &components);
+        grEffect->getConstantColorComponents(&color, &components);
 
         REPORTER_ASSERT(reporter, filterColor(color, components) == test.outputColor);
         REPORTER_ASSERT(reporter, test.outputComponents == components);