sk_sp for gpu.

tests/GLProgramsTest.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.
  */
 
 // This is a GPU-backend specific test. It relies on static intializers to work
 
 #include "SkTypes.h"
@@ skipping 48 matching lines @@
             b->add32(i);
         }
     }
 
 private:
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 class BigKeyProcessor : public GrFragmentProcessor {
 public:
-    static GrFragmentProcessor* Create() {
-        return new BigKeyProcessor;
+    static sk_sp<GrFragmentProcessor> Make() {
+        return sk_sp<GrFragmentProcessor>(new BigKeyProcessor);
     }
 
     const char* name() const override { return "Big Ole Key"; }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
         return new GLBigKeyProcessor;
     }
 
 private:
     BigKeyProcessor() {
         this->initClassID<BigKeyProcessor>();
     }
     virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                        GrProcessorKeyBuilder* b) const override {
         GLBigKeyProcessor::GenKey(*this, caps, b);
     }
     bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override { }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(BigKeyProcessor);
 
-const GrFragmentProcessor* BigKeyProcessor::TestCreate(GrProcessorTestData*) {
-    return BigKeyProcessor::Create();
+sk_sp<GrFragmentProcessor> BigKeyProcessor::TestCreate(GrProcessorTestData*) {
+    return BigKeyProcessor::Make();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class BlockInputFragmentProcessor : public GrFragmentProcessor {
 public:
-    static GrFragmentProcessor* Create(const GrFragmentProcessor* fp) {
-        return new BlockInputFragmentProcessor(fp);
+    static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor> fp) {
+        return sk_sp<GrFragmentProcessor>(new BlockInputFragmentProcessor(fp));
     }
 
     const char* name() const override { return "Block Input"; }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLFP; }
 
 private:
     class GLFP : public GrGLSLFragmentProcessor {
     public:
         void emitCode(EmitArgs& args) override {
             this->emitChild(0, nullptr, args);
         }
 
     private:
         typedef GrGLSLFragmentProcessor INHERITED;
     };
 
-    BlockInputFragmentProcessor(const GrFragmentProcessor* child) {
+    BlockInputFragmentProcessor(sk_sp<GrFragmentProcessor> child) {
         this->initClassID<BlockInputFragmentProcessor>();
-        this->registerChildProcessor(child);
+        this->registerChildProcessor(std::move(child));
     }
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {}
 
     bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->setToOther(kRGBA_GrColorComponentFlags, GrColor_WHITE,
                           GrInvariantOutput::kWillNot_ReadInput);
         this->childProcessor(0).computeInvariantOutput(inout);
@@ skipping 41 matching lines @@
     }
 
     // TODO: need a real way to do this via the drawContext
     texture = drawContext->asTexture();
     context->textureProvider()->assignUniqueKeyToTexture(key, texture.get());
 
     return drawContext;
 }
 
 static void set_random_xpf(GrPipelineBuilder* pipelineBuilder, GrProcessorTestData* d) {
-    SkAutoTUnref<const GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::Create(d));
+    sk_sp<GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::Make(d));
     SkASSERT(xpf);
-    pipelineBuilder->setXPFactory(xpf.get());
+    pipelineBuilder->setXPFactory(std::move(xpf));
 }
 
-static const GrFragmentProcessor* create_random_proc_tree(GrProcessorTestData* d,
-                                                           int minLevels, int maxLevels) {
+static sk_sp<GrFragmentProcessor> create_random_proc_tree(GrProcessorTestData* d,
+                                                          int minLevels, int maxLevels) {
     SkASSERT(1 <= minLevels);
     SkASSERT(minLevels <= maxLevels);
 
     // Return a leaf node if maxLevels is 1 or if we randomly chose to terminate.
     // If returning a leaf node, make sure that it doesn't have children (e.g. another
     // GrComposeEffect)
     const float terminateProbability = 0.3f;
     if (1 == minLevels) {
         bool terminate = (1 == maxLevels) || (d->fRandom->nextF() < terminateProbability);
         if (terminate) {
-            const GrFragmentProcessor* fp;
+            sk_sp<GrFragmentProcessor> fp;
             while (true) {
-                fp = GrProcessorTestFactory<GrFragmentProcessor>::Create(d);
+                fp = GrProcessorTestFactory<GrFragmentProcessor>::Make(d);
                 SkASSERT(fp);
                 if (0 == fp->numChildProcessors()) {
                     break;
                 }
-                fp->unref();
             }
             return fp;
         }
     }
     // If we didn't terminate, choose either the left or right subtree to fulfill
     // the minLevels requirement of this tree; the other child can have as few levels as it wants.
     // Also choose a random xfer mode that's supported by CreateFrom2Procs().
     if (minLevels > 1) {
         --minLevels;
     }
-    SkAutoTUnref<const GrFragmentProcessor> minLevelsChild(create_random_proc_tree(d, minLevels,
-                                                                                   maxLevels - 1));
-    SkAutoTUnref<const GrFragmentProcessor> otherChild(create_random_proc_tree(d, 1,
-                                                                               maxLevels - 1));
+    sk_sp<GrFragmentProcessor> minLevelsChild(create_random_proc_tree(d, minLevels, maxLevels - 1));
+    sk_sp<GrFragmentProcessor> otherChild(create_random_proc_tree(d, 1, maxLevels - 1));
     SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(d->fRandom->nextRangeU(0,
                                                           SkXfermode::kLastCoeffMode));
-    const GrFragmentProcessor* fp;
+    sk_sp<GrFragmentProcessor> fp;
     if (d->fRandom->nextF() < 0.5f) {
-        fp = GrXfermodeFragmentProcessor::CreateFromTwoProcessors(minLevelsChild, otherChild, mode);
+        fp = GrXfermodeFragmentProcessor::MakeFromTwoProcessors(std::move(minLevelsChild),
+                                                                std::move(otherChild), mode);
         SkASSERT(fp);
     } else {
-        fp = GrXfermodeFragmentProcessor::CreateFromTwoProcessors(otherChild, minLevelsChild, mode);
+        fp = GrXfermodeFragmentProcessor::MakeFromTwoProcessors(std::move(otherChild),
+                                                                std::move(minLevelsChild), mode);
         SkASSERT(fp);
     }
     return fp;
 }
 
 static void set_random_color_coverage_stages(GrPipelineBuilder* pipelineBuilder,
                                              GrProcessorTestData* d, int maxStages) {
     // Randomly choose to either create a linear pipeline of procs or create one proc tree
     const float procTreeProbability = 0.5f;
     if (d->fRandom->nextF() < procTreeProbability) {
         // A full tree with 5 levels (31 nodes) may exceed the max allowed length of the gl
         // processor key; maxTreeLevels should be a number from 1 to 4 inclusive.
         const int maxTreeLevels = 4;
-        SkAutoTUnref<const GrFragmentProcessor> fp(
-                                        create_random_proc_tree(d, 2, maxTreeLevels));
-        pipelineBuilder->addColorFragmentProcessor(fp);
+        sk_sp<GrFragmentProcessor> fp(create_random_proc_tree(d, 2, maxTreeLevels));
+        pipelineBuilder->addColorFragmentProcessor(std::move(fp));
     } else {
         int numProcs = d->fRandom->nextULessThan(maxStages + 1);
         int numColorProcs = d->fRandom->nextULessThan(numProcs + 1);
 
         for (int s = 0; s < numProcs;) {
-            SkAutoTUnref<const GrFragmentProcessor> fp(
-                GrProcessorTestFactory<GrFragmentProcessor>::Create(d));
+            sk_sp<GrFragmentProcessor> fp(GrProcessorTestFactory<GrFragmentProcessor>::Make(d));
             SkASSERT(fp);
 
             // finally add the stage to the correct pipeline in the drawstate
             if (s < numColorProcs) {
-                pipelineBuilder->addColorFragmentProcessor(fp);
+                pipelineBuilder->addColorFragmentProcessor(std::move(fp));
             } else {
-                pipelineBuilder->addCoverageFragmentProcessor(fp);
+                pipelineBuilder->addCoverageFragmentProcessor(std::move(fp));
             }
             ++s;
         }
     }
 }
 
 static void set_random_state(GrPipelineBuilder* pipelineBuilder,
                              GrDrawContext* drawContext,
                              SkRandom* random) {
     int state = 0;
@@ skipping 103 matching lines @@
 
     int fpFactoryCnt = GrProcessorTestFactory<GrFragmentProcessor>::Count();
     for (int i = 0; i < fpFactoryCnt; ++i) {
         // Since FP factories internally randomize, call each 10 times.
         for (int j = 0; j < 10; ++j) {
             SkAutoTUnref<GrDrawBatch> batch(GrRandomDrawBatch(&random, context));
             SkASSERT(batch);
             GrProcessorTestData ptd(&random, context, context->caps(),
                                     drawContext.get(), dummyTextures);
             GrPipelineBuilder builder;
-            builder.setXPFactory(GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
+            builder.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
-            SkAutoTUnref<const GrFragmentProcessor> fp(
-                GrProcessorTestFactory<GrFragmentProcessor>::CreateIdx(i, &ptd));
-            SkAutoTUnref<const GrFragmentProcessor> blockFP(
-                BlockInputFragmentProcessor::Create(fp));
-            builder.addColorFragmentProcessor(blockFP);
+            sk_sp<GrFragmentProcessor> fp(
+                GrProcessorTestFactory<GrFragmentProcessor>::MakeIdx(i, &ptd));
+            sk_sp<GrFragmentProcessor> blockFP(
+                BlockInputFragmentProcessor::Make(std::move(fp)));
+            builder.addColorFragmentProcessor(std::move(blockFP));
 
             drawContext->drawContextPriv().testingOnly_drawBatch(builder, batch);
             drawingManager->flush();
         }
     }
 
     return true;
 }
 
 static int get_glprograms_max_stages(GrContext* context) {
@@ skipping 60 matching lines @@
     GrContextOptions opts;
     opts.fSuppressPrints = true;
     sk_gpu_test::GrContextFactory debugFactory(opts);
     skiatest::RunWithGPUTestContexts(test_glprograms_native, &is_native_gl_context_type,
                                      reporter, &debugFactory);
     skiatest::RunWithGPUTestContexts(test_glprograms_other_contexts,
                                      &is_other_rendering_gl_context_type, reporter, &debugFactory);
 }
 
 #endif