use Make instead of Create to return a shared shader

src/core/SkBitmapProcShader.cpp

 /*
  * Copyright 2011 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 "SkBitmapProcState.h"
 #include "SkBitmapProvider.h"
@@ skipping 271 matching lines @@
 SkFlattenable* SkBitmapProcShader::CreateProc(SkReadBuffer& buffer) {
     SkMatrix lm;
     buffer.readMatrix(&lm);
     SkBitmap bm;
     if (!buffer.readBitmap(&bm)) {
         return nullptr;
     }
     bm.setImmutable();
     TileMode mx = (TileMode)buffer.readUInt();
     TileMode my = (TileMode)buffer.readUInt();
-    return SkShader::CreateBitmapShader(bm, mx, my, &lm);
+    return SkShader::MakeBitmapShader(bm, mx, my, &lm).release();
 }
 
 void SkBitmapProcShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeMatrix(this->getLocalMatrix());
     buffer.writeBitmap(fRawBitmap);
     buffer.writeUInt(fTileModeX);
     buffer.writeUInt(fTileModeY);
 }
 
 bool SkBitmapProcShader::isOpaque() const {
@@ skipping 42 matching lines @@
 static bool bitmap_is_too_big(const SkBitmap& bm) {
     // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it
     // communicates between its matrix-proc and its sampler-proc. Until we can
     // widen that, we have to reject bitmaps that are larger.
     //
     static const int kMaxSize = 65535;
 
     return bm.width() > kMaxSize || bm.height() > kMaxSize;
 }
 
-SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
-                               SkShader::TileMode tmy, const SkMatrix* localMatrix,
-                               SkTBlitterAllocator* allocator) {
+sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
+                                   SkShader::TileMode tmy, const SkMatrix* localMatrix,
+                                   SkTBlitterAllocator* allocator) {
     SkShader* shader;
     SkColor color;
     if (src.isNull() || bitmap_is_too_big(src)) {
         if (nullptr == allocator) {
             shader = new SkEmptyShader;
         } else {
             shader = allocator->createT<SkEmptyShader>();
         }
     } else if (can_use_color_shader(src, &color)) {
         if (nullptr == allocator) {
             shader = new SkColorShader(color);
         } else {
             shader = allocator->createT<SkColorShader>(color);
         }
     } else {
         if (nullptr == allocator) {
             shader = new SkBitmapProcShader(src, tmx, tmy, localMatrix);
         } else {
             shader = allocator->createT<SkBitmapProcShader>(src, tmx, tmy, localMatrix);
         }
     }
-    return shader;
+    return sk_sp<SkShader>(shader);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef SK_IGNORE_TO_STRING
 void SkBitmapProcShader::toString(SkString* str) const {
     static const char* gTileModeName[SkShader::kTileModeCount] = {
         "clamp", "repeat", "mirror"
     };
 
@@ skipping 68 matching lines @@
         inner.reset(GrSimpleTextureEffect::Create(texture, matrix, params));
     }
 
     if (kAlpha_8_SkColorType == fRawBitmap.colorType()) {
         return GrFragmentProcessor::MulOutputByInputUnpremulColor(inner);
     }
     return GrFragmentProcessor::MulOutputByInputAlpha(inner);
 }
 
 #endif