SkPaint::FilterLevel -> SkFilterQuality

src/effects/SkMatrixImageFilter.cpp

 /*
  * Copyright 2014 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrixImageFilter.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkDevice.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMatrix.h"
 #include "SkRect.h"
 
 SkMatrixImageFilter::SkMatrixImageFilter(const SkMatrix& transform,
-                                         SkPaint::FilterLevel filterLevel,
+                                         SkFilterQuality filterQuality,
                                          SkImageFilter* input,
                                          uint32_t uniqueID)
   : INHERITED(1, &input, NULL, uniqueID),
     fTransform(transform),
-    fFilterLevel(filterLevel) {
+    fFilterQuality(filterQuality) {
 }
 
 SkMatrixImageFilter* SkMatrixImageFilter::Create(const SkMatrix& transform,
-                                                 SkPaint::FilterLevel filterLevel,
+                                                 SkFilterQuality filterQuality,
                                                  SkImageFilter* input,
                                                  uint32_t uniqueID) {
-    return SkNEW_ARGS(SkMatrixImageFilter, (transform, filterLevel, input, uniqueID));
+    return SkNEW_ARGS(SkMatrixImageFilter, (transform, filterQuality, input, uniqueID));
 }
 
 SkFlattenable* SkMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
-    SkPaint::FilterLevel level = static_cast<SkPaint::FilterLevel>(buffer.readInt());
-    return Create(matrix, level, common.getInput(0), common.uniqueID());
+    SkFilterQuality quality = static_cast<SkFilterQuality>(buffer.readInt());
+    return Create(matrix, quality, common.getInput(0), common.uniqueID());
 }
 
 void SkMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeMatrix(fTransform);
-    buffer.writeInt(fFilterLevel);
+    buffer.writeInt(fFilterQuality);
 }
 
 SkMatrixImageFilter::~SkMatrixImageFilter() {
 }
 
 bool SkMatrixImageFilter::onFilterImage(Proxy* proxy,
                                         const SkBitmap& source,
                                         const Context& ctx,
                                         SkBitmap* result,
                                         SkIPoint* offset) const {
@@ skipping 21 matching lines @@
     if (NULL == device.get()) {
         return false;
     }
 
     SkCanvas canvas(device.get());
     canvas.translate(-SkIntToScalar(dstBounds.x()), -SkIntToScalar(dstBounds.y()));
     canvas.concat(matrix);
     SkPaint paint;
 
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
-    paint.setFilterLevel(fFilterLevel);
+    paint.setFilterQuality(fFilterQuality);
     canvas.drawBitmap(src, srcRect.x(), srcRect.y(), &paint);
 
     *result = device.get()->accessBitmap(false);
     offset->fX = dstBounds.fLeft;
     offset->fY = dstBounds.fTop;
     return true;
 }
 
 void SkMatrixImageFilter::computeFastBounds(const SkRect& src, SkRect* dst) const {
     SkRect bounds = src;
@@ skipping 37 matching lines @@
                  fTransform[SkMatrix::kMTransX],
                  fTransform[SkMatrix::kMSkewY],
                  fTransform[SkMatrix::kMScaleY],
                  fTransform[SkMatrix::kMTransY],
                  fTransform[SkMatrix::kMPersp0],
                  fTransform[SkMatrix::kMPersp1],
                  fTransform[SkMatrix::kMPersp2]);
 
     str->append("<dt>FilterLevel:</dt><dd>");
     static const char* gFilterLevelStrings[] = { "None", "Low", "Medium", "High" };
-    str->append(gFilterLevelStrings[fFilterLevel]);    
+    str->append(gFilterLevelStrings[fFilterQuality]);
     str->append("</dd>");
 
     str->appendf(")");
 }
 #endif