use Make instead of Create to return a shared shader

src/core/SkComposeShader.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkComposeShader.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
 #include "SkColorShader.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkXfermode.h"
 #include "SkString.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode) {
-    fShaderA = sA;  sA->ref();
-    fShaderB = sB;  sB->ref();
+SkComposeShader::SkComposeShader(sk_sp<SkShader> sA, sk_sp<SkShader> sB, SkXfermode* mode)
+    : fShaderA(std::move(sA))
+    , fShaderB(std::move(sB))
+{
     // mode may be null
     fMode = mode;
     SkSafeRef(mode);
 }
 
 SkComposeShader::~SkComposeShader() {
     SkSafeUnref(fMode);
-    fShaderB->unref();
-    fShaderA->unref();
 }
 
 size_t SkComposeShader::onContextSize(const ContextRec& rec) const {
     return sizeof(ComposeShaderContext)
         + fShaderA->contextSize(rec)
         + fShaderB->contextSize(rec);
 }
 
 class SkAutoAlphaRestore {
 public:
     SkAutoAlphaRestore(SkPaint* paint, uint8_t newAlpha) {
         fAlpha = paint->getAlpha();
         fPaint = paint;
         paint->setAlpha(newAlpha);
     }
 
     ~SkAutoAlphaRestore() {
         fPaint->setAlpha(fAlpha);
     }
 private:
     SkPaint*    fPaint;
     uint8_t     fAlpha;
 };
 #define SkAutoAlphaRestore(...) SK_REQUIRE_LOCAL_VAR(SkAutoAlphaRestore)
 
 SkFlattenable* SkComposeShader::CreateProc(SkReadBuffer& buffer) {
-    SkAutoTUnref<SkShader> shaderA(buffer.readShader());
-    SkAutoTUnref<SkShader> shaderB(buffer.readShader());
+    sk_sp<SkShader> shaderA(buffer.readShader());
+    sk_sp<SkShader> shaderB(buffer.readShader());
     SkAutoTUnref<SkXfermode> mode(buffer.readXfermode());
-    if (!shaderA.get() || !shaderB.get()) {
+    if (!shaderA || !shaderB) {
         return nullptr;
     }
     return new SkComposeShader(shaderA, shaderB, mode);

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

SkComposeShader(std::move(shaderA), std::move(shaderB), mode);

 }
 
 void SkComposeShader::flatten(SkWriteBuffer& buffer) const {
-    buffer.writeFlattenable(fShaderA);
-    buffer.writeFlattenable(fShaderB);
+    buffer.writeFlattenable(fShaderA.get());
+    buffer.writeFlattenable(fShaderB.get());
     buffer.writeFlattenable(fMode);
 }
 
 template <typename T> void safe_call_destructor(T* obj) {
     if (obj) {
         obj->~T();
     }
 }
 
 SkShader::Context* SkComposeShader::onCreateContext(const ContextRec& rec, void* storage) const {
@@ skipping 33 matching lines @@
     , fShaderContextA(contextA)
     , fShaderContextB(contextB) {}
 
 SkComposeShader::ComposeShaderContext::~ComposeShaderContext() {
     fShaderContextA->~Context();
     fShaderContextB->~Context();
 }
 
 bool SkComposeShader::asACompose(ComposeRec* rec) const {
     if (rec) {
-        rec->fShaderA = fShaderA;
-        rec->fShaderB = fShaderB;
+        rec->fShaderA = fShaderA.get();
+        rec->fShaderB = fShaderB.get();
         rec->fMode = fMode;
     }
     return true;
 }
 
 
 // larger is better (fewer times we have to loop), but we shouldn't
 // take up too much stack-space (each element is 4 bytes)
 #define TMP_COLOR_COUNT     64
 
@@ skipping 114 matching lines @@
     }
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer) {
+sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
+                                            SkXfermode* xfer) {
     if (!dst || !src) {
         return nullptr;
     }
-    return new SkComposeShader(dst, src, xfer);
+    return sk_make_sp<SkComposeShader>(dst, src, xfer);

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

std::move args?

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

Done.

 }
 
-SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode mode) {
+sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
+                                            SkXfermode::Mode mode) {
     SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(mode));
-    return CreateComposeShader(dst, src, xfer);
+    return MakeComposeShader(dst, src, xfer);

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

ditto

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

Done.

 }