sk_sp for gpu.

src/gpu/batches/GrMSAAPathRenderer.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrMSAAPathRenderer.h"
 
 #include "GrAuditTrail.h"
@@ skipping 66 matching lines @@
 };
 
 static inline void append_contour_edge_indices(uint16_t fanCenterIdx,
                                                uint16_t edgeV0Idx,
                                                MSAALineVertices& lines) {
     *(lines.nextIndex++) = fanCenterIdx;
     *(lines.nextIndex++) = edgeV0Idx;
     *(lines.nextIndex++) = edgeV0Idx + 1;
 }
 
-static inline void add_quad(MSAALineVertices& lines, MSAAQuadVertices& quads, const SkPoint pts[], 
+static inline void add_quad(MSAALineVertices& lines, MSAAQuadVertices& quads, const SkPoint pts[],
                             SkColor color, bool indexed, uint16_t subpathLineIdxStart) {
     SkASSERT(lines.nextVertex < lines.verticesEnd);
     *lines.nextVertex = { pts[2], color };
     if (indexed) {
         int prevIdx = (uint16_t) (lines.nextVertex - lines.vertices - 1);
         if (prevIdx > subpathLineIdxStart) {
             append_contour_edge_indices(subpathLineIdxStart, prevIdx, lines);
         }
     }
     lines.nextVertex++;
@@ skipping 39 matching lines @@
 
             // emit attributes
             varyingHandler->emitAttributes(qp);
             varyingHandler->addPassThroughAttribute(qp.inColor(), args.fOutputColor);
 
             GrGLSLVertToFrag uv(kVec2f_GrSLType);
             varyingHandler->addVarying("uv", &uv, kHigh_GrSLPrecision);
             vsBuilder->codeAppendf("%s = %s;", uv.vsOut(), qp.inUV()->fName);
 
             // Setup position
-            this->setupPosition(vsBuilder, uniformHandler, gpArgs, qp.inPosition()->fName, 
+            this->setupPosition(vsBuilder, uniformHandler, gpArgs, qp.inPosition()->fName,
                                 qp.viewMatrix(), &fViewMatrixUniform);
 
             // emit transforms
-            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar, 
-                                 qp.inPosition()->fName, SkMatrix::I(), args.fTransformsIn, 
+            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
+                                 qp.inPosition()->fName, SkMatrix::I(), args.fTransformsIn,
                                  args.fTransformsOut);
 
             GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
-            fsBuilder->codeAppendf("if (%s.x * %s.x >= %s.y) discard;", uv.fsIn(), uv.fsIn(), 
+            fsBuilder->codeAppendf("if (%s.x * %s.x >= %s.y) discard;", uv.fsIn(), uv.fsIn(),
                                                                         uv.fsIn());
             fsBuilder->codeAppendf("%s = vec4(1.0);", args.fOutputCoverage);
         }
 
         static inline void GenKey(const GrGeometryProcessor& gp,
                                   const GrGLSLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const MSAAQuadProcessor& qp = gp.cast<MSAAQuadProcessor>();
             uint32_t key = 0;
             key |= qp.viewMatrix().hasPerspective() ? 0x1 : 0x0;
@@ skipping 30 matching lines @@
     }
 
     virtual GrGLSLPrimitiveProcessor* createGLSLInstance(const GrGLSLCaps&) const override {
         return new GLSLProcessor(*this);
     }
 
 private:
     MSAAQuadProcessor(const SkMatrix& viewMatrix)
         : fViewMatrix(viewMatrix) {
         this->initClassID<MSAAQuadProcessor>();
-        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType, 
+        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                        kHigh_GrSLPrecision));
-        fInUV = &this->addVertexAttrib(Attribute("inUV", kVec2f_GrVertexAttribType, 
+        fInUV = &this->addVertexAttrib(Attribute("inUV", kVec2f_GrVertexAttribType,
                                                  kHigh_GrSLPrecision));
         fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
         this->setSampleShading(1.0f);
     }
 
     const Attribute* fInPosition;
     const Attribute* fInUV;
     const Attribute* fInColor;
     SkMatrix         fViewMatrix;
-    
+
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 class MSAAPathBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     struct Geometry {
         GrColor fColor;
         SkPath fPath;
         SkScalar fTolerance;
     };
 
-    static MSAAPathBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix, 
+    static MSAAPathBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix,
                                const SkRect& devBounds) {
         return new MSAAPathBatch(geometry, viewMatrix, devBounds);
     }
 
     const char* name() const override { return "MSAAPathBatch"; }
 
-    void computePipelineOptimizations(GrInitInvariantOutput* color, 
+    void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setKnownSingleComponent(0xff);
     }
 
     bool isValid() const {
         return !fIsIndexed || fMaxLineIndices <= SK_MaxU16;
     }
 
 private:
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle any color overrides
         if (!overrides.readsColor()) {
             fGeoData[0].fColor = GrColor_ILLEGAL;
         }
         overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
     }
 
-    void computeWorstCasePointCount(const SkPath& path, int* subpaths, SkScalar tol, 
+    void computeWorstCasePointCount(const SkPath& path, int* subpaths, SkScalar tol,
                                     int* outLinePointCount, int* outQuadPointCount) const {
         int linePointCount = 0;
         int quadPointCount = 0;
         *subpaths = 1;
 
         bool first = true;
 
         SkPath::Iter iter(path, false);
         SkPath::Verb verb;
 
@@ skipping 38 matching lines @@
         *outQuadPointCount = quadPointCount;
     }
 
     void onPrepareDraws(Target* target) const override {
         SkASSERT(this->isValid());
         if (fMaxLineVertices == 0) {
             SkASSERT(fMaxQuadVertices == 0);
             return;
         }
 
-        GrPrimitiveType primitiveType = fIsIndexed ? kTriangles_GrPrimitiveType 
+        GrPrimitiveType primitiveType = fIsIndexed ? kTriangles_GrPrimitiveType
                                                    : kTriangleFan_GrPrimitiveType;
 
         // allocate vertex / index buffers
         const GrBuffer* lineVertexBuffer;
         int firstLineVertex;
         MSAALineVertices lines;
         size_t lineVertexStride = sizeof(MSAALineVertices::Vertex);
-        lines.vertices = (MSAALineVertices::Vertex*) target->makeVertexSpace(lineVertexStride, 
+        lines.vertices = (MSAALineVertices::Vertex*) target->makeVertexSpace(lineVertexStride,
                                                                              fMaxLineVertices,
-                                                                             &lineVertexBuffer, 
+                                                                             &lineVertexBuffer,
                                                                              &firstLineVertex);
         if (!lines.vertices) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
         lines.nextVertex = lines.vertices;
         SkDEBUGCODE(lines.verticesEnd = lines.vertices + fMaxLineVertices;)
 
         MSAAQuadVertices quads;
         size_t quadVertexStride = sizeof(MSAAQuadVertices::Vertex);
         SkAutoFree quadVertexPtr(sk_malloc_throw(fMaxQuadVertices * quadVertexStride));
         quads.vertices = (MSAAQuadVertices::Vertex*) quadVertexPtr.get();
         quads.nextVertex = quads.vertices;
         SkDEBUGCODE(quads.verticesEnd = quads.vertices + fMaxQuadVertices;)
 
         const GrBuffer* lineIndexBuffer = nullptr;
         int firstLineIndex;
         if (fIsIndexed) {
-            lines.indices = target->makeIndexSpace(fMaxLineIndices, &lineIndexBuffer, 
+            lines.indices = target->makeIndexSpace(fMaxLineIndices, &lineIndexBuffer,
                                                    &firstLineIndex);
             if (!lines.indices) {
                 SkDebugf("Could not allocate indices\n");
                 return;
             }
             lines.nextIndex = lines.indices;
         } else {
             lines.indices = nullptr;
             lines.nextIndex = nullptr;
         }
@@ skipping 23 matching lines @@
             }
         }
         int lineVertexOffset = (int) (lines.nextVertex - lines.vertices);
         int lineIndexOffset = (int) (lines.nextIndex - lines.indices);
         SkASSERT(lineVertexOffset <= fMaxLineVertices && lineIndexOffset <= fMaxLineIndices);
         int quadVertexOffset = (int) (quads.nextVertex - quads.vertices);
         int quadIndexOffset = (int) (quads.nextIndex - quads.indices);
         SkASSERT(quadVertexOffset <= fMaxQuadVertices && quadIndexOffset <= fMaxQuadIndices);
 
         if (lineVertexOffset) {
-            SkAutoTUnref<const GrGeometryProcessor> lineGP;
+            sk_sp<GrGeometryProcessor> lineGP;
             {
                 using namespace GrDefaultGeoProcFactory;
-                lineGP.reset(GrDefaultGeoProcFactory::Create(Color(Color::kAttribute_Type), 
-                                                             Coverage(255),
-                                                             LocalCoords(LocalCoords::kUnused_Type), 
-                                                             fViewMatrix));
+                lineGP = GrDefaultGeoProcFactory::Make(Color(Color::kAttribute_Type),
+                                                       Coverage(255),
+                                                       LocalCoords(LocalCoords::kUnused_Type),
+                                                       fViewMatrix);
             }
             SkASSERT(lineVertexStride == lineGP->getVertexStride());
 
             GrMesh lineMeshes;
             if (fIsIndexed) {
-                lineMeshes.initIndexed(primitiveType, lineVertexBuffer, lineIndexBuffer, 
-                                         firstLineVertex, firstLineIndex, lineVertexOffset, 
+                lineMeshes.initIndexed(primitiveType, lineVertexBuffer, lineIndexBuffer,
+                                         firstLineVertex, firstLineIndex, lineVertexOffset,
                                          lineIndexOffset);
             } else {
-                lineMeshes.init(primitiveType, lineVertexBuffer, firstLineVertex, 
+                lineMeshes.init(primitiveType, lineVertexBuffer, firstLineVertex,
                                   lineVertexOffset);
             }
-            target->draw(lineGP, lineMeshes);
+            target->draw(lineGP.get(), lineMeshes);
         }
 
         if (quadVertexOffset) {
             SkAutoTUnref<const GrGeometryProcessor> quadGP(MSAAQuadProcessor::Create(fViewMatrix));
             SkASSERT(quadVertexStride == quadGP->getVertexStride());
 
             const GrBuffer* quadVertexBuffer;
             int firstQuadVertex;
-            MSAAQuadVertices::Vertex* quadVertices = (MSAAQuadVertices::Vertex*) 
+            MSAAQuadVertices::Vertex* quadVertices = (MSAAQuadVertices::Vertex*)
                     target->makeVertexSpace(quadVertexStride, quadVertexOffset, &quadVertexBuffer,
                                             &firstQuadVertex);
             memcpy(quadVertices, quads.vertices, quadVertexStride * quadVertexOffset);
             GrMesh quadMeshes;
             if (fIsIndexed) {
                 const GrBuffer* quadIndexBuffer;
                 int firstQuadIndex;
-                uint16_t* quadIndices = (uint16_t*) target->makeIndexSpace(quadIndexOffset, 
-                                                                           &quadIndexBuffer, 
+                uint16_t* quadIndices = (uint16_t*) target->makeIndexSpace(quadIndexOffset,
+                                                                           &quadIndexBuffer,
                                                                            &firstQuadIndex);
                 memcpy(quadIndices, quads.indices, sizeof(uint16_t) * quadIndexOffset);
-                quadMeshes.initIndexed(kTriangles_GrPrimitiveType, quadVertexBuffer, 
-                                       quadIndexBuffer, firstQuadVertex, firstQuadIndex, 
+                quadMeshes.initIndexed(kTriangles_GrPrimitiveType, quadVertexBuffer,
+                                       quadIndexBuffer, firstQuadVertex, firstQuadIndex,
                                        quadVertexOffset, quadIndexOffset);
             } else {
-                quadMeshes.init(kTriangles_GrPrimitiveType, quadVertexBuffer, firstQuadVertex, 
+                quadMeshes.init(kTriangles_GrPrimitiveType, quadVertexBuffer, firstQuadVertex,
                                 quadVertexOffset);
             }
             target->draw(quadGP, quadMeshes);
         }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
     MSAAPathBatch(const Geometry& geometry, const SkMatrix& viewMatrix, const SkRect& devBounds)
         : INHERITED(ClassID())
         , fViewMatrix(viewMatrix) {
         fGeoData.push_back(geometry);
         this->setBounds(devBounds);
         int contourCount;
-        this->computeWorstCasePointCount(geometry.fPath, &contourCount, kTolerance, 
+        this->computeWorstCasePointCount(geometry.fPath, &contourCount, kTolerance,
                                          &fMaxLineVertices, &fMaxQuadVertices);
         fMaxLineIndices = fMaxLineVertices * 3;
         fMaxQuadIndices = fMaxQuadVertices * 3;
         fIsIndexed = contourCount > 1;
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         MSAAPathBatch* that = t->cast<MSAAPathBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                      that->bounds(), caps)) {
             return false;
         }
 
         if (!fViewMatrix.cheapEqualTo(that->fViewMatrix)) {
             return false;
         }
 
-        if ((fMaxLineIndices + that->fMaxLineIndices > SK_MaxU16) || 
+        if ((fMaxLineIndices + that->fMaxLineIndices > SK_MaxU16) ||
             (fMaxQuadIndices + that->fMaxQuadIndices > SK_MaxU16)) {
             return false;
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
         this->joinBounds(that->bounds());
         fIsIndexed = true;
         fMaxLineVertices += that->fMaxLineVertices;
         fMaxQuadVertices += that->fMaxQuadVertices;
         fMaxLineIndices += that->fMaxLineIndices;
@@ skipping 34 matching lines @@
                             if (prevIdx > subpathIdxStart) {
                                 append_contour_edge_indices(subpathIdxStart, prevIdx, lines);
                             }
                         }
                         SkASSERT(lines.nextVertex < lines.verticesEnd);
                         *(lines.nextVertex++) = { pts[1], color };
                         break;
                     case SkPath::kConic_Verb: {
                         SkScalar weight = iter.conicWeight();
                         SkAutoConicToQuads converter;
-                        const SkPoint* quadPts = converter.computeQuads(pts, weight, 
+                        const SkPoint* quadPts = converter.computeQuads(pts, weight,
                                                                         kTolerance);
                         for (int i = 0; i < converter.countQuads(); ++i) {
-                            add_quad(lines, quads, quadPts + i * 2, color, isIndexed, 
+                            add_quad(lines, quads, quadPts + i * 2, color, isIndexed,
                                      subpathIdxStart);
                         }
                         break;
                     }
                     case SkPath::kQuad_Verb: {
                         add_quad(lines, quads, pts, color, isIndexed, subpathIdxStart);
-                        break;                        
+                        break;
                     }
                     case SkPath::kCubic_Verb: {
                         SkSTArray<15, SkPoint, true> quadPts;
                         GrPathUtils::convertCubicToQuads(pts, kTolerance, &quadPts);
                         int count = quadPts.count();
                         for (int i = 0; i < count; i += 3) {
                             add_quad(lines, quads, &quadPts[i], color, isIndexed, subpathIdxStart);
                         }
                         break;
                     }
@@ skipping 127 matching lines @@
                 pipelineBuilder.setUserStencil(userStencilSettings);
             }
 
             drawContext->drawBatch(pipelineBuilder, clip, batch);
         } else {
             MSAAPathBatch::Geometry geometry;
             geometry.fColor = color;
             geometry.fPath = path;
             geometry.fTolerance = kTolerance;
 
-            SkAutoTUnref<MSAAPathBatch> batch(MSAAPathBatch::Create(geometry, viewMatrix, 
+            SkAutoTUnref<MSAAPathBatch> batch(MSAAPathBatch::Create(geometry, viewMatrix,
                                                                     devBounds));
             if (!batch->isValid()) {
                 return false;
             }
 
             GrPipelineBuilder pipelineBuilder(paint, drawContext->mustUseHWAA(paint));
             pipelineBuilder.setDrawFace(drawFace[p]);
             if (passes[p]) {
                 pipelineBuilder.setUserStencil(passes[p]);
             } else {
@@ skipping 46 matching lines @@
                                   false);
 }
 
 void GrMSAAPathRenderer::onStencilPath(const StencilPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fDrawContext->auditTrail(),
                               "GrMSAAPathRenderer::onStencilPath");
     SkASSERT(SkPath::kInverseEvenOdd_FillType != args.fPath->getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != args.fPath->getFillType());
 
     GrPaint paint;
-    SkSafeUnref(paint.setXPFactory(GrDisableColorXPFactory::Create()));
+    paint.setXPFactory(GrDisableColorXPFactory::Make());
     paint.setAntiAlias(args.fIsAA);
 
     this->internalDrawPath(args.fDrawContext,
                            paint,
                            &GrUserStencilSettings::kUnused,
                            *args.fClip,
                            GrColor_WHITE,
                            *args.fViewMatrix,
                            *args.fPath,
                            true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////