switch xfermodes over to sk_sp

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(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);
-}
-
 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) {
     sk_sp<SkShader> shaderA(buffer.readShader());
     sk_sp<SkShader> shaderB(buffer.readShader());
-    SkAutoTUnref<SkXfermode> mode(buffer.readXfermode());
+    sk_sp<SkXfermode> mode(buffer.readXfermode());
     if (!shaderA || !shaderB) {
         return nullptr;
     }
-    return new SkComposeShader(std::move(shaderA), std::move(shaderB), mode);
+    return new SkComposeShader(std::move(shaderA), std::move(shaderB), std::move(mode));
 }
 
 void SkComposeShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeFlattenable(fShaderA.get());
     buffer.writeFlattenable(fShaderB.get());
-    buffer.writeFlattenable(fMode);
+    buffer.writeFlattenable(fMode.get());
 }
 
 template <typename T> void safe_call_destructor(T* obj) {
     if (obj) {
         obj->~T();
     }
 }
 
 SkShader::Context* SkComposeShader::onCreateContext(const ContextRec& rec, void* storage) const {
     char* aStorage = (char*) storage + sizeof(ComposeShaderContext);
@@ skipping 34 matching lines @@
 
 SkComposeShader::ComposeShaderContext::~ComposeShaderContext() {
     fShaderContextA->~Context();
     fShaderContextB->~Context();
 }
 
 bool SkComposeShader::asACompose(ComposeRec* rec) const {
     if (rec) {
         rec->fShaderA = fShaderA.get();
         rec->fShaderB = fShaderB.get();
-        rec->fMode = fMode;
+        rec->fMode = fMode.get();
     }
     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
 
 void SkComposeShader::ComposeShaderContext::shadeSpan(int x, int y, SkPMColor result[], int count) {
     SkShader::Context* shaderContextA = fShaderContextA;
     SkShader::Context* shaderContextB = fShaderContextB;
-    SkXfermode*        mode = static_cast<const SkComposeShader&>(fShader).fMode;
+    SkXfermode*        mode = static_cast<const SkComposeShader&>(fShader).fMode.get();
     unsigned           scale = SkAlpha255To256(this->getPaintAlpha());
 
     SkPMColor   tmp[TMP_COLOR_COUNT];
 
     if (nullptr == mode) {   // implied SRC_OVER
         // TODO: when we have a good test-case, should use SkBlitRow::Proc32
         // for these loops
         do {
             int n = count;
             if (n > TMP_COLOR_COUNT) {
@@ skipping 101 matching lines @@
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
-                                            SkXfermode* xfer) {
+                                            sk_sp<SkXfermode> xfer) {
     if (!dst || !src) {
         return nullptr;
     }
-    return sk_make_sp<SkComposeShader>(std::move(dst), std::move(src), xfer);
+    return sk_make_sp<SkComposeShader>(std::move(dst), std::move(src), std::move(xfer));
 }
 
 sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
                                             SkXfermode::Mode mode) {
-    SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(mode));
-    return MakeComposeShader(std::move(dst), std::move(src), xfer);
+    return MakeComposeShader(std::move(dst), std::move(src), SkXfermode::Make(mode));
 }