use Make instead of Create to return a shared shader

src/core/SkPictureShader.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 "SkPictureShader.h"
 
 #include "SkBitmap.h"
@@ skipping 84 matching lines @@
 
 SkPictureShader::SkPictureShader(const SkPicture* picture, TileMode tmx, TileMode tmy,
                                  const SkMatrix* localMatrix, const SkRect* tile)
     : INHERITED(localMatrix)
     , fPicture(SkRef(picture))
     , fTile(tile ? *tile : picture->cullRect())
     , fTmx(tmx)
     , fTmy(tmy) {
 }
 
-SkShader* SkPictureShader::Create(const SkPicture* picture, TileMode tmx, TileMode tmy,
-                                         const SkMatrix* localMatrix, const SkRect* tile) {
+sk_sp<SkShader> SkPictureShader::Make(const SkPicture* picture, TileMode tmx, TileMode tmy,
+                                      const SkMatrix* localMatrix, const SkRect* tile) {
     if (!picture || picture->cullRect().isEmpty() || (tile && tile->isEmpty())) {
-        return SkShader::CreateEmptyShader();
+        return SkShader::MakeEmptyShader();
     }
-    return new SkPictureShader(picture, tmx, tmy, localMatrix, tile);
+    return sk_sp<SkShader>(new SkPictureShader(picture, tmx, tmy, localMatrix, tile));
 }
 
 SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) {
     SkMatrix lm;
     buffer.readMatrix(&lm);
     TileMode mx = (TileMode)buffer.read32();
     TileMode my = (TileMode)buffer.read32();
     SkRect tile;
     buffer.readRect(&tile);
 
     SkAutoTUnref<SkPicture> picture;
 
     if (buffer.isCrossProcess() && SkPicture::PictureIOSecurityPrecautionsEnabled()) {
         if (buffer.isVersionLT(SkReadBuffer::kPictureShaderHasPictureBool_Version)) {
             // Older code blindly serialized pictures.  We don't trust them.
             buffer.validate(false);
             return nullptr;
         }
         // Newer code won't serialize pictures in disallow-cross-process-picture mode.
         // Assert that they didn't serialize anything except a false here.
         buffer.validate(!buffer.readBool());
     } else {
         // Old code always serialized the picture.  New code writes a 'true' first if it did.
         if (buffer.isVersionLT(SkReadBuffer::kPictureShaderHasPictureBool_Version) ||
             buffer.readBool()) {
             picture.reset(SkPicture::CreateFromBuffer(buffer));
         }
     }
-    return SkPictureShader::Create(picture, mx, my, &lm, &tile);
+    return SkPictureShader::Make(picture, mx, my, &lm, &tile).release();
 }
 
 void SkPictureShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeMatrix(this->getLocalMatrix());
     buffer.write32(fTmx);
     buffer.write32(fTmy);
     buffer.writeRect(fTile);
 
     // The deserialization code won't trust that our serialized picture is safe to deserialize.
     // So write a 'false' telling it that we're not serializing a picture.
     if (buffer.isCrossProcess() && SkPicture::PictureIOSecurityPrecautionsEnabled()) {
         buffer.writeBool(false);
     } else {
         buffer.writeBool(true);
         fPicture->flatten(buffer);
     }
 }
 
-SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkMatrix* localM,
-                                           const int maxTextureSize) const {
+sk_sp<SkShader> SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkMatrix* localM,
+                                                 const int maxTextureSize) const {
     SkASSERT(fPicture && !fPicture->cullRect().isEmpty());
 
     SkMatrix m;
     m.setConcat(viewMatrix, this->getLocalMatrix());
     if (localM) {
         m.preConcat(*localM);
     }
 
     // Use a rotation-invariant scale
     SkPoint scale;
@@ skipping 26 matching lines @@
         }
     }
 #endif
 
 #ifdef SK_SUPPORT_LEGACY_PICTURESHADER_ROUNDING
     const SkISize tileSize = scaledSize.toRound();
 #else
     const SkISize tileSize = scaledSize.toCeil();
 #endif
     if (tileSize.isEmpty()) {
-        return SkShader::CreateEmptyShader();
+        return SkShader::MakeEmptyShader();
     }
 
     // The actual scale, compensating for rounding & clamping.
     const SkSize tileScale = SkSize::Make(SkIntToScalar(tileSize.width()) / fTile.width(),
                                           SkIntToScalar(tileSize.height()) / fTile.height());
 
     SkAutoTUnref<SkShader> tileShader;

[f(malita), 2016/03/08 15:50:35]

Looks like this local should also get the sk_sp facelift.  Doesn't have to be
this CL though.

[reed1, 2016/03/08 20:17:15]

Doh! Done.

     BitmapShaderKey key(fPicture->uniqueID(),
                         fTile,
                         fTmx,
                         fTmy,
                         tileScale,
                         this->getLocalMatrix());
 
     if (!SkResourceCache::Find(key, BitmapShaderRec::Visitor, &tileShader)) {
         SkMatrix tileMatrix;
         tileMatrix.setRectToRect(fTile, SkRect::MakeIWH(tileSize.width(), tileSize.height()),
                                  SkMatrix::kFill_ScaleToFit);
 
         SkAutoTUnref<SkImage> tileImage(
             SkImage::NewFromPicture(fPicture, tileSize, &tileMatrix, nullptr));
         if (!tileImage) {
             return nullptr;
         }
 
         SkMatrix shaderMatrix = this->getLocalMatrix();
         shaderMatrix.preScale(1 / tileScale.width(), 1 / tileScale.height());
         tileShader.reset(tileImage->newShader(fTmx, fTmy, &shaderMatrix));
 
         const SkImageInfo tileInfo = SkImageInfo::MakeN32Premul(tileSize);
         SkResourceCache::Add(new BitmapShaderRec(key, tileShader.get(),
                                                  tileInfo.getSafeSize(tileInfo.minRowBytes())));
     }
 
-    return tileShader.detach();
+    return sk_sp<SkShader>(tileShader.detach());
 }
 
 size_t SkPictureShader::onContextSize(const ContextRec&) const {
     return sizeof(PictureShaderContext);
 }
 
 SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const {
-    SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix));
-    if (nullptr == bitmapShader.get()) {
+    sk_sp<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix));
+    if (!bitmapShader) {
         return nullptr;
     }
     return PictureShaderContext::Create(storage, *this, rec, bitmapShader);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 SkShader::Context* SkPictureShader::PictureShaderContext::Create(void* storage,
-                   const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader) {
+                   const SkPictureShader& shader, const ContextRec& rec,
+                                                                 sk_sp<SkShader> bitmapShader) {
     PictureShaderContext* ctx = new (storage) PictureShaderContext(shader, rec, bitmapShader);

[f(malita), 2016/03/08 15:50:35]

std::move(bitmapShader)

     if (nullptr == ctx->fBitmapShaderContext) {
         ctx->~PictureShaderContext();
         ctx = nullptr;
     }
     return ctx;
 }
 
 SkPictureShader::PictureShaderContext::PictureShaderContext(
-        const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader)
+        const SkPictureShader& shader, const ContextRec& rec, sk_sp<SkShader> bitmapShader)
     : INHERITED(shader, rec)
-    , fBitmapShader(SkRef(bitmapShader))
+    , fBitmapShader(bitmapShader)

[f(malita), 2016/03/08 15:50:35]

ditto

[reed1, 2016/03/08 20:17:15]

Done, but I think I had to change the subsequent references to fBitmapShader,
since move will have killed bitmapShader (set it to null)

 {
     fBitmapShaderContextStorage = sk_malloc_throw(bitmapShader->contextSize(rec));
     fBitmapShaderContext = bitmapShader->createContext(rec, fBitmapShaderContextStorage);
     //if fBitmapShaderContext is null, we are invalid
 }
 
 SkPictureShader::PictureShaderContext::~PictureShaderContext() {
     if (fBitmapShaderContext) {
         fBitmapShaderContext->~Context();
     }
@@ skipping 36 matching lines @@
 #if SK_SUPPORT_GPU
 const GrFragmentProcessor* SkPictureShader::asFragmentProcessor(
                                                     GrContext* context,
                                                     const SkMatrix& viewM,
                                                     const SkMatrix* localMatrix,
                                                     SkFilterQuality fq) const {
     int maxTextureSize = 0;
     if (context) {
         maxTextureSize = context->caps()->maxTextureSize();
     }
-    SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize));
+    sk_sp<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize));
     if (!bitmapShader) {
         return nullptr;
     }
     return bitmapShader->asFragmentProcessor(context, viewM, nullptr, fq);
 }
 #endif