Hide filterquality enum entirely

Introduce private SkLegacyFQ to allow us to continue deserializing
old content with filter-qualities, but still remove the public enum.

Need to finish removing references in clients.

Change-Id: Iacfb602ec497260e53defc4b95e297ed1ef4e69c
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/429476
Auto-Submit: Mike Reed <reed@google.com>
Commit-Queue: Florin Malita <fmalita@google.com>
Reviewed-by: Florin Malita <fmalita@chromium.org>
diff --git a/include/core/SkFilterQuality.h b/include/core/SkFilterQuality.h
index 5af85ec..37dd078 100644
--- a/include/core/SkFilterQuality.h
+++ b/include/core/SkFilterQuality.h
@@ -10,6 +10,12 @@
 
 #include "include/core/SkTypes.h"
 
+#ifndef SK_SUPPORT_LEGACY_FILTERQUALITY
+#define SK_SUPPORT_LEGACY_FILTERQUALITY
+#endif
+
+#ifdef SK_SUPPORT_LEGACY_FILTERQUALITY
+
 /**
  *  Controls how much filtering to be done when scaling/transforming complex colors
  *  e.g. images.
@@ -26,3 +32,5 @@
 };
 
 #endif
+
+#endif
diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h
index 9ecc0c1..bc32bf3 100644
--- a/include/core/SkPaint.h
+++ b/include/core/SkPaint.h
@@ -733,8 +733,12 @@
             unsigned    fCapType : 2;
             unsigned    fJoinType : 2;
             unsigned    fStyle : 2;
+#ifdef SK_SUPPORT_LEGACY_FILTERQUALITY
             unsigned    fFilterQuality : 2;
             unsigned    fPadding : 22;  // 22 == 32 -1-1-2-2-2-2
+#else
+            unsigned    fPadding : 24;  // 24 == 32 -1-1-2-2-2
+#endif
         } fBitfields;
         uint32_t fBitfieldsUInt;
     };
diff --git a/include/core/SkSamplingOptions.h b/include/core/SkSamplingOptions.h
index 00d0c98..6296bfce 100644
--- a/include/core/SkSamplingOptions.h
+++ b/include/core/SkSamplingOptions.h
@@ -79,11 +79,13 @@
         : useCubic(true)
         , cubic(c) {}
 
+#ifdef SK_SUPPORT_LEGACY_FILTERQUALITY
     enum MediumBehavior {
         kMedium_asMipmapNearest,    // historic cpu behavior
         kMedium_asMipmapLinear,     // historic gpu behavior
     };
     explicit SkSamplingOptions(SkFilterQuality, MediumBehavior = kMedium_asMipmapNearest);
+#endif
 
     bool operator==(const SkSamplingOptions& other) const {
         return useCubic == other.useCubic
diff --git a/src/core/SkMatrixImageFilter.cpp b/src/core/SkMatrixImageFilter.cpp
index 90fd3b9..665dcd4 100644
--- a/src/core/SkMatrixImageFilter.cpp
+++ b/src/core/SkMatrixImageFilter.cpp
@@ -46,8 +46,7 @@
 
     auto sampling = [&]() {
         if (buffer.isVersionLT(SkPicturePriv::kMatrixImageFilterSampling_Version)) {
-            return SkSamplingOptions(buffer.read32LE(kLast_SkFilterQuality),
-                                     SkSamplingOptions::kMedium_asMipmapLinear);
+            return SkSamplingPriv::FromFQ(buffer.read32LE(kLast_SkLegacyFQ), kLinear_SkMediumAs);
         } else {
             return SkSamplingPriv::Read(buffer);
         }
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 0fc25b1..97ac845 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -51,7 +51,9 @@
                  (unsigned)SkPaint::kDefault_Cap,   // fCapType
                  (unsigned)SkPaint::kDefault_Join,  // fJoinType
                  (unsigned)SkPaint::kFill_Style,    // fStyle
+#ifdef SK_SUPPORT_LEGACY_FILTERQUALITY
                  (unsigned)kNone_SkFilterQuality,   // fFilterQuality
+#endif
                  0}                                 // fPadding
 {
     static_assert(sizeof(fBitfields) == sizeof(fBitfieldsUInt), "");
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
index 9c5ab0b..528d101 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -19,17 +19,22 @@
 #include "src/core/SkPictureRecord.h"
 #include "src/core/SkReadBuffer.h"
 #include "src/core/SkSafeMath.h"
+#include "src/core/SkSamplingPriv.h"
 #include "src/core/SkVerticesPriv.h"
 #include "src/utils/SkPatchUtils.h"
 
-static SkFilterQuality get_filter_quality(const SkPaint& paint) {
+static SkLegacyFQ get_filter_quality(const SkPaint& paint) {
 #ifdef SK_SUPPORT_LEGACY_SETFILTERQUALITY
-    return paint.getFilterQuality();
+    return (SkLegacyFQ)paint.getFilterQuality();
 #else
-    return kNone_SkFilterQuality;
+    return kNone_SkLegacyFQ;
 #endif
 }
 
+static SkLegacyFQ get_filter_quality(const SkPaint* paint) {
+    return paint ? get_filter_quality(*paint) : kNone_SkLegacyFQ;
+}
+
 static const SkRect* get_rect_ptr(SkReadBuffer* reader, SkRect* storage) {
     if (reader->readBool()) {
         reader->readRect(storage);
@@ -296,8 +301,7 @@
             if (op == DRAW_EDGEAA_IMAGE_SET2) {
                 sampling = reader->readSampling();
             } else {
-                sampling = SkSamplingOptions(paint ? get_filter_quality(*paint)
-                                                   : kNone_SkFilterQuality);
+                sampling = SkSamplingPriv::FromFQ(get_filter_quality(paint));
             }
 
             SkCanvas::SrcRectConstraint constraint =
@@ -365,8 +369,7 @@
             BREAK_ON_READ_ERROR(reader);
 
             canvas->drawImage(image, loc.fX, loc.fY,
-                              SkSamplingOptions(paint ? get_filter_quality(*paint)
-                                                      : kNone_SkFilterQuality),
+                              SkSamplingPriv::FromFQ(get_filter_quality(paint)),
                               paint);
         } break;
         case DRAW_IMAGE2: {
@@ -388,7 +391,7 @@
             BREAK_ON_READ_ERROR(reader);
 
             SkFilterMode filter = SkFilterMode::kNearest;
-            if (paint && get_filter_quality(*paint) != kNone_SkFilterQuality) {
+            if (paint && get_filter_quality(*paint) != kNone_SkLegacyFQ) {
                 filter = SkFilterMode::kLinear;
             }
             canvas->drawImageLattice(image, lattice, *dst, filter, paint);
@@ -414,7 +417,7 @@
             BREAK_ON_READ_ERROR(reader);
 
             SkFilterMode filter = SkFilterMode::kNearest;
-            if (paint && get_filter_quality(*paint) != kNone_SkFilterQuality) {
+            if (paint && get_filter_quality(*paint) != kNone_SkLegacyFQ) {
                 filter = SkFilterMode::kLinear;
             }
             canvas->drawImageNine(image, center, dst, filter, paint);
@@ -435,8 +438,7 @@
             }
             BREAK_ON_READ_ERROR(reader);
 
-            auto sampling = SkSamplingOptions(paint ? get_filter_quality(*paint)
-                                                    : kNone_SkFilterQuality);
+            auto sampling = SkSamplingPriv::FromFQ(get_filter_quality(paint));
             if (src) {
                 canvas->drawImageRect(image, *src, dst, sampling, paint, constraint);
             } else {
diff --git a/src/core/SkReadBuffer.cpp b/src/core/SkReadBuffer.cpp
index 75c268e..798654c 100644
--- a/src/core/SkReadBuffer.cpp
+++ b/src/core/SkReadBuffer.cpp
@@ -540,6 +540,6 @@
     return value;
 }
 
-SkFilterQuality SkReadBuffer::checkFilterQuality() {
-    return this->checkRange<SkFilterQuality>(kNone_SkFilterQuality, kLast_SkFilterQuality);
+SkLegacyFQ SkReadBuffer::checkFilterQuality() {
+    return this->checkRange<SkLegacyFQ>(kNone_SkLegacyFQ, kLast_SkLegacyFQ);
 }
diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h
index e436d63..77c687c 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -22,6 +22,7 @@
 #include "src/core/SkMaskFilterBase.h"
 #include "src/core/SkPaintPriv.h"
 #include "src/core/SkPicturePriv.h"
+#include "src/core/SkSamplingPriv.h"
 #include "src/core/SkWriteBuffer.h"
 #include "src/shaders/SkShaderBase.h"
 
@@ -203,7 +204,7 @@
                                              static_cast<int32_t>(max)));
     }
 
-    SkFilterQuality checkFilterQuality();
+    SkLegacyFQ checkFilterQuality();
 
     SkSamplingOptions readSampling();
 
diff --git a/src/core/SkSamplingPriv.h b/src/core/SkSamplingPriv.h
index b20b0e9..e42d2df 100644
--- a/src/core/SkSamplingPriv.h
+++ b/src/core/SkSamplingPriv.h
@@ -13,6 +13,23 @@
 class SkReadBuffer;
 class SkWriteBuffer;
 
+// Private copy of SkFilterQuality, just for legacy deserialization
+// Matches values in SkFilterQuality
+enum SkLegacyFQ {
+    kNone_SkLegacyFQ   = 0,    //!< nearest-neighbor; fastest but lowest quality
+    kLow_SkLegacyFQ    = 1,    //!< bilerp
+    kMedium_SkLegacyFQ = 2,    //!< bilerp + mipmaps; good for down-scaling
+    kHigh_SkLegacyFQ   = 3,    //!< bicubic resampling; slowest but good quality
+
+    kLast_SkLegacyFQ = kHigh_SkLegacyFQ,
+};
+
+// Matches values in SkSamplingOptions::MediumBehavior
+enum SkMediumAs {
+    kNearest_SkMediumAs,
+    kLinear_SkMediumAs,
+};
+
 class SkSamplingPriv {
 public:
     enum {
@@ -28,6 +45,8 @@
 
     static SkSamplingOptions Read(SkReadBuffer&);
     static void Write(SkWriteBuffer&, const SkSamplingOptions&);
+
+    static SkSamplingOptions FromFQ(SkLegacyFQ, SkMediumAs = kNearest_SkMediumAs);
 };
 
 #endif
diff --git a/src/effects/imagefilters/SkImageImageFilter.cpp b/src/effects/imagefilters/SkImageImageFilter.cpp
index 2425a14..f71009e 100644
--- a/src/effects/imagefilters/SkImageImageFilter.cpp
+++ b/src/effects/imagefilters/SkImageImageFilter.cpp
@@ -74,8 +74,7 @@
 sk_sp<SkFlattenable> SkImageImageFilter::CreateProc(SkReadBuffer& buffer) {
     SkSamplingOptions sampling;
     if (buffer.isVersionLT(SkPicturePriv::kImageFilterImageSampling_Version)) {
-        sampling = SkSamplingOptions(buffer.checkFilterQuality(),
-                                     SkSamplingOptions::kMedium_asMipmapLinear);
+        sampling = SkSamplingPriv::FromFQ(buffer.checkFilterQuality(), kLinear_SkMediumAs);
     } else {
         sampling = buffer.readSampling();
     }
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index 755e11c..171f50b 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -804,23 +804,20 @@
 #include "src/core/SkSamplingPriv.h"
 #include "src/core/SkWriteBuffer.h"
 
-SkSamplingOptions::SkSamplingOptions(SkFilterQuality fq, MediumBehavior behavior) {
+SkSamplingOptions SkSamplingPriv::FromFQ(SkLegacyFQ fq, SkMediumAs behavior) {
     switch (fq) {
-        case SkFilterQuality::kHigh_SkFilterQuality:
-            *this = SkSamplingOptions(SkCubicResampler{1/3.0f, 1/3.0f});
-            break;
-        case SkFilterQuality::kMedium_SkFilterQuality:
-            *this = SkSamplingOptions(SkFilterMode::kLinear,
-                                      behavior == kMedium_asMipmapNearest ? SkMipmapMode::kNearest
-                                                                          : SkMipmapMode::kLinear);
-            break;
-        case SkFilterQuality::kLow_SkFilterQuality:
-            *this = SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kNone);
-            break;
-        case SkFilterQuality::kNone_SkFilterQuality:
-            *this = SkSamplingOptions(SkFilterMode::kNearest, SkMipmapMode::kNone);
+        case kHigh_SkLegacyFQ:
+            return SkSamplingOptions(SkCubicResampler{1/3.0f, 1/3.0f});
+        case kMedium_SkLegacyFQ:
+            return SkSamplingOptions(SkFilterMode::kLinear,
+                                      behavior == kNearest_SkMediumAs ? SkMipmapMode::kNearest
+                                                                      : SkMipmapMode::kLinear);
+        case kLow_SkLegacyFQ:
+            return SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kNone);
+        case kNone_SkLegacyFQ:
             break;
     }
+    return SkSamplingOptions(SkFilterMode::kNearest, SkMipmapMode::kNone);
 }
 
 SkSamplingOptions SkSamplingPriv::Read(SkReadBuffer& buffer) {
@@ -845,3 +842,9 @@
         buffer.writeUInt((unsigned)sampling.mipmap);
     }
 }
+
+#ifdef SK_SUPPORT_LEGACY_FILTERQUALITY
+SkSamplingOptions::SkSamplingOptions(SkFilterQuality fq, MediumBehavior behavior) {
+    *this = SkSamplingPriv::FromFQ((SkLegacyFQ)fq, (SkMediumAs)behavior);
+}
+#endif