Fix quickReject computation for blurs

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 29 matching lines @@
 
 // we use the same effect slot on GrPaint for bitmaps and shaders (since drawBitmap, drawSprite,
 // and drawDevice ignore SkShader)
 enum {
     kShaderEffectIdx = 0,
     kBitmapEffectIdx = 0,
     kColorFilterEffectIdx = 1,
     kXfermodeEffectIdx = 2,
 };
 
-#define MAX_BLUR_SIGMA 4.0f
-// FIXME:  This value comes from from SkBlurMaskFilter.cpp.
-// Should probably be put in a common header someplace.
-#define MAX_BLUR_RADIUS SkIntToScalar(128)
-// This constant approximates the scaling done in the software path's
-// "high quality" mode, in SkBlurMask::Blur() (1 / sqrt(3)).
-// IMHO, it actually should be 1:  we blur "less" than we should do
-// according to the CSS and canvas specs, simply because Safari does the same.
-// Firefox used to do the same too, until 4.0 where they fixed it.  So at some
-// point we should probably get rid of these scaling constants and rebaseline
-// all the blur tests.
-#define BLUR_SIGMA_SCALE 0.6f
 // This constant represents the screen alignment criterion in texels for
 // requiring texture domain clamping to prevent color bleeding when drawing
 // a sub region of a larger source image.
 #define COLOR_BLEED_TOLERANCE SkFloatToScalar(0.001f)
 
 #define DO_DEFERRED_CLEAR()             \
     do {                                \
         if (fNeedClear) {               \
             this->clear(SK_ColorTRANSPARENT); \
         }                               \
@@ skipping 719 matching lines @@
 bool drawWithGPUMaskFilter(GrContext* context, const SkPath& devPath, const SkStrokeRec& stroke,
                            SkMaskFilter* filter, const SkRegion& clip,
                            SkBounder* bounder, GrPaint* grp) {
     SkMaskFilter::BlurInfo info;
     SkMaskFilter::BlurType blurType = filter->asABlur(&info);
     if (SkMaskFilter::kNone_BlurType == blurType) {
         return false;
     }
     SkScalar radius = info.fIgnoreTransform ? info.fRadius
                                             : context->getMatrix().mapRadius(info.fRadius);
-    radius = SkMinScalar(radius, MAX_BLUR_RADIUS);
+    radius = SkMinScalar(radius, info.fMaxRadius);
     if (radius <= 0) {
         return false;
     }
 
     SkRect srcRect = devPath.getBounds();
     if (shouldDrawBlurWithCPU(srcRect, radius)) {
         return false;
     }
 
-    float sigma = SkScalarToFloat(radius) * BLUR_SIGMA_SCALE;
+    float sigma = SkScalarToFloat(radius) * info.fSigmaFraction;
     float sigma3 = sigma * 3.0f;
 
     SkRect clipRect;
     clipRect.set(clip.getBounds());
 
     // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area.
     srcRect.inset(SkFloatToScalar(-sigma3), SkFloatToScalar(-sigma3));
     clipRect.inset(SkFloatToScalar(-sigma3), SkFloatToScalar(-sigma3));
     srcRect.intersect(clipRect);
     SkRect finalRect = srcRect;
@@ skipping 1030 matching lines @@
                          GrTexture* texture,
                          bool needClear)
     : SkDevice(make_bitmap(context, texture->asRenderTarget())) {
 
     GrAssert(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;
 }