Update tiled bitmap path to respect bleed flag

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/GrTextureDomainEffect.h"
@@ skipping 1160 matching lines @@
     params.setFilterMode(textureFilterMode);
 
     if (!this->shouldTileBitmap(bitmap, params, srcRectPtr)) {
         // take the simple case
         this->internalDrawBitmap(bitmap, srcRect, m, params, paint, flags);
     } else {
         this->drawTiledBitmap(bitmap, srcRect, m, params, paint, flags);
     }
 }
 
+// This method outsets 'iRect' by 1 all around and then clamps its extents to
+// 'clamp'. 'offset' is adjusted to remain positioned over the top-left corner
+// of 'iRect' despite the possible outsets/clamps.
+static inline void clamped_unit_outset_with_offset(SkIRect* iRect, SkPoint* offset, 
+                                                   const SkIRect& clamp) {
+    iRect->outset(1, 1);
+
+    if (iRect->fLeft < clamp.fLeft) {
+        iRect->fLeft = clamp.fLeft;
+    } else {
+        offset->fX -= SK_Scalar1;
+    }
+    if (iRect->fTop < clamp.fTop) {
+        iRect->fTop = clamp.fTop;
+    } else {
+        offset->fY -= SK_Scalar1;
+    }
+
+    if (iRect->fRight > clamp.fRight) {
+        iRect->fRight = clamp.fRight;
+    }
+    if (iRect->fBottom > clamp.fBottom) {
+        iRect->fBottom = clamp.fBottom;
+    }
+}
+
 // Break 'bitmap' into several tiles to draw it since it has already
 // been determined to be too large to fit in VRAM
 void SkGpuDevice::drawTiledBitmap(const SkBitmap& bitmap,
                                   const SkRect& srcRect,
                                   const SkMatrix& m,
                                   const GrTextureParams& params,
                                   const SkPaint& paint,
                                   SkCanvas::DrawBitmapRectFlags flags) {
-    // TODO: this method needs to be updated to respect the bleed flag
-    const int maxTextureSize = fContext->getMaxTextureSize();
+    int maxTextureSize = fContext->getMaxTextureSize();
+    if (SkPaint::kNone_FilterLevel != paint.getFilterLevel()) {
+        // We may need a skosh more room if we have to bump out the tile
+        // by 1 pixel all around
+        maxTextureSize -= 2;
+    }
 
     int tileSize = determine_tile_size(bitmap, srcRect, maxTextureSize);
 
     // compute clip bounds in local coordinates
     SkRect clipRect;
     {
         const GrRenderTarget* rt = fContext->getRenderTarget();
         clipRect.setWH(SkIntToScalar(rt->width()), SkIntToScalar(rt->height()));
         if (!fContext->getClip()->fClipStack->intersectRectWithClip(&clipRect)) {
             return;
@@ skipping 20 matching lines @@
                 continue;
             }
 
             if (!tileR.intersect(srcRect)) {
                 continue;
             }
 
             SkBitmap tmpB;
             SkIRect iTileR;
             tileR.roundOut(&iTileR);
+            SkPoint offset = SkPoint::Make(SkIntToScalar(iTileR.fLeft), 
+                                           SkIntToScalar(iTileR.fTop));
+
+            if (SkPaint::kNone_FilterLevel != paint.getFilterLevel()) {
+                SkIRect iClampRect;
+
+                if (SkCanvas::kBleed_DrawBitmapRectFlag & flags) {
+                    // In bleed mode we want to always expand the tile on all edges
+                    // but stay within the bitmap bounds
+                    iClampRect = SkIRect::MakeWH(bitmap.width(), bitmap.height());
+                } else {
+                    // In texture-domain/clamp mode we only want to expand the
+                    // tile on edges interior to "srcRect" (i.e., we want to
+                    // not bleed across the original clamped edges)
+                    srcRect.roundOut(&iClampRect);
+                }
+
+                clamped_unit_outset_with_offset(&iTileR, &offset, iClampRect);
+            }
+
             if (bitmap.extractSubset(&tmpB, iTileR)) {
                 // now offset it to make it "local" to our tmp bitmap
-                tileR.offset(SkIntToScalar(-iTileR.fLeft), SkIntToScalar(-iTileR.fTop));
+                tileR.offset(-offset.fX, -offset.fY);
                 SkMatrix tmpM(m);
-                tmpM.preTranslate(SkIntToScalar(iTileR.fLeft),
-                                  SkIntToScalar(iTileR.fTop));
+                tmpM.preTranslate(offset.fX, offset.fY);
 
                 this->internalDrawBitmap(tmpB, tileR, tmpM, params, paint, flags);
             }
         }
     }
 }
 
 static bool has_aligned_samples(const SkRect& srcRect,
                                 const SkRect& transformedRect) {
     // detect pixel disalignment
@@ skipping 550 matching lines @@
                          GrTexture* texture,
                          bool needClear)
     : SkDevice(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;
 }