Goodbye GrEffectRef.

src/effects/SkMagnifierImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkMagnifierImageFilter.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkValidationUtils.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 #if SK_SUPPORT_GPU
 #include "effects/GrSingleTextureEffect.h"
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLTexture.h"
 #include "GrTBackendEffectFactory.h"
 
 class GrGLMagnifierEffect;
 
 class GrMagnifierEffect : public GrSingleTextureEffect {
 
 public:
-    static GrEffectRef* Create(GrTexture* texture,
-                               float xOffset,
-                               float yOffset,
-                               float xInvZoom,
-                               float yInvZoom,
-                               float xInvInset,
-                               float yInvInset) {
+    static GrEffect* Create(GrTexture* texture,
+                            float xOffset,
+                            float yOffset,
+                            float xInvZoom,
+                            float yInvZoom,
+                            float xInvInset,
+                            float yInvInset) {
         return SkNEW_ARGS(GrMagnifierEffect, (texture,
                                               xOffset,
                                               yOffset,
                                               xInvZoom,
                                               yInvZoom,
                                               xInvInset,
                                               yInvInset));
     }
 
     virtual ~GrMagnifierEffect() {};
@@ skipping 129 matching lines @@
     const GrMagnifierEffect& zoom = drawEffect.castEffect<GrMagnifierEffect>();
     uman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset());
     uman.set2f(fInvZoomVar, zoom.x_inv_zoom(), zoom.y_inv_zoom());
     uman.set2f(fInvInsetVar, zoom.x_inv_inset(), zoom.y_inv_inset());
 }
 
 /////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(GrMagnifierEffect);
 
-GrEffectRef* GrMagnifierEffect::TestCreate(SkRandom* random,
-                                           GrContext* context,
-                                           const GrDrawTargetCaps&,
-                                           GrTexture** textures) {
+GrEffect* GrMagnifierEffect::TestCreate(SkRandom* random,
+                                        GrContext* context,
+                                        const GrDrawTargetCaps&,
+                                        GrTexture** textures) {
     GrTexture* texture = textures[0];
     const int kMaxWidth = 200;
     const int kMaxHeight = 200;
     const int kMaxInset = 20;
     uint32_t width = random->nextULessThan(kMaxWidth);
     uint32_t height = random->nextULessThan(kMaxHeight);
     uint32_t x = random->nextULessThan(kMaxWidth - width);
     uint32_t y = random->nextULessThan(kMaxHeight - height);
     uint32_t inset = random->nextULessThan(kMaxInset);
 
-    GrEffectRef* effect = GrMagnifierEffect::Create(
+    GrEffect* effect = GrMagnifierEffect::Create(
         texture,
         (float) width / texture->width(),
         (float) height / texture->height(),
         texture->width() / (float) x,
         texture->height() / (float) y,
         (float) inset / texture->width(),
         (float) inset / texture->height());
     SkASSERT(NULL != effect);
     return effect;
 }
@@ skipping 36 matching lines @@
                     (fSrcRect.fLeft >= 0) && (fSrcRect.fTop >= 0));
 }
 
 // FIXME:  implement single-input semantics
 SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset)
     : INHERITED(0), fSrcRect(srcRect), fInset(inset) {
     SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0);
 }
 
 #if SK_SUPPORT_GPU
-bool SkMagnifierImageFilter::asNewEffect(GrEffectRef** effect, GrTexture* texture, const SkMatrix&, const SkIRect&) const {
+bool SkMagnifierImageFilter::asNewEffect(GrEffect** effect, GrTexture* texture, const SkMatrix&,
+                                         const SkIRect&) const {
     if (effect) {
         SkScalar yOffset = (texture->origin() == kTopLeft_GrSurfaceOrigin) ? fSrcRect.y() :
                            (texture->height() - (fSrcRect.y() + fSrcRect.height()));
         SkScalar invInset = fInset > 0 ? SkScalarInvert(fInset) : SK_Scalar1;
         *effect = GrMagnifierEffect::Create(texture,
                                             fSrcRect.x() / texture->width(),
                                             yOffset / texture->height(),
                                             fSrcRect.width() / texture->width(),
                                             fSrcRect.height() / texture->height(),
                                             texture->width() * invInset,
@@ skipping 74 matching lines @@
 
             int x_val = SkPin32(SkScalarFloorToInt(x_interp), 0, width - 1);
             int y_val = SkPin32(SkScalarFloorToInt(y_interp), 0, height - 1);
 
             *dptr = sptr[y_val * width + x_val];
             dptr++;
         }
     }
     return true;
 }