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"
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "GrContext.h"
 #include "GrTextContext.h"
 
 #include "SkGrTexturePixelRef.h"
 
 #include "SkColorFilter.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkPathEffect.h"
 #include "SkRRect.h"
 #include "SkStroke.h"
 #include "SkUtils.h"
+#include "SkBlurMaskFilter.h"
 
 #define CACHE_COMPATIBLE_DEVICE_TEXTURES 1
 
 #if 0
     extern bool (*gShouldDrawProc)();
     #define CHECK_SHOULD_DRAW(draw, forceI)                     \
         do {                                                    \
             if (gShouldDrawProc && !gShouldDrawProc()) return;  \
             this->prepareDraw(draw, forceI);                    \
         } while (0)
 #else
     #define CHECK_SHOULD_DRAW(draw, forceI) this->prepareDraw(draw, forceI)
 #endif
 
 // 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 729 matching lines @@
     radius = SkMinScalar(radius, MAX_BLUR_RADIUS);
     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) * SkBlurMaskFilter::kBLUR_SIGMA_SCALE;

[bsalomon, 2013/06/14 18:23:54]

Could the radius returned in info already account for this?

     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;
 }