move common blur types into central header

tests/BlurTest.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 "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
@@ skipping 85 matching lines @@
 }
 
 static void test_blur_drawing(skiatest::Reporter* reporter) {
 
     SkPaint paint;
     paint.setColor(SK_ColorGRAY);
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(SkIntToScalar(strokeWidth));
 
     SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5));
-    for (int style = 0; style < SkBlurMaskFilter::kBlurStyleCount; ++style) {
-        SkBlurMaskFilter::BlurStyle blurStyle =
-            static_cast<SkBlurMaskFilter::BlurStyle>(style);
+    for (int style = 0; style <= kLastEnum_SkBlurStyle; ++style) {
+        SkBlurStyle blurStyle = static_cast<SkBlurStyle>(style);
 
         const uint32_t flagPermutations = SkBlurMaskFilter::kAll_BlurFlag;
         for (uint32_t flags = 0; flags < flagPermutations; ++flags) {
             SkMaskFilter* filter;
             filter = SkBlurMaskFilter::Create(blurStyle, sigma, flags);
 
             paint.setMaskFilter(filter);
             filter->unref();
 
             for (size_t test = 0; test < SK_ARRAY_COUNT(tests); ++test) {
@@ skipping 43 matching lines @@
     SkMask src, dst;
 
     src.fBounds.set(0, 0, width, height);
     src.fFormat = SkMask::kA8_Format;
     src.fRowBytes = src.fBounds.width();
     src.fImage = SkMask::AllocImage(src.computeTotalImageSize());
 
     memset(src.fImage, 0xff, src.computeTotalImageSize());
 
     dst.fImage = NULL;
-    SkBlurMask::BlurGroundTruth(sigma, &dst, src, SkBlurMask::kNormal_Style);
+    SkBlurMask::BlurGroundTruth(sigma, &dst, src, kNormal_SkBlurStyle);
 
     int midX = dst.fBounds.centerX();
     int midY = dst.fBounds.centerY();
     uint8_t* bytes = dst.getAddr8(midX, midY);
     int i;
     for (i = 0; i < dst.fBounds.width()-(midX-dst.fBounds.fLeft); ++i) {
         if (i < resultCount) {
             result[i] = bytes[i];
         }
     }
@@ skipping 41 matching lines @@
 static void blur_path(SkCanvas* canvas, const SkPath& path,
                       SkScalar gaussianSigma) {
 
     SkScalar midX = path.getBounds().centerX();
     SkScalar midY = path.getBounds().centerY();
 
     canvas->translate(-midX, -midY);
 
     SkPaint blurPaint;
     blurPaint.setColor(SK_ColorWHITE);
-    SkMaskFilter* filter = SkBlurMaskFilter::Create(SkBlurMaskFilter::kNormal_BlurStyle,
+    SkMaskFilter* filter = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
                                                     gaussianSigma,
                                                     SkBlurMaskFilter::kHighQuality_BlurFlag);
     blurPaint.setMaskFilter(filter)->unref();
 
     canvas->drawColor(SK_ColorBLACK);
     canvas->drawPath(path, blurPaint);
 }
 
 // Readback the blurred draw results from the canvas
 static void readback(SkCanvas* canvas, int* result, int resultCount) {
@@ skipping 133 matching lines @@
         write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize);
         write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize);
 #endif
     }
 }
 
 DEF_GPUTEST(Blur, reporter, factory) {
     test_blur_drawing(reporter);
     test_sigma_range(reporter, factory);
 }