Goodbye GrEffectRef.

src/gpu/effects/GrConvexPolyEffect.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 "GrConvexPolyEffect.h"
 
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
 #include "GrTBackendEffectFactory.h"
 
 #include "SkPath.h"
 
 //////////////////////////////////////////////////////////////////////////////
 class GLAARectEffect;
 
 class AARectEffect : public GrEffect {
 public:
     typedef GLAARectEffect GLEffect;
 
     const SkRect& getRect() const { return fRect; }
 
     static const char* Name() { return "AARect"; }
 
-    static GrEffectRef* Create(GrEffectEdgeType edgeType, const SkRect& rect) {
+    static GrEffect* Create(GrEffectEdgeType edgeType, const SkRect& rect) {
         return SkNEW_ARGS(AARectEffect, (edgeType, rect));
     }
 
     virtual void getConstantColorComponents(GrColor* color,
                                             uint32_t* validFlags) const SK_OVERRIDE {
         if (fRect.isEmpty()) {
             // An empty rect will have no coverage anywhere.
             *color = 0x00000000;
             *validFlags = kRGBA_GrColorComponentFlags;
         } else {
@@ skipping 19 matching lines @@
     GrEffectEdgeType fEdgeType;
 
     typedef GrEffect INHERITED;
 
     GR_DECLARE_EFFECT_TEST;
 
 };
 
 GR_DEFINE_EFFECT_TEST(AARectEffect);
 
-GrEffectRef* AARectEffect::TestCreate(SkRandom* random,
-                                      GrContext*,
-                                      const GrDrawTargetCaps& caps,
-                                      GrTexture*[]) {
+GrEffect* AARectEffect::TestCreate(SkRandom* random,
+                                   GrContext*,
+                                   const GrDrawTargetCaps& caps,
+                                   GrTexture*[]) {
     SkRect rect = SkRect::MakeLTRB(random->nextSScalar1(),
                                    random->nextSScalar1(),
                                    random->nextSScalar1(),
                                    random->nextSScalar1());
-    GrEffectRef* effect;
+    GrEffect* effect;
     do {
         GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(random->nextULessThan(
                                                                     kGrEffectEdgeTypeCnt));
 
         effect = AARectEffect::Create(edgeType, rect);
     } while (NULL == effect);
     return effect;
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 169 matching lines @@
 
 GrGLEffect::EffectKey GrGLConvexPolyEffect::GenKey(const GrDrawEffect& drawEffect,
                                                    const GrGLCaps&) {
     const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>();
     GR_STATIC_ASSERT(kGrEffectEdgeTypeCnt <= 8);
     return (cpe.getEdgeCount() << 3) | cpe.getEdgeType();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrEffectRef* GrConvexPolyEffect::Create(GrEffectEdgeType type, const SkPath& path, const SkVector* offset) {
+GrEffect* GrConvexPolyEffect::Create(GrEffectEdgeType type, const SkPath& path,
+                                     const SkVector* offset) {
     if (kHairlineAA_GrEffectEdgeType == type) {
         return NULL;
     }
     if (path.getSegmentMasks() != SkPath::kLine_SegmentMask ||
         !path.isConvex()) {
         return NULL;
     }
 
     if (path.countPoints() > kMaxEdges) {
         return NULL;
@@ skipping 29 matching lines @@
             edges[3 * n + 2] = -(edges[3 * n] * p.fX + edges[3 * n + 1] * p.fY);
             ++n;
         }
     }
     if (path.isInverseFillType()) {
         type = GrInvertEffectEdgeType(type);
     }
     return Create(type, n, edges);
 }
 
-GrEffectRef* GrConvexPolyEffect::Create(GrEffectEdgeType edgeType, const SkRect& rect) {
+GrEffect* GrConvexPolyEffect::Create(GrEffectEdgeType edgeType, const SkRect& rect) {
     if (kHairlineAA_GrEffectEdgeType == edgeType){
         return NULL;
     }
     return AARectEffect::Create(edgeType, rect);
 }
 
 GrConvexPolyEffect::~GrConvexPolyEffect() {}
 
 void GrConvexPolyEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     *validFlags = 0;
@@ skipping 21 matching lines @@
     const GrConvexPolyEffect& cpe = CastEffect<GrConvexPolyEffect>(other);
     // ignore the fact that 0 == -0 and just use memcmp.
     return (cpe.fEdgeType == fEdgeType && cpe.fEdgeCount == fEdgeCount &&
             0 == memcmp(cpe.fEdges, fEdges, 3 * fEdgeCount * sizeof(SkScalar)));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(GrConvexPolyEffect);
 
-GrEffectRef* GrConvexPolyEffect::TestCreate(SkRandom* random,
-                                            GrContext*,
-                                            const GrDrawTargetCaps& caps,
-                                            GrTexture*[]) {
+GrEffect* GrConvexPolyEffect::TestCreate(SkRandom* random,
+                                         GrContext*,
+                                         const GrDrawTargetCaps& caps,
+                                         GrTexture*[]) {
     int count = random->nextULessThan(kMaxEdges) + 1;
     SkScalar edges[kMaxEdges * 3];
     for (int i = 0; i < 3 * count; ++i) {
         edges[i] = random->nextSScalar1();
     }
 
-    GrEffectRef* effect;
+    GrEffect* effect;
     do {
         GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
                                         random->nextULessThan(kGrEffectEdgeTypeCnt));
         effect = GrConvexPolyEffect::Create(edgeType, count, edges);
     } while (NULL == effect);
     return effect;
 }