sk_sp for gpu.

tools/debugger/SkOverdrawMode.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorPriv.h"
 #include "SkOverdrawMode.h"
 #include "SkString.h"
 #include "SkXfermode.h"
 
 #if SK_SUPPORT_GPU
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrXferProcessor.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLXferProcessor.h"
 
  ///////////////////////////////////////////////////////////////////////////////
  // Fragment Processor
  ///////////////////////////////////////////////////////////////////////////////
 
 class GLOverdrawFP;
 
 class GrOverdrawFP : public GrFragmentProcessor {
 public:
-    static const GrFragmentProcessor* Create(const GrFragmentProcessor* dst) {
-        return new GrOverdrawFP(dst);
+    static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor> dst) {
+        return sk_sp<GrFragmentProcessor>(new GrOverdrawFP(std::move(dst)));
     }
 
     ~GrOverdrawFP() override { }
 
     const char* name() const override { return "Overdraw"; }
 
     SkString dumpInfo() const override {
         SkString str;
         return str;
     }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
     void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
     }
 
-    GrOverdrawFP(const GrFragmentProcessor* dst) {
+    GrOverdrawFP(sk_sp<GrFragmentProcessor> dst) {
         this->initClassID<GrOverdrawFP>();
 
         SkASSERT(dst);
-        SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(dst);
+        SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(std::move(dst));
         SkASSERT(0 == dstIndex);
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
     typedef GrFragmentProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void add_overdraw_code(GrGLSLFragmentBuilder* fragBuilder,
@@ skipping 54 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLSLFragmentProcessor* GrOverdrawFP::onCreateGLSLInstance() const {
     return new GLOverdrawFP;
 }
 
 void GrOverdrawFP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLOverdrawFP::GenKey(*this, caps, b);
 }
 
-const GrFragmentProcessor* GrOverdrawFP::TestCreate(GrProcessorTestData* d) {
-    SkAutoTUnref<const GrFragmentProcessor> dst(GrProcessorUnitTest::CreateChildFP(d));
-    return new GrOverdrawFP(dst);
+sk_sp<GrFragmentProcessor> GrOverdrawFP::TestCreate(GrProcessorTestData* d) {
+    return GrOverdrawFP::Make(GrProcessorUnitTest::MakeChildFP(d));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrOverdrawFP);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Xfer Processor
 ///////////////////////////////////////////////////////////////////////////////
 
 class OverdrawXP : public GrXferProcessor {
 public:
@@ skipping 57 matching lines @@
 
 void OverdrawXP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLOverdrawXP::GenKey(*this, caps, b);
 }
 
 GrGLSLXferProcessor* OverdrawXP::createGLSLInstance() const { return new GLOverdrawXP(*this); }
 
 ///////////////////////////////////////////////////////////////////////////////
 class GrOverdrawXPFactory : public GrXPFactory {
 public:
-    static GrXPFactory* Create() { return new GrOverdrawXPFactory(); }
+    static sk_sp<GrXPFactory> Make() { return sk_sp<GrXPFactory>(new GrOverdrawXPFactory()); }
 
     void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                   GrXPFactory::InvariantBlendedColor* blendedColor) const override {
         blendedColor->fWillBlendWithDst = true;
         blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
     }
 
 private:
     GrOverdrawXPFactory() {
         this->initClassID<GrOverdrawXPFactory>();
@@ skipping 12 matching lines @@
 
     bool onIsEqual(const GrXPFactory& xpfBase) const override { return true; }
 
     GR_DECLARE_XP_FACTORY_TEST;
 
     typedef GrXPFactory INHERITED;
 };
 
 GR_DEFINE_XP_FACTORY_TEST(GrOverdrawXPFactory);
 
-const GrXPFactory* GrOverdrawXPFactory::TestCreate(GrProcessorTestData* d) {
-    return GrOverdrawXPFactory::Create();
+sk_sp<GrXPFactory> GrOverdrawXPFactory::TestCreate(GrProcessorTestData* d) {
+    return GrOverdrawXPFactory::Make();
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 class SkOverdrawXfermode : public SkXfermode {
 public:
     static SkXfermode* Create() {
         return new SkOverdrawXfermode;
     }
 
@@ skipping 25 matching lines @@
             nextIdx = 11 - (SkColorGetG(dst)+22)/45;
         }
         SkASSERT(nextIdx < (int)SK_ARRAY_COUNT(gTable));
 
         return gTable[nextIdx];
     }
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkOverdrawXfermode)
 
 #if SK_SUPPORT_GPU
-    const GrFragmentProcessor* getFragmentProcessorForImageFilter(
-                                                const GrFragmentProcessor* dst) const override {
-        return GrOverdrawFP::Create(dst);
+    sk_sp<GrFragmentProcessor> makeFragmentProcessorForImageFilter(
+                                                sk_sp<GrFragmentProcessor> dst) const override {
+        return GrOverdrawFP::Make(dst);
     }
 
-    GrXPFactory* asXPFactory() const override {
-        return GrOverdrawXPFactory::Create();
+    sk_sp<GrXPFactory> asXPFactory() const override {
+        return GrOverdrawXPFactory::Make();
     }
 #endif
 
 #ifndef SK_IGNORE_TO_STRING
     void toString(SkString* str) const override { str->set("SkOverdrawXfermode"); }
 #endif
 
 private:
     friend class SkOverdrawMode;
 
     void flatten(SkWriteBuffer& buffer) const override { }
 
     typedef SkXfermode INHERITED;
 };
 
 sk_sp<SkFlattenable> SkOverdrawXfermode::CreateProc(SkReadBuffer& buffer) {
     return sk_sp<SkFlattenable>(Create());
 }
 
 sk_sp<SkXfermode> SkOverdrawMode::Make() { return sk_make_sp<SkOverdrawXfermode>(); }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkOverdrawMode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkOverdrawXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END