diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
index a8810f9..0c873ee 100644
--- a/gpu/include/GrContext.h
+++ b/gpu/include/GrContext.h
@@ -490,6 +490,21 @@
     void writePixels(int left, int top, int width, int height,
                      GrPixelConfig, const void* buffer, size_t stride);
 
+    /**
+     * Performs a 1D convolution over a rectangle of pixels.  Set
+     * imageIncrement to (1/w, 0) for a convolution in X, (0, 1/h) for a
+     * convolution in Y, where w, h are the texture dimensions.
+     * @param srcTexture      the texture to read from
+     * @param dstRect         the destination rectangle
+     * @param imageIncrement  the displacement between pixel samples
+     * @param kernel          the convolution kernel (kernelWidth elements)
+     * @param kernelWidth     the width of the convolution kernel
+     */
+    void convolveRect(GrTexture* srcTexture,
+                      const SkRect& dstRect,
+                      float imageIncrement[2],
+                      const float* kernel,
+                      int kernelWidth);
     ///////////////////////////////////////////////////////////////////////////
     // Helpers
 
diff --git a/gpu/include/GrSamplerState.h b/gpu/include/GrSamplerState.h
index d10d8c4..c7a4f2b 100644
--- a/gpu/include/GrSamplerState.h
+++ b/gpu/include/GrSamplerState.h
@@ -21,6 +21,8 @@
 #include "GrTypes.h"
 #include "GrMatrix.h"
 
+#define MAX_KERNEL_WIDTH 25
+
 class GrSamplerState {
 public:
     enum Filter {
@@ -39,6 +41,10 @@
          * between texels in x and y spaced 4 texels apart.)
          */
         k4x4Downsample_Filter,
+        /**
+         * Apply a separable convolution kernel.
+         */
+        kConvolution_Filter
     };
 
     /**
@@ -148,6 +154,9 @@
     const GrRect& getTextureDomain() const { return fTextureDomain; }
     bool hasTextureDomain() const {return SkIntToScalar(0) != fTextureDomain.right();}
     Filter getFilter() const { return fFilter; }
+    int getKernelWidth() const { return fKernelWidth; }
+    const float* getKernel() const { return fKernel; }
+    const float* getImageIncrement() const { return fImageIncrement; }
 
     bool isGradient() const {
         return  kRadial_SampleMode == fSampleMode ||
@@ -220,6 +229,19 @@
         fRadial2PosRoot = posRoot;
     }
 
+    void setConvolutionParams(int kernelWidth, const float* kernel, float imageIncrement[2]) {
+        GrAssert(kernelWidth >= 0 && kernelWidth <= MAX_KERNEL_WIDTH);
+        fKernelWidth = kernelWidth;
+        if (NULL != kernel) {
+            memcpy(fKernel, kernel, kernelWidth * sizeof(float));
+        }
+        if (NULL != imageIncrement) {
+            memcpy(fImageIncrement, imageIncrement, sizeof(fImageIncrement));
+        } else {
+            memset(fImageIncrement, 0, sizeof(fImageIncrement));
+        }
+    }
+
     static const GrSamplerState& ClampNoFilter() {
         return gClampNoFilter;
     }
@@ -237,6 +259,11 @@
     GrScalar    fRadial2Radius0;
     bool        fRadial2PosRoot;
 
+    // These are undefined unless fFilter == kConvolution_Filter
+    int         fKernelWidth;
+    float       fKernel[MAX_KERNEL_WIDTH];
+    float       fImageIncrement[2];
+
     static const GrSamplerState gClampNoFilter;
 };
 
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index b75c917..092b0ba 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -1699,3 +1699,22 @@
     }
 }
 
+void GrContext::convolveRect(GrTexture* srcTexture,
+                             const SkRect& rect,
+                             float imageIncrement[2],
+                             const float* kernel,
+                             int kernelWidth) {
+    GrDrawTarget::AutoStateRestore asr(fGpu);
+    GrMatrix sampleM;
+    GrSamplerState sampler(GrSamplerState::kClamp_WrapMode, 
+                           GrSamplerState::kClamp_WrapMode,
+                           GrSamplerState::kConvolution_Filter);
+    sampler.setConvolutionParams(kernelWidth, kernel, imageIncrement);
+    sampleM.setScale(GR_Scalar1 / srcTexture->width(),
+                     GR_Scalar1 / srcTexture->height());
+    sampler.setMatrix(sampleM);
+    fGpu->setSamplerState(0, sampler);
+    fGpu->setViewMatrix(GrMatrix::I());
+    fGpu->setTexture(0, srcTexture);
+    fGpu->drawSimpleRect(rect, NULL, 1 << 0);
+}
diff --git a/gpu/src/GrGLProgram.cpp b/gpu/src/GrGLProgram.cpp
index d6a832c..4290c96 100644
--- a/gpu/src/GrGLProgram.cpp
+++ b/gpu/src/GrGLProgram.cpp
@@ -136,6 +136,13 @@
     s->appendS32(stage);
 }
 
+static void convolve_param_names(int stage, GrStringBuilder* k, GrStringBuilder* i) {
+    *k = "uKernel";
+    k->appendS32(stage);
+    *i = "uImageIncrement";
+    i->appendS32(stage);
+}
+
 static void tex_domain_name(int stage, GrStringBuilder* s) {
     *s = "uTexDom";
     s->appendS32(stage);
@@ -941,6 +948,22 @@
                                              texDomName.c_str()));
                 GrAssert(kUnusedUniform != locations.fTexDomUni);
             }
+
+            GrStringBuilder kernelName, imageIncrementName;
+            convolve_param_names(s, &kernelName, &imageIncrementName);
+            if (kUseUniform == locations.fKernelUni) {
+                locations.fKernelUni = GR_GL(GetUniformLocation(
+                                             progID,
+                                             kernelName.c_str()));
+                GrAssert(kUnusedUniform != locations.fKernelUni);
+            }
+
+            if (kUseUniform == locations.fImageIncrementUni) {
+                locations.fImageIncrementUni = GR_GL(GetUniformLocation(
+                                                     progID,
+                                                     imageIncrementName.c_str()));
+                GrAssert(kUnusedUniform != locations.fImageIncrementUni);
+            }
         }
     }
     GR_GL(UseProgram(progID));
@@ -1058,6 +1081,24 @@
         }
     }
 
+    GrStringBuilder kernelName, kernelWidthName, imageIncrementName;
+    convolve_param_names(stageNum, &kernelName, &imageIncrementName);
+
+    if (ProgramDesc::StageDesc::kConvolution_FetchMode == desc.fFetchMode) {
+        segments->fFSUnis.appendf("uniform float %s[%d];\n",
+                                  kernelName.c_str(), desc.fKernelWidth);
+        segments->fFSUnis.appendf("uniform vec2 %s;\n",
+                                  imageIncrementName.c_str());
+        segments->fVSUnis.appendf("uniform vec2 %s;\n",
+                                  imageIncrementName.c_str());
+        locations->fKernelUni = kUseUniform;
+        locations->fImageIncrementUni = kUseUniform;
+        float scale = (desc.fKernelWidth - 1) * 0.5f;
+        segments->fVSCode.appendf("\t%s -= vec2(%g, %g) * %s;\n",
+                                  varyingName.c_str(), scale, scale,
+                                  imageIncrementName.c_str());
+}
+
     /// Fragment Shader Stuff
     GrStringBuilder fsCoordName;
     // function used to access the shader, may be made projective
@@ -1229,6 +1270,17 @@
         segments->fFSCode.appendf("\t%s += %s(%s, %s + vec2(-%s.x,+%s.y))%s;\n", accumVar.c_str(), texFunc.c_str(), samplerName.c_str(), sampleCoords.c_str(), texelSizeName.c_str(), texelSizeName.c_str(), smear);
         segments->fFSCode.appendf("\t%s += %s(%s, %s + vec2(+%s.x,+%s.y))%s;\n", accumVar.c_str(), texFunc.c_str(), samplerName.c_str(), sampleCoords.c_str(), texelSizeName.c_str(), texelSizeName.c_str(), smear);
         segments->fFSCode.appendf("\t%s = .25 * %s%s;\n", fsOutColor, accumVar.c_str(), modulate.c_str());
+    } else if (ProgramDesc::StageDesc::kConvolution_FetchMode == desc.fFetchMode) {
+        segments->fFSCode.append("\tvec4 sum = vec4(0, 0, 0, 0);\n");
+        segments->fFSCode.appendf("\tvec2 coord = %s;\n", sampleCoords.c_str());
+        segments->fFSCode.appendf("\tfor (int i = 0; i < %d; i++) {\n", desc.fKernelWidth);
+        segments->fFSCode.appendf("\t\tsum += %s(%s, coord)%s * %s[i];\n",
+                                  texFunc.c_str(), samplerName.c_str(),
+                                  smear, kernelName.c_str());
+        segments->fFSCode.appendf("\t\tcoord += %s;\n",
+                                  imageIncrementName.c_str());
+        segments->fFSCode.appendf("\t}\n");
+        segments->fFSCode.appendf("\t%s = sum%s;\n", fsOutColor, modulate.c_str());
     } else {
         segments->fFSCode.appendf("\t%s = %s(%s, %s)%s%s;\n", fsOutColor, texFunc.c_str(), samplerName.c_str(), sampleCoords.c_str(), smear, modulate.c_str());
     }
diff --git a/gpu/src/GrGLProgram.h b/gpu/src/GrGLProgram.h
index edd4737..60a7177 100644
--- a/gpu/src/GrGLProgram.h
+++ b/gpu/src/GrGLProgram.h
@@ -114,6 +114,7 @@
             enum FetchMode {
                 kSingle_FetchMode,
                 k2x2_FetchMode,
+                kConvolution_FetchMode,
 
                 kFetchModeCnt,
             };
@@ -132,6 +133,7 @@
             uint8_t fModulation;  // casts to enum Modulation
             uint8_t fFetchMode;  // casts to enum FetchMode
             uint8_t fCoordMapping;  // casts to enum CoordMapping
+            uint8_t fKernelWidth;
 
             inline bool isEnabled() const {
                 return fOptFlags & kIsEnabled_OptFlagBit;
@@ -197,12 +199,16 @@
         GrGLint fSamplerUni;
         GrGLint fRadial2Uni;
         GrGLint fTexDomUni;
+        GrGLint fKernelUni;
+        GrGLint fImageIncrementUni;
         void reset() {
             fTextureMatrixUni = kUnusedUniform;
             fNormalizedTexelSizeUni = kUnusedUniform;
             fSamplerUni = kUnusedUniform;
             fRadial2Uni = kUnusedUniform;
             fTexDomUni = kUnusedUniform;
+            fKernelUni = kUnusedUniform;
+            fImageIncrementUni = kUnusedUniform;
         }
     };
 
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index 1f9afdc..1a9d7fe 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -574,8 +574,8 @@
         fHWDrawState.fSamplerStates[s].setRadial2Params(-GR_ScalarMax,
                                                         -GR_ScalarMax,
                                                         true);
-
         fHWDrawState.fSamplerStates[s].setMatrix(GrMatrix::InvalidMatrix());
+        fHWDrawState.fSamplerStates[s].setConvolutionParams(0, NULL, NULL);
     }
 
     fHWBounds.fScissorRect.invalidate();
@@ -586,6 +586,7 @@
     fHWDrawState.fStencilSettings.invalidate();
     fHWStencilClip = false;
     fClipState.fClipIsDirty = true;
+    fClipState.fClipInStencil = false;
 
     fHWGeometryState.fIndexBuffer = NULL;
     fHWGeometryState.fVertexBuffer = NULL;
@@ -1786,6 +1787,20 @@
     }
 }
 
+static unsigned grToGLFilter(GrSamplerState::Filter filter) {
+    switch (filter) {
+        case GrSamplerState::kBilinear_Filter:
+        case GrSamplerState::k4x4Downsample_Filter:
+            return GR_GL_LINEAR;
+        case GrSamplerState::kNearest_Filter:
+        case GrSamplerState::kConvolution_Filter:
+            return GR_GL_NEAREST;
+        default:
+            GrAssert(!"Unknown filter type");
+            return GR_GL_LINEAR;
+    }
+}
+
 bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) {
 
     // GrGpu::setupClipAndFlushState should have already checked this
@@ -1827,11 +1842,7 @@
                                                 nextTexture->getTexParams();
             GrGLTexture::TexParams newTexParams;
 
-            if (GrSamplerState::kNearest_Filter == sampler.getFilter()) {
-                newTexParams.fFilter = GR_GL_NEAREST;
-            } else {
-                newTexParams.fFilter = GR_GL_LINEAR;
-            }
+            newTexParams.fFilter = grToGLFilter(sampler.getFilter());
 
             newTexParams.fWrapS =
                         GrGLTexture::WrapMode2GLWrap()[sampler.getWrapX()];
diff --git a/gpu/src/GrGpuGLShaders.cpp b/gpu/src/GrGpuGLShaders.cpp
index 1309802..a52501b 100644
--- a/gpu/src/GrGpuGLShaders.cpp
+++ b/gpu/src/GrGpuGLShaders.cpp
@@ -453,6 +453,18 @@
     }
 }
 
+void GrGpuGLShaders::flushConvolution(int s) {
+    const GrSamplerState& sampler = fCurrDrawState.fSamplerStates[s];
+    int kernelUni = fProgramData->fUniLocations.fStages[s].fKernelUni;
+    if (GrGLProgram::kUnusedUniform != kernelUni) {
+        GR_GL(Uniform1fv(kernelUni, sampler.getKernelWidth(), sampler.getKernel()));
+    }
+    int imageIncrementUni = fProgramData->fUniLocations.fStages[s].fImageIncrementUni;
+    if (GrGLProgram::kUnusedUniform != imageIncrementUni) {
+        GR_GL(Uniform2fv(imageIncrementUni, 1, sampler.getImageIncrement()));
+    }
+}
+
 void GrGpuGLShaders::flushTexelSize(int s) {
     const int& uni = fProgramData->fUniLocations.fStages[s].fNormalizedTexelSizeUni;
     if (GrGLProgram::kUnusedUniform != uni) {
@@ -587,6 +599,8 @@
 
         this->flushRadial2(s);
 
+        this->flushConvolution(s);
+
         this->flushTexelSize(s);
 
         this->flushTextureDomain(s);
@@ -784,6 +798,10 @@
                 case GrSamplerState::k4x4Downsample_Filter:
                     stage.fFetchMode = StageDesc::k2x2_FetchMode;
                     break;
+                // performs fKernelWidth texture2D()s
+                case GrSamplerState::kConvolution_Filter:
+                    stage.fFetchMode = StageDesc::kConvolution_FetchMode;
+                    break;
                 default:
                     GrCrash("Unexpected filter!");
                     break;
@@ -802,6 +820,11 @@
             } else {
                 stage.fModulation = StageDesc::kColor_Modulation;
             }
+            if (sampler.getFilter() == GrSamplerState::kConvolution_Filter) {
+                stage.fKernelWidth = sampler.getKernelWidth();
+            } else {
+                stage.fKernelWidth = 0;
+            }
         } else {
             stage.fOptFlags     = 0;
             stage.fCoordMapping = (StageDesc::CoordMapping)0;
diff --git a/gpu/src/GrGpuGLShaders.h b/gpu/src/GrGpuGLShaders.h
index 17811c8..43ff5ea 100644
--- a/gpu/src/GrGpuGLShaders.h
+++ b/gpu/src/GrGpuGLShaders.h
@@ -70,6 +70,9 @@
     // flushes the parameters to two point radial gradient
     void flushRadial2(int stage);
 
+    // flushes the parameters for convolution
+    void flushConvolution(int stage);
+
     // flushes the normalized texel size
     void flushTexelSize(int stage);
 
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index d6ee03d..54f0e79 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -47,6 +47,8 @@
 };
 
 
+#define USE_GPU_BLUR false
+#define MAX_SIGMA 4.0f
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGpuDevice::SkAutoCachedTexture::
@@ -790,6 +792,214 @@
 #include "SkMaskFilter.h"
 #include "SkBounder.h"
 
+static GrPathFill skToGrFillType(SkPath::FillType fillType) {
+    switch (fillType) {
+        case SkPath::kWinding_FillType:
+            return kWinding_PathFill;
+        case SkPath::kEvenOdd_FillType:
+            return kEvenOdd_PathFill;
+        case SkPath::kInverseWinding_FillType:
+            return kInverseWinding_PathFill;
+        case SkPath::kInverseEvenOdd_FillType:
+            return kInverseEvenOdd_PathFill;
+        default:
+            SkDebugf("Unsupported path fill type\n");
+            return kHairLine_PathFill;
+    }
+}
+
+static float gauss(float x, float sigma)
+{
+    // Note that the constant term (1/(sqrt(2*pi*sigma^2)) is dropped here,
+    // since we renormalize the kernel after generation anyway.
+    return exp(- (x * x) / (2.0f * sigma * sigma));
+}
+
+static void buildKernel(float sigma, float* kernel, int kernelWidth)
+{
+    int halfWidth = (kernelWidth - 1) / 2;
+    float sum = 0.0f;
+    for (int i = 0; i < kernelWidth; ++i) {
+        kernel[i] = gauss(i - halfWidth, sigma);
+        sum += kernel[i];
+    }
+    // Normalize the kernel
+    float scale = 1.0f / sum;
+    for (int i = 0; i < kernelWidth; ++i)
+        kernel[i] *= scale;
+}
+
+static void swap(GrTexture*& a, GrTexture*& b)
+{
+    GrTexture* tmp = a;
+    a = b;
+    b = tmp;
+}
+
+static void scaleRect(SkRect* rect, float scale)
+{
+    rect->fLeft *= scale;
+    rect->fTop *= scale;
+    rect->fRight *= scale;
+    rect->fBottom *= scale;
+}
+
+static bool drawWithGPUMaskFilter(GrContext* context, const SkPath& path,
+                                  SkMaskFilter* filter, const SkMatrix& matrix,
+                                  const SkRegion& clip, SkBounder* bounder,
+                                  GrPaint* grp) {
+    SkMaskFilter::BlurInfo info;
+    if (!filter->asABlur(&info)) {
+        return false;
+    }
+    float radius = info.fIgnoreTransform ? info.fRadius
+                                         : matrix.mapRadius(info.fRadius);
+    float sigma = radius * 0.6666f;
+    SkRect srcRect = path.getBounds();
+
+    int scaleFactor = 1;
+
+    while (sigma > MAX_SIGMA) {
+        scaleFactor *= 2;
+        sigma *= 0.5f;
+    }
+    scaleRect(&srcRect, 1.0f / scaleFactor);
+    int halfWidth = static_cast<int>(sigma * 3.0f);
+    int kernelWidth = halfWidth * 2 + 1;
+
+    SkIRect srcIRect;
+    srcRect.roundOut(&srcIRect);
+    srcRect.set(srcIRect);
+    srcRect.inset(-halfWidth, -halfWidth);
+
+    scaleRect(&srcRect, scaleFactor);
+    SkRect finalRect = srcRect;
+
+    SkIRect finalIRect;
+    finalRect.roundOut(&finalIRect);
+    if (clip.quickReject(finalIRect)) {
+        return false;
+    }
+    if (bounder && !bounder->doIRect(finalIRect)) {
+        return false;
+    }
+    GrPoint offset = GrPoint::Make(-srcRect.fLeft, -srcRect.fTop);
+    srcRect.offset(-srcRect.fLeft, -srcRect.fTop);
+    const GrTextureDesc desc = {
+        kRenderTarget_GrTextureFlagBit,
+        kNone_GrAALevel,
+        srcRect.width(),
+        srcRect.height(),
+        // We actually only need A8, but it often isn't supported as a
+        // render target
+        kRGBA_8888_GrPixelConfig
+    };
+
+    GrTextureEntry* srcEntry = context->findApproximateKeylessTexture(desc);
+    GrTextureEntry* dstEntry = context->findApproximateKeylessTexture(desc);
+    if (NULL == srcEntry || NULL == dstEntry) {
+        return false;
+    }
+    GrTexture* srcTexture = srcEntry->texture();
+    GrTexture* dstTexture = dstEntry->texture();
+    if (NULL == srcTexture || NULL == dstTexture) {
+        return false;
+    }
+    GrRenderTarget* oldRenderTarget = context->getRenderTarget();
+    context->setRenderTarget(dstTexture->asRenderTarget());
+    // FIXME:  could just clear bounds
+    context->clear(NULL, 0);
+    GrMatrix transM;
+    GrPaint tempPaint;
+    tempPaint.reset();
+
+    GrAutoMatrix avm(context, GrMatrix::I());
+    // Draw hard shadow to offscreen context, with path topleft at origin 0,0.
+    context->drawPath(tempPaint, path, skToGrFillType(path.getFillType()), &offset);
+    swap(srcTexture, dstTexture);
+
+    GrMatrix sampleM;
+    sampleM.setScale(GR_Scalar1 / srcTexture->width(),
+                     GR_Scalar1 / srcTexture->height());
+    GrPaint paint;
+    paint.reset();
+    paint.getTextureSampler(0)->setFilter(GrSamplerState::kBilinear_Filter);
+    paint.getTextureSampler(0)->setMatrix(sampleM);
+    for (int i = 1; i < scaleFactor; i *= 2) {
+        context->setRenderTarget(dstTexture->asRenderTarget());
+        SkRect dstRect(srcRect);
+        scaleRect(&dstRect, 0.5f);
+        // Clear out 1 pixel border for linear filtering.
+        // FIXME:  for now, clear everything
+        context->clear(NULL, 0);
+        paint.setTexture(0, srcTexture);
+        context->drawRectToRect(paint, dstRect, srcRect);
+        srcRect = dstRect;
+        swap(srcTexture, dstTexture);
+    }
+
+    SkAutoTMalloc<float> kernelStorage(kernelWidth);
+    float* kernel = kernelStorage.get();
+    buildKernel(sigma, kernel, kernelWidth);
+
+    float imageIncrementX[2] = {1.0f / srcTexture->width(), 0.0f};
+    context->setRenderTarget(dstTexture->asRenderTarget());
+    context->clear(NULL, 0);
+    context->convolveRect(srcTexture, srcRect, imageIncrementX, kernel,
+                          kernelWidth);
+    swap(srcTexture, dstTexture);
+
+    float imageIncrementY[2] = {0.0f, 1.0f / srcTexture->height()};
+    context->setRenderTarget(dstTexture->asRenderTarget());
+    context->clear(NULL, 0);
+    context->convolveRect(srcTexture, srcRect, imageIncrementY, kernel,
+                          kernelWidth);
+    swap(srcTexture, dstTexture);
+
+    if (scaleFactor > 1) {
+        // FIXME:  This should be mitchell, not bilinear.
+        paint.getTextureSampler(0)->setFilter(GrSamplerState::kBilinear_Filter);
+        sampleM.setScale(GR_Scalar1 / srcTexture->width(),
+                         GR_Scalar1 / srcTexture->height());
+        paint.getTextureSampler(0)->setMatrix(sampleM);
+        context->setRenderTarget(dstTexture->asRenderTarget());
+        // Clear out 2 pixel border for bicubic filtering.
+        // FIXME:  for now, clear everything
+        context->clear(NULL, 0);
+        paint.setTexture(0, srcTexture);
+        SkRect dstRect(srcRect);
+        scaleRect(&dstRect, scaleFactor);
+        context->drawRectToRect(paint, dstRect, srcRect);
+        srcRect = dstRect;
+        swap(srcTexture, dstTexture);
+    }
+
+    context->setRenderTarget(oldRenderTarget);
+    
+    if (grp->hasTextureOrMask()) {
+        GrMatrix inverse;
+        if (!matrix.invert(&inverse)) {
+            return false;
+        }
+        grp->preConcatActiveSamplerMatrices(inverse);
+    }
+
+    static const int MASK_IDX = GrPaint::kMaxMasks - 1;
+    // we assume the last mask index is available for use
+    GrAssert(NULL == grp->getMask(MASK_IDX));
+    grp->setMask(MASK_IDX, srcTexture);
+    grp->getMaskSampler(MASK_IDX)->setClampNoFilter();
+
+    GrMatrix m;
+    m.setTranslate(-finalRect.fLeft, -finalRect.fTop);
+    m.postIDiv(srcTexture->width(), srcTexture->height());
+    grp->getMaskSampler(MASK_IDX)->setMatrix(m);
+    context->drawRect(*grp, finalRect);
+    context->unlockTexture(srcEntry);
+    context->unlockTexture(dstEntry);
+    return true;
+}
+
 static bool drawWithMaskFilter(GrContext* context, const SkPath& path,
                                SkMaskFilter* filter, const SkMatrix& matrix,
                                const SkRegion& clip, SkBounder* bounder,
@@ -928,9 +1138,15 @@
 
         // transform the path into device space
         pathPtr->transform(*draw.fMatrix, devPathPtr);
-
-        drawWithMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
-                           *draw.fMatrix, *draw.fClip, draw.fBounder, &grPaint);
+        if (USE_GPU_BLUR) {
+            drawWithGPUMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
+                                  *draw.fMatrix, *draw.fClip, draw.fBounder,
+                                  &grPaint);
+        } else {
+            drawWithMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
+                               *draw.fMatrix, *draw.fClip, draw.fBounder,
+                               &grPaint);
+        }
         return;
     }