sk_sp for gpu.

src/gpu/batches/GrDrawAtlasBatch.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 "GrDrawAtlasBatch.h"
 #include "GrBatchFlushState.h"
 #include "GrBatchTest.h"
@@ skipping 18 matching lines @@
     }
 
     // setup batch properties
     fColorIgnored = !overrides.readsColor();
     fColor = fGeoData[0].fColor;
     // We'd like to assert this, but we can't because of GLPrograms test
     //SkASSERT(init.readsLocalCoords());
     fCoverageIgnored = !overrides.readsCoverage();
 }
 
-static const GrGeometryProcessor* set_vertex_attributes(bool hasColors,
+static sk_sp<GrGeometryProcessor> set_vertex_attributes(bool hasColors,
                                                         GrColor color,
                                                         const SkMatrix& viewMatrix,
                                                         bool coverageIgnored) {
     using namespace GrDefaultGeoProcFactory;
     Color gpColor(color);
     if (hasColors) {
         gpColor.fType = Color::kAttribute_Type;
     }
 
     Coverage coverage(coverageIgnored ? Coverage::kNone_Type : Coverage::kSolid_Type);
     LocalCoords localCoords(LocalCoords::kHasExplicit_Type);
-    return GrDefaultGeoProcFactory::Create(gpColor, coverage, localCoords, viewMatrix);
+    return GrDefaultGeoProcFactory::Make(gpColor, coverage, localCoords, viewMatrix);
 }
 
 void GrDrawAtlasBatch::onPrepareDraws(Target* target) const {
     // Setup geometry processor
-    SkAutoTUnref<const GrGeometryProcessor> gp(set_vertex_attributes(this->hasColors(),
-                                                                     this->color(),
-                                                                     this->viewMatrix(),
-                                                                     this->coverageIgnored()));
+    sk_sp<GrGeometryProcessor> gp(set_vertex_attributes(this->hasColors(),
+                                                        this->color(),
+                                                        this->viewMatrix(),
+                                                        this->coverageIgnored()));
 
     int instanceCount = fGeoData.count();
     size_t vertexStride = gp->getVertexStride();
     SkASSERT(vertexStride == sizeof(SkPoint) + sizeof(SkPoint)
              + (this->hasColors() ? sizeof(GrColor) : 0));
 
     QuadHelper helper;
     int numQuads = this->quadCount();
     void* verts = helper.init(target, vertexStride, numQuads);
     if (!verts) {
         SkDebugf("Could not allocate vertices\n");
         return;
     }
 
     uint8_t* vertPtr = reinterpret_cast<uint8_t*>(verts);
     for (int i = 0; i < instanceCount; i++) {
         const Geometry& args = fGeoData[i];
 
         size_t allocSize = args.fVerts.count();
         memcpy(vertPtr, args.fVerts.begin(), allocSize);
         vertPtr += allocSize;
     }
-    helper.recordDraw(target, gp);
+    helper.recordDraw(target, gp.get());
 }
 
 GrDrawAtlasBatch::GrDrawAtlasBatch(const Geometry& geometry, const SkMatrix& viewMatrix,
                                    int spriteCount, const SkRSXform* xforms, const SkRect* rects,
                                    const SkColor* colors)
     : INHERITED(ClassID()) {
     SkASSERT(xforms);
     SkASSERT(rects);
 
     fViewMatrix = viewMatrix;
@@ skipping 163 matching lines @@
 
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
 
     GrDrawAtlasBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     return GrDrawAtlasBatch::Create(geometry, viewMatrix, spriteCount, xforms.begin(),
                                     texRects.begin(), hasColors ? colors.begin() : nullptr);
 }
 
 #endif