Refugee from Dead Machine 4: MDB Monster

src/effects/SkMorphologyImageFilter.cpp

 /*
  * Copyright 2012 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 "SkMorphologyImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkDevice.h"
 #include "SkOpts.h"
 #include "SkReadBuffer.h"
 #include "SkRect.h"
 #include "SkWriteBuffer.h"
 #if SK_SUPPORT_GPU
+#include "SkGR.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrInvariantOutput.h"
 #include "GrTexture.h"
 #include "effects/Gr1DKernelEffect.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #endif
@@ skipping 177 matching lines @@
  */
 class GrMorphologyEffect : public Gr1DKernelEffect {
 
 public:
 
     enum MorphologyType {
         kErode_MorphologyType,
         kDilate_MorphologyType,
     };
 
-    static GrFragmentProcessor* Create(GrTexture* tex, Direction dir, int radius,
-                                       MorphologyType type) {
-        return new GrMorphologyEffect(tex, dir, radius, type);
+    static GrFragmentProcessor* Create(GrTexture* tex,
+                                       Direction dir, int radius, MorphologyType type, GrRenderTarget* dst) {
+        return new GrMorphologyEffect(tex, dir, radius, type, dst);
     }
 
-    static GrFragmentProcessor* Create(GrTexture* tex, Direction dir, int radius,
-                                       MorphologyType type, float bounds[2]) {
-        return new GrMorphologyEffect(tex, dir, radius, type, bounds);
+    static GrFragmentProcessor* Create(GrTexture* tex,
+                                       Direction dir, int radius, MorphologyType type,
+                                       float bounds[2], GrRenderTarget* dst) {
+        return new GrMorphologyEffect(tex, dir, radius, type, bounds, dst);
     }
 
     virtual ~GrMorphologyEffect();
 
     MorphologyType type() const { return fType; }
     bool useRange() const { return fUseRange; }
     const float* range() const { return fRange; }
 
     const char* name() const override { return "Morphology"; }
 
 protected:
 
     MorphologyType fType;
     bool fUseRange;
     float fRange[2];
 
 private:
     GrGLFragmentProcessor* onCreateGLInstance() const override;
 
     void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
-    GrMorphologyEffect(GrTexture*, Direction, int radius, MorphologyType);
+    GrMorphologyEffect(GrTexture*, Direction, int radius, MorphologyType, GrRenderTarget* dst);
     GrMorphologyEffect(GrTexture*, Direction, int radius, MorphologyType,
-                       float bounds[2]);
+                       float bounds[2], GrRenderTarget* dst);
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef Gr1DKernelEffect INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLMorphologyEffect : public GrGLFragmentProcessor {
 public:
@@ skipping 135 matching lines @@
             pdman.set2f(fRangeUni, range[0], range[1]);
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrMorphologyEffect::GrMorphologyEffect(GrTexture* texture,
                                        Direction direction,
                                        int radius,
-                                       MorphologyType type)
-    : INHERITED(texture, direction, radius)
+                                       MorphologyType type, GrRenderTarget* dst)
+    : INHERITED(texture, direction, radius, dst)
     , fType(type), fUseRange(false) {
     this->initClassID<GrMorphologyEffect>();
 }
 
 GrMorphologyEffect::GrMorphologyEffect(GrTexture* texture,
                                        Direction direction,
                                        int radius,
                                        MorphologyType type,
-                                       float range[2])
-    : INHERITED(texture, direction, radius)
+                                       float range[2], GrRenderTarget* dst)
+    : INHERITED(texture, direction, radius, dst)
     , fType(type), fUseRange(true) {
     this->initClassID<GrMorphologyEffect>();
     fRange[0] = range[0];
     fRange[1] = range[1];
 }
 
 GrMorphologyEffect::~GrMorphologyEffect() {
 }
 
 void GrMorphologyEffect::onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
@@ skipping 23 matching lines @@
 
 const GrFragmentProcessor* GrMorphologyEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                       GrProcessorUnitTest::kAlphaTextureIdx;
     Direction dir = d->fRandom->nextBool() ? kX_Direction : kY_Direction;
     static const int kMaxRadius = 10;
     int radius = d->fRandom->nextRangeU(1, kMaxRadius);
     MorphologyType type = d->fRandom->nextBool() ? GrMorphologyEffect::kErode_MorphologyType :
                                                GrMorphologyEffect::kDilate_MorphologyType;
 
-    return GrMorphologyEffect::Create(d->fTextures[texIdx], dir, radius, type);
+    return GrMorphologyEffect::Create(d->fTextures[texIdx], dir, radius, type, NULL);
 }
 
 namespace {
 
 
 void apply_morphology_rect(GrDrawContext* drawContext,
                            const GrClip& clip,
                            GrTexture* texture,
                            const SkIRect& srcRect,
                            const SkIRect& dstRect,
                            int radius,
                            GrMorphologyEffect::MorphologyType morphType,
                            float bounds[2],
                            Gr1DKernelEffect::Direction direction) {
     GrPaint paint;
     paint.addColorFragmentProcessor(GrMorphologyEffect::Create(texture,
                                                                direction,
                                                                radius,
                                                                morphType,
-                                                               bounds))->unref();
+                                                               bounds, drawContext->rt_remove_me()))->unref();
+
     drawContext->fillRectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
-                                     SkRect::Make(srcRect));
+                                SkRect::Make(srcRect));
 }
 
 void apply_morphology_rect_no_bounds(GrDrawContext* drawContext,
                                      const GrClip& clip,
                                      GrTexture* texture,
                                      const SkIRect& srcRect,
                                      const SkIRect& dstRect,
                                      int radius,
                                      GrMorphologyEffect::MorphologyType morphType,
                                      Gr1DKernelEffect::Direction direction) {
     GrPaint paint;
     paint.addColorFragmentProcessor(GrMorphologyEffect::Create(texture,
                                                                direction,
                                                                radius,
-                                                               morphType))->unref();
+                                                               morphType, drawContext->rt_remove_me()))->unref();
+
     drawContext->fillRectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
                                 SkRect::Make(srcRect));
 }
 
 void apply_morphology_pass(GrDrawContext* drawContext,
                            const GrClip& clip,
                            GrTexture* texture,
                            const SkIRect& srcRect,
                            const SkIRect& dstRect,
                            int radius,
@@ skipping 64 matching lines @@
         if (radius.fHeight > 0) {
             // Optimization: we will fall through and allocate the "real" texture after this one
             // so ours can be approximate (likely faster to allocate)
             horiConstraint = GrTextureProvider::kApprox_SizeConstraint;
         }
 
         GrTexture* scratch = context->textureProvider()->createTexture(desc, horiConstraint);
         if (nullptr == scratch) {
             return false;
         }
+
         SkAutoTUnref<GrDrawContext> dstDrawContext(
                                                 context->drawContext(scratch->asRenderTarget()));
         if (!dstDrawContext) {
             return false;
         }
 
         apply_morphology_pass(dstDrawContext, clip, srcTexture,
                               srcRect, dstRect, radius.fWidth, morphType,
                               Gr1DKernelEffect::kX_Direction);
         SkIRect clearRect = SkIRect::MakeXYWH(dstRect.fLeft, dstRect.fBottom,
                                               dstRect.width(), radius.fHeight);
         GrColor clearColor = GrMorphologyEffect::kErode_MorphologyType == morphType ?
                                 SK_ColorWHITE :
                                 SK_ColorTRANSPARENT;
+
         dstDrawContext->clear(&clearRect, clearColor, false);
 
         srcTexture.reset(scratch);
         srcRect = dstRect;
     }
     if (radius.fHeight > 0) {
         GrTexture* scratch = context->textureProvider()->createTexture(desc, constraint);
         if (nullptr == scratch) {
             return false;
         }
+
         SkAutoTUnref<GrDrawContext> dstDrawContext(
                                                 context->drawContext(scratch->asRenderTarget()));
         if (!dstDrawContext) {
             return false;
         }
 
         apply_morphology_pass(dstDrawContext, clip, srcTexture,
                               srcRect, dstRect, radius.fHeight, morphType,
                               Gr1DKernelEffect::kY_Direction);
 
@@ skipping 54 matching lines @@
                                          SkBitmap* result, SkIPoint* offset) const {
     return this->filterImageGPUGeneric(true, proxy, src, ctx, result, offset);
 }
 
 bool SkErodeImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context& ctx,
                                         SkBitmap* result, SkIPoint* offset) const {
     return this->filterImageGPUGeneric(false, proxy, src, ctx, result, offset);
 }
 
 #endif