Fix textureDomain/bleed prevention in msaa

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 "GrBlurUtils.h"
@@ skipping 827 matching lines @@
             COLOR_BLEED_TOLERANCE &&
         SkScalarAbs(transformedRect.height() - srcRect.height()) <
             COLOR_BLEED_TOLERANCE) {
         return true;
     }
     return false;
 }
 
 static bool may_color_bleed(const SkRect& srcRect,
                             const SkRect& transformedRect,
-                            const SkMatrix& m) {
+                            const SkMatrix& m,
+                            bool isMSAA) {
     // Only gets called if has_aligned_samples returned false.
     // So we can assume that sampling is axis aligned but not texel aligned.
     SkASSERT(!has_aligned_samples(srcRect, transformedRect));
     SkRect innerSrcRect(srcRect), innerTransformedRect,
         outerTransformedRect(transformedRect);
-    innerSrcRect.inset(SK_ScalarHalf, SK_ScalarHalf);
+    if (isMSAA) {
+        innerSrcRect.inset(SK_Scalar1, SK_Scalar1);
+    } else {
+        innerSrcRect.inset(SK_ScalarHalf, SK_ScalarHalf);
+    }
     m.mapRect(&innerTransformedRect, innerSrcRect);
 
     // The gap between outerTransformedRect and innerTransformedRect
     // represents the projection of the source border area, which is
     // problematic for color bleeding.  We must check whether any
     // destination pixels sample the border area.
     outerTransformedRect.inset(COLOR_BLEED_TOLERANCE, COLOR_BLEED_TOLERANCE);
     innerTransformedRect.outset(COLOR_BLEED_TOLERANCE, COLOR_BLEED_TOLERANCE);
     SkIRect outer, inner;
     outerTransformedRect.round(&outer);
     innerTransformedRect.round(&inner);
     // If the inner and outer rects round to the same result, it means the
     // border does not overlap any pixel centers. Yay!
     return inner != outer;
 }
 
 static bool needs_texture_domain(const SkBitmap& bitmap,
                                  const SkRect& srcRect,
                                  GrTextureParams &params,
                                  const SkMatrix& contextMatrix,
-                                 bool bicubic) {
+                                 bool bicubic,
+                                 bool isMSAA) {
     bool needsTextureDomain = false;
     GrTexture* tex = bitmap.getTexture();
     int width = tex ? tex->width() : bitmap.width();
     int height = tex ? tex->height() : bitmap.height();
 
     if (bicubic || params.filterMode() != GrTextureParams::kNone_FilterMode) {
         // Need texture domain if drawing a sub rect
         needsTextureDomain = srcRect.width() < width ||
                              srcRect.height() < height;
         if (!bicubic && needsTextureDomain && contextMatrix.rectStaysRect()) {
             // sampling is axis-aligned
             SkRect transformedRect;
             contextMatrix.mapRect(&transformedRect, srcRect);
 
             if (has_aligned_samples(srcRect, transformedRect)) {
                 params.setFilterMode(GrTextureParams::kNone_FilterMode);
                 needsTextureDomain = false;
             } else {
-                needsTextureDomain = may_color_bleed(srcRect, transformedRect, contextMatrix);
+                needsTextureDomain = may_color_bleed(srcRect, transformedRect,
+                                                     contextMatrix, isMSAA);
             }
         }
     }
     return needsTextureDomain;
 }
 
 void SkGpuDevice::drawBitmapCommon(const SkDraw& draw,
                                    const SkBitmap& bitmap,
                                    const SkRect* srcRectPtr,
                                    const SkSize* dstSizePtr,
@@ skipping 160 matching lines @@
     if (this->shouldTileBitmap(bitmap, viewM, params, srcRectPtr, maxTileSize, &tileSize,
                                &clippedSrcRect)) {
         this->drawTiledBitmap(bitmap, viewM, srcRect, clippedSrcRect, params, paint, constraint,
                               tileSize, doBicubic);
     } else {
         // take the simple case
         bool needsTextureDomain = needs_texture_domain(bitmap,
                                                        srcRect,
                                                        params,
                                                        viewM,
-                                                       doBicubic);
+                                                       doBicubic,
+                                                       fRenderTarget->isUnifiedMultisampled());
         this->internalDrawBitmap(bitmap,
                                  viewM,
                                  srcRect,
                                  params,
                                  paint,
                                  constraint,
                                  doBicubic,
                                  needsTextureDomain);
     }
 }
@@ skipping 60 matching lines @@
                     srcRect.roundOut(&iClampRect);
                 }
                 int outset = bicubic ? GrBicubicEffect::kFilterTexelPad : 1;
                 clamped_outset_with_offset(&iTileR, outset, &offset, iClampRect);
             }
 
             if (bitmap.extractSubset(&tmpB, iTileR)) {
                 // now offset it to make it "local" to our tmp bitmap
                 tileR.offset(-offset.fX, -offset.fY);
                 GrTextureParams paramsTemp = params;
-                bool needsTextureDomain = needs_texture_domain(bitmap,
-                                                               srcRect,
-                                                               paramsTemp,
-                                                               viewM,
-                                                               bicubic);
+                bool needsTextureDomain = needs_texture_domain(
+                                                         bitmap, srcRect, paramsTemp,
+                                                         viewM, bicubic,
+                                                         fRenderTarget->isUnifiedMultisampled());
                 this->internalDrawBitmap(tmpB,
                                          viewM,
                                          tileR,
                                          paramsTemp,
                                          paint,
                                          constraint,
                                          bicubic,
                                          needsTextureDomain);
             }
         }
@@ skipping 685 matching lines @@
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif