move common blur types into central header

BUG=skia:
R=scroggo@google.com, djsollen@google.com

Author: reed@google.com

Review URL: https://codereview.chromium.org/253833002

git-svn-id: http://skia.googlecode.com/svn/trunk/src@14411 2bbb7eff-a529-9590-31e7-b0007b416f81

7 files changed, 91 insertions, 118 deletions

diff --git a/animator/SkDrawBlur.cpp b/animator/SkDrawBlur.cpp
index 5f388c93..36d64528 100644
--- a/animator/SkDrawBlur.cpp
+++ b/animator/SkDrawBlur.cpp
@@ -22,11 +22,12 @@ DEFINE_GET_MEMBER(SkDrawBlur);
 
 SkDrawBlur::SkDrawBlur()
     : fSigma(-1)
-    , fBlurStyle(SkBlurMaskFilter::kNormal_BlurStyle) {
+    , fBlurStyle(kNormal_SkBlurStyle) {
 }
 
 SkMaskFilter* SkDrawBlur::getMaskFilter() {
-    if (fSigma < 0)
+    if (fSigma <= 0) {
         return NULL;
-    return SkBlurMaskFilter::Create((SkBlurMaskFilter::BlurStyle) fBlurStyle, fSigma);
+    }
+    return SkBlurMaskFilter::Create((SkBlurStyle)fBlurStyle, fSigma);
 }
diff --git a/animator/SkDrawBlur.h b/animator/SkDrawBlur.h
index 462a0413..75075922 100644
--- a/animator/SkDrawBlur.h
+++ b/animator/SkDrawBlur.h
@@ -17,7 +17,7 @@ class SkDrawBlur : public SkDrawMaskFilter {
     virtual SkMaskFilter* getMaskFilter() SK_OVERRIDE;
 protected:
     SkScalar fSigma;
-    int /*SkBlurMaskFilter::BlurStyle*/ fBlurStyle;
+    int /*SkBlurStyle*/ fBlurStyle;
 
     typedef SkDrawMaskFilter INHERITED;
 };
diff --git a/effects/SkBlurDrawLooper.cpp b/effects/SkBlurDrawLooper.cpp
index 78506690..03e635be 100644
--- a/effects/SkBlurDrawLooper.cpp
+++ b/effects/SkBlurDrawLooper.cpp
@@ -46,9 +46,7 @@ void SkBlurDrawLooper::init(SkScalar sigma, SkScalar dx, SkScalar dy,
             SkBlurMaskFilter::kHighQuality_BlurFlag :
             SkBlurMaskFilter::kNone_BlurFlag;
 
-        fBlur = SkBlurMaskFilter::Create(SkBlurMaskFilter::kNormal_BlurStyle,
-                                         sigma,
-                                         blurFlags);
+        fBlur = SkBlurMaskFilter::Create(kNormal_SkBlurStyle, sigma, blurFlags);
     } else {
         fBlur = NULL;
     }
diff --git a/effects/SkBlurMask.cpp b/effects/SkBlurMask.cpp
index f33817ad..51604cd5 100644
--- a/effects/SkBlurMask.cpp
+++ b/effects/SkBlurMask.cpp
@@ -435,11 +435,11 @@ static void merge_src_with_blur(uint8_t dst[], int dstRB,
 static void clamp_with_orig(uint8_t dst[], int dstRowBytes,
                             const uint8_t src[], int srcRowBytes,
                             int sw, int sh,
-                            SkBlurMask::Style style) {
+                            SkBlurStyle style) {
     int x;
     while (--sh >= 0) {
         switch (style) {
-        case SkBlurMask::kSolid_Style:
+        case kSolid_SkBlurStyle:
             for (x = sw - 1; x >= 0; --x) {
                 int s = *src;
                 int d = *dst;
@@ -448,7 +448,7 @@ static void clamp_with_orig(uint8_t dst[], int dstRowBytes,
                 src += 1;
             }
             break;
-        case SkBlurMask::kOuter_Style:
+        case kOuter_SkBlurStyle:
             for (x = sw - 1; x >= 0; --x) {
                 if (*src) {
                     *dst = SkToU8(SkAlphaMul(*dst, SkAlpha255To256(255 - *src)));
@@ -475,21 +475,19 @@ void SkMask_FreeImage(uint8_t* image) {
     SkMask::FreeImage(image);
 }
 
-bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
-                         SkScalar sigma, Style style, Quality quality,
-                         SkIPoint* margin, bool force_quality) {
-
+bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, SkScalar sigma, SkBlurStyle style,
+                         SkBlurQuality quality, SkIPoint* margin, bool force_quality) {
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
     }
 
     // Force high quality off for small radii (performance)
     if (!force_quality && sigma <= SkIntToScalar(2)) {
-        quality = kLow_Quality;
+        quality = kLow_SkBlurQuality;
     }
 
     SkScalar passRadius;
-    if (kHigh_Quality == quality) {
+    if (kHigh_SkBlurQuality == quality) {
         // For the high quality path the 3 pass box blur kernel width is
         // 6*rad+1 while the full Gaussian width is 6*sigma.
         passRadius = sigma - (1/6.0f);
@@ -502,7 +500,7 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
 
     // highQuality: use three box blur passes as a cheap way
     // to approximate a Gaussian blur
-    int passCount = (kHigh_Quality == quality) ? 3 : 1;
+    int passCount = (kHigh_SkBlurQuality == quality) ? 3 : 1;
 
     int rx = SkScalarCeilToInt(passRadius);
     int outerWeight = 255 - SkScalarRoundToInt((SkIntToScalar(rx) - passRadius) * 255);
@@ -548,7 +546,7 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
         if (outerWeight == 255) {
             int loRadius, hiRadius;
             get_adjusted_radii(passRadius, &loRadius, &hiRadius);
-            if (kHigh_Quality == quality) {
+            if (kHigh_SkBlurQuality == quality) {
                 // Do three X blurs, with a transpose on the final one.
                 w = boxBlur(sp, src.fRowBytes, tp, loRadius, hiRadius, w, h, false);
                 w = boxBlur(tp, w,             dp, hiRadius, loRadius, w, h, false);
@@ -562,7 +560,7 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
                 h = boxBlur(tp, h,             dp, ry, ry, h, w, true);
             }
         } else {
-            if (kHigh_Quality == quality) {
+            if (kHigh_SkBlurQuality == quality) {
                 // Do three X blurs, with a transpose on the final one.
                 w = boxBlurInterp(sp, src.fRowBytes, tp, rx, w, h, false, outerWeight);
                 w = boxBlurInterp(tp, w,             dp, rx, w, h, false, outerWeight);
@@ -580,7 +578,7 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
         dst->fImage = dp;
         // if need be, alloc the "real" dst (same size as src) and copy/merge
         // the blur into it (applying the src)
-        if (style == kInner_Style) {
+        if (style == kInner_SkBlurStyle) {
             // now we allocate the "real" dst, mirror the size of src
             size_t srcSize = src.computeImageSize();
             if (0 == srcSize) {
@@ -592,14 +590,14 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
                                 dp + passCount * (rx + ry * dst->fRowBytes),
                                 dst->fRowBytes, sw, sh);
             SkMask::FreeImage(dp);
-        } else if (style != kNormal_Style) {
+        } else if (style != kNormal_SkBlurStyle) {
             clamp_with_orig(dp + passCount * (rx + ry * dst->fRowBytes),
                             dst->fRowBytes, sp, src.fRowBytes, sw, sh, style);
         }
         (void)autoCall.detach();
     }
 
-    if (style == kInner_Style) {
+    if (style == kInner_SkBlurStyle) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
@@ -734,7 +732,7 @@ void SkBlurMask::ComputeBlurredScanline(uint8_t *pixels, const uint8_t *profile,
 }
 
 bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst,
-                          const SkRect &src, Style style,
+                          const SkRect &src, SkBlurStyle style,
                           SkIPoint *margin, SkMask::CreateMode createMode) {
     int profile_size = SkScalarCeilToInt(6*sigma);
 
@@ -756,7 +754,7 @@ bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst,
     int             sh = SkScalarFloorToInt(src.height());
 
     if (createMode == SkMask::kJustComputeBounds_CreateMode) {
-        if (style == kInner_Style) {
+        if (style == kInner_SkBlurStyle) {
             dst->fBounds.set(SkScalarRoundToInt(src.fLeft),
                              SkScalarRoundToInt(src.fTop),
                              SkScalarRoundToInt(src.fRight),
@@ -797,7 +795,7 @@ bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst,
         }
     }
 
-    if (style == kInner_Style) {
+    if (style == kInner_SkBlurStyle) {
         // now we allocate the "real" dst, mirror the size of src
         size_t srcSize = (size_t)(src.width() * src.height());
         if (0 == srcSize) {
@@ -817,12 +815,12 @@ bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst,
                          SkScalarRoundToInt(src.fBottom)); // restore trimmed bounds
         dst->fRowBytes = sw;
 
-    } else if (style == kOuter_Style) {
+    } else if (style == kOuter_SkBlurStyle) {
         for (int y = pad ; y < dstHeight-pad ; y++) {
             uint8_t *dst_scanline = dp + y*dstWidth + pad;
             memset(dst_scanline, 0, sw);
         }
-    } else if (style == kSolid_Style) {
+    } else if (style == kSolid_SkBlurStyle) {
         for (int y = pad ; y < dstHeight-pad ; y++) {
             uint8_t *dst_scanline = dp + y*dstWidth + pad;
             memset(dst_scanline, 0xff, sw);
@@ -835,7 +833,7 @@ bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst,
 }
 
 bool SkBlurMask::BlurRRect(SkScalar sigma, SkMask *dst,
-                           const SkRRect &src, Style style,
+                           const SkRRect &src, SkBlurStyle style,
                            SkIPoint *margin, SkMask::CreateMode createMode) {
     // Temporary for now -- always fail, should cause caller to fall back
     // to old path.  Plumbing just to land API and parallelize effort.
@@ -848,7 +846,7 @@ bool SkBlurMask::BlurRRect(SkScalar sigma, SkMask *dst,
 // useful for correctness comparisons.
 
 bool SkBlurMask::BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src,
-                                 Style style, SkIPoint* margin) {
+                                 SkBlurStyle style, SkIPoint* margin) {
 
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
@@ -964,7 +962,7 @@ bool SkBlurMask::BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src,
         dst->fImage = dstPixels;
         // if need be, alloc the "real" dst (same size as src) and copy/merge
         // the blur into it (applying the src)
-        if (style == kInner_Style) {
+        if (style == kInner_SkBlurStyle) {
             // now we allocate the "real" dst, mirror the size of src
             size_t srcSize = src.computeImageSize();
             if (0 == srcSize) {
@@ -976,14 +974,14 @@ bool SkBlurMask::BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src,
                 dstPixels + pad*dst->fRowBytes + pad,
                 dst->fRowBytes, srcWidth, srcHeight);
             SkMask::FreeImage(dstPixels);
-        } else if (style != kNormal_Style) {
+        } else if (style != kNormal_SkBlurStyle) {
             clamp_with_orig(dstPixels + pad*dst->fRowBytes + pad,
                 dst->fRowBytes, srcPixels, src.fRowBytes, srcWidth, srcHeight, style);
         }
         (void)autoCall.detach();
     }
 
-    if (style == kInner_Style) {
+    if (style == kInner_SkBlurStyle) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
diff --git a/effects/SkBlurMask.h b/effects/SkBlurMask.h
index d4cd3d1e..16009609 100644
--- a/effects/SkBlurMask.h
+++ b/effects/SkBlurMask.h
@@ -1,4 +1,3 @@
-
 /*
  * Copyright 2006 The Android Open Source Project
  *
@@ -6,37 +5,21 @@
  * found in the LICENSE file.
  */
 
-
 #ifndef SkBlurMask_DEFINED
 #define SkBlurMask_DEFINED
 
+#include "SkBlurTypes.h"
 #include "SkShader.h"
 #include "SkMask.h"
 #include "SkRRect.h"
 
 class SkBlurMask {
 public:
-    enum Style {
-        kNormal_Style,  //!< fuzzy inside and outside
-        kSolid_Style,   //!< solid inside, fuzzy outside
-        kOuter_Style,   //!< nothing inside, fuzzy outside
-        kInner_Style,   //!< fuzzy inside, nothing outside
-
-        kStyleCount
-    };
-
-    enum Quality {
-        kLow_Quality,   //!< box blur
-        kHigh_Quality   //!< three pass box blur (similar to gaussian)
-    };
-
-    static bool BlurRect(SkScalar sigma, SkMask *dst, const SkRect &src,
-                         Style style,
+    static bool BlurRect(SkScalar sigma, SkMask *dst, const SkRect &src, SkBlurStyle,
                          SkIPoint *margin = NULL,
                          SkMask::CreateMode createMode =
                                                 SkMask::kComputeBoundsAndRenderImage_CreateMode);
-    static bool BlurRRect(SkScalar sigma, SkMask *dst, const SkRRect &src,
-                         Style style,
+    static bool BlurRRect(SkScalar sigma, SkMask *dst, const SkRRect &src, SkBlurStyle,
                          SkIPoint *margin = NULL,
                          SkMask::CreateMode createMode =
                                                 SkMask::kComputeBoundsAndRenderImage_CreateMode);
@@ -48,13 +31,12 @@ public:
     // rectangle will lie.
 
     static bool BoxBlur(SkMask* dst, const SkMask& src,
-                        SkScalar sigma, Style style, Quality quality,
+                        SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
                         SkIPoint* margin = NULL, bool forceQuality = false);
 
     // the "ground truth" blur does a gaussian convolution; it's slow
     // but useful for comparison purposes.
-    static bool BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src,
-                                Style style,
+    static bool BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src, SkBlurStyle,
                                 SkIPoint* margin = NULL);
 
     static SkScalar ConvertRadiusToSigma(SkScalar radius);
diff --git a/effects/SkBlurMaskFilter.cpp b/effects/SkBlurMaskFilter.cpp
index 9f8935ab..c4069ca3 100644
--- a/effects/SkBlurMaskFilter.cpp
+++ b/effects/SkBlurMaskFilter.cpp
@@ -30,7 +30,7 @@
 
 class SkBlurMaskFilterImpl : public SkMaskFilter {
 public:
-    SkBlurMaskFilterImpl(SkScalar sigma, SkBlurMaskFilter::BlurStyle, uint32_t flags);
+    SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, uint32_t flags);
 
     // overrides from SkMaskFilter
     virtual SkMask::Format getFormat() const SK_OVERRIDE;
@@ -83,9 +83,9 @@ private:
     // a request like 10,000)
     static const SkScalar kMAX_BLUR_SIGMA;
 
-    SkScalar                    fSigma;
-    SkBlurMaskFilter::BlurStyle fBlurStyle;
-    uint32_t                    fBlurFlags;
+    SkScalar    fSigma;
+    SkBlurStyle fBlurStyle;
+    uint32_t    fBlurFlags;
 
     SkBlurMaskFilterImpl(SkReadBuffer&);
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
@@ -102,50 +102,42 @@ private:
 
 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
 
-SkMaskFilter* SkBlurMaskFilter::Create(SkScalar radius,
-                                       SkBlurMaskFilter::BlurStyle style,
-                                       uint32_t flags) {
-    // use !(radius > 0) instead of radius <= 0 to reject NaN values
-    if (!(radius > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount
-        || flags > SkBlurMaskFilter::kAll_BlurFlag) {
+SkMaskFilter* SkBlurMaskFilter::Create(SkBlurStyle style, SkScalar sigma, uint32_t flags) {
+    if (!SkScalarIsFinite(sigma) || sigma <= 0) {
         return NULL;
     }
+    if ((unsigned)style > (unsigned)kLastEnum_SkBlurStyle) {
+        return NULL;
+    }
+    if (flags > SkBlurMaskFilter::kAll_BlurFlag) {
+        return NULL;
+    }
+    return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags));
+}
 
+#ifdef SK_SUPPORT_LEGACY_BLURMASKFILTER_STYLE
+SkMaskFilter* SkBlurMaskFilter::Create(SkScalar radius,
+                                       SkBlurMaskFilter::BlurStyle style,
+                                       uint32_t flags) {
     SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius);
-
-    return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags));
+    return Create((SkBlurStyle)style, sigma, flags);
 }
 
 SkMaskFilter* SkBlurMaskFilter::Create(SkBlurMaskFilter::BlurStyle style,
                                        SkScalar sigma,
                                        uint32_t flags) {
-    // use !(sigma > 0) instead of sigma <= 0 to reject NaN values
-    if (!(sigma > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount
-        || flags > SkBlurMaskFilter::kAll_BlurFlag) {
-        return NULL;
-    }
-
-    return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags));
+    return Create((SkBlurStyle)style, sigma, flags);
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma,
-                                           SkBlurMaskFilter::BlurStyle style,
-                                           uint32_t flags)
-    : fSigma(sigma), fBlurStyle(style), fBlurFlags(flags) {
-#if 0
-    fGamma = NULL;
-    if (gammaScale) {
-        fGamma = new U8[256];
-        if (gammaScale > 0)
-            SkBlurMask::BuildSqrGamma(fGamma, gammaScale);
-        else
-            SkBlurMask::BuildSqrtGamma(fGamma, -gammaScale);
-    }
-#endif
-    SkASSERT(fSigma >= 0);
-    SkASSERT((unsigned)style < SkBlurMaskFilter::kBlurStyleCount);
+SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle style, uint32_t flags)
+    : fSigma(sigma)
+    , fBlurStyle(style)
+    , fBlurFlags(flags) {
+    SkASSERT(fSigma > 0);
+    SkASSERT((unsigned)style <= kLastEnum_SkBlurStyle);
     SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag);
 }
 
@@ -158,12 +150,11 @@ bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src,
                                       SkIPoint* margin) const{
     SkScalar sigma = this->computeXformedSigma(matrix);
 
-    SkBlurMask::Quality blurQuality =
+    SkBlurQuality blurQuality =
         (fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ?
-            SkBlurMask::kHigh_Quality : SkBlurMask::kLow_Quality;
+            kHigh_SkBlurQuality : kLow_SkBlurQuality;
 
-    return SkBlurMask::BoxBlur(dst, src, sigma, (SkBlurMask::Style)fBlurStyle,
-                               blurQuality, margin);
+    return SkBlurMask::BoxBlur(dst, src, sigma, fBlurStyle, blurQuality, margin);
 }
 
 bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r,
@@ -171,7 +162,7 @@ bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r,
                                           SkIPoint* margin, SkMask::CreateMode createMode) const{
     SkScalar sigma = computeXformedSigma(matrix);
 
-    return SkBlurMask::BlurRect(sigma, dst, r, (SkBlurMask::Style)fBlurStyle,
+    return SkBlurMask::BlurRect(sigma, dst, r, fBlurStyle,
                                 margin, createMode);
 }
 
@@ -180,7 +171,7 @@ bool SkBlurMaskFilterImpl::filterRRectMask(SkMask* dst, const SkRRect& r,
                                           SkIPoint* margin, SkMask::CreateMode createMode) const{
     SkScalar sigma = computeXformedSigma(matrix);
 
-    return SkBlurMask::BlurRRect(sigma, dst, r, (SkBlurMask::Style)fBlurStyle,
+    return SkBlurMask::BlurRRect(sigma, dst, r, fBlurStyle,
                                 margin, createMode);
 }
 
@@ -298,7 +289,7 @@ SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& ma
 
     // TODO: report correct metrics for innerstyle, where we do not grow the
     // total bounds, but we do need an inset the size of our blur-radius
-    if (SkBlurMaskFilter::kInner_BlurStyle == fBlurStyle) {
+    if (kInner_SkBlurStyle == fBlurStyle) {
         return kUnimplemented_FilterReturn;
     }
 
@@ -410,8 +401,7 @@ SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
 
     // TODO: report correct metrics for innerstyle, where we do not grow the
     // total bounds, but we do need an inset the size of our blur-radius
-    if (SkBlurMaskFilter::kInner_BlurStyle == fBlurStyle ||
-        SkBlurMaskFilter::kOuter_BlurStyle == fBlurStyle) {
+    if (kInner_SkBlurStyle == fBlurStyle || kOuter_SkBlurStyle == fBlurStyle) {
         return kUnimplemented_FilterReturn;
     }
 
@@ -531,10 +521,10 @@ void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkReadBuffer& buffer)
         : SkMaskFilter(buffer) {
     fSigma = buffer.readScalar();
-    fBlurStyle = (SkBlurMaskFilter::BlurStyle)buffer.readInt();
+    fBlurStyle = (SkBlurStyle)buffer.readInt();
     fBlurFlags = buffer.readUInt() & SkBlurMaskFilter::kAll_BlurFlag;
-    SkASSERT(fSigma >= 0);
-    SkASSERT((unsigned)fBlurStyle < SkBlurMaskFilter::kBlurStyleCount);
+    SkASSERT(fSigma > 0);
+    SkASSERT((unsigned)fBlurStyle <= kLastEnum_SkBlurStyle);
 }
 
 void SkBlurMaskFilterImpl::flatten(SkWriteBuffer& buffer) const {
@@ -785,7 +775,7 @@ bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrContext* context,
                                                GrPaint* grp,
                                                const SkStrokeRec& strokeRec,
                                                const SkPath& path) const {
-    if (fBlurStyle != SkBlurMaskFilter::kNormal_BlurStyle) {
+    if (fBlurStyle != kNormal_SkBlurStyle) {
         return false;
     }
 
@@ -888,7 +878,8 @@ GrEffectRef* GrRRectBlurEffect::Create(GrContext* context, float sigma, const Sk
     texDesc.fHeight = texSide;
     texDesc.fConfig = kAlpha_8_GrPixelConfig;
 
-    GrTexture *blurNinePatchTexture = context->findAndRefTexture(texDesc, blurRRectNinePatchID, &params);
+    GrTexture *blurNinePatchTexture = context->findAndRefTexture(texDesc, blurRRectNinePatchID,
+                                                                 &params);
 
     if (NULL == blurNinePatchTexture) {
         SkMask mask;
@@ -910,12 +901,15 @@ GrEffectRef* GrRRectBlurEffect::Create(GrContext* context, float sigma, const Sk
         SkPath path;
         path.addRRect( smallRRect );
 
-        SkDraw::DrawToMask(path, &mask.fBounds, NULL, NULL, &mask, SkMask::kJustRenderImage_CreateMode, SkPaint::kFill_Style);
+        SkDraw::DrawToMask(path, &mask.fBounds, NULL, NULL, &mask,
+                           SkMask::kJustRenderImage_CreateMode, SkPaint::kFill_Style);
 
         SkMask blurred_mask;
-        SkBlurMask::BoxBlur(&blurred_mask, mask, sigma, SkBlurMask::kNormal_Style, SkBlurMask::kHigh_Quality, NULL, true );
+        SkBlurMask::BoxBlur(&blurred_mask, mask, sigma, kNormal_SkBlurStyle,
+                            kHigh_SkBlurQuality, NULL, true );
 
-        blurNinePatchTexture = context->createTexture(&params, texDesc, blurRRectNinePatchID, blurred_mask.fImage, 0);
+        blurNinePatchTexture = context->createTexture(&params, texDesc, blurRRectNinePatchID,
+                                                      blurred_mask.fImage, 0);
     }
 
     if (NULL == blurNinePatchTexture) {
@@ -935,9 +929,10 @@ const GrBackendEffectFactory& GrRRectBlurEffect::getFactory() const {
 }
 
 GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture)
-    : fRRect(rrect),
-      fSigma(sigma),
-      fNinePatchAccess(ninePatchTexture) {
+    : fRRect(rrect)
+    , fSigma(sigma)
+    , fNinePatchAccess(ninePatchTexture)
+{
     this->addTextureAccess(&fNinePatchAccess);
     this->setWillReadFragmentPosition();
 }
@@ -1070,7 +1065,7 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context,
                                                     GrPaint* grp,
                                                     const SkStrokeRec& strokeRec,
                                                     const SkRRect& rrect) const {
-    if (fBlurStyle != SkBlurMaskFilter::kNormal_BlurStyle) {
+    if (fBlurStyle != kNormal_SkBlurStyle) {
         return false;
     }
 
@@ -1154,7 +1149,7 @@ bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src,
 
     // If we're doing a normal blur, we can clobber the pathTexture in the
     // gaussianBlur.  Otherwise, we need to save it for later compositing.
-    bool isNormalBlur = (SkBlurMaskFilter::kNormal_BlurStyle == fBlurStyle);
+    bool isNormalBlur = (kNormal_SkBlurStyle == fBlurStyle);
     *result = SkGpuBlurUtils::GaussianBlur(context, src, isNormalBlur && canOverwriteSrc,
                                            clipRect, false, xformedSigma, xformedSigma);
     if (NULL == *result) {
@@ -1169,14 +1164,14 @@ bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src,
         // Blend pathTexture over blurTexture.
         GrContext::AutoRenderTarget art(context, (*result)->asRenderTarget());
         paint.addColorEffect(GrSimpleTextureEffect::Create(src, matrix))->unref();
-        if (SkBlurMaskFilter::kInner_BlurStyle == fBlurStyle) {
+        if (kInner_SkBlurStyle == fBlurStyle) {
             // inner:  dst = dst * src
             paint.setBlendFunc(kDC_GrBlendCoeff, kZero_GrBlendCoeff);
-        } else if (SkBlurMaskFilter::kSolid_BlurStyle == fBlurStyle) {
+        } else if (kSolid_SkBlurStyle == fBlurStyle) {
             // solid:  dst = src + dst - src * dst
             //             = (1 - dst) * src + 1 * dst
             paint.setBlendFunc(kIDC_GrBlendCoeff, kOne_GrBlendCoeff);
-        } else if (SkBlurMaskFilter::kOuter_BlurStyle == fBlurStyle) {
+        } else if (kOuter_SkBlurStyle == fBlurStyle) {
             // outer:  dst = dst * (1 - src)
             //             = 0 * src + (1 - src) * dst
             paint.setBlendFunc(kZero_GrBlendCoeff, kISC_GrBlendCoeff);
@@ -1198,7 +1193,7 @@ void SkBlurMaskFilterImpl::toString(SkString* str) const {
     str->appendScalar(fSigma);
     str->append(" ");
 
-    static const char* gStyleName[SkBlurMaskFilter::kBlurStyleCount] = {
+    static const char* gStyleName[kLastEnum_SkBlurStyle + 1] = {
         "normal", "solid", "outer", "inner"
     };
 
diff --git a/effects/SkEmbossMaskFilter.cpp b/effects/SkEmbossMaskFilter.cpp
index 19725f1a..9bf5025e 100644
--- a/effects/SkEmbossMaskFilter.cpp
+++ b/effects/SkEmbossMaskFilter.cpp
@@ -76,8 +76,7 @@ bool SkEmbossMaskFilter::filterMask(SkMask* dst, const SkMask& src,
                                     const SkMatrix& matrix, SkIPoint* margin) const {
     SkScalar sigma = matrix.mapRadius(fBlurSigma);
 
-    if (!SkBlurMask::BoxBlur(dst, src, sigma, SkBlurMask::kInner_Style,
-                             SkBlurMask::kLow_Quality)) {
+    if (!SkBlurMask::BoxBlur(dst, src, sigma, kInner_SkBlurStyle, kLow_SkBlurQuality)) {
         return false;
     }