sk_sp for gpu.

src/gpu/batches/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 813 matching lines @@
         const Geometry& args = fGeoData[i];
         quadCount += gather_lines_and_quads(args.fPath, args.fViewMatrix, args.fDevClipBounds,
                                             &lines, &quads, &conics, &qSubdivs, &cWeights);
     }
 
     int lineCount = lines.count() / 2;
     int conicCount = conics.count() / 3;
 
     // do lines first
     if (lineCount) {
-        SkAutoTUnref<const GrGeometryProcessor> lineGP;
+        sk_sp<GrGeometryProcessor> lineGP;
         {
             using namespace GrDefaultGeoProcFactory;
 
             Color color(this->color());
             Coverage coverage(Coverage::kAttribute_Type);
             LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
                                     LocalCoords::kUnused_Type);
             localCoords.fMatrix = geometryProcessorLocalM;
-            lineGP.reset(GrDefaultGeoProcFactory::Create(color, coverage, localCoords,
-                                                         *geometryProcessorViewM));
+            lineGP = GrDefaultGeoProcFactory::Make(color, coverage, localCoords,
+                                                   *geometryProcessorViewM);
         }
 
         SkAutoTUnref<const GrBuffer> linesIndexBuffer(
             ref_lines_index_buffer(target->resourceProvider()));
 
         const GrBuffer* vertexBuffer;
         int firstVertex;
 
         size_t vertexStride = lineGP->getVertexStride();
         int vertexCount = kLineSegNumVertices * lineCount;
         LineVertex* verts = reinterpret_cast<LineVertex*>(
             target->makeVertexSpace(vertexStride, vertexCount, &vertexBuffer, &firstVertex));
 
         if (!verts|| !linesIndexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         SkASSERT(lineGP->getVertexStride() == sizeof(LineVertex));
 
         for (int i = 0; i < lineCount; ++i) {
             add_line(&lines[2*i], toSrc, this->coverage(), &verts);
         }
 
         GrMesh mesh;
         mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, linesIndexBuffer,
                            firstVertex, kLineSegNumVertices, kIdxsPerLineSeg, lineCount,
                            kLineSegsNumInIdxBuffer);
-        target->draw(lineGP, mesh);
+        target->draw(lineGP.get(), mesh);
     }
 
     if (quadCount || conicCount) {
-        SkAutoTUnref<const GrGeometryProcessor> quadGP(
-            GrQuadEffect::Create(this->color(),
-                                 *geometryProcessorViewM,
-                                 kHairlineAA_GrProcessorEdgeType,
-                                 target->caps(),
-                                 *geometryProcessorLocalM,
-                                 this->usesLocalCoords(),
-                                 this->coverage()));
+        sk_sp<GrGeometryProcessor> quadGP(
+            GrQuadEffect::Make(this->color(),
+                               *geometryProcessorViewM,
+                               kHairlineAA_GrProcessorEdgeType,
+                               target->caps(),
+                               *geometryProcessorLocalM,
+                               this->usesLocalCoords(),
+                               this->coverage()));
 
-        SkAutoTUnref<const GrGeometryProcessor> conicGP(
-            GrConicEffect::Create(this->color(),
-                                  *geometryProcessorViewM,
-                                  kHairlineAA_GrProcessorEdgeType,
-                                  target->caps(),
-                                  *geometryProcessorLocalM,
-                                  this->usesLocalCoords(),
-                                  this->coverage()));
+        sk_sp<GrGeometryProcessor> conicGP(
+            GrConicEffect::Make(this->color(),
+                                *geometryProcessorViewM,
+                                kHairlineAA_GrProcessorEdgeType,
+                                target->caps(),
+                                *geometryProcessorLocalM,
+                                this->usesLocalCoords(),
+                                this->coverage()));
 
         const GrBuffer* vertexBuffer;
         int firstVertex;
 
         SkAutoTUnref<const GrBuffer> quadsIndexBuffer(
             ref_quads_index_buffer(target->resourceProvider()));
 
         size_t vertexStride = sizeof(BezierVertex);
         int vertexCount = kQuadNumVertices * quadCount + kQuadNumVertices * conicCount;
         void *vertices = target->makeVertexSpace(vertexStride, vertexCount,
@@ skipping 16 matching lines @@
         // Start Conics
         for (int i = 0; i < conicCount; ++i) {
             add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &bezVerts);
         }
 
         if (quadCount > 0) {
             GrMesh mesh;
             mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
                                firstVertex, kQuadNumVertices, kIdxsPerQuad, quadCount,
                                kQuadsNumInIdxBuffer);
-            target->draw(quadGP, mesh);
+            target->draw(quadGP.get(), mesh);
             firstVertex += quadCount * kQuadNumVertices;
         }
 
         if (conicCount > 0) {
             GrMesh mesh;
             mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
                                firstVertex, kQuadNumVertices, kIdxsPerQuad, conicCount,
                                kQuadsNumInIdxBuffer);
-            target->draw(conicGP, mesh);
+            target->draw(conicGP.get(), mesh);
         }
     }
 }
 
 static GrDrawBatch* create_hairline_batch(GrColor color,
                                           const SkMatrix& viewMatrix,
                                           const SkPath& path,
                                           const GrStyle& style,
                                           const SkIRect& devClipBounds) {
     SkScalar hairlineCoverage;
@@ skipping 39 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAHairlineBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     SkPath path = GrTest::TestPath(random);
     SkIRect devClipBounds;
     devClipBounds.setEmpty();
     return create_hairline_batch(color, viewMatrix, path, GrStyle::SimpleHairline(), devClipBounds);
 }
 
 #endif