sk_sp for gpu.

src/gpu/effects/GrDashingEffect.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 "GrDashingEffect.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 214 matching lines @@
     matrix.mapPoints(&verts[idx], 4);
 }
 
 
 /**
  * An GrGeometryProcessor that renders a dashed line.
  * This GrGeometryProcessor is meant for dashed lines that only have a single on/off interval pair.
  * Bounding geometry is rendered and the effect computes coverage based on the fragment's
  * position relative to the dashed line.
  */
-static GrGeometryProcessor* create_dash_gp(GrColor,
-                                           AAMode aaMode,
-                                           DashCap cap,
-                                           const SkMatrix& localMatrix,
-                                           bool usesLocalCoords);
+static sk_sp<GrGeometryProcessor> make_dash_gp(GrColor,
+                                               AAMode aaMode,
+                                               DashCap cap,
+                                               const SkMatrix& localMatrix,
+                                               bool usesLocalCoords);
 
 class DashBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
     struct Geometry {
         SkMatrix fViewMatrix;
         SkMatrix fSrcRotInv;
         SkPoint fPtsRot[2];
         SkScalar fSrcStrokeWidth;
         SkScalar fPhase;
@@ skipping 74 matching lines @@
         bool fHasStartRect;
         bool fHasEndRect;
     };
 
     void onPrepareDraws(Target* target) const override {
         int instanceCount = fGeoData.count();
         SkPaint::Cap cap = this->cap();
         bool isRoundCap = SkPaint::kRound_Cap == cap;
         DashCap capType = isRoundCap ? kRound_DashCap : kNonRound_DashCap;
 
-        SkAutoTUnref<const GrGeometryProcessor> gp;
+        sk_sp<GrGeometryProcessor> gp;
         if (this->fullDash()) {
-            gp.reset(create_dash_gp(this->color(), this->aaMode(), capType, this->viewMatrix(),
-                                    this->usesLocalCoords()));
+            gp = make_dash_gp(this->color(), this->aaMode(), capType, this->viewMatrix(),
+                              this->usesLocalCoords());
         } else {
             // Set up the vertex data for the line and start/end dashes
             using namespace GrDefaultGeoProcFactory;
             Color color(this->color());
             Coverage coverage(this->coverageIgnored() ? Coverage::kNone_Type :
                                                         Coverage::kSolid_Type);
             LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
                                                               LocalCoords::kUnused_Type);
-            gp.reset(CreateForDeviceSpace(color, coverage, localCoords, this->viewMatrix()));
+            gp = MakeForDeviceSpace(color, coverage, localCoords, this->viewMatrix());
         }
 
         if (!gp) {
             SkDebugf("Could not create GrGeometryProcessor\n");
             return;
         }
 
         // useAA here means Edge AA or MSAA
         bool useAA = this->aaMode() != AAMode::kNone;
         bool fullDash = this->fullDash();
@@ skipping 258 matching lines @@
                 } else {
                     SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
                     SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
                     setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts);
                 }
                 curVIdx += 4;
             }
             rectIndex++;
         }
         SkASSERT(0 == (curVIdx % 4) && (curVIdx / 4) == totalRectCount);
-        helper.recordDraw(target, gp);
+        helper.recordDraw(target, gp.get());
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         DashBatch* that = t->cast<DashBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                     that->bounds(), caps)) {
             return false;
         }
 
         if (this->aaMode() != that->aaMode()) {
@@ skipping 114 matching lines @@
  * Both of the previous two parameters are in device space. This effect also requires the setting of
  * a vec2 vertex attribute for the the four corners of the bounding rect. This attribute is the
  * "dash position" of each vertex. In other words it is the vertex coords (in device space) if we
  * transform the line to be horizontal, with the start of line at the origin then shifted to the
  * right by half the off interval. The line then goes in the positive x direction.
  */
 class DashingCircleEffect : public GrGeometryProcessor {
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
-    static GrGeometryProcessor* Create(GrColor,
-                                       AAMode aaMode,
-                                       const SkMatrix& localMatrix,
-                                       bool usesLocalCoords);
+    static sk_sp<GrGeometryProcessor> Make(GrColor,
+                                           AAMode aaMode,
+                                           const SkMatrix& localMatrix,
+                                           bool usesLocalCoords);
 
     const char* name() const override { return "DashingCircleEffect"; }
 
     const Attribute* inPosition() const { return fInPosition; }
 
     const Attribute* inDashParams() const { return fInDashParams; }
 
     const Attribute* inCircleParams() const { return fInCircleParams; }
 
     AAMode aaMode() const { return fAAMode; }
@@ skipping 138 matching lines @@
     const DashingCircleEffect& dce = gp.cast<DashingCircleEffect>();
     uint32_t key = 0;
     key |= dce.usesLocalCoords() && dce.localMatrix().hasPerspective() ? 0x1 : 0x0;
     key |= dce.colorIgnored() ? 0x2 : 0x0;
     key |= static_cast<uint32_t>(dce.aaMode()) << 8;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrGeometryProcessor* DashingCircleEffect::Create(GrColor color,
-                                                 AAMode aaMode,
-                                                 const SkMatrix& localMatrix,
-                                                 bool usesLocalCoords) {
-    return new DashingCircleEffect(color, aaMode, localMatrix, usesLocalCoords);
+sk_sp<GrGeometryProcessor> DashingCircleEffect::Make(GrColor color,
+                                                     AAMode aaMode,
+                                                     const SkMatrix& localMatrix,
+                                                     bool usesLocalCoords) {
+    return sk_sp<GrGeometryProcessor>(
+        new DashingCircleEffect(color, aaMode, localMatrix, usesLocalCoords));
 }
 
 void DashingCircleEffect::getGLSLProcessorKey(const GrGLSLCaps& caps,
                                               GrProcessorKeyBuilder* b) const {
     GLDashingCircleEffect::GenKey(*this, caps, b);
 }
 
 GrGLSLPrimitiveProcessor* DashingCircleEffect::createGLSLInstance(const GrGLSLCaps&) const {
     return new GLDashingCircleEffect();
 }
 
 DashingCircleEffect::DashingCircleEffect(GrColor color,
                                          AAMode aaMode,
                                          const SkMatrix& localMatrix,
                                          bool usesLocalCoords)
     : fColor(color)
     , fLocalMatrix(localMatrix)
     , fUsesLocalCoords(usesLocalCoords)
     , fAAMode(aaMode) {
     this->initClassID<DashingCircleEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInDashParams = &this->addVertexAttrib(Attribute("inDashParams", kVec3f_GrVertexAttribType));
     fInCircleParams = &this->addVertexAttrib(Attribute("inCircleParams",
                                                        kVec2f_GrVertexAttribType));
 }
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect);
 
-const GrGeometryProcessor* DashingCircleEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> DashingCircleEffect::TestCreate(GrProcessorTestData* d) {
     AAMode aaMode = static_cast<AAMode>(d->fRandom->nextULessThan(GrDashingEffect::kAAModeCnt));
-    return DashingCircleEffect::Create(GrRandomColor(d->fRandom),
-                                      aaMode, GrTest::TestMatrix(d->fRandom),
-                                      d->fRandom->nextBool());
+    return DashingCircleEffect::Make(GrRandomColor(d->fRandom),
+                                    aaMode, GrTest::TestMatrix(d->fRandom),
+                                    d->fRandom->nextBool());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingLineEffect;
 
 /*
  * This effect will draw a dashed line. The width of the dash is given by the strokeWidth and the
  * length and spacing by the DashInfo. Both of the previous two parameters are in device space.
  * This effect also requires the setting of a vec2 vertex attribute for the the four corners of the
  * bounding rect. This attribute is the "dash position" of each vertex. In other words it is the
  * vertex coords (in device space) if we transform the line to be horizontal, with the start of
  * line at the origin then shifted to the right by half the off interval. The line then goes in the
  * positive x direction.
  */
 class DashingLineEffect : public GrGeometryProcessor {
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
-    static GrGeometryProcessor* Create(GrColor,
-                                       AAMode aaMode,
-                                       const SkMatrix& localMatrix,
-                                       bool usesLocalCoords);
+    static sk_sp<GrGeometryProcessor> Make(GrColor,
+                                           AAMode aaMode,
+                                           const SkMatrix& localMatrix,
+                                           bool usesLocalCoords);
 
     const char* name() const override { return "DashingEffect"; }
 
     const Attribute* inPosition() const { return fInPosition; }
 
     const Attribute* inDashParams() const { return fInDashParams; }
 
     const Attribute* inRectParams() const { return fInRectParams; }
 
     AAMode aaMode() const { return fAAMode; }
@@ skipping 151 matching lines @@
     const DashingLineEffect& de = gp.cast<DashingLineEffect>();
     uint32_t key = 0;
     key |= de.usesLocalCoords() && de.localMatrix().hasPerspective() ? 0x1 : 0x0;
     key |= de.colorIgnored() ? 0x2 : 0x0;
     key |= static_cast<int>(de.aaMode()) << 8;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrGeometryProcessor* DashingLineEffect::Create(GrColor color,
-                                               AAMode aaMode,
-                                               const SkMatrix& localMatrix,
-                                               bool usesLocalCoords) {
-    return new DashingLineEffect(color, aaMode, localMatrix, usesLocalCoords);
+sk_sp<GrGeometryProcessor> DashingLineEffect::Make(GrColor color,
+                                                   AAMode aaMode,
+                                                   const SkMatrix& localMatrix,
+                                                   bool usesLocalCoords) {
+    return sk_sp<GrGeometryProcessor>(
+        new DashingLineEffect(color, aaMode, localMatrix, usesLocalCoords));
 }
 
 void DashingLineEffect::getGLSLProcessorKey(const GrGLSLCaps& caps,
                                             GrProcessorKeyBuilder* b) const {
     GLDashingLineEffect::GenKey(*this, caps, b);
 }
 
 GrGLSLPrimitiveProcessor* DashingLineEffect::createGLSLInstance(const GrGLSLCaps&) const {
     return new GLDashingLineEffect();
 }
 
 DashingLineEffect::DashingLineEffect(GrColor color,
                                      AAMode aaMode,
                                      const SkMatrix& localMatrix,
                                      bool usesLocalCoords)
     : fColor(color)
     , fLocalMatrix(localMatrix)
     , fUsesLocalCoords(usesLocalCoords)
     , fAAMode(aaMode) {
     this->initClassID<DashingLineEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInDashParams = &this->addVertexAttrib(Attribute("inDashParams", kVec3f_GrVertexAttribType));
     fInRectParams = &this->addVertexAttrib(Attribute("inRect", kVec4f_GrVertexAttribType));
 }
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect);
 
-const GrGeometryProcessor* DashingLineEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> DashingLineEffect::TestCreate(GrProcessorTestData* d) {
     AAMode aaMode = static_cast<AAMode>(d->fRandom->nextULessThan(GrDashingEffect::kAAModeCnt));
-    return DashingLineEffect::Create(GrRandomColor(d->fRandom),
-                                     aaMode, GrTest::TestMatrix(d->fRandom),
-                                     d->fRandom->nextBool());
+    return DashingLineEffect::Make(GrRandomColor(d->fRandom),
+                                   aaMode, GrTest::TestMatrix(d->fRandom),
+                                   d->fRandom->nextBool());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-static GrGeometryProcessor* create_dash_gp(GrColor color,
-                                           AAMode aaMode,
-                                           DashCap cap,
-                                           const SkMatrix& viewMatrix,
-                                           bool usesLocalCoords) {
+static sk_sp<GrGeometryProcessor> make_dash_gp(GrColor color,
+                                               AAMode aaMode,
+                                               DashCap cap,
+                                               const SkMatrix& viewMatrix,
+                                               bool usesLocalCoords) {
     SkMatrix invert;
     if (usesLocalCoords && !viewMatrix.invert(&invert)) {
         SkDebugf("Failed to invert\n");
         return nullptr;
     }
 
     switch (cap) {
         case kRound_DashCap:
-            return DashingCircleEffect::Create(color, aaMode, invert, usesLocalCoords);
+            return DashingCircleEffect::Make(color, aaMode, invert, usesLocalCoords);
         case kNonRound_DashCap:
-            return DashingLineEffect::Create(color, aaMode, invert, usesLocalCoords);
+            return DashingLineEffect::Make(color, aaMode, invert, usesLocalCoords);
     }
     return nullptr;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 DRAW_BATCH_TEST_DEFINE(DashBatch) {
     GrColor color = GrRandomColor(random);
@@ skipping 57 matching lines @@
     p.setStrokeWidth(SkIntToScalar(1));
     p.setStrokeCap(cap);
     p.setPathEffect(GrTest::TestDashPathEffect::Make(intervals, 2, phase));
 
     GrStyle style(p);
 
     return GrDashingEffect::CreateDashLineBatch(color, viewMatrix, pts, aaMode, style);
 }
 
 #endif