Refugee from Dead Machine 4: MDB Monster

src/gpu/GrBlurUtils.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 "GrBlurUtils.h"
 #include "GrDrawContext.h"
 #include "GrCaps.h"
@@ skipping 18 matching lines @@
                       const GrClip& clip,
                       const SkMatrix& viewMatrix,
                       const SkRect& maskRect,
                       GrPaint* grp,
                       GrTexture* mask) {
     SkMatrix matrix;
     matrix.setTranslate(-maskRect.fLeft, -maskRect.fTop);
     matrix.postIDiv(mask->width(), mask->height());
 
     grp->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(mask, matrix,
-                                                                    kDevice_GrCoordSet))->unref();
+                                                                    kDevice_GrCoordSet, drawContext->rt_remove_me()))->unref();
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
     drawContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), maskRect, inverse);
     return true;
 }
 
 static bool draw_with_mask_filter(GrDrawContext* drawContext,
@@ skipping 27 matching lines @@
     // the current clip (and identity matrix) and GrPaint settings
     GrSurfaceDesc desc;
     desc.fWidth = dstM.fBounds.width();
     desc.fHeight = dstM.fBounds.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     SkAutoTUnref<GrTexture> texture(textureProvider->createApproxTexture(desc));
     if (!texture) {
         return false;
     }
-    texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+    texture->writePixels(NULL, 0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                                dstM.fImage, dstM.fRowBytes);
 
+    texture->setFromRawPixels(true);
+    texture->setException(true);
+
     SkRect maskRect = SkRect::Make(dstM.fBounds);
 
     return draw_mask(drawContext, clipData, viewMatrix, maskRect, grp, texture);
 }
 
 // Create a mask of 'devPath' and place the result in 'mask'.
+// If this returns non-NULL then 'outputDrawContext' will be set to the 
+// drawContext used to create it (and it will have an associated rendertarget).
+// TODO: just return drawContext?
 static GrTexture* create_mask_GPU(GrContext* context,
                                   SkRect* maskRect,
                                   const SkPath& devPath,
                                   const GrStrokeInfo& strokeInfo,
                                   bool doAA,
                                   int sampleCnt) {
     // This mask will ultimately be drawn as a non-AA rect (see draw_mask). 
     // Non-AA rects have a bad habit of snapping arbitrarily. Integerize here 
     // so the mask draws in a reproducible manner.
     *maskRect = SkRect::Make(maskRect->roundOut());
@@ skipping 202 matching lines @@
             // should I push prePathMatrix on our MV stack temporarily, instead
             // of applying it here? See SkDraw.cpp
             pathPtr->transform(*prePathMatrix, result);
             pathPtr = result;
         }
     }
     // at this point we're done with prePathMatrix
     SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(context, paint, viewMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(context, paint, viewMatrix, &grPaint, renderTarget)) {
         return;
     }
 
     if (paint.getMaskFilter()) {
         draw_path_with_mask_filter(context, drawContext, renderTarget, clip, &grPaint, viewMatrix,
                                    paint.getMaskFilter(), paint.getPathEffect(), strokeInfo,
                                    pathPtr, pathIsMutable);
     } else {
         SkTLazy<SkPath> tmpPath2;
         if (!strokeInfo.isDashed() && pathEffect &&
             pathEffect->filterPath(tmpPath2.init(), *pathPtr, &strokeInfo, nullptr)) {
             pathPtr = tmpPath2.get();
             pathPtr->setIsVolatile(true);
             pathIsMutable = true;
         }
+#if 1
         drawContext->drawPath(clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
+#else
+        // avoid possibly allocating a new path in transform if we can
+        SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init();
+        if (!pathIsMutable) {
+            devPathPtr->setIsVolatile(true);
+        }
+
+        // transform the path into device space
+        pathPtr->transform(viewMatrix, devPathPtr);
+
+        SkRect maskRect;
+        if (paint.getMaskFilter()->canFilterMaskGPU(SkRRect::MakeRect(devPathPtr->getBounds()),
+                                                    clipBounds,
+                                                    viewMatrix,
+                                                    &maskRect)) {
+            SkIRect finalIRect;
+            maskRect.roundOut(&finalIRect);
+            if (clip_bounds_quick_reject(clipBounds, finalIRect)) {
+                // clipped out
+                return;
+            }
+
+            if (paint.getMaskFilter()->directFilterMaskGPU(context->textureProvider(),
+                                                           drawContext,
+                                                           &grPaint,
+                                                           clip,
+                                                           viewMatrix,
+                                                           strokeInfo,
+                                                           *devPathPtr)) {
+                // the mask filter was able to draw itself directly, so there's nothing
+                // left to do.
+                return;
+            }
+
+            SkAutoTUnref<GrTexture> mask(create_mask_GPU(context,
+                                                         &maskRect,
+                                                         *devPathPtr,
+                                                         strokeInfo,
+                                                         grPaint.isAntiAlias(),
+                                                         renderTarget->numColorSamples()));
+            if (mask) {
+                SkASSERT(mask->asRenderTarget());
+
+                GrTexture* filtered;
+
+                if (paint.getMaskFilter()->filterMaskGPU(mask, viewMatrix, maskRect,
+                                                         &filtered, true)) {
+                    // filterMaskGPU gives us ownership of a ref to the result
+                    SkAutoTUnref<GrTexture> atu(filtered);
+                    if (draw_mask(drawContext,
+                                  clip,
+                                  viewMatrix,
+                                  maskRect,
+                                  &grPaint,
+                                  filtered)) {
+                        // This path is completely drawn
+                        return;
+                    }
+                }
+            }
+        }
+
+        // draw the mask on the CPU - this is a fallthrough path in case the
+        // GPU path fails
+        SkPaint::Style style = strokeInfo.isHairlineStyle() ? SkPaint::kStroke_Style :
+                                                              SkPaint::kFill_Style;
+        draw_with_mask_filter(drawContext, context->textureProvider(),
+                              clip, viewMatrix, *devPathPtr,
+                              paint.getMaskFilter(), clipBounds, &grPaint, style);
+        return;
+#endif
     }
 }