diff --git a/gm/gm_files.mk b/gm/gm_files.mk
index e867820..fec20b6 100644
--- a/gm/gm_files.mk
+++ b/gm/gm_files.mk
@@ -3,6 +3,7 @@
     blurs.cpp \
     filltypes.cpp \
     gradients.cpp \
+    nocolorbleed.cpp \
     pathfill.cpp \
     points.cpp \
     poly2poly.cpp \
diff --git a/gm/nocolorbleed.cpp b/gm/nocolorbleed.cpp
new file mode 100755
index 0000000..85bad30
--- /dev/null
+++ b/gm/nocolorbleed.cpp
@@ -0,0 +1,65 @@
+#include "gm.h"
+
+namespace skiagm {
+
+class NoColorBleedGM : public GM {
+public:
+	NoColorBleedGM() {}
+
+protected:
+    virtual SkString onShortName() {
+        return SkString("nocolorbleed");
+    }
+
+	virtual SkISize onISize() {
+        return make_isize(200, 200);
+    }
+
+    void drawBG(SkCanvas* canvas) {
+        canvas->drawColor(0xFFDDDDDD);
+    }
+
+    virtual void onDraw(SkCanvas* canvas) {
+        drawBG(canvas);
+
+        SkBitmap sprite;
+        sprite.setConfig(SkBitmap::kARGB_8888_Config, 4, 4, 4*sizeof(SkColor));
+        SkColor spriteData[16] = {
+            SK_ColorBLACK,  SK_ColorCYAN,    SK_ColorMAGENTA, SK_ColorYELLOW,
+            SK_ColorBLACK,  SK_ColorWHITE,   SK_ColorBLACK,   SK_ColorRED,
+            SK_ColorGREEN,  SK_ColorBLACK,   SK_ColorWHITE,   SK_ColorBLUE,
+            SK_ColorYELLOW, SK_ColorMAGENTA, SK_ColorCYAN,    SK_ColorBLACK
+        };
+        sprite.setPixels(spriteData);
+
+        // We draw a magnified subrect of the sprite
+        // sample interpolation may cause color bleeding around edges
+        // the subrect is a pure white area
+        SkIRect srcRect;
+        SkRect dstRect;
+        SkPaint paint;
+        paint.setFilterBitmap(true);
+        //First row : full texture with and without filtering
+        srcRect.setXYWH(0, 0, 4, 4);
+        dstRect.setXYWH(0.0f, 0.0f, 100.0f, 100.0f);
+        canvas->drawBitmapRect(sprite, &srcRect, dstRect, &paint);
+        dstRect.setXYWH(100.0f, 0.0f, 100.0f, 100.0f);
+        canvas->drawBitmapRect(sprite, &srcRect, dstRect);
+        //Second row : sub rect of texture with and without filtering
+        srcRect.setXYWH(1, 1, 2, 2);
+        dstRect.setXYWH(25.0f, 125.0f, 50.0f, 50.0f);
+        canvas->drawBitmapRect(sprite, &srcRect, dstRect, &paint);
+        dstRect.setXYWH(125.0f, 125.0f, 50.0f, 50.0f);
+        canvas->drawBitmapRect(sprite, &srcRect, dstRect);
+    }
+
+private:
+    typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new NoColorBleedGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gpu/include/GrSamplerState.h b/gpu/include/GrSamplerState.h
index dd47c53..f477495 100644
--- a/gpu/include/GrSamplerState.h
+++ b/gpu/include/GrSamplerState.h
@@ -94,6 +94,7 @@
         fSampleMode = kNormal_SampleMode;
         fFilter = filter;
         fMatrix.setIdentity();
+        fTextureDomain.setEmpty();
     }
 
     GrSamplerState(WrapMode wx, WrapMode wy, Filter filter) {
@@ -102,6 +103,7 @@
         fSampleMode = kNormal_SampleMode;
         fFilter = filter;
         fMatrix.setIdentity();
+        fTextureDomain.setEmpty();
     }
 
     GrSamplerState(WrapMode wx, WrapMode wy, 
@@ -111,6 +113,7 @@
         fSampleMode = kNormal_SampleMode;
         fFilter = filter;
         fMatrix = matrix;
+        fTextureDomain.setEmpty();
     }
 
     GrSamplerState(WrapMode wx, WrapMode wy, SampleMode sample, 
@@ -120,12 +123,15 @@
         fSampleMode = sample;
         fMatrix = matrix;
         fFilter = filter;
+        fTextureDomain.setEmpty();
     }
 
     WrapMode getWrapX() const { return fWrapX; }
     WrapMode getWrapY() const { return fWrapY; }
     SampleMode getSampleMode() const { return fSampleMode; }
     const GrMatrix& getMatrix() const { return fMatrix; }
+    const GrRect& getTextureDomain() const { return fTextureDomain; }
+    const bool hasTextureDomain() const {return SkIntToScalar(0) != fTextureDomain.right();}
     Filter getFilter() const { return fFilter; }
 
     bool isGradient() const {
@@ -146,6 +152,13 @@
     void setMatrix(const GrMatrix& matrix) { fMatrix = matrix; }
     
     /**
+     * Sets the sampler's texture coordinate domain to a 
+     * custom rectangle, rather than the default (0,1).
+     * This option is currently only supported with kClamp_WrapMode
+     */
+    void setTextureDomain(const GrRect& textureDomain) { fTextureDomain = textureDomain; }
+
+    /**
      *  Multiplies the current sampler matrix  a matrix
      *
      *  After this call M' = M*m where M is the old matrix, m is the parameter
@@ -169,6 +182,7 @@
         fSampleMode = kNormal_SampleMode;
         fFilter = kNearest_Filter;
         fMatrix.setIdentity();
+        fTextureDomain.setEmpty();
     }
 
     GrScalar getRadial2CenterX1() const { return fRadial2CenterX1; }
@@ -198,6 +212,7 @@
     SampleMode  fSampleMode;
     Filter      fFilter;
     GrMatrix    fMatrix;
+    GrRect      fTextureDomain;
 
     // these are undefined unless fSampleMode == kRadial2_SampleMode
     GrScalar    fRadial2CenterX1;
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index 518b4ee..efee91e 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -19,6 +19,8 @@
 #include "GrGpuVertex.h"
 #include "GrTexture.h"
 
+namespace {
+
 // recursive helper for creating mask with all the tex coord bits set for
 // one stage
 template <int N>
@@ -26,16 +28,16 @@
     return GrDrawTarget::StageTexCoordVertexLayoutBit(stage, N) |
            stage_mask_recur<N+1>(stage);
 }
-template<> // linux build doesn't like static on specializations
+template<> 
 int stage_mask_recur<GrDrawTarget::kNumStages>(int) { return 0; }
 
 // mask of all tex coord indices for one stage
-static int stage_tex_coord_mask(int stage) {
+int stage_tex_coord_mask(int stage) {
     return stage_mask_recur<0>(stage);
 }
 
 // mask of all bits relevant to one stage
-static int stage_mask(int stage) {
+int stage_mask(int stage) {
     return stage_tex_coord_mask(stage) |
            GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(stage);
 }
@@ -47,11 +49,11 @@
     return GrDrawTarget::StageTexCoordVertexLayoutBit(N, texCoordIdx) |
            tex_coord_mask_recur<N+1>(texCoordIdx);
 }
-template<> // linux build doesn't like static on specializations
+template<> 
 int tex_coord_mask_recur<GrDrawTarget::kMaxTexCoords>(int) { return 0; }
 
 // mask of all bits relevant to one texture coordinate index
-static int tex_coord_idx_mask(int texCoordIdx) {
+int tex_coord_idx_mask(int texCoordIdx) {
     return tex_coord_mask_recur<0>(texCoordIdx);
 }
 
@@ -66,6 +68,8 @@
     return true;
 }
 
+} //unnamed namespace
+
 size_t GrDrawTarget::VertexSize(GrVertexLayout vertexLayout) {
     GrAssert(check_layout(vertexLayout));
 
diff --git a/gpu/src/GrGLProgram.cpp b/gpu/src/GrGLProgram.cpp
index 5d2d8b3..ab327d0 100644
--- a/gpu/src/GrGLProgram.cpp
+++ b/gpu/src/GrGLProgram.cpp
@@ -120,6 +120,11 @@
     s->appendS32(stage);
 }
 
+static void tex_domain_name(int stage, GrStringBuilder* s) {
+    *s = "uTexDom";
+    s->appendS32(stage);
+}
+
 GrGLProgram::GrGLProgram() {
     for(int stage = 0; stage < GrDrawTarget::kNumStages; ++stage) {
         fStageEffects[stage] = NULL;
@@ -650,6 +655,15 @@
                                              radial2ParamName.c_str()));
                 GrAssert(kUnusedUniform != locations.fRadial2Uni);
             }
+
+            if (kUseUniform == locations.fTexDomUni) {
+                GrStringBuilder texDomName;
+                tex_domain_name(s, &texDomName);
+                locations.fTexDomUni = GR_GL(GetUniformLocation(
+                                             progID,
+                                             texDomName.c_str()));
+                GrAssert(kUnusedUniform != locations.fTexDomUni);
+            }
         }
     }
     GR_GL(UseProgram(progID));
@@ -869,6 +883,24 @@
         modulate.printf(" * %s", fsInColor);
     }
 
+    if (desc.fOptFlags & 
+        ProgramDesc::StageDesc::kCustomTextureDomain_OptFlagBit) {
+        GrStringBuilder texDomainName;
+        tex_domain_name(stageNum, &texDomainName);
+        segments->fFSUnis.appendf("uniform %s %s;\n", 
+                                  float_vector_type(4),
+                                  texDomainName.c_str());
+        GrStringBuilder coordVar("clampCoord");
+        segments->fFSCode.appendf("\t%s %s = clamp(%s, %s.xy, %s.zw);\n",
+                                  float_vector_type(coordDims),
+                                  coordVar.c_str(),
+                                  sampleCoords.c_str(),
+                                  texDomainName.c_str(),
+                                  texDomainName.c_str());
+        sampleCoords = coordVar;
+        locations->fTexDomUni = kUseUniform;
+    }
+
     if (ProgramDesc::StageDesc::k2x2_FetchMode == desc.fFetchMode) {
         locations->fNormalizedTexelSizeUni = kUseUniform;
         if (complexCoord) {
diff --git a/gpu/src/GrGLProgram.h b/gpu/src/GrGLProgram.h
index 1611ca2..74078e3 100644
--- a/gpu/src/GrGLProgram.h
+++ b/gpu/src/GrGLProgram.h
@@ -70,14 +70,6 @@
      */
     void doGLPost() const;
 
-    /**
-     *  Configures the GrGLProgram based on the state of a GrDrawTarget
-     *  object.  This is the fast and light initialization. Retrieves all the
-     *  state that is required for performing the heavy init (i.e. genProgram),
-     *  or for retrieving heavy init results from cache.
-     */
-    void buildFromTarget(const GrDrawTarget* target);
-
     static int PositionAttributeIdx() { return 0; }
     static int TexCoordAttributeIdx(int tcIdx) { return 1 + tcIdx; }
     static int ColorAttributeIdx() { return 1 + GrDrawTarget::kMaxTexCoords; }
@@ -114,8 +106,9 @@
 
         struct StageDesc {
             enum OptFlagBits {
-                kNoPerspective_OptFlagBit  = 0x1,
-                kIdentityMatrix_OptFlagBit = 0x2
+                kNoPerspective_OptFlagBit       = 1 << 0,
+                kIdentityMatrix_OptFlagBit      = 1 << 1,
+                kCustomTextureDomain_OptFlagBit = 1 << 2
             };
 
             unsigned fOptFlags;
@@ -153,11 +146,13 @@
         GrGLint fNormalizedTexelSizeUni;
         GrGLint fSamplerUni;
         GrGLint fRadial2Uni;
+        GrGLint fTexDomUni;
         void reset() {
             fTextureMatrixUni = kUnusedUniform;
             fNormalizedTexelSizeUni = kUnusedUniform;
             fSamplerUni = kUnusedUniform;
             fRadial2Uni = kUnusedUniform;
+            fTexDomUni = kUnusedUniform;
         }
     };
 
diff --git a/gpu/src/GrGpuGLShaders.cpp b/gpu/src/GrGpuGLShaders.cpp
index fcfc120..125b820 100644
--- a/gpu/src/GrGpuGLShaders.cpp
+++ b/gpu/src/GrGpuGLShaders.cpp
@@ -309,8 +309,39 @@
     }
 }
 
+void GrGpuGLShaders::flushTextureDomain(int s) {
+    const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTexDomUni;
+    if (GrGLProgram::kUnusedUniform != uni) {
+        const GrRect &texDom = 
+            fCurrDrawState.fSamplerStates[s].getTextureDomain();
+
+        float values[4] = {
+            GrScalarToFloat(texDom.left()), 
+            GrScalarToFloat(texDom.top()), 
+            GrScalarToFloat(texDom.right()), 
+            GrScalarToFloat(texDom.bottom())            
+        };
+
+        GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
+        GrGLTexture::Orientation orientation = texture->orientation();
+
+        // vertical flip if necessary
+        if (GrGLTexture::kBottomUp_Orientation == orientation) {
+            values[1] = 1.0f - values[1];
+            values[3] = 1.0f - values[3];
+        }
+
+        values[0] *= SkScalarToFloat(texture->contentScaleX());
+        values[2] *= SkScalarToFloat(texture->contentScaleX());
+        values[1] *= SkScalarToFloat(texture->contentScaleY());
+        values[3] *= SkScalarToFloat(texture->contentScaleY());
+
+        GR_GL(Uniform4fv(uni, 1, values));
+    }
+}
+
 void GrGpuGLShaders::flushTextureMatrix(int s) {
-    const int& uni = fProgramData->fUniLocations.fStages[s].fTextureMatrixUni;
+    const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTextureMatrixUni;
     GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
     if (NULL != texture) {
         if (GrGLProgram::kUnusedUniform != uni &&
@@ -516,6 +547,8 @@
         this->flushRadial2(s);
 
         this->flushTexelSize(s);
+
+        this->flushTextureDomain(s);
     }
     this->flushEdgeAAData();
     resetDirtyFlags();
@@ -702,6 +735,16 @@
                     break;
             }
 
+            if (fCurrDrawState.fSamplerStates[s].hasTextureDomain()) {
+                GrAssert(GrSamplerState::kClamp_WrapMode == 
+                    fCurrDrawState.fSamplerStates[s].getWrapX() && 
+                    GrSamplerState::kClamp_WrapMode ==
+                    fCurrDrawState.fSamplerStates[s].getWrapY());
+                stage.fOptFlags |= 
+                    GrGLProgram::ProgramDesc::StageDesc::
+                    kCustomTextureDomain_OptFlagBit;
+            }
+
             if (GrPixelConfigIsAlphaOnly(texture->config())) {
                 stage.fModulation = GrGLProgram::ProgramDesc::StageDesc::kAlpha_Modulation;
             } else {
@@ -725,4 +768,3 @@
 }
 
 
-
diff --git a/gpu/src/GrGpuGLShaders.h b/gpu/src/GrGpuGLShaders.h
index bb3024f..9392d1c 100644
--- a/gpu/src/GrGpuGLShaders.h
+++ b/gpu/src/GrGpuGLShaders.h
@@ -51,6 +51,9 @@
     // sets the texture matrix uniform for currently bound program
     void flushTextureMatrix(int stage);
 
+    // sets the texture domain uniform for currently bound program
+    void flushTextureDomain(int stage);
+
     // sets the color specified by GrDrawTarget::setColor()
     void flushColor();
 
diff --git a/gyp/skia.gyp b/gyp/skia.gyp
index 7247828..ca0754a 100644
--- a/gyp/skia.gyp
+++ b/gyp/skia.gyp
@@ -1403,6 +1403,7 @@
         '../gm/filltypes.cpp',
         '../gm/gm.h',
         '../gm/gradients.cpp',
+        '../gm/nocolorbleed.cpp',
         '../gm/points.cpp',
         '../gm/poly2poly.cpp',
         '../gm/shadertext.cpp',
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index a015347..360fa34 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -984,11 +984,36 @@
     GrRect dstRect = SkRect::MakeWH(GrIntToScalar(srcRect.width()),
                                     GrIntToScalar(srcRect.height()));
     GrRect paintRect;
-    paintRect.setLTRB(GrFixedToScalar((srcRect.fLeft << 16)   / bitmap.width()),
-                      GrFixedToScalar((srcRect.fTop << 16)    / bitmap.height()),
-                      GrFixedToScalar((srcRect.fRight << 16)  / bitmap.width()),
+    paintRect.setLTRB(GrFixedToScalar((srcRect.fLeft << 16) / bitmap.width()),
+                      GrFixedToScalar((srcRect.fTop << 16) / bitmap.height()),
+                      GrFixedToScalar((srcRect.fRight << 16) / bitmap.width()),
                       GrFixedToScalar((srcRect.fBottom << 16) / bitmap.height()));
 
+    if (GrSamplerState::kNearest_Filter != grPaint->fSampler.getFilter() &&
+        (srcRect.width() < bitmap.width() || 
+        srcRect.height() < bitmap.height())) {
+        // If drawing a subrect of the bitmap and filtering is enabled,
+        // use a constrained texture domain to avoid color bleeding
+        GrScalar left, top, right, bottom;
+        if (srcRect.width() > 1) {
+            GrScalar border = GR_ScalarHalf / bitmap.width();
+            left = paintRect.left() + border;
+            right = paintRect.right() - border;
+        } else {
+            left = right = GrScalarHalf(paintRect.left() + paintRect.right());
+        }
+        if (srcRect.height() > 1) {
+            GrScalar border = GR_ScalarHalf / bitmap.height();
+            top = paintRect.top() + border;
+            bottom = paintRect.bottom() - border;
+        } else {
+            top = bottom = GrScalarHalf(paintRect.top() + paintRect.bottom());
+        }
+        GrRect textureDomain;
+        textureDomain.setLTRB(left, top, right, bottom);
+        grPaint->fSampler.setTextureDomain(textureDomain);
+    }
+
     fContext->drawRectToRect(*grPaint, dstRect, paintRect, &m);
 }