sk_sp for gpu.

src/gpu/batches/GrAAStrokeRectBatch.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAStrokeRectBatch.h"
 
 #include "GrBatchFlushState.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrResourceKey.h"
 #include "GrResourceProvider.h"
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gMiterIndexBufferKey);
 GR_DECLARE_STATIC_UNIQUE_KEY(gBevelIndexBufferKey);
 
 static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
                     r.fRight - dx, r.fBottom - dy, stride);
 }
 
-static const GrGeometryProcessor* create_stroke_rect_gp(bool tweakAlphaForCoverage,
+static sk_sp<GrGeometryProcessor> create_stroke_rect_gp(bool tweakAlphaForCoverage,
                                                         const SkMatrix& viewMatrix,
                                                         bool usesLocalCoords,
                                                         bool coverageIgnored) {
     using namespace GrDefaultGeoProcFactory;
 
     Color color(Color::kAttribute_Type);
     Coverage::Type coverageType;
     // TODO remove coverage if coverage is ignored
     /*if (coverageIgnored) {
         coverageType = Coverage::kNone_Type;
     } else*/ if (tweakAlphaForCoverage) {
         coverageType = Coverage::kSolid_Type;
     } else {
         coverageType = Coverage::kAttribute_Type;
     }
     Coverage coverage(coverageType);
     LocalCoords localCoords(usesLocalCoords ? LocalCoords::kUsePosition_Type :
                                               LocalCoords::kUnused_Type);
-    return CreateForDeviceSpace(color, coverage, localCoords, viewMatrix);
+    return MakeForDeviceSpace(color, coverage, localCoords, viewMatrix);
 }
 
 class AAStrokeRectBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     // TODO support AA rotated stroke rects by copying around view matrices
     struct Geometry {
         SkRect fDevOutside;
         SkRect fDevOutsideAssist;
@@ skipping 122 matching lines @@
     fBatch.fColorIgnored = !overrides.readsColor();
     fBatch.fColor = fGeoData[0].fColor;
     fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
     fBatch.fCoverageIgnored = !overrides.readsCoverage();
     fBatch.fCanTweakAlphaForCoverage = overrides.canTweakAlphaForCoverage();
 }
 
 void AAStrokeRectBatch::onPrepareDraws(Target* target) const {
     bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
-    SkAutoTUnref<const GrGeometryProcessor> gp(create_stroke_rect_gp(canTweakAlphaForCoverage,
-                                                                     this->viewMatrix(),
-                                                                     this->usesLocalCoords(),
-                                                                     this->coverageIgnored()));
+    sk_sp<GrGeometryProcessor> gp(create_stroke_rect_gp(canTweakAlphaForCoverage,
+                                                        this->viewMatrix(),
+                                                        this->usesLocalCoords(),
+                                                        this->coverageIgnored()));
     if (!gp) {
         SkDebugf("Couldn't create GrGeometryProcessor\n");
         return;
     }
 
     size_t vertexStride = gp->getVertexStride();
 
     SkASSERT(canTweakAlphaForCoverage ?
              vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
              vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
@@ skipping 22 matching lines @@
                                            outerVertexNum,
                                            innerVertexNum,
                                            args.fColor,
                                            args.fDevOutside,
                                            args.fDevOutsideAssist,
                                            args.fDevInside,
                                            fMiterStroke,
                                            args.fDegenerate,
                                            canTweakAlphaForCoverage);
     }
-    helper.recordDraw(target, gp);
+    helper.recordDraw(target, gp.get());
 }
 
 const GrBuffer* AAStrokeRectBatch::GetIndexBuffer(GrResourceProvider* resourceProvider,
                                                   bool miterStroke) {
 
     if (miterStroke) {
         static const uint16_t gMiterIndices[] = {
             0 + 0, 1 + 0, 5 + 0, 5 + 0, 4 + 0, 0 + 0,
             1 + 0, 2 + 0, 6 + 0, 6 + 0, 5 + 0, 1 + 0,
             2 + 0, 3 + 0, 7 + 0, 7 + 0, 6 + 0, 2 + 0,
@@ skipping 410 matching lines @@
     SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
     rec.setStrokeStyle(strokeWidth);
     rec.setStrokeParams(SkPaint::kButt_Cap,
                         miterStroke ? SkPaint::kMiter_Join : SkPaint::kBevel_Join,
                         1.f);
     SkMatrix matrix = GrTest::TestMatrixRectStaysRect(random);
     return GrAAStrokeRectBatch::Create(color, matrix, rect, rec);
 }
 
 #endif