sk_sp for gpu.

src/gpu/GrFragmentProcessor.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 "GrFragmentProcessor.h"
 #include "GrCoordTransform.h"
 #include "GrInvariantOutput.h"
@@ skipping 71 matching lines @@
     // Can't add transforms after registering any children since their transforms have already been
     // bubbled up into our fCoordTransforms array
     SkASSERT(fChildProcessors.empty());
 
     fCoordTransforms.push_back(transform);
     fUsesLocalCoords = fUsesLocalCoords || transform->sourceCoords() == kLocal_GrCoordSet;
     SkDEBUGCODE(transform->setInProcessor();)
     fNumTransformsExclChildren++;
 }
 
-int GrFragmentProcessor::registerChildProcessor(const GrFragmentProcessor* child) {
+int GrFragmentProcessor::registerChildProcessor(sk_sp<GrFragmentProcessor> child) {
     // Append the child's transforms to our transforms array and the child's textures array to our
     // textures array
     if (!child->fCoordTransforms.empty()) {
         fCoordTransforms.push_back_n(child->fCoordTransforms.count(),
                                      child->fCoordTransforms.begin());
     }
     if (!child->fTextureAccesses.empty()) {
         fTextureAccesses.push_back_n(child->fTextureAccesses.count(),
                                      child->fTextureAccesses.begin());
     }
 
-    int index = fChildProcessors.count();
-    fChildProcessors.push_back(SkRef(child));
-
     this->combineRequiredFeatures(*child);
 
     if (child->usesLocalCoords()) {
         fUsesLocalCoords = true;
     }
 
+    int index = fChildProcessors.count();
+    fChildProcessors.push_back(child.release());
+
     return index;
 }
 
 void GrFragmentProcessor::notifyRefCntIsZero() const {
     // See comment above GrProgramElement for a detailed explanation of why we do this.
     for (int i = 0; i < fChildProcessors.count(); ++i) {
         fChildProcessors[i]->addPendingExecution();
         fChildProcessors[i]->unref();
     }
 }
 
 bool GrFragmentProcessor::hasSameTransforms(const GrFragmentProcessor& that) const {
     if (this->numTransforms() != that.numTransforms()) {
         return false;
     }
     int count = this->numTransforms();
     for (int i = 0; i < count; ++i) {
         if (this->coordTransform(i) != that.coordTransform(i)) {
             return false;
         }
     }
     return true;
 }
 
-const GrFragmentProcessor* GrFragmentProcessor::MulOutputByInputAlpha(
-    const GrFragmentProcessor* fp) {
+sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputAlpha(
+    sk_sp<GrFragmentProcessor> fp) {
     if (!fp) {
         return nullptr;
     }
-    return GrXfermodeFragmentProcessor::CreateFromDstProcessor(fp, SkXfermode::kDstIn_Mode);
+    return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(fp),
+                                                             SkXfermode::kDstIn_Mode);
 }
 
-const GrFragmentProcessor* GrFragmentProcessor::MulOutputByInputUnpremulColor(
-    const GrFragmentProcessor* fp) {
+sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputUnpremulColor(
+    sk_sp<GrFragmentProcessor> fp) {
 
     class PremulFragmentProcessor : public GrFragmentProcessor {
     public:
-        PremulFragmentProcessor(const GrFragmentProcessor* processor) {
+        PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor) {
             this->initClassID<PremulFragmentProcessor>();
             this->registerChildProcessor(processor);
         }
 
         const char* name() const override { return "Premultiply"; }
 
     private:
         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
             class GLFP : public GrGLSLFragmentProcessor {
             public:
@@ skipping 41 matching lines @@
             if (commonFlags & kB_GrColorComponentFlag) {
                 color |= SkMulDiv255Round(GrColorUnpackB(c0), GrColorUnpackB(c1)) <<
                     GrColor_SHIFT_B;
             }
             inout->setToOther(commonFlags, color, GrInvariantOutput::kWill_ReadInput);
         }
     };
     if (!fp) {
         return nullptr;
     }
-    return new PremulFragmentProcessor(fp);
+    return sk_sp<GrFragmentProcessor>(new PremulFragmentProcessor(std::move(fp)));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-const GrFragmentProcessor* GrFragmentProcessor::OverrideInput(const GrFragmentProcessor* fp,
+sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentProcessor> fp,
                                                               GrColor color) {
     class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
     public:
-        ReplaceInputFragmentProcessor(const GrFragmentProcessor* child, GrColor color)
+        ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor color)
             : fColor(color) {
             this->initClassID<ReplaceInputFragmentProcessor>();
-            this->registerChildProcessor(child);
+            this->registerChildProcessor(std::move(child));
         }
 
         const char* name() const override { return "Replace Color"; }
 
         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
             class GLFP : public GrGLSLFragmentProcessor {
             public:
                 GLFP() : fHaveSetColor(false) {}
                 void emitCode(EmitArgs& args) override {
                     const char* colorName;
@@ skipping 43 matching lines @@
                               GrInvariantOutput::kWillNot_ReadInput);
             this->childProcessor(0).computeInvariantOutput(inout);
         }
 
         GrColor fColor;
     };
 
     GrInvariantOutput childOut(0x0, kNone_GrColorComponentFlags, false);
     fp->computeInvariantOutput(&childOut);
     if (childOut.willUseInputColor()) {
-        return new ReplaceInputFragmentProcessor(fp, color);
+        return sk_sp<GrFragmentProcessor>(new ReplaceInputFragmentProcessor(std::move(fp), color));
     } else {
-        return SkRef(fp);
+        return fp;
     }
 }
 
-const GrFragmentProcessor* GrFragmentProcessor::RunInSeries(const GrFragmentProcessor* series[],
+sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProcessor>* series,
                                                             int cnt) {
     class SeriesFragmentProcessor : public GrFragmentProcessor {
     public:
-        SeriesFragmentProcessor(const GrFragmentProcessor* children[], int cnt){
+        SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt){
             SkASSERT(cnt > 1);
             this->initClassID<SeriesFragmentProcessor>();
             for (int i = 0; i < cnt; ++i) {
-                this->registerChildProcessor(children[i]);
+                this->registerChildProcessor(std::move(children[i]));
             }
         }
 
         const char* name() const override { return "Series"; }
 
         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
             class GLFP : public GrGLSLFragmentProcessor {
             public:
                 void emitCode(EmitArgs& args) override {
                     SkString input(args.fInputColor);
@@ skipping 10 matching lines @@
             return new GLFP;
         }
 
     private:
         void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override {}
 
         bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
 
         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
             GrProcOptInfo info;
-            SkTDArray<const GrFragmentProcessor*> children;
-            children.setCount(this->numChildProcessors());
-            for (int i = 0; i < children.count(); ++i) {
-                children[i] = &this->childProcessor(i);
-            }
-            info.calcWithInitialValues(children.begin(), children.count(), inout->color(),
-                                       inout->validFlags(), false, false);
+            info.calcWithInitialValues(fChildProcessors.begin(), fChildProcessors.count(),
+                                       inout->color(), inout->validFlags(), false, false);
             for (int i = 0; i < this->numChildProcessors(); ++i) {
                 this->childProcessor(i).computeInvariantOutput(inout);
             }
         }
     };
 
     if (!cnt) {
         return nullptr;
     }
 
     // Run the through the series, do the invariant output processing, and look for eliminations.
-    SkTDArray<const GrFragmentProcessor*> replacementSeries;
-    SkAutoTUnref<const GrFragmentProcessor> colorFP;
     GrProcOptInfo info;
+    info.calcWithInitialValues(sk_sp_address_as_pointer_address(series), cnt,
+                               0x0, kNone_GrColorComponentFlags, false, false);
+    if (kRGBA_GrColorComponentFlags == info.validFlags()) {
+        return GrConstColorProcessor::Make(info.color(), GrConstColorProcessor::kIgnore_InputMode);
+    }
 
-    info.calcWithInitialValues(series, cnt, 0x0, kNone_GrColorComponentFlags, false, false);
-    if (kRGBA_GrColorComponentFlags == info.validFlags()) {
-        return GrConstColorProcessor::Create(info.color(),
-                                             GrConstColorProcessor::kIgnore_InputMode);
+    SkTArray<sk_sp<GrFragmentProcessor>> replacementSeries;
+
+    int firstIdx = info.firstEffectiveProcessorIndex();
+    cnt -= firstIdx;
+    if (firstIdx > 0 && info.inputColorIsUsed()) {
+        sk_sp<GrFragmentProcessor> colorFP(GrConstColorProcessor::Make(
+            info.inputColorToFirstEffectiveProccesor(), GrConstColorProcessor::kIgnore_InputMode));
+        cnt += 1;
+        replacementSeries.reserve(cnt);
+        replacementSeries.emplace_back(std::move(colorFP));
+        for (int i = 0; i < cnt - 1; ++i) {
+            replacementSeries.emplace_back(std::move(series[firstIdx + i]));
+        }
+        series = replacementSeries.begin();
     } else {
-        int firstIdx = info.firstEffectiveProcessorIndex();
+        series += firstIdx;
         cnt -= firstIdx;
-        if (firstIdx > 0 && info.inputColorIsUsed()) {
-            colorFP.reset(GrConstColorProcessor::Create(info.inputColorToFirstEffectiveProccesor(),
-                                                        GrConstColorProcessor::kIgnore_InputMode));
-            cnt += 1;
-            replacementSeries.setCount(cnt);
-            replacementSeries[0] = colorFP;
-            for (int i = 0; i < cnt - 1; ++i) {
-                replacementSeries[i + 1] = series[firstIdx + i];
-            }
-            series = replacementSeries.begin();
-        } else {
-            series += firstIdx;
-            cnt -= firstIdx;
-        }
     }
 
     if (1 == cnt) {
-        return SkRef(series[0]);
-    } else {
-        return new SeriesFragmentProcessor(series, cnt);
+        return series[0];
     }
+    return sk_sp<GrFragmentProcessor>(new SeriesFragmentProcessor(series, cnt));
 }