Fast blurred rectangles on GPU

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
@@ skipping 901 matching lines @@
                 pathIsMutable = true;
                 stroke.setFillStyle();
             }
         }
 
         // avoid possibly allocating a new path in transform if we can
         SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init();
 
         // transform the path into device space
         pathPtr->transform(fContext->getMatrix(), devPathPtr);
-
+        
         SkRect maskRect;
         if (paint.getMaskFilter()->canFilterMaskGPU(devPathPtr->getBounds(),
                                                     draw.fClip->getBounds(),
                                                     fContext->getMatrix(),
                                                     &maskRect)) {
             // The context's matrix may change while creating the mask, so save the CTM here to
             // pass to filterMaskGPU.
             const SkMatrix ctm = fContext->getMatrix();
 
             SkIRect finalIRect;
             maskRect.roundOut(&finalIRect);
             if (draw.fClip->quickReject(finalIRect)) {
                 // clipped out
                 return;
             }
             if (NULL != draw.fBounder && !draw.fBounder->doIRect(finalIRect)) {
                 // nothing to draw
                 return;
             }
+            
+            if (paint.getMaskFilter()->directFilterMaskGPU(fContext, &grPaint,
+                                                           SkStrokeRec(paint), *devPathPtr)) {
+                // the mask filter was able to draw itself directly, so there's nothing
+                // left to do.
+                return;
+            }
 
             GrAutoScratchTexture mask;
 
             if (create_mask_GPU(fContext, maskRect, *devPathPtr, stroke,
                                 grPaint.isAntiAlias(), &mask)) {
                 GrTexture* filtered;
 
                 if (paint.getMaskFilter()->filterMaskGPU(mask.texture(),
                                                          ctm, maskRect, &filtered, true)) {
                     // filterMaskGPU gives us ownership of a ref to the result
@@ skipping 1010 matching lines @@
                          GrTexture* texture,
                          bool needClear)
     : SkBitmapDevice(make_bitmap(context, texture->asRenderTarget())) {
 
     SkASSERT(texture && texture->asRenderTarget());
     // This constructor is called from onCreateCompatibleDevice. It has locked the RT in the texture
     // cache. We pass true for the third argument so that it will get unlocked.
     this->initFromRenderTarget(context, texture->asRenderTarget(), true);
     fNeedClear = needClear;
 }