sk_sp for gpu.

src/gpu/GrDefaultGeoProcFactory.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDefaultGeoProcFactory.h"
 
 #include "GrInvariantOutput.h"
+#include "SkRefCnt.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
 #include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "glsl/GrGLSLUtil.h"
 
 /*
  * The default Geometry Processor simply takes position and multiplies it by the uniform view
  * matrix. It also leaves coverage untouched.  Behind the scenes, we may add per vertex color or
  * local coords.
  */
 
 enum GPFlag {
     kColor_GPFlag =                 0x1,
     kLocalCoord_GPFlag =            0x2,
     kCoverage_GPFlag=               0x4,
     kTransformedLocalCoord_GPFlag = 0x8,
 };
 
 class DefaultGeoProc : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(uint32_t gpTypeFlags,
-                                       GrColor color,
-                                       const SkMatrix& viewMatrix,
-                                       const SkMatrix& localMatrix,
-                                       bool localCoordsWillBeRead,
-                                       bool coverageWillBeIgnored,
-                                       uint8_t coverage) {
-        return new DefaultGeoProc(gpTypeFlags, color, viewMatrix, localMatrix, coverage,
-                                  localCoordsWillBeRead, coverageWillBeIgnored);
+    static sk_sp<GrGeometryProcessor> Make(uint32_t gpTypeFlags,
+                                             GrColor color,
+                                             const SkMatrix& viewMatrix,
+                                             const SkMatrix& localMatrix,
+                                             bool localCoordsWillBeRead,
+                                             bool coverageWillBeIgnored,
+                                             uint8_t coverage) {
+        return sk_sp<GrGeometryProcessor>(new DefaultGeoProc(
+                gpTypeFlags, color, viewMatrix, localMatrix, coverage,
+                localCoordsWillBeRead, coverageWillBeIgnored));
     }
 
     const char* name() const override { return "DefaultGeometryProcessor"; }
 
     const Attribute* inPosition() const { return fInPosition; }
     const Attribute* inColor() const { return fInColor; }
     const Attribute* inLocalCoords() const { return fInLocalCoords; }
     const Attribute* inCoverage() const { return fInCoverage; }
     GrColor color() const { return fColor; }
     bool colorIgnored() const { return GrColor_ILLEGAL == fColor; }
@@ skipping 212 matching lines @@
     bool fLocalCoordsWillBeRead;
     bool fCoverageWillBeIgnored;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);
 
-const GrGeometryProcessor* DefaultGeoProc::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> DefaultGeoProc::TestCreate(GrProcessorTestData* d) {
     uint32_t flags = 0;
     if (d->fRandom->nextBool()) {
         flags |= kColor_GPFlag;
     }
     if (d->fRandom->nextBool()) {
         flags |= kCoverage_GPFlag;
     }
     if (d->fRandom->nextBool()) {
         flags |= kLocalCoord_GPFlag;
     }
     if (d->fRandom->nextBool()) {
         flags |= kTransformedLocalCoord_GPFlag;
     }
 
-    return DefaultGeoProc::Create(flags,
-                                  GrRandomColor(d->fRandom),
-                                  GrTest::TestMatrix(d->fRandom),
-                                  GrTest::TestMatrix(d->fRandom),
-                                  d->fRandom->nextBool(),
-                                  d->fRandom->nextBool(),
-                                  GrRandomCoverage(d->fRandom));
+    return DefaultGeoProc::Make(flags,
+                                GrRandomColor(d->fRandom),
+                                GrTest::TestMatrix(d->fRandom),
+                                GrTest::TestMatrix(d->fRandom),
+                                d->fRandom->nextBool(),
+                                d->fRandom->nextBool(),
+                                GrRandomCoverage(d->fRandom));
 }
 
-const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(const Color& color,
-                                                           const Coverage& coverage,
-                                                           const LocalCoords& localCoords,
-                                                           const SkMatrix& viewMatrix) {
+sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::Make(const Color& color,
+                                                         const Coverage& coverage,
+                                                         const LocalCoords& localCoords,
+                                                         const SkMatrix& viewMatrix) {
     uint32_t flags = 0;
     flags |= color.fType == Color::kAttribute_Type ? kColor_GPFlag : 0;
     flags |= coverage.fType == Coverage::kAttribute_Type ? kCoverage_GPFlag : 0;
     flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoord_GPFlag : 0;
     flags |= localCoords.fType == LocalCoords::kHasTransformed_Type ?
                                   kTransformedLocalCoord_GPFlag : 0;
 
     uint8_t inCoverage = coverage.fCoverage;
     bool coverageWillBeIgnored = coverage.fType == Coverage::kNone_Type;
     bool localCoordsWillBeRead = localCoords.fType != LocalCoords::kUnused_Type;
 
     GrColor inColor = color.fColor;
-    return DefaultGeoProc::Create(flags,
-                                  inColor,
-                                  viewMatrix,
-                                  localCoords.fMatrix ? *localCoords.fMatrix : SkMatrix::I(),
-                                  localCoordsWillBeRead,
-                                  coverageWillBeIgnored,
-                                  inCoverage);
+    return DefaultGeoProc::Make(flags,
+                                inColor,
+                                viewMatrix,
+                                localCoords.fMatrix ? *localCoords.fMatrix : SkMatrix::I(),
+                                localCoordsWillBeRead,
+                                coverageWillBeIgnored,
+                                inCoverage);
 }
 
-const GrGeometryProcessor* GrDefaultGeoProcFactory::CreateForDeviceSpace(
+sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::MakeForDeviceSpace(
                                                                      const Color& color,
                                                                      const Coverage& coverage,
                                                                      const LocalCoords& localCoords,
                                                                      const SkMatrix& viewMatrix) {
     SkMatrix invert = SkMatrix::I();
     if (LocalCoords::kUnused_Type != localCoords.fType) {
         SkASSERT(LocalCoords::kUsePosition_Type == localCoords.fType);
         if (!viewMatrix.isIdentity() && !viewMatrix.invert(&invert)) {
             SkDebugf("Could not invert\n");
             return nullptr;
         }
 
         if (localCoords.hasLocalMatrix()) {
             invert.preConcat(*localCoords.fMatrix);
         }
     }
 
     LocalCoords inverted(LocalCoords::kUsePosition_Type, &invert);
-    return Create(color, coverage, inverted, SkMatrix::I());
+    return Make(color, coverage, inverted, SkMatrix::I());
 }