Create MSAA render target for blur mask texture

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/GrBicubicEffect.h"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrTextureDomain.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "GrContext.h"
 #include "GrBitmapTextContext.h"
 #include "GrDistanceFieldTextContext.h"
 #include "GrLayerCache.h"
 #include "GrLayerHoister.h"
 #include "GrPictureUtils.h"
 #include "GrRecordReplaceDraw.h"
 #include "GrStrokeInfo.h"
 #include "GrTracing.h"
+#include "GrGpu.h"
 
 #include "SkGrTexturePixelRef.h"
 
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
@@ skipping 602 matching lines @@
     return draw_mask(context, maskRect, grp, texture);
 }
 
 // Create a mask of 'devPath' and place the result in 'mask'. Return true on
 // success; false otherwise.
 bool create_mask_GPU(GrContext* context,
                      const SkRect& maskRect,
                      const SkPath& devPath,
                      const GrStrokeInfo& strokeInfo,
                      bool doAA,
-                     GrAutoScratchTexture* mask) {
+                     GrAutoScratchTexture* mask,
+                     int SampleCnt) {
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit;
     desc.fWidth = SkScalarCeilToInt(maskRect.width());
     desc.fHeight = SkScalarCeilToInt(maskRect.height());
+    desc.fSampleCnt = SampleCnt;
     // We actually only need A8, but it often isn't supported as a
     // render target so default to RGBA_8888
     desc.fConfig = kRGBA_8888_GrPixelConfig;
-    if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
+
+    if (context->isConfigRenderable(kAlpha_8_GrPixelConfig,
+                                    desc.fSampleCnt > 0)) {
         desc.fConfig = kAlpha_8_GrPixelConfig;
     }
 
     mask->set(context, desc);
     if (NULL == mask->texture()) {
         return false;
     }
 
     GrTexture* maskTexture = mask->texture();
     SkRect clipRect = SkRect::MakeWH(maskRect.width(), maskRect.height());
@@ skipping 113 matching lines @@
             if (paint.getMaskFilter()->directFilterMaskGPU(fContext, &grPaint,
                                                            stroke, *devPathPtr)) {
                 // the mask filter was able to draw itself directly, so there's nothing
                 // left to do.
                 return;
             }
 
             GrAutoScratchTexture mask;
 
             if (create_mask_GPU(fContext, maskRect, *devPathPtr, strokeInfo,
-                                grPaint.isAntiAlias(), &mask)) {
+                                grPaint.isAntiAlias(), &mask, fRenderTarget->numSamples())) {
                 GrTexture* filtered;
 
                 if (paint.getMaskFilter()->filterMaskGPU(mask.texture(),
                                                          ctm, maskRect, &filtered, true)) {
                     // filterMaskGPU gives us ownership of a ref to the result
                     SkAutoTUnref<GrTexture> atu(filtered);
 
                     // If the scratch texture that we used as the filter src also holds the filter
                     // result then we must detach so that this texture isn't recycled for a later
                     // draw.
@@ skipping 1071 matching lines @@
     GrLayerHoister::UnlockLayers(fContext->getLayerCache(), atlased, nonAtlased, recycled);
 
     return true;
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }