Goodbye GrEffectRef.

src/gpu/effects/GrOvalEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalEffect.h"
 
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
 #include "GrTBackendEffectFactory.h"
 
 #include "SkRect.h"
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLCircleEffect;
 
 class CircleEffect : public GrEffect {
 public:
-    static GrEffectRef* Create(GrEffectEdgeType, const SkPoint& center, SkScalar radius);
+    static GrEffect* Create(GrEffectEdgeType, const SkPoint& center, SkScalar radius);
 
     virtual ~CircleEffect() {};
     static const char* Name() { return "Circle"; }
 
     const SkPoint& getCenter() const { return fCenter; }
     SkScalar getRadius() const { return fRadius; }
 
     GrEffectEdgeType getEdgeType() const { return fEdgeType; }
 
     typedef GLCircleEffect GLEffect;
 
     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
 
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
 
 private:
     CircleEffect(GrEffectEdgeType, const SkPoint& center, SkScalar radius);
 
     virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
 
     SkPoint             fCenter;
     SkScalar            fRadius;
     GrEffectEdgeType    fEdgeType;
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrEffect INHERITED;
 };
 
-GrEffectRef* CircleEffect::Create(GrEffectEdgeType edgeType,
-                                  const SkPoint& center,
-                                  SkScalar radius) {
+GrEffect* CircleEffect::Create(GrEffectEdgeType edgeType, const SkPoint& center, SkScalar radius) {
     SkASSERT(radius >= 0);
     return SkNEW_ARGS(CircleEffect, (edgeType, center, radius));
 }
 
 void CircleEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     *validFlags = 0;
 }
 
 const GrBackendEffectFactory& CircleEffect::getFactory() const {
     return GrTBackendEffectFactory<CircleEffect>::getInstance();
 }
 
 CircleEffect::CircleEffect(GrEffectEdgeType edgeType, const SkPoint& c, SkScalar r)
     : fCenter(c)
     , fRadius(r)
     , fEdgeType(edgeType) {
     this->setWillReadFragmentPosition();
 }
 
 bool CircleEffect::onIsEqual(const GrEffect& other) const {
     const CircleEffect& ce = CastEffect<CircleEffect>(other);
     return fEdgeType == ce.fEdgeType && fCenter == ce.fCenter && fRadius == ce.fRadius;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(CircleEffect);
 
-GrEffectRef* CircleEffect::TestCreate(SkRandom* random,
-                                      GrContext*,
-                                      const GrDrawTargetCaps& caps,
-                                      GrTexture*[]) {
+GrEffect* CircleEffect::TestCreate(SkRandom* random,
+                                   GrContext*,
+                                   const GrDrawTargetCaps& caps,
+                                   GrTexture*[]) {
     SkPoint center;
     center.fX = random->nextRangeScalar(0.f, 1000.f);
     center.fY = random->nextRangeScalar(0.f, 1000.f);
     SkScalar radius = random->nextRangeF(0.f, 1000.f);
     GrEffectEdgeType et;
     do {
         et = (GrEffectEdgeType)random->nextULessThan(kGrEffectEdgeTypeCnt);
     } while (kHairlineAA_GrEffectEdgeType == et);
     return CircleEffect::Create(et, center, radius);
 }
@@ skipping 85 matching lines @@
         fPrevRadius = ce.getRadius();
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLEllipseEffect;
 
 class EllipseEffect : public GrEffect {
 public:
-    static GrEffectRef* Create(GrEffectEdgeType, const SkPoint& center, SkScalar rx, SkScalar ry);
+    static GrEffect* Create(GrEffectEdgeType, const SkPoint& center, SkScalar rx, SkScalar ry);
 
     virtual ~EllipseEffect() {};
     static const char* Name() { return "Ellipse"; }
 
     const SkPoint& getCenter() const { return fCenter; }
     SkVector getRadii() const { return fRadii; }
 
     GrEffectEdgeType getEdgeType() const { return fEdgeType; }
 
     typedef GLEllipseEffect GLEffect;
 
     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
 
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
 
 private:
     EllipseEffect(GrEffectEdgeType, const SkPoint& center, SkScalar rx, SkScalar ry);
 
     virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
 
     SkPoint             fCenter;
     SkVector            fRadii;
     GrEffectEdgeType    fEdgeType;
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrEffect INHERITED;
 };
 
-GrEffectRef* EllipseEffect::Create(GrEffectEdgeType edgeType,
-                                   const SkPoint& center,
-                                   SkScalar rx,
-                                   SkScalar ry) {
+GrEffect* EllipseEffect::Create(GrEffectEdgeType edgeType,
+                                const SkPoint& center,
+                                SkScalar rx,
+                                SkScalar ry) {
     SkASSERT(rx >= 0 && ry >= 0);
     return SkNEW_ARGS(EllipseEffect, (edgeType, center, rx, ry));
 }
 
 void EllipseEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     *validFlags = 0;
 }
 
 const GrBackendEffectFactory& EllipseEffect::getFactory() const {
     return GrTBackendEffectFactory<EllipseEffect>::getInstance();
 }
 
 EllipseEffect::EllipseEffect(GrEffectEdgeType edgeType, const SkPoint& c, SkScalar rx, SkScalar ry)
     : fCenter(c)
     , fRadii(SkVector::Make(rx, ry))
     , fEdgeType(edgeType) {
     this->setWillReadFragmentPosition();
 }
 
 bool EllipseEffect::onIsEqual(const GrEffect& other) const {
     const EllipseEffect& ee = CastEffect<EllipseEffect>(other);
     return fEdgeType == ee.fEdgeType && fCenter == ee.fCenter && fRadii == ee.fRadii;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(EllipseEffect);
 
-GrEffectRef* EllipseEffect::TestCreate(SkRandom* random,
-                                       GrContext*,
-                                       const GrDrawTargetCaps& caps,
-                                       GrTexture*[]) {
+GrEffect* EllipseEffect::TestCreate(SkRandom* random,
+                                    GrContext*,
+                                    const GrDrawTargetCaps& caps,
+                                    GrTexture*[]) {
     SkPoint center;
     center.fX = random->nextRangeScalar(0.f, 1000.f);
     center.fY = random->nextRangeScalar(0.f, 1000.f);
     SkScalar rx = random->nextRangeF(0.f, 1000.f);
     SkScalar ry = random->nextRangeF(0.f, 1000.f);
     GrEffectEdgeType et;
     do {
         et = (GrEffectEdgeType)random->nextULessThan(kGrEffectEdgeTypeCnt);
     } while (kHairlineAA_GrEffectEdgeType == et);
     return EllipseEffect::Create(et, center, rx, ry);
@@ skipping 91 matching lines @@
         SkScalar invRXSqd = 1.f / (ee.getRadii().fX * ee.getRadii().fX);
         SkScalar invRYSqd = 1.f / (ee.getRadii().fY * ee.getRadii().fY);
         uman.set4f(fEllipseUniform, ee.getCenter().fX, ee.getCenter().fY, invRXSqd, invRYSqd);
         fPrevCenter = ee.getCenter();
         fPrevRadii = ee.getRadii();
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrEffectRef* GrOvalEffect::Create(GrEffectEdgeType edgeType, const SkRect& oval) {
+GrEffect* GrOvalEffect::Create(GrEffectEdgeType edgeType, const SkRect& oval) {
     if (kHairlineAA_GrEffectEdgeType == edgeType) {
         return NULL;
     }
     SkScalar w = oval.width();
     SkScalar h = oval.height();
     if (SkScalarNearlyEqual(w, h)) {
         w /= 2;
         return CircleEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, oval.fTop + w), w);
     } else {
         w /= 2;
         h /= 2;
         return EllipseEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, oval.fTop + h), w, h);
     }
 
     return NULL;
 }