sk_sp for gpu.

gm/beziereffects.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This test only works with the GPU backend.
 
 #include "gm.h"
@@ skipping 16 matching lines @@
 }
 
 namespace skiagm {
 
 class BezierCubicOrConicTestBatch : public GrTestBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     const char* name() const override { return "BezierCubicOrConicTestBatch"; }
 
-    BezierCubicOrConicTestBatch(const GrGeometryProcessor* gp, const SkRect& bounds,
+    BezierCubicOrConicTestBatch(sk_sp<GrGeometryProcessor> gp, const SkRect& bounds,
                                 GrColor color, const SkScalar klmEqs[9], SkScalar sign)
         : INHERITED(ClassID(), bounds, color)
-        , fGeometryProcessor(SkRef(gp)) {
+        , fGeometryProcessor(std::move(gp)) {
         for (int i = 0; i < 9; i++) {
             fKlmEqs[i] = klmEqs[i];
         }
         fSign = sign;
     }
 
 private:
 
     struct Vertex {
         SkPoint fPosition;
         float   fKLM[4]; // The last value is ignored. The effect expects a vec4f.
     };
 
     void onPrepareDraws(Target* target) const override {
         QuadHelper helper;
         size_t vertexStride = fGeometryProcessor->getVertexStride();
         SkASSERT(vertexStride == sizeof(Vertex));
         Vertex* verts = reinterpret_cast<Vertex*>(helper.init(target, vertexStride, 1));
         if (!verts) {
             return;
         }
         const SkRect& bounds = this->bounds();
         verts[0].fPosition.setRectFan(bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom,
                                       sizeof(Vertex));
         for (int v = 0; v < 4; ++v) {
             verts[v].fKLM[0] = eval_line(verts[v].fPosition, fKlmEqs + 0, fSign);
             verts[v].fKLM[1] = eval_line(verts[v].fPosition, fKlmEqs + 3, fSign);
             verts[v].fKLM[2] = eval_line(verts[v].fPosition, fKlmEqs + 6, 1.f);
         }
-        helper.recordDraw(target, fGeometryProcessor);
+        helper.recordDraw(target, fGeometryProcessor.get());
     }
 
-    SkScalar                                fKlmEqs[9];
-    SkScalar                                fSign;
-    SkAutoTUnref<const GrGeometryProcessor> fGeometryProcessor;
+    SkScalar                   fKlmEqs[9];
+    SkScalar                   fSign;
+    sk_sp<GrGeometryProcessor> fGeometryProcessor;
 
     static const int kVertsPerCubic = 4;
     static const int kIndicesPerCubic = 6;
 
     typedef GrTestBatch INHERITED;
 };
 
 /**
  * This GM directly exercises effects that draw Bezier curves in the GPU backend.
  */
@@ skipping 42 matching lines @@
         static const GrColor color = 0xff000000;
 
         for (int i = 0; i < kNumCubics; ++i) {
             SkPoint baseControlPts[] = {
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
             };
             for(int edgeType = 0; edgeType < kGrProcessorEdgeTypeCnt; ++edgeType) {
-                SkAutoTUnref<GrGeometryProcessor> gp;
+                sk_sp<GrGeometryProcessor> gp;
                 GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)edgeType;
-                gp.reset(GrCubicEffect::Create(color, SkMatrix::I(), et,
-                                               *context->caps()));
+                gp = GrCubicEffect::Make(color, SkMatrix::I(), et, *context->caps());
                 if (!gp) {
                     continue;
                 }
                 SkScalar x = SkScalarMul(col, w);
                 SkScalar y = SkScalarMul(row, h);
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
                     {x + baseControlPts[2].fX, y + baseControlPts[2].fY},
                     {x + baseControlPts[3].fX, y + baseControlPts[3].fY}
@@ skipping 32 matching lines @@
                     bounds.set(pts, 4);
 
                     SkPaint boundsPaint;
                     boundsPaint.setColor(0xff808080);
                     boundsPaint.setStrokeWidth(0);
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPipelineBuilder pipelineBuilder;
                     pipelineBuilder.setXPFactory(
-                        GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
+                        GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
                     SkAutoTUnref<GrDrawBatch> batch(
                         new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, klmSigns[c]));
 
                     drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
                     ++row;
@@ skipping 57 matching lines @@
         static const GrColor color = 0xff000000;
 
         for (int i = 0; i < kNumConics; ++i) {
             SkPoint baseControlPts[] = {
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
             };
             SkScalar weight = rand.nextRangeF(0.f, 2.f);
             for(int edgeType = 0; edgeType < kGrProcessorEdgeTypeCnt; ++edgeType) {
-                SkAutoTUnref<GrGeometryProcessor> gp;
+                sk_sp<GrGeometryProcessor> gp;
                 GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)edgeType;
-                gp.reset(GrConicEffect::Create(color, SkMatrix::I(), et,
-                                               *context->caps(), SkMatrix::I(), false));
+                gp = GrConicEffect::Make(color, SkMatrix::I(), et,
+                                         *context->caps(), SkMatrix::I(), false);
                 if (!gp) {
                     continue;
                 }
 
                 SkScalar x = SkScalarMul(col, w);
                 SkScalar y = SkScalarMul(row, h);
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
                     {x + baseControlPts[2].fX, y + baseControlPts[2].fY}
@@ skipping 30 matching lines @@
                     bounds.set(pts, 3);
 
                     SkPaint boundsPaint;
                     boundsPaint.setColor(0xff808080);
                     boundsPaint.setStrokeWidth(0);
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPipelineBuilder pipelineBuilder;
                     pipelineBuilder.setXPFactory(
-                        GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
+                        GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
                     SkAutoTUnref<GrDrawBatch> batch(
                         new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, 1.f));
 
                     drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
                     ++row;
@@ skipping 43 matching lines @@
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 class BezierQuadTestBatch : public GrTestBatch {
 public:
     DEFINE_BATCH_CLASS_ID
     const char* name() const override { return "BezierQuadTestBatch"; }
 
-    BezierQuadTestBatch(const GrGeometryProcessor* gp, const SkRect& bounds, GrColor color,
+    BezierQuadTestBatch(sk_sp<GrGeometryProcessor> gp, const SkRect& bounds, GrColor color,
                         const GrPathUtils::QuadUVMatrix& devToUV)
         : INHERITED(ClassID(), bounds, color)
         , fDevToUV(devToUV)
-        , fGeometryProcessor(SkRef(gp)) {
+        , fGeometryProcessor(std::move(gp)) {
     }
 
 private:
 
     struct Vertex {
         SkPoint fPosition;
         float   fKLM[4]; // The last value is ignored. The effect expects a vec4f.
     };
 
     void onPrepareDraws(Target* target) const override {
         QuadHelper helper;
         size_t vertexStride = fGeometryProcessor->getVertexStride();
         SkASSERT(vertexStride == sizeof(Vertex));
         Vertex* verts = reinterpret_cast<Vertex*>(helper.init(target, vertexStride, 1));
         if (!verts) {
             return;
         }
         const SkRect& bounds = this->bounds();
         verts[0].fPosition.setRectFan(bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom,
                                       sizeof(Vertex));
         fDevToUV.apply<4, sizeof(Vertex), sizeof(SkPoint)>(verts);
-        helper.recordDraw(target, fGeometryProcessor);
+        helper.recordDraw(target, fGeometryProcessor.get());
     }
 
-    GrPathUtils::QuadUVMatrix               fDevToUV;
-    SkAutoTUnref<const GrGeometryProcessor> fGeometryProcessor;
+    GrPathUtils::QuadUVMatrix  fDevToUV;
+    sk_sp<GrGeometryProcessor> fGeometryProcessor;
 
     static const int kVertsPerCubic = 4;
     static const int kIndicesPerCubic = 6;
 
     typedef GrTestBatch INHERITED;
 };
 
 /**
  * This GM directly exercises effects that draw Bezier quad curves in the GPU backend.
  */
@@ skipping 41 matching lines @@
         int col = 0;
         static const GrColor color = 0xff000000;
 
         for (int i = 0; i < kNumQuads; ++i) {
             SkPoint baseControlPts[] = {
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
             };
             for(int edgeType = 0; edgeType < kGrProcessorEdgeTypeCnt; ++edgeType) {
-                SkAutoTUnref<GrGeometryProcessor> gp;
+                sk_sp<GrGeometryProcessor> gp;
                 GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)edgeType;
-                gp.reset(GrQuadEffect::Create(color, SkMatrix::I(), et,
-                                              *context->caps(), SkMatrix::I(), false));
+                gp = GrQuadEffect::Make(color, SkMatrix::I(), et,
+                                        *context->caps(), SkMatrix::I(), false);
                 if (!gp) {
                     continue;
                 }
 
                 SkScalar x = SkScalarMul(col, w);
                 SkScalar y = SkScalarMul(row, h);
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
                     {x + baseControlPts[2].fX, y + baseControlPts[2].fY}
@@ skipping 27 matching lines @@
                     bounds.set(pts, 3);
 
                     SkPaint boundsPaint;
                     boundsPaint.setColor(0xff808080);
                     boundsPaint.setStrokeWidth(0);
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPipelineBuilder pipelineBuilder;
                     pipelineBuilder.setXPFactory(
-                        GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
+                        GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
                     GrPathUtils::QuadUVMatrix DevToUV(pts);
 
                     SkAutoTUnref<GrDrawBatch> batch(
                         new BezierQuadTestBatch(gp, bounds, color, DevToUV));
 
                     drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
                     ++row;
                 }
             }
         }
     }
 
 private:
     typedef GM INHERITED;
 };
 
 DEF_GM(return new BezierCubicEffects;)
 DEF_GM(return new BezierConicEffects;)
 DEF_GM(return new BezierQuadEffects;)
 }
 
 #endif