diff --git a/gm/textblob.cpp b/gm/textblob.cpp
index e813aff..867e6cd 100644
--- a/gm/textblob.cpp
+++ b/gm/textblob.cpp
@@ -128,7 +128,8 @@
         SkTextBlobBuilder builder;
 
         SkFont font;
-        font.setFlags(font.getFlags() | SkFont::kSubpixel_Flag|SkFont::kDEPRECATED_Antialias_Flag);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kAntiAlias);
         font.setTypeface(fTypeface);
 
         for (unsigned l = 0; l < SK_ARRAY_COUNT(blobConfigs[blobIndex]); ++l) {
diff --git a/gm/textblobshader.cpp b/gm/textblobshader.cpp
index fcebadf..779b5b9 100644
--- a/gm/textblobshader.cpp
+++ b/gm/textblobshader.cpp
@@ -31,7 +31,8 @@
 
     void onOnceBeforeDraw() override {
         SkFont font;
-        font.setFlags(font.getFlags() | SkFont::kSubpixel_Flag | SkFont::kDEPRECATED_Antialias_Flag);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kAntiAlias);
         font.setSize(30);
         font.setTypeface(sk_tool_utils::create_portable_typeface());
 
diff --git a/include/core/SkFont.h b/include/core/SkFont.h
index 6b31ece..13cfaa1 100644
--- a/include/core/SkFont.h
+++ b/include/core/SkFont.h
@@ -12,11 +12,15 @@
 #include "SkScalar.h"
 #include "SkTypeface.h"
 
+// TODO: remove this, and opt in/out per client
+#define SK_SUPPORT_LEGACY_FONT_FLAGS
+
 class SkPaint;
 struct SkFontMetrics;
 
 class SK_API SkFont {
 public:
+#ifdef SK_SUPPORT_LEGACY_FONT_FLAGS
     enum Flags {
         /**
          *  Use the system's automatic hinting mechanism to hint the typeface.
@@ -37,6 +41,13 @@
         kDEPRECATED_Antialias_Flag  = 1 << 5,
         kDEPRECATED_LCDRender_Flag  = 1 << 6,
     };
+#endif
+
+    enum class Edging {
+        kAlias,
+        kAntiAlias,
+        kSubpixelAntiAlias,
+    };
 
     enum Hinting : uint8_t {
         kNo_Hinting     = 0, //!< glyph outlines unchanged
@@ -46,17 +57,18 @@
     };
 
     SkFont();
+    SkFont(sk_sp<SkTypeface>, SkScalar size);
+    SkFont(sk_sp<SkTypeface>, SkScalar size, SkScalar scaleX, SkScalar skewX);
+#ifdef SK_SUPPORT_LEGACY_FONT_FLAGS
     SkFont(sk_sp<SkTypeface>, SkScalar size, uint32_t flags);
     SkFont(sk_sp<SkTypeface>, SkScalar size, SkScalar scaleX, SkScalar skewX, uint32_t flags);
+#endif
 
-    bool isForceAutoHinting() const { return SkToBool(fFlags & kForceAutoHinting_Flag); }
-    bool isEmbeddedBitmaps() const { return SkToBool(fFlags & kEmbeddedBitmaps_Flag); }
-    bool isSubpixel() const { return SkToBool(fFlags & kSubpixel_Flag); }
-    bool isLinearMetrics() const { return SkToBool(fFlags & kLinearMetrics_Flag); }
-    bool isEmbolden() const { return SkToBool(fFlags & kEmbolden_Flag); }
-
-    bool DEPRECATED_isAntiAlias() const { return SkToBool(fFlags & kDEPRECATED_Antialias_Flag); }
-    bool DEPRECATED_isLCDRender() const { return SkToBool(fFlags & kDEPRECATED_LCDRender_Flag); }
+    bool isForceAutoHinting() const { return SkToBool(fFlags & kForceAutoHinting_PrivFlag); }
+    bool isEmbeddedBitmaps() const { return SkToBool(fFlags & kEmbeddedBitmaps_PrivFlag); }
+    bool isSubpixel() const { return SkToBool(fFlags & kSubpixel_PrivFlag); }
+    bool isLinearMetrics() const { return SkToBool(fFlags & kLinearMetrics_PrivFlag); }
+    bool isEmbolden() const { return SkToBool(fFlags & kEmbolden_PrivFlag); }
 
     void setForceAutoHinting(bool);
     void setEmbeddedBitmaps(bool);
@@ -64,8 +76,8 @@
     void setLinearMetrics(bool);
     void setEmbolden(bool);
 
-    void DEPRECATED_setAntiAlias(bool);
-    void DEPRECATED_setLCDRender(bool);
+    Edging getEdging() const { return (Edging)fEdging; }
+    void setEdging(Edging);
 
     void setHinting(SkFontHinting);
 
@@ -84,16 +96,25 @@
      */
     SkFont makeWithSize(SkScalar size) const;
 
+#ifdef SK_SUPPORT_LEGACY_FONT_FLAGS
+    bool DEPRECATED_isAntiAlias() const { return SkToBool(fFlags & kDEPRECATED_Antialias_Flag); }
+    bool DEPRECATED_isLCDRender() const { return SkToBool(fFlags & kDEPRECATED_LCDRender_Flag); }
+
+    void DEPRECATED_setAntiAlias(bool);
+    void DEPRECATED_setLCDRender(bool);
+
     /**
      *  Return a font with the same attributes of this font, but with the flags.
      */
     SkFont makeWithFlags(uint32_t newFlags) const;
+    uint32_t    getFlags() const { return fFlags; }
+    void setFlags(uint32_t);
+#endif
 
     SkTypeface* getTypeface() const { return fTypeface.get(); }
     SkScalar    getSize() const { return fSize; }
     SkScalar    getScaleX() const { return fScaleX; }
     SkScalar    getSkewX() const { return fSkewX; }
-    uint32_t    getFlags() const { return fFlags; }
 
     sk_sp<SkTypeface> refTypeface() const { return fTypeface; }
 
@@ -101,7 +122,6 @@
     void setSize(SkScalar);
     void setScaleX(SkScalar);
     void setSkewX(SkScalar);
-    void setFlags(uint32_t);
 
     /** Converts text into glyph indices.
         Returns the number of glyph indices represented by text.
@@ -149,6 +169,14 @@
     static SkFont LEGACY_ExtractFromPaint(const SkPaint&);
 
 private:
+    enum PrivFlags {
+        kForceAutoHinting_PrivFlag      = 1 << 0,
+        kEmbeddedBitmaps_PrivFlag       = 1 << 1,
+        kSubpixel_PrivFlag              = 1 << 2,
+        kLinearMetrics_PrivFlag         = 1 << 3,
+        kEmbolden_PrivFlag              = 1 << 4,
+    };
+
     static constexpr unsigned kAllFlags = 0x07F;
 
     sk_sp<SkTypeface> fTypeface;
@@ -156,6 +184,7 @@
     SkScalar    fScaleX;
     SkScalar    fSkewX;
     uint8_t     fFlags;
+    uint8_t     fEdging;
     uint8_t     fHinting;
 
     SkScalar setupForAsPaths(SkPaint*);
diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
index 300a8d2..b04226a 100644
--- a/src/core/SkFont.cpp
+++ b/src/core/SkFont.cpp
@@ -18,27 +18,38 @@
 
 #define kDefault_Size       12
 #define kDefault_Flags      0
+#define kDefault_Edging     SkFont::Edging::kAntiAlias
 #define kDefault_Hinting    kNormal_SkFontHinting
 
 static inline SkScalar valid_size(SkScalar size) {
     return SkTMax<SkScalar>(0, size);
 }
 
-SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size, SkScalar scaleX, SkScalar skewX,
-               uint32_t flags)
+SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size, SkScalar scaleX, SkScalar skewX)
     : fTypeface(face ? std::move(face) : SkTypeface::MakeDefault())
     , fSize(valid_size(size))
     , fScaleX(scaleX)
     , fSkewX(skewX)
-    , fFlags(flags & kAllFlags)
+    , fFlags(kDefault_Flags)
+    , fEdging(static_cast<unsigned>(kDefault_Edging))
     , fHinting(static_cast<unsigned>(kDefault_Hinting))
 {}
 
-SkFont::SkFont() : SkFont(nullptr, kDefault_Size, 1, 0, kDefault_Flags)
-{}
+SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size) : SkFont(std::move(face), size, 1, 0) {}
 
-SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size, uint32_t flags)
-    : SkFont(std::move(face), size, 1, 0, flags) {}
+SkFont::SkFont() : SkFont(nullptr, kDefault_Size) {}
+
+#ifdef SK_SUPPORT_LEGACY_FONT_FLAGS
+SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size, SkScalar scaleX, SkScalar skewX,
+               uint32_t legacy_flags) : SkFont(std::move(face), size, scaleX, skewX) {
+    this->setFlags(legacy_flags);
+}
+
+SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size, uint32_t legacy_flags)
+    : SkFont(std::move(face), size) {
+    this->setFlags(legacy_flags);
+}
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -47,27 +58,59 @@
 }
 
 void SkFont::setForceAutoHinting(bool predicate) {
-    fFlags = set_clear_mask(fFlags, predicate, kForceAutoHinting_Flag);
+    fFlags = set_clear_mask(fFlags, predicate, kForceAutoHinting_PrivFlag);
 }
 void SkFont::setEmbeddedBitmaps(bool predicate) {
-    fFlags = set_clear_mask(fFlags, predicate, kEmbeddedBitmaps_Flag);
+    fFlags = set_clear_mask(fFlags, predicate, kEmbeddedBitmaps_PrivFlag);
 }
 void SkFont::setSubpixel(bool predicate) {
-    fFlags = set_clear_mask(fFlags, predicate, kSubpixel_Flag);
+    fFlags = set_clear_mask(fFlags, predicate, kSubpixel_PrivFlag);
 }
 void SkFont::setLinearMetrics(bool predicate) {
-    fFlags = set_clear_mask(fFlags, predicate, kLinearMetrics_Flag);
+    fFlags = set_clear_mask(fFlags, predicate, kLinearMetrics_PrivFlag);
 }
 void SkFont::setEmbolden(bool predicate) {
-    fFlags = set_clear_mask(fFlags, predicate, kEmbolden_Flag);
+    fFlags = set_clear_mask(fFlags, predicate, kEmbolden_PrivFlag);
 }
 
-void SkFont::DEPRECATED_setAntiAlias(bool predicate) {
-    fFlags = set_clear_mask(fFlags, predicate, kDEPRECATED_Antialias_Flag);
+#ifdef SK_SUPPORT_LEGACY_FONT_FLAGS
+void SkFont::DEPRECATED_setAntiAlias(bool doAA) {
+    if (!doAA) {
+        this->setEdging(Edging::kAlias);
+    } else {
+        if (this->getEdging() == Edging::kAlias) {
+            this->setEdging(Edging::kAntiAlias);
+        }
+        // else leave the current fEdging as is
+    }
 }
 
-void SkFont::DEPRECATED_setLCDRender(bool predicate) {
-    fFlags = set_clear_mask(fFlags, predicate, kDEPRECATED_LCDRender_Flag);
+void SkFont::DEPRECATED_setLCDRender(bool doLCD) {
+    if (doLCD) {
+        this->setEdging(Edging::kSubpixelAntiAlias);
+    } else {
+        if (this->getEdging() == Edging::kSubpixelAntiAlias) {
+            this->setEdging(Edging::kAntiAlias);
+        }
+        // else leave the current fEdging as is
+    }
+}
+
+void SkFont::setFlags(uint32_t legacy_flags) {
+    fFlags = legacy_flags & 0x1F;   // the first 5 flags are fine
+    this->DEPRECATED_setAntiAlias(SkToBool(legacy_flags & kDEPRECATED_Antialias_Flag));
+    this->DEPRECATED_setLCDRender(SkToBool(legacy_flags & kDEPRECATED_LCDRender_Flag));
+}
+
+SkFont SkFont::makeWithFlags(uint32_t newFlags) const {
+    SkFont font = *this;
+    font.setFlags(newFlags);
+    return font;
+}
+#endif
+
+void SkFont::setEdging(Edging e) {
+    fEdging = SkToU8(e);
 }
 
 void SkFont::setHinting(SkFontHinting h) {
@@ -83,33 +126,25 @@
 void SkFont::setSkewX(SkScalar skew) {
     fSkewX = skew;
 }
-void SkFont::setFlags(uint32_t flags) {
-    fFlags = flags & kAllFlags;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkFont SkFont::makeWithSize(SkScalar newSize) const {
-    return {this->refTypeface(), newSize, this->getScaleX(), this->getSkewX(), this->getFlags()};
+    SkFont font = *this;
+    font.setSize(newSize);
+    return font;
 }
 
-SkFont SkFont::makeWithFlags(uint32_t newFlags) const {
-    return {this->refTypeface(), this->getSize(), this->getScaleX(), this->getSkewX(), newFlags};
-}
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkScalar SkFont::setupForAsPaths(SkPaint* paint) {
-    constexpr uint32_t flagsToIgnore =  kLinearMetrics_Flag        |
-                                        kDEPRECATED_LCDRender_Flag |
-                                        kEmbeddedBitmaps_Flag      |
-                                        kForceAutoHinting_Flag;
+    constexpr uint32_t flagsToIgnore = kLinearMetrics_PrivFlag        |
+                                       kEmbeddedBitmaps_PrivFlag      |
+                                       kForceAutoHinting_PrivFlag;
 
-    uint32_t flags = (this->getFlags() & ~flagsToIgnore) | kSubpixel_Flag;
-
-    this->setFlags(flags);
+    fFlags = (fFlags & ~flagsToIgnore) | kSubpixel_PrivFlag;
     this->setHinting(kNo_SkFontHinting);
+
     if (paint) {
-       paint->setStyle(SkPaint::kFill_Style);
+        paint->setStyle(SkPaint::kFill_Style);
         paint->setPathEffect(nullptr);
     }
     SkScalar textSize = fSize;
@@ -337,13 +372,21 @@
     paint->setTextScaleX(fScaleX);
     paint->setTextSkewX(fSkewX);
 
-    paint->setEmbeddedBitmapText(SkToBool(fFlags & kEmbeddedBitmaps_Flag));
-    paint->setFakeBoldText(SkToBool(fFlags & kEmbolden_Flag));
-    paint->setAutohinted(SkToBool(fFlags & kForceAutoHinting_Flag));
-    paint->setSubpixelText(SkToBool(fFlags & kSubpixel_Flag));
-    paint->setLinearText(SkToBool(fFlags & kLinearMetrics_Flag));
-    paint->setAntiAlias(SkToBool(fFlags & kDEPRECATED_Antialias_Flag));
-    paint->setLCDRenderText(SkToBool(fFlags & kDEPRECATED_LCDRender_Flag));
+    paint->setEmbeddedBitmapText(SkToBool(fFlags & kEmbeddedBitmaps_PrivFlag));
+    paint->setFakeBoldText(SkToBool(fFlags & kEmbolden_PrivFlag));
+    paint->setAutohinted(SkToBool(fFlags & kForceAutoHinting_PrivFlag));
+    paint->setSubpixelText(SkToBool(fFlags & kSubpixel_PrivFlag));
+    paint->setLinearText(SkToBool(fFlags & kLinearMetrics_PrivFlag));
+
+    bool doAA = false,
+         doLCD = false;
+    switch (this->getEdging()) {
+        case Edging::kAlias:                                        break;
+        case Edging::kAntiAlias:         doAA = true;               break;
+        case Edging::kSubpixelAntiAlias: doAA = true; doLCD = true; break;
+    }
+    paint->setAntiAlias(doAA);
+    paint->setLCDRenderText(doLCD);
 
     paint->setHinting((SkFontHinting)this->getHinting());
 }
@@ -351,30 +394,33 @@
 SkFont SkFont::LEGACY_ExtractFromPaint(const SkPaint& paint) {
     uint32_t flags = 0;
     if (paint.isEmbeddedBitmapText()) {
-        flags |= kEmbeddedBitmaps_Flag;
+        flags |= kEmbeddedBitmaps_PrivFlag;
     }
     if (paint.isFakeBoldText()) {
-        flags |= kEmbolden_Flag;
+        flags |= kEmbolden_PrivFlag;
     }
     if (paint.isAutohinted()) {
-        flags |= kForceAutoHinting_Flag;
+        flags |= kForceAutoHinting_PrivFlag;
     }
     if (paint.isSubpixelText()) {
-        flags |= kSubpixel_Flag;
+        flags |= kSubpixel_PrivFlag;
     }
     if (paint.isLinearText()) {
-        flags |= kLinearMetrics_Flag;
+        flags |= kLinearMetrics_PrivFlag;
     }
 
+    Edging edging = Edging::kAlias;
     if (paint.isAntiAlias()) {
-        flags |= kDEPRECATED_Antialias_Flag;
+        edging = Edging::kAntiAlias;
     }
     if (paint.isLCDRenderText()) {
-        flags |= kDEPRECATED_LCDRender_Flag;
+        edging = Edging::kSubpixelAntiAlias;
     }
 
     SkFont font(sk_ref_sp(paint.getTypeface()), paint.getTextSize(), paint.getTextScaleX(),
-                paint.getTextSkewX(), flags);
+                paint.getTextSkewX());
+    font.fFlags = flags;
+    font.setEdging(edging);
     font.setHinting((SkFontHinting)paint.getHinting());
     return font;
 }
diff --git a/tests/FontMgrTest.cpp b/tests/FontMgrTest.cpp
index 2f63a2a..502c1ca 100644
--- a/tests/FontMgrTest.cpp
+++ b/tests/FontMgrTest.cpp
@@ -18,8 +18,7 @@
 #include <vector>
 
 static void test_font(skiatest::Reporter* reporter) {
-    uint32_t flags = 0;
-    SkFont font(nullptr, 24, flags);
+    SkFont font(nullptr, 24);
 
     REPORTER_ASSERT(reporter, font.getTypeface());
     REPORTER_ASSERT(reporter, 24 == font.getSize());