fix memory leak, remake Imageshader to use sk_sp

src/image/SkImageShader.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 "SkBitmapProcShader.h"
 #include "SkBitmapProvider.h"
 #include "SkColorShader.h"
 #include "SkColorTable.h"
 #include "SkEmptyShader.h"
 #include "SkImage_Base.h"
 #include "SkImageShader.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
-SkImageShader::SkImageShader(const SkImage* img, TileMode tmx, TileMode tmy, const SkMatrix* matrix)
+SkImageShader::SkImageShader(sk_sp<SkImage> img, TileMode tmx, TileMode tmy, const SkMatrix* matrix)
     : INHERITED(matrix)
-    , fImage(SkRef(img))
+    , fImage(std::move(img))
     , fTileModeX(tmx)
     , fTileModeY(tmy)
 {}
 
 sk_sp<SkFlattenable> SkImageShader::CreateProc(SkReadBuffer& buffer) {
     const TileMode tx = (TileMode)buffer.readUInt();
     const TileMode ty = (TileMode)buffer.readUInt();
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
     sk_sp<SkImage> img = buffer.readImage();
     if (!img) {
         return nullptr;
     }
-    return SkImageShader::Make(img.release(), tx, ty, &matrix);
+    return SkImageShader::Make(std::move(img), tx, ty, &matrix);
 }
 
 void SkImageShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeUInt(fTileModeX);
     buffer.writeUInt(fTileModeY);
     buffer.writeMatrix(this->getLocalMatrix());
-    buffer.writeImage(fImage);
+    buffer.writeImage(fImage.get());
 }
 
 bool SkImageShader::isOpaque() const {
     return fImage->isOpaque();
 }
 
 size_t SkImageShader::onContextSize(const ContextRec& rec) const {
-    return SkBitmapProcLegacyShader::ContextSize(rec, SkBitmapProvider(fImage).info());
+    return SkBitmapProcLegacyShader::ContextSize(rec, SkBitmapProvider(fImage.get()).info());
 }
 
 SkShader::Context* SkImageShader::onCreateContext(const ContextRec& rec, void* storage) const {
     return SkBitmapProcLegacyShader::MakeContext(*this, fTileModeX, fTileModeY,
-                                           SkBitmapProvider(fImage), rec, storage);
+                                                 SkBitmapProvider(fImage.get()), rec, storage);
 }
 
 SkImage* SkImageShader::onIsAImage(SkMatrix* texM, TileMode xy[]) const {
     if (texM) {
         *texM = this->getLocalMatrix();
     }
     if (xy) {
         xy[0] = (TileMode)fTileModeX;
         xy[1] = (TileMode)fTileModeY;
     }
@@ skipping 57 matching lines @@
             const SkColorTable& ctable = *pmap.ctable();
             *color = SkUnPreMultiply::PMColorToColor(ctable[*pmap.addr8(0, 0)]);
             return true;
         }
         default: // just skip the other configs for now
             break;
     }
     return false;
 }
 
-sk_sp<SkShader> SkImageShader::Make(const SkImage* image, TileMode tx, TileMode ty,
+sk_sp<SkShader> SkImageShader::Make(sk_sp<SkImage> image, TileMode tx, TileMode ty,
                                     const SkMatrix* localMatrix,
                                     SkTBlitterAllocator* allocator) {
     SkShader* shader;
     SkColor color;
     if (!image || bitmap_is_too_big(image->width(), image->height())) {
         if (nullptr == allocator) {
             shader = new SkEmptyShader;
         } else {
             shader = allocator->createT<SkEmptyShader>();
         }
-    } else if (can_use_color_shader(image, &color)) {
+    } else if (can_use_color_shader(image.get(), &color)) {
         if (nullptr == allocator) {
             shader = new SkColorShader(color);
         } else {
             shader = allocator->createT<SkColorShader>(color);
         }
     } else {
         if (nullptr == allocator) {
             shader = new SkImageShader(image, tx, ty, localMatrix);
         } else {
             shader = allocator->createT<SkImageShader>(image, tx, ty, localMatrix);
@@ skipping 80 matching lines @@
 
 sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
                                    SkShader::TileMode tmy, const SkMatrix* localMatrix,
                                    SkCopyPixelsMode cpm, SkTBlitterAllocator* allocator) {
     // Until we learn otherwise, it seems that any caller that is passing an allocator must be
     // assuming that the returned shader will have a stack-frame lifetime, so we assert that
     // they are also asking for kNever_SkCopyPixelsMode. If that proves otherwise, we can remove
     // or modify this assert.
     SkASSERT(!allocator || (kNever_SkCopyPixelsMode == cpm));
 
-    return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, cpm, allocator).get(),
+    return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, cpm, allocator),
                                tmx, tmy, localMatrix, allocator);
 }
 
 static sk_sp<SkFlattenable> SkBitmapProcShader_CreateProc(SkReadBuffer& buffer) {
     SkMatrix lm;
     buffer.readMatrix(&lm);
     sk_sp<SkImage> image = buffer.readBitmapAsImage();
     SkShader::TileMode mx = (SkShader::TileMode)buffer.readUInt();
     SkShader::TileMode my = (SkShader::TileMode)buffer.readUInt();
     return image ? image->makeShader(mx, my, &lm) : nullptr;
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShader)
 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkImageShader)
 SkFlattenable::Register("SkBitmapProcShader", SkBitmapProcShader_CreateProc, kSkShader_Type);
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END