src/gpu/GrBlurUtils.cpp - platform/external/skia - Gitiles

 /*
  * 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 "src/gpu/GrBlurUtils.h"

 #include "include/private/GrRecordingContext.h"
 #include "src/gpu/GrCaps.h"
 #include "src/gpu/GrFixedClip.h"
 #include "src/gpu/GrProxyProvider.h"
 #include "src/gpu/GrRecordingContextPriv.h"
 #include "src/gpu/GrRenderTargetContext.h"
 #include "src/gpu/GrRenderTargetContextPriv.h"
 #include "src/gpu/GrSoftwarePathRenderer.h"
 #include "src/gpu/GrStyle.h"
 #include "src/gpu/GrTextureProxy.h"
 #include "src/gpu/effects/generated/GrSimpleTextureEffect.h"
 #include "src/gpu/geometry/GrShape.h"

 #include "include/core/SkPaint.h"
 #include "src/core/SkDraw.h"
 #include "src/core/SkMaskFilterBase.h"
 #include "src/core/SkTLazy.h"
 #include "src/gpu/SkGr.h"

 static bool clip_bounds_quick_reject(const SkIRect& clipBounds, const SkIRect& rect) {
     return clipBounds.isEmpty() || rect.isEmpty() || !SkIRect::Intersects(clipBounds, rect);
 }

 // Draw a mask using the supplied paint. Since the coverage/geometry
 // is already burnt into the mask this boils down to a rect draw.
 // Return true if the mask was successfully drawn.
 static bool draw_mask(GrRenderTargetContext* renderTargetContext,
                       const GrClip& clip,
                       const SkMatrix& viewMatrix,
                       const SkIRect& maskRect,
                       GrPaint&& paint,
                       sk_sp<GrTextureProxy> mask) {
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }

     SkMatrix matrix = SkMatrix::MakeTrans(-SkIntToScalar(maskRect.fLeft),
                                           -SkIntToScalar(maskRect.fTop));
     matrix.preConcat(viewMatrix);
     paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(std::move(mask), matrix));

     renderTargetContext->fillRectWithLocalMatrix(clip, std::move(paint), GrAA::kNo, SkMatrix::I(),
                                                  SkRect::Make(maskRect), inverse);
     return true;
 }

 static void mask_release_proc(void* addr, void* /*context*/) {
     SkMask::FreeImage(addr);
 }

 static bool sw_draw_with_mask_filter(GrRecordingContext* context,
                                      GrRenderTargetContext* renderTargetContext,
                                      const GrClip& clipData,
                                      const SkMatrix& viewMatrix,
                                      const GrShape& shape,
                                      const SkMaskFilter* filter,
                                      const SkIRect& clipBounds,
                                      GrPaint&& paint,
                                      const GrUniqueKey& key) {
     SkASSERT(filter);
     SkASSERT(!shape.style().applies());

     auto proxyProvider = context->priv().proxyProvider();

     sk_sp<GrTextureProxy> filteredMask;

     SkStrokeRec::InitStyle fillOrHairline = shape.style().isSimpleHairline()
                                                     ? SkStrokeRec::kHairline_InitStyle
                                                     : SkStrokeRec::kFill_InitStyle;

     if (key.isValid()) {
         // TODO: this cache look up is duplicated in draw_shape_with_mask_filter for gpu
         filteredMask = proxyProvider->findOrCreateProxyByUniqueKey(key, kTopLeft_GrSurfaceOrigin);
     }

     SkIRect drawRect;
     if (filteredMask) {
         SkRect devBounds = shape.bounds();
         viewMatrix.mapRect(&devBounds);

         // Here we need to recompute the destination bounds in order to draw the mask correctly
         SkMask srcM, dstM;
         if (!SkDraw::ComputeMaskBounds(devBounds, &clipBounds, filter, &viewMatrix,
                                        &srcM.fBounds)) {
             return false;
         }

         srcM.fFormat = SkMask::kA8_Format;

         if (!as_MFB(filter)->filterMask(&dstM, srcM, viewMatrix, nullptr)) {
             return false;
         }

         // Unfortunately, we cannot double check that the computed bounds (i.e., dstM.fBounds)
         // match the stored bounds of the mask bc the proxy may have been recreated and,
         // when it is recreated, it just gets the bounds of the underlying GrTexture (which
         // might be a loose fit).
         drawRect = dstM.fBounds;
     } else {
         // TODO: it seems like we could create an SkDraw here and set its fMatrix field rather
         // than explicitly transforming the path to device space.
         SkPath devPath;

         shape.asPath(&devPath);

         devPath.transform(viewMatrix);

         SkMask srcM, dstM;
         if (!SkDraw::DrawToMask(devPath, &clipBounds, filter, &viewMatrix, &srcM,
                                 SkMask::kComputeBoundsAndRenderImage_CreateMode, fillOrHairline)) {
             return false;
         }
         SkAutoMaskFreeImage autoSrc(srcM.fImage);

         SkASSERT(SkMask::kA8_Format == srcM.fFormat);

         if (!as_MFB(filter)->filterMask(&dstM, srcM, viewMatrix, nullptr)) {
             return false;
         }
         // this will free-up dstM when we're done (allocated in filterMask())
         SkAutoMaskFreeImage autoDst(dstM.fImage);

         if (clip_bounds_quick_reject(clipBounds, dstM.fBounds)) {
             return false;
         }

         // we now have a device-aligned 8bit mask in dstM, ready to be drawn using
         // the current clip (and identity matrix) and GrPaint settings
         SkBitmap bm;
         if (!bm.installPixels(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
                               autoDst.release(), dstM.fRowBytes, mask_release_proc, nullptr)) {
             return false;
         }
         bm.setImmutable();

         sk_sp<SkImage> image = SkImage::MakeFromBitmap(bm);
         if (!image) {
             return false;
         }

         filteredMask = proxyProvider->createTextureProxy(std::move(image), GrRenderable::kNo, 1,
                                                          SkBudgeted::kYes, SkBackingFit::kApprox);
         if (!filteredMask) {
             return false;
         }

         SkASSERT(kTopLeft_GrSurfaceOrigin == filteredMask->origin());

         drawRect = dstM.fBounds;

         if (key.isValid()) {
             proxyProvider->assignUniqueKeyToProxy(key, filteredMask.get());
         }
     }

     return draw_mask(renderTargetContext, clipData, viewMatrix, drawRect,
                      std::move(paint), std::move(filteredMask));
 }

 // Create a mask of 'shape' and place the result in 'mask'.
 static sk_sp<GrTextureProxy> create_mask_GPU(GrRecordingContext* context,
                                              const SkIRect& maskRect,
                                              const SkMatrix& origViewMatrix,
                                              const GrShape& shape,
                                              int sampleCnt) {
     sk_sp<GrRenderTargetContext> rtContext(
             context->priv().makeDeferredRenderTargetContextWithFallback(
                     SkBackingFit::kApprox, maskRect.width(), maskRect.height(),
                     GrColorType::kAlpha_8, nullptr, sampleCnt, GrMipMapped::kNo,
                     kTopLeft_GrSurfaceOrigin));
     if (!rtContext) {
         return nullptr;
     }

     rtContext->priv().absClear(nullptr, SK_PMColor4fTRANSPARENT);

     GrPaint maskPaint;
     maskPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);

     // setup new clip
     const SkIRect clipRect = SkIRect::MakeWH(maskRect.width(), maskRect.height());
     GrFixedClip clip(clipRect);

     // Draw the mask into maskTexture with the path's integerized top-left at
     // the origin using maskPaint.
     SkMatrix viewMatrix = origViewMatrix;
     viewMatrix.postTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop));
     rtContext->drawShape(clip, std::move(maskPaint), GrAA::kYes, viewMatrix, shape);
     return rtContext->asTextureProxyRef();
 }

 static bool get_unclipped_shape_dev_bounds(const GrShape& shape, const SkMatrix& matrix,
                                            SkIRect* devBounds) {
     SkRect shapeBounds = shape.styledBounds();
     if (shapeBounds.isEmpty()) {
         return false;
     }
     SkRect shapeDevBounds;
     matrix.mapRect(&shapeDevBounds, shapeBounds);
     // Even though these are "unclipped" bounds we still clip to the int32_t range.
     // This is the largest int32_t that is representable exactly as a float. The next 63 larger ints
     // would round down to this value when cast to a float, but who really cares.
     // INT32_MIN is exactly representable.
     static constexpr int32_t kMaxInt = 2147483520;
     if (!shapeDevBounds.intersect(SkRect::MakeLTRB(INT32_MIN, INT32_MIN, kMaxInt, kMaxInt))) {
         return false;
     }
     // Make sure that the resulting SkIRect can have representable width and height
     if (SkScalarRoundToInt(shapeDevBounds.width()) > kMaxInt ||
         SkScalarRoundToInt(shapeDevBounds.height()) > kMaxInt) {
         return false;
     }
     shapeDevBounds.roundOut(devBounds);
     return true;
 }

 // Gets the shape bounds, the clip bounds, and the intersection (if any). Returns false if there
 // is no intersection.
 static bool get_shape_and_clip_bounds(GrRenderTargetContext* renderTargetContext,
                                       const GrClip& clip,
                                       const GrShape& shape,
                                       const SkMatrix& matrix,
                                       SkIRect* unclippedDevShapeBounds,
                                       SkIRect* devClipBounds) {
     // compute bounds as intersection of rt size, clip, and path
     clip.getConservativeBounds(renderTargetContext->width(),
                                renderTargetContext->height(),
                                devClipBounds);

     if (!get_unclipped_shape_dev_bounds(shape, matrix, unclippedDevShapeBounds)) {
         *unclippedDevShapeBounds = SkIRect::EmptyIRect();
         return false;
     }

     return true;
 }

 static void draw_shape_with_mask_filter(GrRecordingContext* context,
                                         GrRenderTargetContext* renderTargetContext,
                                         const GrClip& clip,
                                         GrPaint&& paint,
                                         const SkMatrix& viewMatrix,
                                         const SkMaskFilterBase* maskFilter,
                                         const GrShape& origShape) {
     SkASSERT(maskFilter);

     const GrShape* shape = &origShape;
     SkTLazy<GrShape> tmpShape;

     if (origShape.style().applies()) {
         SkScalar styleScale =  GrStyle::MatrixToScaleFactor(viewMatrix);
         if (0 == styleScale) {
             return;
         }

         tmpShape.init(origShape.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, styleScale));
         if (tmpShape.get()->isEmpty()) {
             return;
         }

         shape = tmpShape.get();
     }

     if (maskFilter->directFilterMaskGPU(context,
                                         renderTargetContext,
                                         std::move(paint),
                                         clip,
                                         viewMatrix,
                                         *shape)) {
         // the mask filter was able to draw itself directly, so there's nothing
         // left to do.
         return;
     }
     assert_alive(paint);

     // If the path is hairline, ignore inverse fill.
     bool inverseFilled = shape->inverseFilled() &&
                          !GrPathRenderer::IsStrokeHairlineOrEquivalent(shape->style(),
                                                                        viewMatrix, nullptr);

     SkIRect unclippedDevShapeBounds, devClipBounds;
     if (!get_shape_and_clip_bounds(renderTargetContext, clip, *shape, viewMatrix,
                                    &unclippedDevShapeBounds,
                                    &devClipBounds)) {
         // TODO: just cons up an opaque mask here
         if (!inverseFilled) {
             return;
         }
     }

     // To prevent overloading the cache with entries during animations we limit the cache of masks
     // to cases where the matrix preserves axis alignment.
 #ifdef SK_DISABLE_MASKFILTERED_MASK_CACHING
     bool useCache = false;
 #else
     bool useCache = !inverseFilled && viewMatrix.preservesAxisAlignment() &&
                     shape->hasUnstyledKey() && as_MFB(maskFilter)->asABlur(nullptr);
 #endif

     const SkIRect* boundsForClip = &devClipBounds;
     if (useCache) {
         SkIRect clippedMaskRect, unClippedMaskRect;
         maskFilter->canFilterMaskGPU(*shape, unclippedDevShapeBounds, devClipBounds,
                                      viewMatrix, &clippedMaskRect);
         maskFilter->canFilterMaskGPU(*shape, unclippedDevShapeBounds, unclippedDevShapeBounds,
                                      viewMatrix, &unClippedMaskRect);
         if (clippedMaskRect.isEmpty()) {
             return;
         }

         // Use the cache only if >50% of the filtered mask is visible.
         int unclippedWidth = unClippedMaskRect.width();
         int unclippedHeight = unClippedMaskRect.height();
         int64_t unclippedArea = sk_64_mul(unclippedWidth, unclippedHeight);
         int64_t clippedArea = sk_64_mul(clippedMaskRect.width(), clippedMaskRect.height());
         int maxTextureSize = renderTargetContext->caps()->maxTextureSize();
         if (unclippedArea > 2 * clippedArea || unclippedWidth > maxTextureSize ||
             unclippedHeight > maxTextureSize) {
             useCache = false;
         } else {
             // Make the clip not affect the mask
             boundsForClip = &unclippedDevShapeBounds;
         }
     }

     GrUniqueKey maskKey;
     if (useCache) {
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
         GrUniqueKey::Builder builder(&maskKey, kDomain, 5 + 2 + shape->unstyledKeySize(),
                                      "Mask Filtered Masks");

         // We require the upper left 2x2 of the matrix to match exactly for a cache hit.
         SkScalar sx = viewMatrix.get(SkMatrix::kMScaleX);
         SkScalar sy = viewMatrix.get(SkMatrix::kMScaleY);
         SkScalar kx = viewMatrix.get(SkMatrix::kMSkewX);
         SkScalar ky = viewMatrix.get(SkMatrix::kMSkewY);
         SkScalar tx = viewMatrix.get(SkMatrix::kMTransX);
         SkScalar ty = viewMatrix.get(SkMatrix::kMTransY);
         // Allow 8 bits each in x and y of subpixel positioning.
         SkFixed fracX = SkScalarToFixed(SkScalarFraction(tx)) & 0x0000FF00;
         SkFixed fracY = SkScalarToFixed(SkScalarFraction(ty)) & 0x0000FF00;

         builder[0] = SkFloat2Bits(sx);
         builder[1] = SkFloat2Bits(sy);
         builder[2] = SkFloat2Bits(kx);
         builder[3] = SkFloat2Bits(ky);
         // Distinguish between hairline and filled paths. For hairlines, we also need to include
         // the cap. (SW grows hairlines by 0.5 pixel with round and square caps). Note that
         // stroke-and-fill of hairlines is turned into pure fill by SkStrokeRec, so this covers
         // all cases we might see.
         uint32_t styleBits = shape->style().isSimpleHairline()
                                     ? ((shape->style().strokeRec().getCap() << 1) | 1)
                                     : 0;
         builder[4] = fracX | (fracY >> 8) | (styleBits << 16);

         SkMaskFilterBase::BlurRec rec;
         SkAssertResult(as_MFB(maskFilter)->asABlur(&rec));

         builder[5] = rec.fStyle;  // TODO: we could put this with the other style bits
         builder[6] = SkFloat2Bits(rec.fSigma);
         shape->writeUnstyledKey(&builder[7]);
     }

     SkIRect maskRect;
     if (maskFilter->canFilterMaskGPU(*shape,
                                      unclippedDevShapeBounds,
                                      *boundsForClip,
                                      viewMatrix,
                                      &maskRect)) {
         if (clip_bounds_quick_reject(*boundsForClip, maskRect)) {
             // clipped out
             return;
         }

         sk_sp<GrTextureProxy> filteredMask;

         GrProxyProvider* proxyProvider = context->priv().proxyProvider();

         if (maskKey.isValid()) {
             // TODO: this cache look up is duplicated in sw_draw_with_mask_filter for raster
             filteredMask = proxyProvider->findOrCreateProxyByUniqueKey(
                                                 maskKey, kTopLeft_GrSurfaceOrigin);
         }

         if (!filteredMask) {
             sk_sp<GrTextureProxy> maskProxy(create_mask_GPU(
                                                         context,
                                                         maskRect,
                                                         viewMatrix,
                                                         *shape,
                                                         renderTargetContext->numSamples()));
             if (maskProxy) {
                 filteredMask = maskFilter->filterMaskGPU(context,
                                                          std::move(maskProxy),
                                                          viewMatrix,
                                                          maskRect);
                 SkASSERT(kTopLeft_GrSurfaceOrigin == filteredMask->origin());

                 if (filteredMask && maskKey.isValid()) {
                     proxyProvider->assignUniqueKeyToProxy(maskKey, filteredMask.get());
                 }
             }
         }

         if (filteredMask) {
             if (draw_mask(renderTargetContext, clip, viewMatrix,
                           maskRect, std::move(paint), std::move(filteredMask))) {
                 // This path is completely drawn
                 return;
             }
             assert_alive(paint);
         }
     }

     sw_draw_with_mask_filter(context, renderTargetContext, clip, viewMatrix, *shape,
                              maskFilter, *boundsForClip, std::move(paint), maskKey);
 }

 void GrBlurUtils::drawShapeWithMaskFilter(GrRecordingContext* context,
                                           GrRenderTargetContext* renderTargetContext,
                                           const GrClip& clip,
                                           const GrShape& shape,
                                           GrPaint&& paint,
                                           const SkMatrix& viewMatrix,
                                           const SkMaskFilter* mf) {
     draw_shape_with_mask_filter(context, renderTargetContext, clip, std::move(paint),
                                 viewMatrix, as_MFB(mf), shape);
 }

 void GrBlurUtils::drawShapeWithMaskFilter(GrRecordingContext* context,
                                           GrRenderTargetContext* renderTargetContext,
                                           const GrClip& clip,
                                           const SkPaint& paint,
                                           const SkMatrix& viewMatrix,
                                           const GrShape& shape) {
     if (context->priv().abandoned()) {
         return;
     }

     GrPaint grPaint;
     if (!SkPaintToGrPaint(context, renderTargetContext->colorSpaceInfo(), paint, viewMatrix,
                           &grPaint)) {
         return;
     }

     SkMaskFilterBase* mf = as_MFB(paint.getMaskFilter());
     if (mf && !mf->hasFragmentProcessor()) {
         // The MaskFilter wasn't already handled in SkPaintToGrPaint
         draw_shape_with_mask_filter(context, renderTargetContext, clip, std::move(grPaint),
                                     viewMatrix, mf, shape);
     } else {
         GrAA aa = GrAA(paint.isAntiAlias());
         renderTargetContext->drawShape(clip, std::move(grPaint), aa, viewMatrix, shape);
     }
 }
	/*
	* 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 "src/gpu/GrBlurUtils.h"

	#include "include/private/GrRecordingContext.h"
	#include "src/gpu/GrCaps.h"
	#include "src/gpu/GrFixedClip.h"
	#include "src/gpu/GrProxyProvider.h"
	#include "src/gpu/GrRecordingContextPriv.h"
	#include "src/gpu/GrRenderTargetContext.h"
	#include "src/gpu/GrRenderTargetContextPriv.h"
	#include "src/gpu/GrSoftwarePathRenderer.h"
	#include "src/gpu/GrStyle.h"
	#include "src/gpu/GrTextureProxy.h"
	#include "src/gpu/effects/generated/GrSimpleTextureEffect.h"
	#include "src/gpu/geometry/GrShape.h"

	#include "include/core/SkPaint.h"
	#include "src/core/SkDraw.h"
	#include "src/core/SkMaskFilterBase.h"
	#include "src/core/SkTLazy.h"
	#include "src/gpu/SkGr.h"

	static bool clip_bounds_quick_reject(const SkIRect& clipBounds, const SkIRect& rect) {
	return clipBounds.isEmpty() \|\| rect.isEmpty() \|\| !SkIRect::Intersects(clipBounds, rect);
	}

	// Draw a mask using the supplied paint. Since the coverage/geometry
	// is already burnt into the mask this boils down to a rect draw.
	// Return true if the mask was successfully drawn.
	static bool draw_mask(GrRenderTargetContext* renderTargetContext,
	const GrClip& clip,
	const SkMatrix& viewMatrix,
	const SkIRect& maskRect,
	GrPaint&& paint,
	sk_sp<GrTextureProxy> mask) {
	SkMatrix inverse;
	if (!viewMatrix.invert(&inverse)) {
	return false;
	}

	SkMatrix matrix = SkMatrix::MakeTrans(-SkIntToScalar(maskRect.fLeft),
	-SkIntToScalar(maskRect.fTop));
	matrix.preConcat(viewMatrix);
	paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(std::move(mask), matrix));

	renderTargetContext->fillRectWithLocalMatrix(clip, std::move(paint), GrAA::kNo, SkMatrix::I(),
	SkRect::Make(maskRect), inverse);
	return true;
	}

	static void mask_release_proc(void* addr, void* /context/) {
	SkMask::FreeImage(addr);
	}

	static bool sw_draw_with_mask_filter(GrRecordingContext* context,
	GrRenderTargetContext* renderTargetContext,
	const GrClip& clipData,
	const SkMatrix& viewMatrix,
	const GrShape& shape,
	const SkMaskFilter* filter,
	const SkIRect& clipBounds,
	GrPaint&& paint,
	const GrUniqueKey& key) {
	SkASSERT(filter);
	SkASSERT(!shape.style().applies());

	auto proxyProvider = context->priv().proxyProvider();

	sk_sp<GrTextureProxy> filteredMask;

	SkStrokeRec::InitStyle fillOrHairline = shape.style().isSimpleHairline()
	? SkStrokeRec::kHairline_InitStyle
	: SkStrokeRec::kFill_InitStyle;

	if (key.isValid()) {
	// TODO: this cache look up is duplicated in draw_shape_with_mask_filter for gpu
	filteredMask = proxyProvider->findOrCreateProxyByUniqueKey(key, kTopLeft_GrSurfaceOrigin);
	}

	SkIRect drawRect;
	if (filteredMask) {
	SkRect devBounds = shape.bounds();
	viewMatrix.mapRect(&devBounds);

	// Here we need to recompute the destination bounds in order to draw the mask correctly
	SkMask srcM, dstM;
	if (!SkDraw::ComputeMaskBounds(devBounds, &clipBounds, filter, &viewMatrix,
	&srcM.fBounds)) {
	return false;
	}

	srcM.fFormat = SkMask::kA8_Format;

	if (!as_MFB(filter)->filterMask(&dstM, srcM, viewMatrix, nullptr)) {
	return false;
	}

	// Unfortunately, we cannot double check that the computed bounds (i.e., dstM.fBounds)
	// match the stored bounds of the mask bc the proxy may have been recreated and,
	// when it is recreated, it just gets the bounds of the underlying GrTexture (which
	// might be a loose fit).
	drawRect = dstM.fBounds;
	} else {
	// TODO: it seems like we could create an SkDraw here and set its fMatrix field rather
	// than explicitly transforming the path to device space.
	SkPath devPath;

	shape.asPath(&devPath);

	devPath.transform(viewMatrix);

	SkMask srcM, dstM;
	if (!SkDraw::DrawToMask(devPath, &clipBounds, filter, &viewMatrix, &srcM,
	SkMask::kComputeBoundsAndRenderImage_CreateMode, fillOrHairline)) {
	return false;
	}
	SkAutoMaskFreeImage autoSrc(srcM.fImage);

	SkASSERT(SkMask::kA8_Format == srcM.fFormat);

	if (!as_MFB(filter)->filterMask(&dstM, srcM, viewMatrix, nullptr)) {
	return false;
	}
	// this will free-up dstM when we're done (allocated in filterMask())
	SkAutoMaskFreeImage autoDst(dstM.fImage);

	if (clip_bounds_quick_reject(clipBounds, dstM.fBounds)) {
	return false;
	}

	// we now have a device-aligned 8bit mask in dstM, ready to be drawn using
	// the current clip (and identity matrix) and GrPaint settings
	SkBitmap bm;
	if (!bm.installPixels(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
	autoDst.release(), dstM.fRowBytes, mask_release_proc, nullptr)) {
	return false;
	}
	bm.setImmutable();

	sk_sp<SkImage> image = SkImage::MakeFromBitmap(bm);
	if (!image) {
	return false;
	}

	filteredMask = proxyProvider->createTextureProxy(std::move(image), GrRenderable::kNo, 1,
	SkBudgeted::kYes, SkBackingFit::kApprox);
	if (!filteredMask) {
	return false;
	}

	SkASSERT(kTopLeft_GrSurfaceOrigin == filteredMask->origin());

	drawRect = dstM.fBounds;

	if (key.isValid()) {
	proxyProvider->assignUniqueKeyToProxy(key, filteredMask.get());
	}
	}

	return draw_mask(renderTargetContext, clipData, viewMatrix, drawRect,
	std::move(paint), std::move(filteredMask));
	}

	// Create a mask of 'shape' and place the result in 'mask'.
	static sk_sp<GrTextureProxy> create_mask_GPU(GrRecordingContext* context,
	const SkIRect& maskRect,
	const SkMatrix& origViewMatrix,
	const GrShape& shape,
	int sampleCnt) {
	sk_sp<GrRenderTargetContext> rtContext(
	context->priv().makeDeferredRenderTargetContextWithFallback(
	SkBackingFit::kApprox, maskRect.width(), maskRect.height(),
	GrColorType::kAlpha_8, nullptr, sampleCnt, GrMipMapped::kNo,
	kTopLeft_GrSurfaceOrigin));
	if (!rtContext) {
	return nullptr;
	}

	rtContext->priv().absClear(nullptr, SK_PMColor4fTRANSPARENT);

	GrPaint maskPaint;
	maskPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);

	// setup new clip
	const SkIRect clipRect = SkIRect::MakeWH(maskRect.width(), maskRect.height());
	GrFixedClip clip(clipRect);

	// Draw the mask into maskTexture with the path's integerized top-left at
	// the origin using maskPaint.
	SkMatrix viewMatrix = origViewMatrix;
	viewMatrix.postTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop));
	rtContext->drawShape(clip, std::move(maskPaint), GrAA::kYes, viewMatrix, shape);
	return rtContext->asTextureProxyRef();
	}

	static bool get_unclipped_shape_dev_bounds(const GrShape& shape, const SkMatrix& matrix,
	SkIRect* devBounds) {
	SkRect shapeBounds = shape.styledBounds();
	if (shapeBounds.isEmpty()) {
	return false;
	}
	SkRect shapeDevBounds;
	matrix.mapRect(&shapeDevBounds, shapeBounds);
	// Even though these are "unclipped" bounds we still clip to the int32_t range.
	// This is the largest int32_t that is representable exactly as a float. The next 63 larger ints
	// would round down to this value when cast to a float, but who really cares.
	// INT32_MIN is exactly representable.
	static constexpr int32_t kMaxInt = 2147483520;
	if (!shapeDevBounds.intersect(SkRect::MakeLTRB(INT32_MIN, INT32_MIN, kMaxInt, kMaxInt))) {
	return false;
	}
	// Make sure that the resulting SkIRect can have representable width and height
	if (SkScalarRoundToInt(shapeDevBounds.width()) > kMaxInt \|\|
	SkScalarRoundToInt(shapeDevBounds.height()) > kMaxInt) {
	return false;
	}
	shapeDevBounds.roundOut(devBounds);
	return true;
	}

	// Gets the shape bounds, the clip bounds, and the intersection (if any). Returns false if there
	// is no intersection.
	static bool get_shape_and_clip_bounds(GrRenderTargetContext* renderTargetContext,
	const GrClip& clip,
	const GrShape& shape,
	const SkMatrix& matrix,
	SkIRect* unclippedDevShapeBounds,
	SkIRect* devClipBounds) {
	// compute bounds as intersection of rt size, clip, and path
	clip.getConservativeBounds(renderTargetContext->width(),
	renderTargetContext->height(),
	devClipBounds);

	if (!get_unclipped_shape_dev_bounds(shape, matrix, unclippedDevShapeBounds)) {
	*unclippedDevShapeBounds = SkIRect::EmptyIRect();
	return false;
	}

	return true;
	}

	static void draw_shape_with_mask_filter(GrRecordingContext* context,
	GrRenderTargetContext* renderTargetContext,
	const GrClip& clip,
	GrPaint&& paint,
	const SkMatrix& viewMatrix,
	const SkMaskFilterBase* maskFilter,
	const GrShape& origShape) {
	SkASSERT(maskFilter);

	const GrShape* shape = &origShape;
	SkTLazy<GrShape> tmpShape;

	if (origShape.style().applies()) {
	SkScalar styleScale = GrStyle::MatrixToScaleFactor(viewMatrix);
	if (0 == styleScale) {
	return;
	}

	tmpShape.init(origShape.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, styleScale));
	if (tmpShape.get()->isEmpty()) {
	return;
	}

	shape = tmpShape.get();
	}

	if (maskFilter->directFilterMaskGPU(context,
	renderTargetContext,
	std::move(paint),
	clip,
	viewMatrix,
	*shape)) {
	// the mask filter was able to draw itself directly, so there's nothing
	// left to do.
	return;
	}
	assert_alive(paint);

	// If the path is hairline, ignore inverse fill.
	bool inverseFilled = shape->inverseFilled() &&
	!GrPathRenderer::IsStrokeHairlineOrEquivalent(shape->style(),
	viewMatrix, nullptr);

	SkIRect unclippedDevShapeBounds, devClipBounds;
	if (!get_shape_and_clip_bounds(renderTargetContext, clip, *shape, viewMatrix,
	&unclippedDevShapeBounds,
	&devClipBounds)) {
	// TODO: just cons up an opaque mask here
	if (!inverseFilled) {
	return;
	}
	}

	// To prevent overloading the cache with entries during animations we limit the cache of masks
	// to cases where the matrix preserves axis alignment.
	#ifdef SK_DISABLE_MASKFILTERED_MASK_CACHING
	bool useCache = false;
	#else
	bool useCache = !inverseFilled && viewMatrix.preservesAxisAlignment() &&
	shape->hasUnstyledKey() && as_MFB(maskFilter)->asABlur(nullptr);
	#endif

	const SkIRect* boundsForClip = &devClipBounds;
	if (useCache) {
	SkIRect clippedMaskRect, unClippedMaskRect;
	maskFilter->canFilterMaskGPU(*shape, unclippedDevShapeBounds, devClipBounds,
	viewMatrix, &clippedMaskRect);
	maskFilter->canFilterMaskGPU(*shape, unclippedDevShapeBounds, unclippedDevShapeBounds,
	viewMatrix, &unClippedMaskRect);
	if (clippedMaskRect.isEmpty()) {
	return;
	}

	// Use the cache only if >50% of the filtered mask is visible.
	int unclippedWidth = unClippedMaskRect.width();
	int unclippedHeight = unClippedMaskRect.height();
	int64_t unclippedArea = sk_64_mul(unclippedWidth, unclippedHeight);
	int64_t clippedArea = sk_64_mul(clippedMaskRect.width(), clippedMaskRect.height());
	int maxTextureSize = renderTargetContext->caps()->maxTextureSize();
	if (unclippedArea > 2 * clippedArea \|\| unclippedWidth > maxTextureSize \|\|
	unclippedHeight > maxTextureSize) {
	useCache = false;
	} else {
	// Make the clip not affect the mask
	boundsForClip = &unclippedDevShapeBounds;
	}
	}

	GrUniqueKey maskKey;
	if (useCache) {
	static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
	GrUniqueKey::Builder builder(&maskKey, kDomain, 5 + 2 + shape->unstyledKeySize(),
	"Mask Filtered Masks");

	// We require the upper left 2x2 of the matrix to match exactly for a cache hit.
	SkScalar sx = viewMatrix.get(SkMatrix::kMScaleX);
	SkScalar sy = viewMatrix.get(SkMatrix::kMScaleY);
	SkScalar kx = viewMatrix.get(SkMatrix::kMSkewX);
	SkScalar ky = viewMatrix.get(SkMatrix::kMSkewY);
	SkScalar tx = viewMatrix.get(SkMatrix::kMTransX);
	SkScalar ty = viewMatrix.get(SkMatrix::kMTransY);
	// Allow 8 bits each in x and y of subpixel positioning.
	SkFixed fracX = SkScalarToFixed(SkScalarFraction(tx)) & 0x0000FF00;
	SkFixed fracY = SkScalarToFixed(SkScalarFraction(ty)) & 0x0000FF00;

	builder[0] = SkFloat2Bits(sx);
	builder[1] = SkFloat2Bits(sy);
	builder[2] = SkFloat2Bits(kx);
	builder[3] = SkFloat2Bits(ky);
	// Distinguish between hairline and filled paths. For hairlines, we also need to include
	// the cap. (SW grows hairlines by 0.5 pixel with round and square caps). Note that
	// stroke-and-fill of hairlines is turned into pure fill by SkStrokeRec, so this covers
	// all cases we might see.
	uint32_t styleBits = shape->style().isSimpleHairline()
	? ((shape->style().strokeRec().getCap() << 1) \| 1)
	: 0;
	builder[4] = fracX \| (fracY >> 8) \| (styleBits << 16);

	SkMaskFilterBase::BlurRec rec;
	SkAssertResult(as_MFB(maskFilter)->asABlur(&rec));

	builder[5] = rec.fStyle; // TODO: we could put this with the other style bits
	builder[6] = SkFloat2Bits(rec.fSigma);
	shape->writeUnstyledKey(&builder[7]);
	}

	SkIRect maskRect;
	if (maskFilter->canFilterMaskGPU(*shape,
	unclippedDevShapeBounds,
	*boundsForClip,
	viewMatrix,
	&maskRect)) {
	if (clip_bounds_quick_reject(*boundsForClip, maskRect)) {
	// clipped out
	return;
	}

	sk_sp<GrTextureProxy> filteredMask;

	GrProxyProvider* proxyProvider = context->priv().proxyProvider();

	if (maskKey.isValid()) {
	// TODO: this cache look up is duplicated in sw_draw_with_mask_filter for raster
	filteredMask = proxyProvider->findOrCreateProxyByUniqueKey(
	maskKey, kTopLeft_GrSurfaceOrigin);
	}

	if (!filteredMask) {
	sk_sp<GrTextureProxy> maskProxy(create_mask_GPU(
	context,
	maskRect,
	viewMatrix,
	*shape,
	renderTargetContext->numSamples()));
	if (maskProxy) {
	filteredMask = maskFilter->filterMaskGPU(context,
	std::move(maskProxy),
	viewMatrix,
	maskRect);
	SkASSERT(kTopLeft_GrSurfaceOrigin == filteredMask->origin());

	if (filteredMask && maskKey.isValid()) {
	proxyProvider->assignUniqueKeyToProxy(maskKey, filteredMask.get());
	}
	}
	}

	if (filteredMask) {
	if (draw_mask(renderTargetContext, clip, viewMatrix,
	maskRect, std::move(paint), std::move(filteredMask))) {
	// This path is completely drawn
	return;
	}
	assert_alive(paint);
	}
	}

	sw_draw_with_mask_filter(context, renderTargetContext, clip, viewMatrix, *shape,
	maskFilter, *boundsForClip, std::move(paint), maskKey);
	}

	void GrBlurUtils::drawShapeWithMaskFilter(GrRecordingContext* context,
	GrRenderTargetContext* renderTargetContext,
	const GrClip& clip,
	const GrShape& shape,
	GrPaint&& paint,
	const SkMatrix& viewMatrix,
	const SkMaskFilter* mf) {
	draw_shape_with_mask_filter(context, renderTargetContext, clip, std::move(paint),
	viewMatrix, as_MFB(mf), shape);
	}

	void GrBlurUtils::drawShapeWithMaskFilter(GrRecordingContext* context,
	GrRenderTargetContext* renderTargetContext,
	const GrClip& clip,
	const SkPaint& paint,
	const SkMatrix& viewMatrix,
	const GrShape& shape) {
	if (context->priv().abandoned()) {
	return;
	}

	GrPaint grPaint;
	if (!SkPaintToGrPaint(context, renderTargetContext->colorSpaceInfo(), paint, viewMatrix,
	&grPaint)) {
	return;
	}

	SkMaskFilterBase* mf = as_MFB(paint.getMaskFilter());
	if (mf && !mf->hasFragmentProcessor()) {
	// The MaskFilter wasn't already handled in SkPaintToGrPaint
	draw_shape_with_mask_filter(context, renderTargetContext, clip, std::move(grPaint),
	viewMatrix, mf, shape);
	} else {
	GrAA aa = GrAA(paint.isAntiAlias());
	renderTargetContext->drawShape(clip, std::move(grPaint), aa, viewMatrix, shape);
	}
	}