diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index 0f2d632..a5b591e 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -724,6 +724,17 @@
     return !(a == b);
 }
 
+const SkRect& SkClipStack::Iter::Clip::getBounds() const {
+    if (NULL != fRect) {
+        return *fRect;
+    } else if (NULL != fPath) {
+        return fPath->getBounds();
+    } else {
+        static const SkRect kEmpty = {0, 0, 0, 0};
+        return kEmpty;
+    }
+}
+
 SkClipStack::Iter::Iter(const SkClipStack& stack, IterStart startLoc)
     : fStack(&stack) {
     this->reset(stack, startLoc);
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index 2be92dc..606b90e 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "GrClipMaskManager.h"
+#include "effects/GrTextureDomainEffect.h"
 #include "GrGpu.h"
 #include "GrRenderTarget.h"
 #include "GrStencilBuffer.h"
@@ -42,7 +43,13 @@
     mat.preConcat(drawState->getViewMatrix());
 
     drawState->stage(kMaskStage)->reset();
-    drawState->createTextureEffect(kMaskStage, result, mat);
+
+    SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
+    drawState->stage(kMaskStage)->setEffect(
+        GrTextureDomainEffect::Create(result,
+                                      mat,
+                                      GrTextureDomainEffect::MakeTexelDomain(result, domainTexels),
+                                      GrTextureDomainEffect::kDecal_WrapMode))->unref();
 }
 
 bool path_needs_SW_renderer(GrContext* context,
@@ -152,8 +159,7 @@
     GrIRect devClipBounds;
     bool isIntersectionOfRects = false;
 
-    clipDataIn->getConservativeBounds(rt, &devClipBounds,
-                                      &isIntersectionOfRects);
+    clipDataIn->getConservativeBounds(rt, &devClipBounds, &isIntersectionOfRects);
     if (devClipBounds.isEmpty()) {
         return false;
     }
@@ -483,25 +489,31 @@
     return true;
 }
 
-void GrClipMaskManager::drawTexture(GrTexture* target,
-                                    GrTexture* texture) {
+void GrClipMaskManager::mergeMask(GrTexture* dstMask,
+                                  GrTexture* srcMask,
+                                  SkRegion::Op op,
+                                  const GrIRect& dstBound,
+                                  const GrIRect& srcBound) {
     GrDrawState* drawState = fGpu->drawState();
     GrAssert(NULL != drawState);
+    SkMatrix oldMatrix = drawState->getViewMatrix();
+    drawState->viewMatrix()->reset();
 
-    // no AA here since it is encoded in the texture
-    drawState->setRenderTarget(target->asRenderTarget());
+    drawState->setRenderTarget(dstMask->asRenderTarget());
 
+    setup_boolean_blendcoeffs(drawState, op);
+    
     SkMatrix sampleM;
-    sampleM.setIDiv(texture->width(), texture->height());
-
-    drawState->createTextureEffect(0, texture, sampleM);
-
-    GrRect rect = GrRect::MakeWH(SkIntToScalar(target->width()),
-                                 SkIntToScalar(target->height()));
-
-    fGpu->drawSimpleRect(rect, NULL);
+    sampleM.setIDiv(srcMask->width(), srcMask->height());
+    drawState->stage(0)->setEffect(
+        GrTextureDomainEffect::Create(srcMask,
+                                      sampleM,
+                                      GrTextureDomainEffect::MakeTexelDomain(srcMask, srcBound),
+                                      GrTextureDomainEffect::kDecal_WrapMode))->unref();
+    fGpu->drawSimpleRect(SkRect::MakeFromIRect(dstBound), NULL);
 
     drawState->disableStage(0);
+    drawState->setViewMatrix(oldMatrix);
 }
 
 // get a texture to act as a temporary buffer for AA clip boolean operations
@@ -599,14 +611,18 @@
 
     GrDrawTarget::AutoGeometryPush agp(fGpu);
 
-    if (0 != devResultBounds->fTop || 0 != devResultBounds->fLeft ||
-        0 != clipDataIn.fOrigin.fX || 0 != clipDataIn.fOrigin.fY) {
-        // if we were able to trim down the size of the mask we need to
-        // offset the paths & rects that will be used to compute it
-        drawState->viewMatrix()->setTranslate(
-                SkIntToScalar(-devResultBounds->fLeft-clipDataIn.fOrigin.fX),
-                SkIntToScalar(-devResultBounds->fTop-clipDataIn.fOrigin.fY));
-    }
+    // The mask we generate is translated so that its upper-left corner is at devResultBounds
+    // upper-left corner in device space.
+    GrIRect maskResultBounds = GrIRect::MakeWH(devResultBounds->width(), devResultBounds->height());
+
+    // Set the matrix so that rendered clip elements are transformed from the space of the clip
+    // stack to the alpha-mask. This accounts for both translation due to the clip-origin and the
+    // placement of the mask within the device.
+    SkVector clipToMaskOffset = {
+        SkIntToScalar(-devResultBounds->fLeft - clipDataIn.fOrigin.fX),
+        SkIntToScalar(-devResultBounds->fTop - clipDataIn.fOrigin.fY)
+    };
+    drawState->viewMatrix()->setTranslate(clipToMaskOffset);
 
     bool clearToInside;
     SkRegion::Op firstOp = SkRegion::kReplace_Op; // suppress warning
@@ -618,10 +634,12 @@
                                                               &clearToInside,
                                                               &firstOp,
                                                               clipDataIn);
-
-    fGpu->clear(NULL,
+    // The scratch texture that we are drawing into can be substantially larger than the mask. Only
+    // clear the part that we care about.
+    fGpu->clear(&maskResultBounds,
                 clearToInside ? 0xffffffff : 0x00000000,
                 accum->asRenderTarget());
+    bool accumClearedToZero = !clearToInside;
 
     GrAutoScratchTexture temp;
     bool first = true;
@@ -636,8 +654,10 @@
 
         if (SkRegion::kReplace_Op == op) {
             // clear the accumulator and draw the new object directly into it
-            fGpu->clear(NULL, 0x00000000, accum->asRenderTarget());
-
+            if (!accumClearedToZero) {
+                fGpu->clear(&maskResultBounds, 0x00000000, accum->asRenderTarget());
+            }
+            
             setup_boolean_blendcoeffs(drawState, op);
             this->drawClipShape(accum, clip, *devResultBounds);
 
@@ -655,40 +675,31 @@
                 return false;
             }
 
+            // this is the bounds of the clip element in the space of the alpha-mask. The temporary
+            // mask buffer can be substantially larger than the actually clip stack element. We
+            // touch the minimum number of pixels necessary and use decal mode to combine it with
+            // the accumulator
+            GrRect elementMaskBounds = clip->getBounds();
+            elementMaskBounds.offset(clipToMaskOffset);
+            GrIRect elementMaskIBounds;
+            elementMaskBounds.roundOut(&elementMaskIBounds);
+
             // clear the temp target & draw into it
-            fGpu->clear(NULL, 0x00000000, temp.texture()->asRenderTarget());
+            fGpu->clear(&elementMaskIBounds, 0x00000000, temp.texture()->asRenderTarget());
 
             setup_boolean_blendcoeffs(drawState, SkRegion::kReplace_Op);
-            this->drawClipShape(temp.texture(), clip, *devResultBounds);
-
-            // TODO: rather than adding these two translations here
-            // compute the bounding box needed to render the texture
-            // into temp
-            if (0 != devResultBounds->fTop || 0 != devResultBounds->fLeft ||
-                0 != clipDataIn.fOrigin.fX || 0 != clipDataIn.fOrigin.fY) {
-                // In order for the merge of the temp clip into the accumulator
-                // to work we need to disable the translation
-                drawState->viewMatrix()->reset();
-            }
+            this->drawClipShape(temp.texture(), clip, elementMaskIBounds);
 
             // Now draw into the accumulator using the real operation
             // and the temp buffer as a texture
-            setup_boolean_blendcoeffs(drawState, op);
-            this->drawTexture(accum, temp.texture());
-
-            if (0 != devResultBounds->fTop || 0 != devResultBounds->fLeft ||
-                0 != clipDataIn.fOrigin.fX || 0 != clipDataIn.fOrigin.fY) {
-                drawState->viewMatrix()->setTranslate(
-                  SkIntToScalar(-devResultBounds->fLeft-clipDataIn.fOrigin.fX),
-                  SkIntToScalar(-devResultBounds->fTop-clipDataIn.fOrigin.fY));
-            }
-
+            this->mergeMask(accum, temp.texture(), op, maskResultBounds, elementMaskIBounds);
         } else {
             // all the remaining ops can just be directly draw into
             // the accumulation buffer
             setup_boolean_blendcoeffs(drawState, op);
             this->drawClipShape(accum, clip, *devResultBounds);
         }
+        accumClearedToZero = false;
     }
 
     *result = accum;
diff --git a/src/gpu/GrClipMaskManager.h b/src/gpu/GrClipMaskManager.h
index d23a525..89b1ef8 100644
--- a/src/gpu/GrClipMaskManager.h
+++ b/src/gpu/GrClipMaskManager.h
@@ -128,8 +128,11 @@
                        const SkClipStack::Iter::Clip* clip,
                        const GrIRect& resultBounds);
 
-    void drawTexture(GrTexture* target,
-                     GrTexture* texture);
+    void mergeMask(GrTexture* dstMask,
+                   GrTexture* srcMask,
+                   SkRegion::Op op,
+                   const GrIRect& dstBound,
+                   const GrIRect& srcBound);
 
     void getTemp(const GrIRect& bounds, GrAutoScratchTexture* temp);
 
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 14eeace..2d79991 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1435,7 +1435,11 @@
             top = bottom = SkScalarHalf(paintRect.top() + paintRect.bottom());
         }
         textureDomain.setLTRB(left, top, right, bottom);
-        effect.reset(SkNEW_ARGS(GrTextureDomainEffect, (texture, textureDomain, params)));
+        effect.reset(GrTextureDomainEffect::Create(texture,
+                                                   SkMatrix::I(),
+                                                   textureDomain,
+                                                   GrTextureDomainEffect::kClamp_WrapMode,
+                                                   params.isBilerp()));
     } else {
         effect.reset(SkNEW_ARGS(GrSingleTextureEffect, (texture, params)));
     }
diff --git a/src/gpu/effects/GrTextureDomainEffect.cpp b/src/gpu/effects/GrTextureDomainEffect.cpp
index 823b072..e500fad 100644
--- a/src/gpu/effects/GrTextureDomainEffect.cpp
+++ b/src/gpu/effects/GrTextureDomainEffect.cpp
@@ -43,28 +43,40 @@
 }
 
 void GrGLTextureDomainEffect::emitCode(GrGLShaderBuilder* builder,
-                                       const GrEffectStage&,
+                                       const GrEffectStage& stage,
                                        EffectKey key,
                                        const char* vertexCoords,
                                        const char* outputColor,
                                        const char* inputColor,
                                        const TextureSamplerArray& samplers) {
+    const GrTextureDomainEffect& effect =
+        static_cast<const GrTextureDomainEffect&>(*stage.getEffect());
+
     const char* coords;
     fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, vertexCoords, &coords);
+    const char* domain;
     fNameUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                   kVec4f_GrSLType, "TexDom");
+                                    kVec4f_GrSLType, "TexDom", &domain);
+    if (GrTextureDomainEffect::kClamp_WrapMode == effect.wrapMode()) {
 
-    builder->fFSCode.appendf("\tvec2 clampCoord = clamp(%s, %s.xy, %s.zw);\n",
-                           coords,
-                           builder->getUniformCStr(fNameUni),
-                           builder->getUniformCStr(fNameUni));
+        builder->fFSCode.appendf("\tvec2 clampCoord = clamp(%s, %s.xy, %s.zw);\n",
+                               coords, domain, domain);
 
-    builder->fFSCode.appendf("\t%s = ", outputColor);
-    builder->appendTextureLookupAndModulate(&builder->fFSCode,
-                                            inputColor,
-                                            samplers[0],
-                                            "clampCoord");
-    builder->fFSCode.append(";\n");
+        builder->fFSCode.appendf("\t%s = ", outputColor);
+        builder->appendTextureLookupAndModulate(&builder->fFSCode,
+                                                inputColor,
+                                                samplers[0],
+                                                "clampCoord");
+        builder->fFSCode.append(";\n");
+    } else {
+        GrAssert(GrTextureDomainEffect::kDecal_WrapMode == effect.wrapMode());
+        builder->fFSCode.append("\tbvec4 outside;\n");
+        builder->fFSCode.appendf("\toutside.xy = lessThan(%s, %s.xy);\n", coords, domain);
+        builder->fFSCode.appendf("\toutside.zw = greaterThan(%s, %s.zw);\n", coords, domain);
+        builder->fFSCode.appendf("\t%s = any(outside) ? vec4(0.0, 0.0, 0.0, 0.0) : ", outputColor);
+        builder->appendTextureLookupAndModulate(&builder->fFSCode, inputColor, samplers[0], coords);
+        builder->fFSCode.append(";\n");
+    }
 }
 
 void GrGLTextureDomainEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
@@ -98,21 +110,41 @@
 GrGLEffect::EffectKey GrGLTextureDomainEffect::GenKey(const GrEffectStage& stage, const GrGLCaps&) {
     const GrTextureDomainEffect& effect =
         static_cast<const GrTextureDomainEffect&>(*stage.getEffect());
-    return GrGLEffectMatrix::GenKey(effect.getMatrix(), stage.getCoordChangeMatrix(), effect.texture(0));
+    EffectKey key = effect.wrapMode();
+    key <<= GrGLEffectMatrix::kKeyBits;
+    EffectKey matrixKey = GrGLEffectMatrix::GenKey(effect.getMatrix(),
+                                                   stage.getCoordChangeMatrix(),
+                                                   effect.texture(0));
+    return key | matrixKey;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrTextureDomainEffect::GrTextureDomainEffect(GrTexture* texture, const GrRect& domain)
-    : GrSingleTextureEffect(texture)
-    , fTextureDomain(domain) {
+GrEffect* GrTextureDomainEffect::Create(GrTexture* texture,
+                                        const SkMatrix& matrix,
+                                        const GrRect& domain,
+                                        WrapMode wrapMode,
+                                        bool bilerp) {
+    static const SkRect kFullRect = {0, 0, SK_Scalar1, SK_Scalar1};
+    if (kClamp_WrapMode == wrapMode && domain.contains(kFullRect)) {
+        return SkNEW_ARGS(GrSingleTextureEffect, (texture, matrix, bilerp));
+    } else {
+        SkRect clippedDomain;
+        // We don't currently handle domains that are empty or don't intersect the texture.
+        SkAssertResult(clippedDomain.intersect(kFullRect, domain));
+        return SkNEW_ARGS(GrTextureDomainEffect,
+                          (texture, matrix, clippedDomain, wrapMode, bilerp));
+    }
 }
 
 GrTextureDomainEffect::GrTextureDomainEffect(GrTexture* texture,
+                                             const SkMatrix& matrix,
                                              const GrRect& domain,
-                                             const GrTextureParams& params)
-    : GrSingleTextureEffect(texture, params)
+                                             WrapMode wrapMode,
+                                             bool bilerp)
+    : GrSingleTextureEffect(texture, matrix, bilerp)
+    , fWrapMode(wrapMode)
     , fTextureDomain(domain) {
 }
 
@@ -143,5 +175,7 @@
     domain.fRight = random->nextRangeScalar(domain.fLeft, SK_Scalar1);
     domain.fTop = random->nextUScalar1();
     domain.fBottom = random->nextRangeScalar(domain.fTop, SK_Scalar1);
-    return SkNEW_ARGS(GrTextureDomainEffect, (textures[texIdx], domain));
+    WrapMode wrapMode = random->nextBool() ? kClamp_WrapMode : kDecal_WrapMode;
+    const SkMatrix& matrix = GrEffectUnitTest::TestMatrix(random);
+    return GrTextureDomainEffect::Create(textures[texIdx], matrix, domain, wrapMode);
 }
diff --git a/src/gpu/effects/GrTextureDomainEffect.h b/src/gpu/effects/GrTextureDomainEffect.h
index 322f8d0..c1ce6d1 100644
--- a/src/gpu/effects/GrTextureDomainEffect.h
+++ b/src/gpu/effects/GrTextureDomainEffect.h
@@ -14,15 +14,31 @@
 class GrGLTextureDomainEffect;
 
 /**
- * Limits a texture's lookup coordinates to a domain.
+ * Limits a texture's lookup coordinates to a domain. Samples outside the domain are either clamped
+ * the edge of the domain or result in a vec4 of zeros. The domain is clipped to normalized texture
+ * coords ([0,1]x[0,1] square). Bilinear filtering can cause texels outside the domain to affect the
+ * read value unless the caller considers this when calculating the domain. TODO: This should be a
+ * helper that can assist an effect rather than effect unto itself.
  */
 class GrTextureDomainEffect : public GrSingleTextureEffect {
 
 public:
-    /** Uses default texture params (no filter, clamp) */
-    GrTextureDomainEffect(GrTexture*, const GrRect& domain);
+    /**
+     * If SkShader::kDecal_TileMode sticks then this enum could be replaced by SkShader::TileMode.
+     * We could also consider replacing/augmenting Decal mode with Border mode where the color
+     * outside of the domain is user-specifiable. Decal mode currently has a hard (non-lerped)
+     * transition between the border and the interior.
+     */
+    enum WrapMode {
+        kClamp_WrapMode,
+        kDecal_WrapMode,
+    };
 
-    GrTextureDomainEffect(GrTexture*, const GrRect& domain, const GrTextureParams& params);
+    static GrEffect* Create(GrTexture*,
+                            const SkMatrix&,
+                            const SkRect& domain,
+                            WrapMode,
+                            bool bilerp = false);
 
     virtual ~GrTextureDomainEffect();
 
@@ -33,13 +49,34 @@
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
     virtual bool isEqual(const GrEffect&) const SK_OVERRIDE;
 
-    const GrRect& domain() const { return fTextureDomain; }
+    const SkRect& domain() const { return fTextureDomain; }
+    WrapMode wrapMode() const { return fWrapMode; }
+
+    /* Computes a domain that bounds all the texels in texelRect. Note that with bilerp enabled
+       texels neighboring the domain may be read. */
+    static const SkRect MakeTexelDomain(const GrTexture* texture, const SkIRect& texelRect) {
+        SkScalar wInv = SK_Scalar1 / texture->width();
+        SkScalar hInv = SK_Scalar1 / texture->height();
+        SkRect result = {
+            texelRect.fLeft * wInv,
+            texelRect.fTop * hInv,
+            texelRect.fRight * wInv,
+            texelRect.fBottom * hInv
+        };
+        return result;
+    }
 
 protected:
-
-    GrRect fTextureDomain;
+    WrapMode fWrapMode;
+    SkRect   fTextureDomain;
 
 private:
+    GrTextureDomainEffect(GrTexture*,
+                          const SkMatrix&,
+                          const GrRect& domain,
+                          WrapMode,
+                          bool bilerp);
+
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrSingleTextureEffect INHERITED;