sk_sp for gpu.

src/gpu/effects/GrXfermodeFragmentProcessor.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 "effects/GrXfermodeFragmentProcessor.h"
 
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "effects/GrConstColorProcessor.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLBlend.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "SkGrPriv.h"
 
 class ComposeTwoFragmentProcessor : public GrFragmentProcessor {
 public:
-    ComposeTwoFragmentProcessor(const GrFragmentProcessor* src, const GrFragmentProcessor* dst,
-                    SkXfermode::Mode mode)
+    ComposeTwoFragmentProcessor(sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst,
+                                SkXfermode::Mode mode)
         : fMode(mode) {
         this->initClassID<ComposeTwoFragmentProcessor>();
-        SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(src);
-        SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(dst);
+        SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src));
+        SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(std::move(dst));
         SkASSERT(0 == shaderAChildIndex);
         SkASSERT(1 == shaderBChildIndex);
     }
 
     const char* name() const override { return "ComposeTwo"; }
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         b->add32(fMode);
     }
 
@@ skipping 26 matching lines @@
     void emitCode(EmitArgs&) override;
 
 private:
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ComposeTwoFragmentProcessor);
 
-const GrFragmentProcessor* ComposeTwoFragmentProcessor::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> ComposeTwoFragmentProcessor::TestCreate(GrProcessorTestData* d) {
     // Create two random frag procs.
-    SkAutoTUnref<const GrFragmentProcessor> fpA(GrProcessorUnitTest::CreateChildFP(d));
-    SkAutoTUnref<const GrFragmentProcessor> fpB(GrProcessorUnitTest::CreateChildFP(d));
+    sk_sp<GrFragmentProcessor> fpA(GrProcessorUnitTest::MakeChildFP(d));
+    sk_sp<GrFragmentProcessor> fpB(GrProcessorUnitTest::MakeChildFP(d));
 
     SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(
         d->fRandom->nextRangeU(0, SkXfermode::kLastMode));
-    return new ComposeTwoFragmentProcessor(fpA, fpB, mode);
+    return sk_sp<GrFragmentProcessor>(
+        new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode));
 }
 
 GrGLSLFragmentProcessor* ComposeTwoFragmentProcessor::onCreateGLSLInstance() const{
     return new GLComposeTwoFragmentProcessor;
 }
 
 /////////////////////////////////////////////////////////////////////
 
 void GLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) {
 
@@ skipping 21 matching lines @@
                             dstColor.c_str(),
                             args.fOutputColor,
                             mode);
 
     // re-multiply the output color by the input color's alpha
     if (args.fInputColor) {
         fragBuilder->codeAppendf("%s *= %s.a;", args.fOutputColor, args.fInputColor);
     }
 }
 
-const GrFragmentProcessor* GrXfermodeFragmentProcessor::CreateFromTwoProcessors(
-         const GrFragmentProcessor* src, const GrFragmentProcessor* dst, SkXfermode::Mode mode) {
+sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromTwoProcessors(
+         sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kClear_Mode:
-            return GrConstColorProcessor::Create(GrColor_TRANSPARENT_BLACK,
-                                                 GrConstColorProcessor::kIgnore_InputMode);
+            return GrConstColorProcessor::Make(GrColor_TRANSPARENT_BLACK,
+                                               GrConstColorProcessor::kIgnore_InputMode);
         case SkXfermode::kSrc_Mode:
-            return SkRef(src);
+            return src;
         case SkXfermode::kDst_Mode:
-            return SkRef(dst);
+            return dst;
         default:
-            return new ComposeTwoFragmentProcessor(src, dst, mode);
+            return sk_sp<GrFragmentProcessor>(
+                new ComposeTwoFragmentProcessor(std::move(src), std::move(dst), mode));
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class ComposeOneFragmentProcessor : public GrFragmentProcessor {
 public:
     enum Child {
         kDst_Child,
         kSrc_Child,
     };
 
-    ComposeOneFragmentProcessor(const GrFragmentProcessor* dst, SkXfermode::Mode mode, Child child)
+    ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode, Child child)
         : fMode(mode)
         , fChild(child) {
         this->initClassID<ComposeOneFragmentProcessor>();
-        SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(dst);
+        SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(std::move(dst));
         SkASSERT(0 == dstIndex);
     }
 
     const char* name() const override { return "ComposeOne"; }
 
     SkString dumpInfo() const override {
         SkString str;
 
         for (int i = 0; i < this->numChildProcessors(); ++i) {
             str.append(this->childProcessor(i).dumpInfo());
@@ skipping 93 matching lines @@
     }
 
 private:
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ComposeOneFragmentProcessor);
 
-const GrFragmentProcessor* ComposeOneFragmentProcessor::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> ComposeOneFragmentProcessor::TestCreate(GrProcessorTestData* d) {
     // Create one random frag procs.
     // For now, we'll prevent either children from being a shader with children to prevent the
     // possibility of an arbitrarily large tree of procs.
-    SkAutoTUnref<const GrFragmentProcessor> dst(GrProcessorUnitTest::CreateChildFP(d));
+    sk_sp<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
     SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(
         d->fRandom->nextRangeU(0, SkXfermode::kLastMode));
     ComposeOneFragmentProcessor::Child child = d->fRandom->nextBool() ?
         ComposeOneFragmentProcessor::kDst_Child :
         ComposeOneFragmentProcessor::kSrc_Child;
-    return new ComposeOneFragmentProcessor(dst, mode, child);
+    return sk_sp<GrFragmentProcessor>(new ComposeOneFragmentProcessor(std::move(dst), mode, child));
 }
 
 GrGLSLFragmentProcessor* ComposeOneFragmentProcessor::onCreateGLSLInstance() const {
     return new GLComposeOneFragmentProcessor;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-const GrFragmentProcessor* GrXfermodeFragmentProcessor::CreateFromDstProcessor(
-    const GrFragmentProcessor* dst, SkXfermode::Mode mode) {
+sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromDstProcessor(
+    sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kClear_Mode:
-            return GrConstColorProcessor::Create(GrColor_TRANSPARENT_BLACK,
+            return GrConstColorProcessor::Make(GrColor_TRANSPARENT_BLACK,
                                                  GrConstColorProcessor::kIgnore_InputMode);
         case SkXfermode::kSrc_Mode:
             return nullptr;
         default:
-            return new ComposeOneFragmentProcessor(dst, mode,
-                                                   ComposeOneFragmentProcessor::kDst_Child);
+            return sk_sp<GrFragmentProcessor>(
+                new ComposeOneFragmentProcessor(std::move(dst), mode,
+                                                ComposeOneFragmentProcessor::kDst_Child));
     }
 }
 
-const GrFragmentProcessor* GrXfermodeFragmentProcessor::CreateFromSrcProcessor(
-    const GrFragmentProcessor* src, SkXfermode::Mode mode) {
+sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromSrcProcessor(
+    sk_sp<GrFragmentProcessor> src, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kClear_Mode:
-            return GrConstColorProcessor::Create(GrColor_TRANSPARENT_BLACK,
+            return GrConstColorProcessor::Make(GrColor_TRANSPARENT_BLACK,
                                                  GrConstColorProcessor::kIgnore_InputMode);
         case SkXfermode::kDst_Mode:
             return nullptr;
         default:
-            return new ComposeOneFragmentProcessor(src, mode,
-                                                   ComposeOneFragmentProcessor::kSrc_Child);
+            return sk_sp<GrFragmentProcessor>(
+                new ComposeOneFragmentProcessor(src, mode,
+                                                ComposeOneFragmentProcessor::kSrc_Child));
     }
 }