SkPaint::FilterLevel -> SkFilterQuality

src/core/SkPaint.cpp

 /*
  * Copyright 2006 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 "SkPaint.h"
 #include "SkAnnotation.h"
 #include "SkAutoKern.h"
@@ skipping 1878 matching lines @@
 
     // left-align the fields of "known" size, and right-align the last (flatFlags) so it can easly
     // add more bits in the future.
     return (flags << 16) | (hint << 14) | (align << 12) | (filter << 10) | flatFlags;
 }
 
 static FlatFlags unpack_paint_flags(SkPaint* paint, uint32_t packed) {
     paint->setFlags(packed >> 16);
     paint->setHinting((SkPaint::Hinting)((packed >> 14) & BPF_Mask(kHint_BPF)));
     paint->setTextAlign((SkPaint::Align)((packed >> 12) & BPF_Mask(kAlign_BPF)));
-    paint->setFilterLevel((SkPaint::FilterLevel)((packed >> 10) & BPF_Mask(kFilter_BPF)));
+    paint->setFilterQuality((SkFilterQuality)((packed >> 10) & BPF_Mask(kFilter_BPF)));
     return (FlatFlags)(packed & kFlatFlagMask);
 }
 
 // The size of a flat paint's POD fields
 static const uint32_t kPODPaintSize =   5 * sizeof(SkScalar) +
                                         1 * sizeof(SkColor) +
                                         1 * sizeof(uint16_t) +
                                         6 * sizeof(uint8_t);
 
 /*  To save space/time, we analyze the paint, and write a truncated version of
@@ skipping 20 matching lines @@
     uint32_t* ptr = buffer.reserve(kPODPaintSize);
 
     ptr = write_scalar(ptr, this->getTextSize());
     ptr = write_scalar(ptr, this->getTextScaleX());
     ptr = write_scalar(ptr, this->getTextSkewX());
     ptr = write_scalar(ptr, this->getStrokeWidth());
     ptr = write_scalar(ptr, this->getStrokeMiter());
     *ptr++ = this->getColor();
 
     *ptr++ = pack_paint_flags(this->getFlags(), this->getHinting(), this->getTextAlign(),
-                              this->getFilterLevel(), flatFlags);
+                              this->getFilterQuality(), flatFlags);
     *ptr++ = pack_4(this->getStrokeCap(), this->getStrokeJoin(),
                     this->getStyle(), this->getTextEncoding());
 
     // now we're done with ptr and the (pre)reserved space. If we need to write
     // additional fields, use the buffer directly
     if (flatFlags & kHasTypeface_FlatFlag) {
         buffer.writeTypeface(this->getTypeface());
     }
     if (flatFlags & kHasEffects_FlatFlag) {
         buffer.writeFlattenable(this->getPathEffect());
@@ skipping 299 matching lines @@
         SkAddFlagToString(str, this->isAutohinted(), "Autohinted", &needSeparator);
         SkAddFlagToString(str, this->isVerticalText(), "VerticalText", &needSeparator);
         SkAddFlagToString(str, SkToBool(this->getFlags() & SkPaint::kGenA8FromLCD_Flag),
                           "GenA8FromLCD", &needSeparator);
     } else {
         str->append("None");
     }
     str->append(")</dd>");
 
     str->append("<dt>FilterLevel:</dt><dd>");
-    static const char* gFilterLevelStrings[] = { "None", "Low", "Medium", "High" };
-    str->append(gFilterLevelStrings[this->getFilterLevel()]);
+    static const char* gFilterQualityStrings[] = { "None", "Low", "Medium", "High" };
+    str->append(gFilterQualityStrings[this->getFilterQuality()]);
     str->append("</dd>");
 
     str->append("<dt>TextAlign:</dt><dd>");
     static const char* gTextAlignStrings[SkPaint::kAlignCount] = { "Left", "Center", "Right" };
     str->append(gTextAlignStrings[this->getTextAlign()]);
     str->append("</dd>");
 
     str->append("<dt>CapType:</dt><dd>");
     static const char* gStrokeCapStrings[SkPaint::kCapCount] = { "Butt", "Round", "Square" };
     str->append(gStrokeCapStrings[this->getStrokeCap()]);
@@ skipping 161 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     SK_COMPILE_ASSERT(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
                       SkPaint_notPackedTightly);
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }