diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
index e26c7a2..3773551 100644
--- a/src/core/SkFont.cpp
+++ b/src/core/SkFont.cpp
@@ -121,7 +121,7 @@
                                        kForceAutoHinting_PrivFlag;
 
     fFlags = (fFlags & ~flagsToIgnore) | kSubpixel_PrivFlag;
-    this->setHinting(kNo_SkFontHinting);
+    this->setHinting(SkFontHinting::kNone);
 
     if (this->getEdging() == Edging::kSubpixelAntiAlias) {
         this->setEdging(Edging::kAntiAlias);
@@ -597,7 +597,7 @@
     font->fEdging = SkToU8(edging);
 
     unsigned hinting = (packed >> kShift_For_Hinting) & kMask_For_Hinting;
-    if (hinting > (unsigned)kFull_SkFontHinting) {
+    if (hinting > (unsigned)SkFontHinting::kFull) {
         hinting = 0;
     }
     font->fHinting = SkToU8(hinting);
diff --git a/src/core/SkPaintDefaults.h b/src/core/SkPaintDefaults.h
index 4f53253..ce90fd1 100644
--- a/src/core/SkPaintDefaults.h
+++ b/src/core/SkPaintDefaults.h
@@ -21,7 +21,7 @@
 #endif
 
 #ifndef SkPaintDefaults_Hinting
-    #define SkPaintDefaults_Hinting         kNormal_SkFontHinting
+    #define SkPaintDefaults_Hinting         SkFontHinting::kNormal
 #endif
 
 #ifndef SkPaintDefaults_MiterLimit
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 064ceae..11aee17 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -1039,7 +1039,7 @@
     // the point of linear-text.
     SkFontHinting hinting = (SkFontHinting)font.getHinting();
     if (font.isLinearMetrics()) {
-        hinting = kNo_SkFontHinting;
+        hinting = SkFontHinting::kNone;
     }
     rec->setHinting(font.getHinting());
 #else
diff --git a/src/core/SkTextBlob.cpp b/src/core/SkTextBlob.cpp
index d9d9c5f..578a13b 100644
--- a/src/core/SkTextBlob.cpp
+++ b/src/core/SkTextBlob.cpp
@@ -914,7 +914,7 @@
     // can't use our canonical size if we need to apply patheffects
     if (fPaint.getPathEffect() == nullptr) {
         // If the wrong size is going to be used, don't hint anything.
-        fFont.setHinting(kNo_SkFontHinting);
+        fFont.setHinting(SkFontHinting::kNone);
         fFont.setSubpixel(true);
         fScale = fFont.getSize() / SkFontPriv::kCanonicalTextSizeForPaths;
         fFont.setSize(SkIntToScalar(SkFontPriv::kCanonicalTextSizeForPaths));
diff --git a/src/gpu/text/GrTextContext.cpp b/src/gpu/text/GrTextContext.cpp
index 726e535..03374d0 100644
--- a/src/gpu/text/GrTextContext.cpp
+++ b/src/gpu/text/GrTextContext.cpp
@@ -171,7 +171,7 @@
 
     dfFont.setEdging(SkFont::Edging::kAntiAlias);
     dfFont.setForceAutoHinting(false);
-    dfFont.setHinting(kNormal_SkFontHinting);
+    dfFont.setHinting(SkFontHinting::kNormal);
 
     // The sub-pixel position will always happen when transforming to the screen.
     dfFont.setSubpixel(false);
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index cb8844a..422f4d1 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -50,7 +50,7 @@
 
 SkExclusiveStrikePtr SkPDFFont::MakeVectorCache(SkTypeface* face, int* size) {
     SkFont font;
-    font.setHinting(kNo_SkFontHinting);
+    font.setHinting(SkFontHinting::kNone);
     font.setEdging(SkFont::Edging::kAlias);
     font.setTypeface(sk_ref_sp(face));
     int unitsPerEm = face->getUnitsPerEm();
@@ -142,7 +142,7 @@
 
     if (0 == metrics->fStemV || 0 == metrics->fCapHeight) {
         SkFont font;
-        font.setHinting(kNo_SkFontHinting);
+        font.setHinting(SkFontHinting::kNone);
         font.setTypeface(sk_ref_sp(typeface));
         font.setSize(1000);  // glyph coordinate system
         if (0 == metrics->fStemV) {
diff --git a/src/ports/SkFontHost_FreeType.cpp b/src/ports/SkFontHost_FreeType.cpp
index 5627db6..c0d0d3c 100644
--- a/src/ports/SkFontHost_FreeType.cpp
+++ b/src/ports/SkFontHost_FreeType.cpp
@@ -743,14 +743,14 @@
     }
 
     SkFontHinting h = rec->getHinting();
-    if (kFull_SkFontHinting == h && !isLCD(*rec)) {
+    if (SkFontHinting::kFull == h && !isLCD(*rec)) {
         // collapse full->normal hinting if we're not doing LCD
-        h = kNormal_SkFontHinting;
+        h = SkFontHinting::kNormal;
     }
 
     // rotated text looks bad with hinting, so we disable it as needed
     if (!isAxisAligned(*rec)) {
-        h = kNo_SkFontHinting;
+        h = SkFontHinting::kNone;
     }
     rec->setHinting(h);
 
@@ -865,26 +865,26 @@
         if (SkMask::kBW_Format == fRec.fMaskFormat) {
             // See http://code.google.com/p/chromium/issues/detail?id=43252#c24
             loadFlags = FT_LOAD_TARGET_MONO;
-            if (fRec.getHinting() == kNo_SkFontHinting) {
+            if (fRec.getHinting() == SkFontHinting::kNone) {
                 loadFlags = FT_LOAD_NO_HINTING;
                 linearMetrics = true;
             }
         } else {
             switch (fRec.getHinting()) {
-            case kNo_SkFontHinting:
+            case SkFontHinting::kNone:
                 loadFlags = FT_LOAD_NO_HINTING;
                 linearMetrics = true;
                 break;
-            case kSlight_SkFontHinting:
+            case SkFontHinting::kSlight:
                 loadFlags = FT_LOAD_TARGET_LIGHT;  // This implies FORCE_AUTOHINT
                 if (gFTLibrary->lightHintingIsYOnly()) {
                     linearMetrics = true;
                 }
                 break;
-            case kNormal_SkFontHinting:
+            case SkFontHinting::kNormal:
                 loadFlags = FT_LOAD_TARGET_NORMAL;
                 break;
-            case kFull_SkFontHinting:
+            case SkFontHinting::kFull:
                 loadFlags = FT_LOAD_TARGET_NORMAL;
                 if (isLCD(fRec)) {
                     if (fLCDIsVert) {
diff --git a/src/ports/SkFontHost_mac.cpp b/src/ports/SkFontHost_mac.cpp
index d66d8f4..0c50ffc 100644
--- a/src/ports/SkFontHost_mac.cpp
+++ b/src/ports/SkFontHost_mac.cpp
@@ -1317,7 +1317,7 @@
     CGGlyph cgGlyph = SkTo<CGGlyph>(glyph.getGlyphID());
 
     // FIXME: lcd smoothed un-hinted rasterization unsupported.
-    bool requestSmooth = fRec.getHinting() != kNo_SkFontHinting;
+    bool requestSmooth = fRec.getHinting() != SkFontHinting::kNone;
 
     // Draw the glyph
     size_t cgRowBytes;
@@ -2222,7 +2222,7 @@
         // The above turns off subpixel rendering, but the user requested it.
         // Normal hinting will cause the A8 masks to be generated from CoreGraphics subpixel masks.
         // See comments below for more details.
-        rec->setHinting(kNormal_SkFontHinting);
+        rec->setHinting(SkFontHinting::kNormal);
     }
 
     unsigned flagsWeDontSupport = SkScalerContext::kForceAutohinting_Flag  |
@@ -2236,12 +2236,12 @@
     // Only two levels of hinting are supported.
     // kNo_Hinting means avoid CoreGraphics outline dilation (smoothing).
     // kNormal_Hinting means CoreGraphics outline dilation (smoothing) is allowed.
-    if (rec->getHinting() != kNo_SkFontHinting) {
-        rec->setHinting(kNormal_SkFontHinting);
+    if (rec->getHinting() != SkFontHinting::kNone) {
+        rec->setHinting(SkFontHinting::kNormal);
     }
     // If smoothing has no effect, don't request it.
     if (smoothBehavior == SmoothBehavior::none) {
-        rec->setHinting(kNo_SkFontHinting);
+        rec->setHinting(SkFontHinting::kNone);
     }
 
     // FIXME: lcd smoothed un-hinted rasterization unsupported.
@@ -2266,11 +2266,11 @@
         if (smoothBehavior == SmoothBehavior::subpixel) {
             //CoreGraphics creates 555 masks for smoothed text anyway.
             rec->fMaskFormat = SkMask::kLCD16_Format;
-            rec->setHinting(kNormal_SkFontHinting);
+            rec->setHinting(SkFontHinting::kNormal);
         } else {
             rec->fMaskFormat = SkMask::kA8_Format;
             if (smoothBehavior != SmoothBehavior::none) {
-                rec->setHinting(kNormal_SkFontHinting);
+                rec->setHinting(SkFontHinting::kNormal);
             }
         }
     }
@@ -2284,7 +2284,7 @@
 
     // Unhinted A8 masks (those not derived from LCD masks) must respect SK_GAMMA_APPLY_TO_A8.
     // All other masks can use regular gamma.
-    if (SkMask::kA8_Format == rec->fMaskFormat && kNo_SkFontHinting == rec->getHinting()) {
+    if (SkMask::kA8_Format == rec->fMaskFormat && SkFontHinting::kNone == rec->getHinting()) {
 #ifndef SK_GAMMA_APPLY_TO_A8
         // SRGBTODO: Is this correct? Do we want contrast boost?
         rec->ignorePreBlend();
diff --git a/src/ports/SkFontHost_win.cpp b/src/ports/SkFontHost_win.cpp
index 3d6a7c3..cc1a861 100644
--- a/src/ports/SkFontHost_win.cpp
+++ b/src/ports/SkFontHost_win.cpp
@@ -88,7 +88,7 @@
         return true;
     }
 #endif
-    return rec.getHinting() == kNo_SkFontHinting || rec.getHinting() == kSlight_SkFontHinting;
+    return rec.getHinting() == SkFontHinting::kNone || rec.getHinting() == SkFontHinting::kSlight;
 }
 
 static void tchar_to_skstring(const TCHAR t[], SkString* s) {
@@ -637,7 +637,7 @@
     // When GDI hinting, remove the entire Y scale from sA and GsA. (Prevents 'linear' metrics.)
     // When not hinting, remove only the integer Y scale from sA and GsA. (Applied by GDI.)
     SkScalerContextRec::PreMatrixScale scaleConstraints =
-        (fRec.getHinting() == kNo_SkFontHinting || fRec.getHinting() == kSlight_SkFontHinting)
+        (fRec.getHinting() == SkFontHinting::kNone || fRec.getHinting() == SkFontHinting::kSlight)
                    ? SkScalerContextRec::kVerticalInteger_PreMatrixScale
                    : SkScalerContextRec::kVertical_PreMatrixScale;
     SkVector scale;
@@ -1486,7 +1486,7 @@
 
     //GDI only uses hinted outlines when axis aligned.
     UINT format = GGO_NATIVE | GGO_GLYPH_INDEX;
-    if (fRec.getHinting() == kNo_SkFontHinting || fRec.getHinting() == kSlight_SkFontHinting){
+    if (fRec.getHinting() == SkFontHinting::kNone || fRec.getHinting() == SkFontHinting::kSlight){
         format |= GGO_UNHINTED;
     }
     SkAutoSTMalloc<BUFFERSIZE, uint8_t> glyphbuf(BUFFERSIZE);
@@ -1495,7 +1495,7 @@
         return false;
     }
 
-    if (fRec.getHinting() != kSlight_SkFontHinting) {
+    if (fRec.getHinting() != SkFontHinting::kSlight) {
         sk_path_from_gdi_path(path, glyphbuf, total_size);
     } else {
         //GDI only uses hinted outlines when axis aligned.
@@ -2079,21 +2079,21 @@
 
     SkFontHinting h = rec->getHinting();
     switch (h) {
-        case kNo_SkFontHinting:
+        case SkFontHinting::kNone:
             break;
-        case kSlight_SkFontHinting:
+        case SkFontHinting::kSlight:
             // Only do slight hinting when axis aligned.
             // TODO: re-enable slight hinting when FontHostTest can pass.
             //if (!isAxisAligned(*rec)) {
-                h = kNo_SkFontHinting;
+                h = SkFontHinting::kNone;
             //}
             break;
-        case kNormal_SkFontHinting:
-        case kFull_SkFontHinting:
+        case SkFontHinting::kNormal:
+        case SkFontHinting::kFull:
             // TODO: need to be able to distinguish subpixel positioned glyphs
             // and linear metrics.
             //rec->fFlags &= ~SkScalerContext::kSubpixelPositioning_Flag;
-            h = kNormal_SkFontHinting;
+            h = SkFontHinting::kNormal;
             break;
         default:
             SkDEBUGFAIL("unknown hinting");
diff --git a/src/ports/SkScalerContext_win_dw.cpp b/src/ports/SkScalerContext_win_dw.cpp
index de911fc..432356a 100644
--- a/src/ports/SkScalerContext_win_dw.cpp
+++ b/src/ports/SkScalerContext_win_dw.cpp
@@ -351,7 +351,7 @@
 
     // DirectWrite2 allows hinting to be disabled.
     fGridFitMode = DWRITE_GRID_FIT_MODE_ENABLED;
-    if (fRec.getHinting() == kNo_SkFontHinting) {
+    if (fRec.getHinting() == SkFontHinting::kNone) {
         fGridFitMode = DWRITE_GRID_FIT_MODE_DISABLED;
         if (fRenderingMode != DWRITE_RENDERING_MODE_ALIASED) {
             fRenderingMode = DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC;
diff --git a/src/ports/SkTypeface_win_dw.cpp b/src/ports/SkTypeface_win_dw.cpp
index ea98b16..f6ced85 100644
--- a/src/ports/SkTypeface_win_dw.cpp
+++ b/src/ports/SkTypeface_win_dw.cpp
@@ -350,8 +350,8 @@
 
     SkFontHinting h = rec->getHinting();
     // DirectWrite2 allows for hinting to be turned off. Force everything else to normal.
-    if (h != kNo_SkFontHinting || !fFactory2 || !fDWriteFontFace2) {
-        h = kNormal_SkFontHinting;
+    if (h != SkFontHinting::kNone || !fFactory2 || !fDWriteFontFace2) {
+        h = SkFontHinting::kNormal;
     }
     rec->setHinting(h);