SkPaint::FilterLevel -> SkFilterQuality

clone (+rebase) of https://codereview.chromium.org/1009183002/

BUG=skia:
TBR=scroggo@google.com

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

25 files changed, 124 insertions, 124 deletions

diff --git a/gm/bigmatrix.cpp b/gm/bigmatrix.cpp
index df542fdac4..32e637ba66 100644
--- a/gm/bigmatrix.cpp
+++ b/gm/bigmatrix.cpp
@@ -77,7 +77,7 @@ protected:
                                             &s);
         paint.setShader(shader)->unref();
         paint.setAntiAlias(false);
-        paint.setFilterLevel(SkPaint::kLow_FilterLevel);
+        paint.setFilterQuality(kLow_SkFilterQuality);
         rect.setLTRB(pt.fX - small, pt.fY - small,
                      pt.fX + small, pt.fY + small);
         canvas->drawRect(rect, paint);
diff --git a/gm/bitmapfilters.cpp b/gm/bitmapfilters.cpp
index f1348b1437..8b68d3b12b 100644
--- a/gm/bitmapfilters.cpp
+++ b/gm/bitmapfilters.cpp
@@ -41,7 +41,7 @@ static SkScalar draw_bm(SkCanvas* canvas, const SkBitmap& bm,
 static SkScalar draw_set(SkCanvas* c, const SkBitmap& bm, SkScalar x,
                          SkPaint* p) {
     x += draw_bm(c, bm, x, 0, p);
-    p->setFilterLevel(SkPaint::kLow_FilterLevel);
+    p->setFilterQuality(kLow_SkFilterQuality);
     x += draw_bm(c, bm, x, 0, p);
     p->setDither(true);
     return x + draw_bm(c, bm, x, 0, p);
diff --git a/gm/bleed.cpp b/gm/bleed.cpp
index f39f3a111d..7fd2a15209 100644
--- a/gm/bleed.cpp
+++ b/gm/bleed.cpp
@@ -104,14 +104,14 @@ protected:
 
     // Draw only the center of the small bitmap
     void drawCase1(SkCanvas* canvas, int transX, int transY,
-                   SkCanvas::DrawBitmapRectFlags flags, SkPaint::FilterLevel filter) {
+                   SkCanvas::DrawBitmapRectFlags flags, SkFilterQuality filter) {
         SkRect src = SkRect::MakeXYWH(2, 2,
                                       SkIntToScalar(kSmallTextureSize-4),
                                       SkIntToScalar(kSmallTextureSize-4));
         SkRect dst = SkRect::MakeXYWH(0, 0, SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
         SkPaint paint;
-        paint.setFilterLevel(filter);
+        paint.setFilterQuality(filter);
 
         canvas->save();
         canvas->translate(SkIntToScalar(transX), SkIntToScalar(transY));
@@ -121,14 +121,14 @@ protected:
 
     // Draw almost all of the large bitmap
     void drawCase2(SkCanvas* canvas, int transX, int transY,
-                   SkCanvas::DrawBitmapRectFlags flags, SkPaint::FilterLevel filter) {
+                   SkCanvas::DrawBitmapRectFlags flags, SkFilterQuality filter) {
         SkRect src = SkRect::MakeXYWH(2, 2,
                                       SkIntToScalar(fBitmapBig.width()-4),
                                       SkIntToScalar(fBitmapBig.height()-4));
         SkRect dst = SkRect::MakeXYWH(0, 0, SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
         SkPaint paint;
-        paint.setFilterLevel(filter);
+        paint.setFilterQuality(filter);
 
         canvas->save();
         canvas->translate(SkIntToScalar(transX), SkIntToScalar(transY));
@@ -138,14 +138,14 @@ protected:
 
     // Draw ~1/4 of the large bitmap
     void drawCase3(SkCanvas* canvas, int transX, int transY,
-                   SkCanvas::DrawBitmapRectFlags flags, SkPaint::FilterLevel filter) {
+                   SkCanvas::DrawBitmapRectFlags flags, SkFilterQuality filter) {
         SkRect src = SkRect::MakeXYWH(2, 2,
                                       SkIntToScalar(fBitmapBig.width()/2-2),
                                       SkIntToScalar(fBitmapBig.height()/2-2));
         SkRect dst = SkRect::MakeXYWH(0, 0, SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
         SkPaint paint;
-        paint.setFilterLevel(filter);
+        paint.setFilterQuality(filter);
 
         canvas->save();
         canvas->translate(SkIntToScalar(transX), SkIntToScalar(transY));
@@ -155,14 +155,14 @@ protected:
 
     // Draw the center of the small bitmap with a mask filter
     void drawCase4(SkCanvas* canvas, int transX, int transY,
-                   SkCanvas::DrawBitmapRectFlags flags, SkPaint::FilterLevel filter) {
+                   SkCanvas::DrawBitmapRectFlags flags, SkFilterQuality filter) {
         SkRect src = SkRect::MakeXYWH(2, 2,
                                       SkIntToScalar(kSmallTextureSize-4),
                                       SkIntToScalar(kSmallTextureSize-4));
         SkRect dst = SkRect::MakeXYWH(0, 0, SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
         SkPaint paint;
-        paint.setFilterLevel(filter);
+        paint.setFilterQuality(filter);
         SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
                                          SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3)));
         paint.setMaskFilter(mf)->unref();
@@ -189,22 +189,22 @@ protected:
             }
 
             // First draw a column with no bleeding, tiling, or filtering
-            this->drawCase1(canvas, kCol0X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kNone_FilterLevel);
-            this->drawCase2(canvas, kCol0X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kNone_FilterLevel);
-            this->drawCase3(canvas, kCol0X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kNone_FilterLevel);
-            this->drawCase4(canvas, kCol0X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kNone_FilterLevel);
+            this->drawCase1(canvas, kCol0X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, kNone_SkFilterQuality);
+            this->drawCase2(canvas, kCol0X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, kNone_SkFilterQuality);
+            this->drawCase3(canvas, kCol0X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, kNone_SkFilterQuality);
+            this->drawCase4(canvas, kCol0X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, kNone_SkFilterQuality);
 
             // Then draw a column with no bleeding or tiling but with low filtering
-            this->drawCase1(canvas, kCol1X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase2(canvas, kCol1X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase3(canvas, kCol1X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase4(canvas, kCol1X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
+            this->drawCase1(canvas, kCol1X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase2(canvas, kCol1X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase3(canvas, kCol1X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase4(canvas, kCol1X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, kLow_SkFilterQuality);
 
             // Then draw a column with no bleeding or tiling but with high filtering
-            this->drawCase1(canvas, kCol2X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase2(canvas, kCol2X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase3(canvas, kCol2X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase4(canvas, kCol2X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
+            this->drawCase1(canvas, kCol2X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase2(canvas, kCol2X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase3(canvas, kCol2X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase4(canvas, kCol2X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, kHigh_SkFilterQuality);
 
 #if SK_SUPPORT_GPU
             GrContext* ctx = canvas->getGrContext();
@@ -217,28 +217,28 @@ protected:
 #endif
 
             // Then draw a column with no bleeding but with tiling and low filtering
-            this->drawCase1(canvas, kCol3X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase2(canvas, kCol3X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase3(canvas, kCol3X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase4(canvas, kCol3X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
+            this->drawCase1(canvas, kCol3X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase2(canvas, kCol3X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase3(canvas, kCol3X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase4(canvas, kCol3X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, kLow_SkFilterQuality);
 
             // Then draw a column with no bleeding but with tiling and high filtering
-            this->drawCase1(canvas, kCol4X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase2(canvas, kCol4X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase3(canvas, kCol4X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase4(canvas, kCol4X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
+            this->drawCase1(canvas, kCol4X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase2(canvas, kCol4X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase3(canvas, kCol4X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase4(canvas, kCol4X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, kHigh_SkFilterQuality);
 
             // Then draw a column with bleeding, tiling, and low filtering
-            this->drawCase1(canvas, kCol5X, kRow0Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase2(canvas, kCol5X, kRow1Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase3(canvas, kCol5X, kRow2Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
-            this->drawCase4(canvas, kCol5X, kRow3Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
+            this->drawCase1(canvas, kCol5X, kRow0Y, SkCanvas::kBleed_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase2(canvas, kCol5X, kRow1Y, SkCanvas::kBleed_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase3(canvas, kCol5X, kRow2Y, SkCanvas::kBleed_DrawBitmapRectFlag, kLow_SkFilterQuality);
+            this->drawCase4(canvas, kCol5X, kRow3Y, SkCanvas::kBleed_DrawBitmapRectFlag, kLow_SkFilterQuality);
 
             // Finally draw a column with bleeding, tiling, and high filtering
-            this->drawCase1(canvas, kCol6X, kRow0Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase2(canvas, kCol6X, kRow1Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase3(canvas, kCol6X, kRow2Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
-            this->drawCase4(canvas, kCol6X, kRow3Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
+            this->drawCase1(canvas, kCol6X, kRow0Y, SkCanvas::kBleed_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase2(canvas, kCol6X, kRow1Y, SkCanvas::kBleed_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase3(canvas, kCol6X, kRow2Y, SkCanvas::kBleed_DrawBitmapRectFlag, kHigh_SkFilterQuality);
+            this->drawCase4(canvas, kCol6X, kRow3Y, SkCanvas::kBleed_DrawBitmapRectFlag, kHigh_SkFilterQuality);
 
 #if SK_SUPPORT_GPU
             if (ctx) {
diff --git a/gm/blurquickreject.cpp b/gm/blurquickreject.cpp
index 7c74fdf380..c2fee72f01 100644
--- a/gm/blurquickreject.cpp
+++ b/gm/blurquickreject.cpp
@@ -55,7 +55,7 @@ protected:
         hairlinePaint.setStrokeWidth(0);
 
         SkPaint blurPaint;
-        blurPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
+        blurPaint.setFilterQuality(kLow_SkFilterQuality);
         SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
                                                     SkBlurMask::ConvertRadiusToSigma(kBlurRadius));
         blurPaint.setMaskFilter(mf)->unref();
diff --git a/gm/clippedbitmapshaders.cpp b/gm/clippedbitmapshaders.cpp
index ee20847726..6225abeec1 100644
--- a/gm/clippedbitmapshaders.cpp
+++ b/gm/clippedbitmapshaders.cpp
@@ -89,7 +89,7 @@ protected:
         paint.setShader(shader)->unref();
 
         if (fHQ) {
-            paint.setFilterLevel(SkPaint::kHigh_FilterLevel);
+            paint.setFilterQuality(kHigh_SkFilterQuality);
         }
 
         SkScalar margin = (SLIDE_SIZE / 3 - RECT_SIZE) / 2;
diff --git a/gm/downsamplebitmap.cpp b/gm/downsamplebitmap.cpp
index 15280f23e3..9523e068a4 100644
--- a/gm/downsamplebitmap.cpp
+++ b/gm/downsamplebitmap.cpp
@@ -39,20 +39,20 @@ public:
     SkBitmap    fBM;
     SkString    fName;
     bool        fBitmapMade;
-    SkPaint::FilterLevel fFilterLevel;
+    SkFilterQuality fFilterQuality;
 
-    DownsampleBitmapGM(SkPaint::FilterLevel filterLevel)
-        : fFilterLevel(filterLevel)
+    DownsampleBitmapGM(SkFilterQuality filterQuality)
+        : fFilterQuality(filterQuality)
     {
         this->setBGColor(0xFFDDDDDD);
         fBitmapMade = false;
     }
 
-    const char* filterLevelToString() {
-        static const char *filterLevelNames[] = {
+    const char* filterQualityToString() {
+        static const char *filterQualityNames[] = {
             "none", "low", "medium", "high"
         };
-        return filterLevelNames[fFilterLevel];
+        return filterQualityNames[fFilterQuality];
     }
 
 protected:
@@ -87,7 +87,7 @@ protected:
             matrix.setScale( curScale, curScale );
 
             SkPaint paint;
-            paint.setFilterLevel(fFilterLevel);
+            paint.setFilterQuality(fFilterQuality);
 
             canvas->save();
             canvas->translate(0, (SkScalar)curY);
@@ -107,10 +107,10 @@ private:
 
 class DownsampleBitmapTextGM: public DownsampleBitmapGM {
   public:
-      DownsampleBitmapTextGM(float textSize, SkPaint::FilterLevel filterLevel)
-      : INHERITED(filterLevel), fTextSize(textSize)
+      DownsampleBitmapTextGM(float textSize, SkFilterQuality filterQuality)
+      : INHERITED(filterQuality), fTextSize(textSize)
         {
-            fName.printf("downsamplebitmap_text_%s_%.2fpt", this->filterLevelToString(), fTextSize);
+            fName.printf("downsamplebitmap_text_%s_%.2fpt", this->filterQualityToString(), fTextSize);
         }
 
   protected:
@@ -141,10 +141,10 @@ class DownsampleBitmapTextGM: public DownsampleBitmapGM {
 
 class DownsampleBitmapCheckerboardGM: public DownsampleBitmapGM {
   public:
-      DownsampleBitmapCheckerboardGM(int size, int numChecks, SkPaint::FilterLevel filterLevel)
-      : INHERITED(filterLevel), fSize(size), fNumChecks(numChecks)
+      DownsampleBitmapCheckerboardGM(int size, int numChecks, SkFilterQuality filterQuality)
+      : INHERITED(filterQuality), fSize(size), fNumChecks(numChecks)
         {
-            fName.printf("downsamplebitmap_checkerboard_%s_%d_%d", this->filterLevelToString(), fSize, fNumChecks);
+            fName.printf("downsamplebitmap_checkerboard_%s_%d_%d", this->filterQualityToString(), fSize, fNumChecks);
         }
 
   protected:
@@ -160,10 +160,10 @@ class DownsampleBitmapCheckerboardGM: public DownsampleBitmapGM {
 
 class DownsampleBitmapImageGM: public DownsampleBitmapGM {
   public:
-      DownsampleBitmapImageGM(const char filename[], SkPaint::FilterLevel filterLevel)
-      : INHERITED(filterLevel), fFilename(filename)
+      DownsampleBitmapImageGM(const char filename[], SkFilterQuality filterQuality)
+      : INHERITED(filterQuality), fFilename(filename)
         {
-            fName.printf("downsamplebitmap_image_%s_%s", this->filterLevelToString(), filename);
+            fName.printf("downsamplebitmap_image_%s_%s", this->filterQualityToString(), filename);
         }
 
   protected:
@@ -248,26 +248,26 @@ DEF_GM( return new ShowMipLevels; )
 
 //////////////////////////////////////////////////////////////////////////////
 
-DEF_GM( return new DownsampleBitmapTextGM(72, SkPaint::kHigh_FilterLevel); )
-DEF_GM( return new DownsampleBitmapCheckerboardGM(512,256, SkPaint::kHigh_FilterLevel); )
-DEF_GM( return new DownsampleBitmapImageGM("mandrill_512.png", SkPaint::kHigh_FilterLevel); )
+DEF_GM( return new DownsampleBitmapTextGM(72, kHigh_SkFilterQuality); )
+DEF_GM( return new DownsampleBitmapCheckerboardGM(512,256, kHigh_SkFilterQuality); )
+DEF_GM( return new DownsampleBitmapImageGM("mandrill_512.png", kHigh_SkFilterQuality); )
 DEF_GM( return new DownsampleBitmapImageGM("mandrill_132x132_12x12.astc",
-                                            SkPaint::kHigh_FilterLevel); )
+                                            kHigh_SkFilterQuality); )
 
-DEF_GM( return new DownsampleBitmapTextGM(72, SkPaint::kMedium_FilterLevel); )
-DEF_GM( return new DownsampleBitmapCheckerboardGM(512,256, SkPaint::kMedium_FilterLevel); )
-DEF_GM( return new DownsampleBitmapImageGM("mandrill_512.png", SkPaint::kMedium_FilterLevel); )
+DEF_GM( return new DownsampleBitmapTextGM(72, kMedium_SkFilterQuality); )
+DEF_GM( return new DownsampleBitmapCheckerboardGM(512,256, kMedium_SkFilterQuality); )
+DEF_GM( return new DownsampleBitmapImageGM("mandrill_512.png", kMedium_SkFilterQuality); )
 DEF_GM( return new DownsampleBitmapImageGM("mandrill_132x132_12x12.astc",
-                                           SkPaint::kMedium_FilterLevel); )
+                                           kMedium_SkFilterQuality); )
 
-DEF_GM( return new DownsampleBitmapTextGM(72, SkPaint::kLow_FilterLevel); )
-DEF_GM( return new DownsampleBitmapCheckerboardGM(512,256, SkPaint::kLow_FilterLevel); )
-DEF_GM( return new DownsampleBitmapImageGM("mandrill_512.png", SkPaint::kLow_FilterLevel); )
+DEF_GM( return new DownsampleBitmapTextGM(72, kLow_SkFilterQuality); )
+DEF_GM( return new DownsampleBitmapCheckerboardGM(512,256, kLow_SkFilterQuality); )
+DEF_GM( return new DownsampleBitmapImageGM("mandrill_512.png", kLow_SkFilterQuality); )
 DEF_GM( return new DownsampleBitmapImageGM("mandrill_132x132_12x12.astc",
-                                           SkPaint::kLow_FilterLevel); )
+                                           kLow_SkFilterQuality); )
 
-DEF_GM( return new DownsampleBitmapTextGM(72, SkPaint::kNone_FilterLevel); )
-DEF_GM( return new DownsampleBitmapCheckerboardGM(512,256, SkPaint::kNone_FilterLevel); )
-DEF_GM( return new DownsampleBitmapImageGM("mandrill_512.png", SkPaint::kNone_FilterLevel); )
+DEF_GM( return new DownsampleBitmapTextGM(72, kNone_SkFilterQuality); )
+DEF_GM( return new DownsampleBitmapCheckerboardGM(512,256, kNone_SkFilterQuality); )
+DEF_GM( return new DownsampleBitmapImageGM("mandrill_512.png", kNone_SkFilterQuality); )
 DEF_GM( return new DownsampleBitmapImageGM("mandrill_132x132_12x12.astc",
-                                           SkPaint::kNone_FilterLevel); )
+                                           kNone_SkFilterQuality); )
diff --git a/gm/drawbitmaprect.cpp b/gm/drawbitmaprect.cpp
index 39d46dbd80..84766a9b61 100644
--- a/gm/drawbitmaprect.cpp
+++ b/gm/drawbitmaprect.cpp
@@ -217,7 +217,7 @@ protected:
             SkBitmap bm;
 
             bm = make_chessbm(5, 5);
-            paint.setFilterLevel(SkPaint::kLow_FilterLevel);
+            paint.setFilterQuality(kLow_SkFilterQuality);
 
             srcRect.setXYWH(1, 1, 3, 3);
             SkMaskFilter* mf = SkBlurMaskFilter::Create(
diff --git a/gm/filterbitmap.cpp b/gm/filterbitmap.cpp
index 66f9d34d7c..7028012f45 100644
--- a/gm/filterbitmap.cpp
+++ b/gm/filterbitmap.cpp
@@ -25,9 +25,9 @@ static SkSize computeSize(const SkBitmap& bm, const SkMatrix& mat) {
 }
 
 static void draw_cell(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& mat, SkScalar dx,
-                      SkPaint::FilterLevel lvl) {
+                      SkFilterQuality lvl) {
     SkPaint paint;
-    paint.setFilterLevel(lvl);
+    paint.setFilterQuality(lvl);
 
     SkAutoCanvasRestore acr(canvas, true);
     canvas->translate(dx, 0);
@@ -36,10 +36,10 @@ static void draw_cell(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& mat,
 }
 
 static void draw_row(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& mat, SkScalar dx) {
-    draw_cell(canvas, bm, mat, 0 * dx, SkPaint::kNone_FilterLevel);
-    draw_cell(canvas, bm, mat, 1 * dx, SkPaint::kLow_FilterLevel);
-    draw_cell(canvas, bm, mat, 2 * dx, SkPaint::kMedium_FilterLevel);
-    draw_cell(canvas, bm, mat, 3 * dx, SkPaint::kHigh_FilterLevel);
+    draw_cell(canvas, bm, mat, 0 * dx, kNone_SkFilterQuality);
+    draw_cell(canvas, bm, mat, 1 * dx, kLow_SkFilterQuality);
+    draw_cell(canvas, bm, mat, 2 * dx, kMedium_SkFilterQuality);
+    draw_cell(canvas, bm, mat, 3 * dx, kHigh_SkFilterQuality);
 }
 
 class FilterBitmapGM : public skiagm::GM {
diff --git a/gm/filterfastbounds.cpp b/gm/filterfastbounds.cpp
index 206903f3eb..6244001374 100644
--- a/gm/filterfastbounds.cpp
+++ b/gm/filterfastbounds.cpp
@@ -94,7 +94,7 @@ static void create_paints(SkImageFilter* source, SkTArray<SkPaint>* paints) {
         scale.setScale(2.0f, 2.0f);
 
         SkAutoTUnref<SkMatrixImageFilter> scaleMIF(
-            SkMatrixImageFilter::Create(scale, SkPaint::kLow_FilterLevel, source));
+            SkMatrixImageFilter::Create(scale, kLow_SkFilterQuality, source));
 
         add_paint(scaleMIF, paints);
     }
@@ -104,7 +104,7 @@ static void create_paints(SkImageFilter* source, SkTArray<SkPaint>* paints) {
         rot.setRotate(-33.3f);
 
         SkAutoTUnref<SkMatrixImageFilter> rotMIF(
-            SkMatrixImageFilter::Create(rot, SkPaint::kLow_FilterLevel, source));
+            SkMatrixImageFilter::Create(rot, kLow_SkFilterQuality, source));
 
         add_paint(rotMIF, paints);
     }
diff --git a/gm/filterindiabox.cpp b/gm/filterindiabox.cpp
index 1ed2a6924f..2c39a1064b 100644
--- a/gm/filterindiabox.cpp
+++ b/gm/filterindiabox.cpp
@@ -24,9 +24,9 @@ static SkSize computeSize(const SkBitmap& bm, const SkMatrix& mat) {
 }
 
 static void draw_cell(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& mat, SkScalar dx,
-                      SkPaint::FilterLevel lvl) {
+                      SkFilterQuality lvl) {
     SkPaint paint;
-    paint.setFilterLevel(lvl);
+    paint.setFilterQuality(lvl);
 
     SkAutoCanvasRestore acr(canvas, true);
 
@@ -36,10 +36,10 @@ static void draw_cell(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& mat,
 }
 
 static void draw_row(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& mat, SkScalar dx) {
-    draw_cell(canvas, bm, mat, 0 * dx, SkPaint::kNone_FilterLevel);
-    draw_cell(canvas, bm, mat, 1 * dx, SkPaint::kLow_FilterLevel);
-    draw_cell(canvas, bm, mat, 2 * dx, SkPaint::kMedium_FilterLevel);
-    draw_cell(canvas, bm, mat, 3 * dx, SkPaint::kHigh_FilterLevel);
+    draw_cell(canvas, bm, mat, 0 * dx, kNone_SkFilterQuality);
+    draw_cell(canvas, bm, mat, 1 * dx, kLow_SkFilterQuality);
+    draw_cell(canvas, bm, mat, 2 * dx, kMedium_SkFilterQuality);
+    draw_cell(canvas, bm, mat, 3 * dx, kHigh_SkFilterQuality);
 }
 
 class FilterIndiaBoxGM : public skiagm::GM {
diff --git a/gm/giantbitmap.cpp b/gm/giantbitmap.cpp
index 2ac952daf4..bb9a655868 100644
--- a/gm/giantbitmap.cpp
+++ b/gm/giantbitmap.cpp
@@ -109,7 +109,7 @@ protected:
         SkShader* s = SkShader::CreateBitmapShader(getBitmap(), fMode, fMode, &m);
 
         paint.setShader(s)->unref();
-        paint.setFilterLevel(fDoFilter ? SkPaint::kLow_FilterLevel : SkPaint::kNone_FilterLevel);
+        paint.setFilterQuality(fDoFilter ? kLow_SkFilterQuality : kNone_SkFilterQuality);
 
         canvas->translate(SkIntToScalar(50), SkIntToScalar(50));
 
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index 98f5bbb4c2..5608414107 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -91,7 +91,7 @@ protected:
             SkDilateImageFilter::Create(2, 2, checkerboard.get()),
             SkErodeImageFilter::Create(2, 2, checkerboard.get()),
             SkOffsetImageFilter::Create(SkIntToScalar(-16), SkIntToScalar(32)),
-            SkMatrixImageFilter::Create(resizeMatrix, SkPaint::kNone_FilterLevel),
+            SkMatrixImageFilter::Create(resizeMatrix, kNone_SkFilterQuality),
             SkRectShaderImageFilter::Create(noise),
         };
 
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 3a928b7b16..1cb1e5c847 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -100,7 +100,7 @@ protected:
             SkDilateImageFilter::Create(1, 1, checkerboard.get()),
             SkErodeImageFilter::Create(1, 1, checkerboard.get()),
             SkOffsetImageFilter::Create(SkIntToScalar(32), 0),
-            SkMatrixImageFilter::Create(resizeMatrix, SkPaint::kNone_FilterLevel),
+            SkMatrixImageFilter::Create(resizeMatrix, kNone_SkFilterQuality),
             SkRectShaderImageFilter::Create(noise),
             SkLightingImageFilter::CreatePointLitDiffuse(pointLocation, white, surfaceScale, kd),
             SkLightingImageFilter::CreateSpotLitDiffuse(spotLocation, spotTarget, spotExponent,
diff --git a/gm/imageresizetiled.cpp b/gm/imageresizetiled.cpp
index 6eb254cfe1..d06c1fbc5b 100644
--- a/gm/imageresizetiled.cpp
+++ b/gm/imageresizetiled.cpp
@@ -36,7 +36,7 @@ protected:
         SkMatrix matrix;
         matrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR);
         SkAutoTUnref<SkImageFilter> imageFilter(
-            SkMatrixImageFilter::Create(matrix, SkPaint::kNone_FilterLevel));
+            SkMatrixImageFilter::Create(matrix, kNone_SkFilterQuality));
         paint.setImageFilter(imageFilter.get());
         const SkScalar tile_size = SkIntToScalar(100);
         SkRect bounds;
diff --git a/gm/matriximagefilter.cpp b/gm/matriximagefilter.cpp
index 59c5106b7a..eef2b451fc 100644
--- a/gm/matriximagefilter.cpp
+++ b/gm/matriximagefilter.cpp
@@ -23,9 +23,9 @@ protected:
     }
 
     void draw(SkCanvas* canvas, const SkRect& rect, const SkBitmap& bitmap,
-              const SkMatrix& matrix, SkPaint::FilterLevel filterLevel) {
+              const SkMatrix& matrix, SkFilterQuality filter) {
         SkAutoTUnref<SkImageFilter> imageFilter(
-            SkMatrixImageFilter::Create(matrix, filterLevel));
+            SkMatrixImageFilter::Create(matrix, filter));
         SkPaint paint;
         paint.setImageFilter(imageFilter.get());
         canvas->saveLayer(&rect, &paint);
@@ -68,18 +68,18 @@ protected:
         SkRect srcRect = SkRect::MakeWH(96, 96);
 
         canvas->translate(margin, margin);
-        draw(canvas, srcRect, checkerboard, matrix, SkPaint::kNone_FilterLevel);
+        draw(canvas, srcRect, checkerboard, matrix, kNone_SkFilterQuality);
 
         canvas->translate(srcRect.width() + margin, 0);
-        draw(canvas, srcRect, checkerboard, matrix, SkPaint::kLow_FilterLevel);
+        draw(canvas, srcRect, checkerboard, matrix, kLow_SkFilterQuality);
 
 #if 0
         // This may be causing Mac 10.6 to barf.
         canvas->translate(srcRect.width() + margin, 0);
-        draw(canvas, srcRect, checkerboard, matrix, SkPaint::kMedium_FilterLevel);
+        draw(canvas, srcRect, checkerboard, matrix, kMedium_SkFilterQuality);
 
         canvas->translate(srcRect.width() + margin, 0);
-        draw(canvas, srcRect, checkerboard, matrix, SkPaint::kHigh_FilterLevel);
+        draw(canvas, srcRect, checkerboard, matrix, kHigh_SkFilterQuality);
 #endif
     }
 
diff --git a/gm/mipmap.cpp b/gm/mipmap.cpp
index 948fd99ded..70543a91f1 100644
--- a/gm/mipmap.cpp
+++ b/gm/mipmap.cpp
@@ -41,7 +41,7 @@ static void test_mip(SkCanvas* canvas) {
 
     canvas->translate(20, 20);
     for (int i = 0; i < 4; ++i) {
-        paint.setFilterLevel(SkPaint::FilterLevel(i));
+        paint.setFilterQuality(SkFilterQuality(i));
         canvas->drawImageRect(img, NULL, dst, &paint);
         canvas->translate(0, 20);
     }
diff --git a/gm/ninepatchstretch.cpp b/gm/ninepatchstretch.cpp
index 67f6bf4db9..5031480aa5 100644
--- a/gm/ninepatchstretch.cpp
+++ b/gm/ninepatchstretch.cpp
@@ -73,7 +73,7 @@ protected:
         SkScalar y = SkIntToScalar(100);
 
         SkPaint paint;
-        paint.setFilterLevel(SkPaint::kLow_FilterLevel);
+        paint.setFilterQuality(kLow_SkFilterQuality);
 
         for (int iy = 0; iy < 2; ++iy) {
             for (int ix = 0; ix < 2; ++ix) {
diff --git a/gm/pictureimagefilter.cpp b/gm/pictureimagefilter.cpp
index 6f05853f77..36b0817ac9 100644
--- a/gm/pictureimagefilter.cpp
+++ b/gm/pictureimagefilter.cpp
@@ -65,10 +65,10 @@ protected:
                 SkPictureImageFilter::Create(fPicture, emptyRect));
             SkAutoTUnref<SkPictureImageFilter> pictureSourceResampled(
                 SkPictureImageFilter::CreateForLocalSpace(fPicture, fPicture->cullRect(),
-                    SkPaint::kLow_FilterLevel));
+                    kLow_SkFilterQuality));
             SkAutoTUnref<SkPictureImageFilter> pictureSourcePixelated(
                 SkPictureImageFilter::CreateForLocalSpace(fPicture, fPicture->cullRect(),
-                    SkPaint::kNone_FilterLevel));
+                    kNone_SkFilterQuality));
 
             canvas->save();
             // Draw the picture unscaled.
diff --git a/gm/resizeimagefilter.cpp b/gm/resizeimagefilter.cpp
index e87dff0d35..6916f6116b 100644
--- a/gm/resizeimagefilter.cpp
+++ b/gm/resizeimagefilter.cpp
@@ -28,7 +28,7 @@ protected:
     void draw(SkCanvas* canvas,
               const SkRect& rect,
               const SkSize& deviceSize,
-              SkPaint::FilterLevel filterLevel,
+              SkFilterQuality filterQuality,
               SkImageFilter* input = NULL) {
         SkRect dstRect;
         canvas->getTotalMatrix().mapRect(&dstRect, rect);
@@ -42,7 +42,7 @@ protected:
         matrix.setScale(SkScalarInvert(deviceScaleX),
                         SkScalarInvert(deviceScaleY));
         SkAutoTUnref<SkImageFilter> imageFilter(
-            SkMatrixImageFilter::Create(matrix, filterLevel, input));
+            SkMatrixImageFilter::Create(matrix, filterQuality, input));
         SkPaint filteredPaint;
         filteredPaint.setImageFilter(imageFilter.get());
         canvas->saveLayer(&rect, &filteredPaint);
@@ -68,25 +68,25 @@ protected:
         draw(canvas,
              srcRect,
              deviceSize,
-             SkPaint::kNone_FilterLevel);
+             kNone_SkFilterQuality);
 
         canvas->translate(srcRect.width() + SkIntToScalar(10), 0);
         draw(canvas,
              srcRect,
              deviceSize,
-             SkPaint::kLow_FilterLevel);
+             kLow_SkFilterQuality);
 
         canvas->translate(srcRect.width() + SkIntToScalar(10), 0);
         draw(canvas,
              srcRect,
              deviceSize,
-             SkPaint::kMedium_FilterLevel);
+             kMedium_SkFilterQuality);
 
         canvas->translate(srcRect.width() + SkIntToScalar(10), 0);
         draw(canvas,
              srcRect,
              deviceSize,
-             SkPaint::kHigh_FilterLevel);
+             kHigh_SkFilterQuality);
 
         SkBitmap bitmap;
         bitmap.allocN32Pixels(16, 16);
@@ -107,7 +107,7 @@ protected:
         draw(canvas,
              srcRect,
              deviceSize,
-             SkPaint::kHigh_FilterLevel,
+             kHigh_SkFilterQuality,
              source.get());
     }
 
diff --git a/gm/shadertext2.cpp b/gm/shadertext2.cpp
index 31d1e89869..b0637da831 100644
--- a/gm/shadertext2.cpp
+++ b/gm/shadertext2.cpp
@@ -92,7 +92,7 @@ protected:
         fillPaint.setAntiAlias(true);
         sk_tool_utils::set_portable_typeface(&fillPaint);
         fillPaint.setTextSize(SkIntToScalar(kPointSize));
-        fillPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
+        fillPaint.setFilterQuality(kLow_SkFilterQuality);
 
         SkPaint outlinePaint;
         outlinePaint.setAntiAlias(true);
diff --git a/gm/shadertext3.cpp b/gm/shadertext3.cpp
index 7b84f69e49..1e0216ebda 100644
--- a/gm/shadertext3.cpp
+++ b/gm/shadertext3.cpp
@@ -67,7 +67,7 @@ protected:
 
         SkPaint bmpPaint;
         bmpPaint.setAntiAlias(true);
-        bmpPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
+        bmpPaint.setFilterQuality(kLow_SkFilterQuality);
         bmpPaint.setAlpha(0x80);
         canvas->drawBitmap(fBmp, 5.f, 5.f, &bmpPaint);
 
@@ -109,7 +109,7 @@ protected:
                 fillPaint.setAntiAlias(true);
                 sk_tool_utils::set_portable_typeface(&fillPaint);
                 fillPaint.setTextSize(SkIntToScalar(kPointSize));
-                fillPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
+                fillPaint.setFilterQuality(kLow_SkFilterQuality);
                 fillPaint.setShader(shader);
 
                 canvas->drawText(kText, kTextLen, 0, 0, fillPaint);
diff --git a/gm/tallstretchedbitmaps.cpp b/gm/tallstretchedbitmaps.cpp
index 06b23352f4..e62c5d7f81 100644
--- a/gm/tallstretchedbitmaps.cpp
+++ b/gm/tallstretchedbitmaps.cpp
@@ -87,7 +87,7 @@ protected:
                                                bmp.width(), bmp.height());
             SkRect dstRect = SkRect::MakeWH(SkIntToScalar(bmp.width()), 10.f * itemHeight);
             SkPaint paint;
-            paint.setFilterLevel(SkPaint::kLow_FilterLevel);
+            paint.setFilterQuality(kLow_SkFilterQuality);
             canvas->drawBitmapRect(bmp, &subRect, dstRect, &paint);
             canvas->translate(SkIntToScalar(bmp.width() + 10), 0);
         }
diff --git a/gm/tiledscaledbitmap.cpp b/gm/tiledscaledbitmap.cpp
index 6b47315b11..16935ede6b 100644
--- a/gm/tiledscaledbitmap.cpp
+++ b/gm/tiledscaledbitmap.cpp
@@ -58,7 +58,7 @@ protected:
         SkPaint paint;
 
         paint.setAntiAlias(true);
-        paint.setFilterLevel(SkPaint::kHigh_FilterLevel);
+        paint.setFilterQuality(kHigh_SkFilterQuality);
 
         SkMatrix mat;
         mat.setScale(121.f/360.f, 93.f/288.f);
diff --git a/gm/tilemodes.cpp b/gm/tilemodes.cpp
index 8dc54a977b..193f8a6ced 100644
--- a/gm/tilemodes.cpp
+++ b/gm/tilemodes.cpp
@@ -38,7 +38,7 @@ static void setup(SkPaint* paint, const SkBitmap& bm, bool filter,
                   SkShader::TileMode tmx, SkShader::TileMode tmy) {
     SkShader* shader = SkShader::CreateBitmapShader(bm, tmx, tmy);
     paint->setShader(shader)->unref();
-    paint->setFilterLevel(filter ? SkPaint::kLow_FilterLevel : SkPaint::kNone_FilterLevel);
+    paint->setFilterQuality(filter ? kLow_SkFilterQuality : kNone_SkFilterQuality);
 }
 
 static const SkColorType gColorTypes[] = {
diff --git a/gm/tilemodes_scaled.cpp b/gm/tilemodes_scaled.cpp
index 508e57678a..a8227a005b 100644
--- a/gm/tilemodes_scaled.cpp
+++ b/gm/tilemodes_scaled.cpp
@@ -35,11 +35,11 @@ static void makebm(SkBitmap* bm, SkColorType ct, int w, int h) {
     canvas.drawPaint(paint);
 }
 
-static void setup(SkPaint* paint, const SkBitmap& bm, SkPaint::FilterLevel filter_level,
+static void setup(SkPaint* paint, const SkBitmap& bm, SkFilterQuality filter_level,
                   SkShader::TileMode tmx, SkShader::TileMode tmy) {
     SkShader* shader = SkShader::CreateBitmapShader(bm, tmx, tmy);
     paint->setShader(shader)->unref();
-    paint->setFilterLevel(filter_level);
+    paint->setFilterQuality(filter_level);
 }
 
 static const SkColorType gColorTypes[] = {
@@ -91,12 +91,12 @@ protected:
 
         static const char* gColorTypeNames[] = { "8888" , "565", "4444" };
 
-        static const SkPaint::FilterLevel           gFilterLevels[] =
-            { SkPaint::kNone_FilterLevel,
-              SkPaint::kLow_FilterLevel,
-              SkPaint::kMedium_FilterLevel,
-              SkPaint::kHigh_FilterLevel };
-        static const char*          gFilterNames[] = { "None", "Low", "Medium", "High" };
+        static const SkFilterQuality gFilterQualitys[] =
+            { kNone_SkFilterQuality,
+              kLow_SkFilterQuality,
+              kMedium_SkFilterQuality,
+              kHigh_SkFilterQuality };
+        static const char* gFilterNames[] = { "None", "Low", "Medium", "High" };
 
         static const SkShader::TileMode gModes[] = { SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode };
         static const char*          gModeNames[] = {    "C",                    "R",                   "M" };
@@ -124,7 +124,7 @@ protected:
         y = SkIntToScalar(40) / scale;
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypes); i++) {
-            for (size_t j = 0; j < SK_ARRAY_COUNT(gFilterLevels); j++) {
+            for (size_t j = 0; j < SK_ARRAY_COUNT(gFilterQualitys); j++) {
                 x = SkIntToScalar(10)/scale;
                 for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
                     for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
@@ -135,7 +135,7 @@ protected:
                             makebm(&fTexture[i], gColorTypes[i], size, size);
                         }
 #endif
-                        setup(&paint, fTexture[i], gFilterLevels[j], gModes[kx], gModes[ky]);
+                        setup(&paint, fTexture[i], gFilterQualitys[j], gModes[kx], gModes[ky]);
                         paint.setDither(true);
 
                         canvas->save();