sk_sp for gpu.

src/gpu/batches/GrAAFillRectBatch.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 "GrAAFillRectBatch.h"
 
 #include "GrColor.h"
@@ skipping 26 matching lines @@
         2, 3, 7, 7, 6, 2,
         3, 0, 4, 4, 7, 3,
         4, 5, 6, 6, 7, 4,
     };
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFillAARectIdx) == kIndicesPerAAFillRect);
     return resourceProvider->findOrCreateInstancedIndexBuffer(gFillAARectIdx,
         kIndicesPerAAFillRect, kNumAAFillRectsInIndexBuffer, kVertsPerAAFillRect,
         gAAFillRectIndexBufferKey);
 }
 
-static const GrGeometryProcessor* create_fill_rect_gp(
+static sk_sp<GrGeometryProcessor> create_fill_rect_gp(
                                        const SkMatrix& viewMatrix,
                                        const GrXPOverridesForBatch& overrides,
                                        GrDefaultGeoProcFactory::LocalCoords::Type localCoordsType) {
     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 (overrides.canTweakAlphaForCoverage()) {
         coverageType = Coverage::kSolid_Type;
     } else {
         coverageType = Coverage::kAttribute_Type;
     }
     Coverage coverage(coverageType);
 
     // We assume the caller has inverted the viewmatrix
     if (LocalCoords::kHasExplicit_Type == localCoordsType) {
         LocalCoords localCoords(localCoordsType);
-        return GrDefaultGeoProcFactory::Create(color, coverage, localCoords, SkMatrix::I());
+        return GrDefaultGeoProcFactory::Make(color, coverage, localCoords, SkMatrix::I());
     } else {
         LocalCoords localCoords(overrides.readsLocalCoords() ? localCoordsType :
                                                                LocalCoords::kUnused_Type);
-        return CreateForDeviceSpace(color, coverage, localCoords, viewMatrix);
+        return MakeForDeviceSpace(color, coverage, localCoords, viewMatrix);
     }
 }
 
 static void generate_aa_fill_rect_geometry(intptr_t verts,
                                            size_t vertexStride,
                                            GrColor color,
                                            const SkMatrix& viewMatrix,
                                            const SkRect& rect,
                                            const SkRect& devRect,
                                            const GrXPOverridesForBatch& overrides,
@@ skipping 149 matching lines @@
     }
 
     static bool CanCombine(const Geometry& mine, const Geometry& theirs,
                            const GrXPOverridesForBatch& overrides) {
         // We apply the viewmatrix to the rect points on the cpu.  However, if the pipeline uses
         // local coords then we won't be able to batch.  We could actually upload the viewmatrix
         // using vertex attributes in these cases, but haven't investigated that
         return !overrides.readsLocalCoords() || mine.fViewMatrix.cheapEqualTo(theirs.fViewMatrix);
     }
 
-    static const GrGeometryProcessor* CreateGP(const Geometry& geo,
+    static sk_sp<GrGeometryProcessor> MakeGP(const Geometry& geo,
                                                const GrXPOverridesForBatch& overrides) {
-        const GrGeometryProcessor* gp =
+        sk_sp<GrGeometryProcessor> gp =
                 create_fill_rect_gp(geo.fViewMatrix, overrides,
                                     GrDefaultGeoProcFactory::LocalCoords::kUsePosition_Type);
 
         SkASSERT(overrides.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         return gp;
     }
 
@@ skipping 24 matching lines @@
                     geo.fColor,
                     geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, geo.fRect.fBottom);
         return str;
     }
 
     static bool CanCombine(const Geometry& mine, const Geometry& theirs,
                            const GrXPOverridesForBatch& overrides) {
         return true;
     }
 
-    static const GrGeometryProcessor* CreateGP(const Geometry& geo,
+    static sk_sp<GrGeometryProcessor> MakeGP(const Geometry& geo,
                                                const GrXPOverridesForBatch& overrides) {
-        const GrGeometryProcessor* gp =
+        sk_sp<GrGeometryProcessor> gp =
                 create_fill_rect_gp(geo.fViewMatrix, overrides,
                                     GrDefaultGeoProcFactory::LocalCoords::kHasExplicit_Type);
 
         SkASSERT(overrides.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordCoverage));
         return gp;
     }
@@ skipping 115 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAFillRectBatchLocalMatrix) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkMatrix localMatrix = GrTest::TestMatrix(random);
     SkRect rect = GrTest::TestRect(random);
     SkRect devRect = GrTest::TestRect(random);
     return GrAAFillRectBatch::Create(color, viewMatrix, localMatrix, rect, devRect);
 }
 
 #endif