drawText Cleanup

Change-Id: Ibe1ac895f0347faf44820aa70350e7020807cb85
Reviewed-on: https://skia-review.googlesource.com/c/182080
Commit-Queue: Hal Canary <halcanary@google.com>
Reviewed-by: Mike Reed <reed@google.com>

14 files changed, 143 insertions, 263 deletions

diff --git a/gm/drawquadset.cpp b/gm/drawquadset.cpp
index 9c3c6f09b5..f6aaa88379 100644
--- a/gm/drawquadset.cpp
+++ b/gm/drawquadset.cpp
@@ -21,12 +21,7 @@ static constexpr int kRowCount = 4;
 static constexpr int kColCount = 3;
 
 static void draw_text(SkCanvas* canvas, const char* text) {
-    SkPaint paint;
-    paint.setColor(SK_ColorBLACK);
-    paint.setTextSize(12.0f);
-    paint.setAntiAlias(true);
-
-    canvas->drawString(text, 0, 0, paint);
+    canvas->drawString(text, 0, 0, SkFont(nullptr, 12), SkPaint());
 }
 
 static void draw_gradient_tiles(GrRenderTargetContext* rtc, const SkMatrix& view,
diff --git a/gm/dstreadshuffle.cpp b/gm/dstreadshuffle.cpp
index c4c19fcd4e..68dcfc412c 100644
--- a/gm/dstreadshuffle.cpp
+++ b/gm/dstreadshuffle.cpp
@@ -82,10 +82,9 @@ protected:
                 break;
             case kText_ShapeType: {
                 const char* text = "N";
-                paint->setTextSize(100.f);
-                paint->setFakeBoldText(true);
-                sk_tool_utils::set_portable_typeface(paint);
-                canvas->drawString(text, 0.f, 100.f, *paint);
+                SkFont font(sk_tool_utils::create_portable_typeface(), 100);
+                font.setEmbolden(true);
+                canvas->drawString(text, 0.f, 100.f, font, *paint);
             }
             default:
                 break;
diff --git a/gm/emboss.cpp b/gm/emboss.cpp
index a8483d0882..2a962474ee 100644
--- a/gm/emboss.cpp
+++ b/gm/emboss.cpp
@@ -6,10 +6,12 @@
  */
 
 #include "gm.h"
+
 #include "SkBlurMask.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
 #include "SkEmbossMaskFilter.h"
+#include "SkFont.h"
 
 static SkBitmap make_bm() {
     SkBitmap bm;
@@ -69,8 +71,7 @@ protected:
         canvas->translate(SkIntToScalar(100), 0);
 
         paint.setStyle(SkPaint::kFill_Style);
-        paint.setTextSize(50);
-        canvas->drawText("Hello", 5, 0, 50, paint);
+        canvas->drawString("Hello", 0, 50, SkFont(nullptr, 50), paint);
     }
 
 private:
diff --git a/gm/emptypath.cpp b/gm/emptypath.cpp
index 67da93f365..1c775808a7 100644
--- a/gm/emptypath.cpp
+++ b/gm/emptypath.cpp
@@ -61,17 +61,10 @@ protected:
             {SkPaint::kStrokeAndFill_Style, "Stroke And Fill"},
         };
 
-        SkPaint titlePaint;
-        titlePaint.setColor(SK_ColorBLACK);
-        titlePaint.setAntiAlias(true);
-        sk_tool_utils::set_portable_typeface(&titlePaint);
-        titlePaint.setTextSize(15 * SK_Scalar1);
+        SkFont font(sk_tool_utils::create_portable_typeface(), 15);
         const char title[] = "Empty Paths Drawn Into Rectangle Clips With "
                              "Indicated Style and Fill";
-        canvas->drawString(title,
-                           20 * SK_Scalar1,
-                           20 * SK_Scalar1,
-                           titlePaint);
+        canvas->drawString(title, 20.0f, 20.0f, font, SkPaint());
 
         SkRandom rand;
         SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
@@ -106,15 +99,11 @@ protected:
 
                 SkPaint labelPaint;
                 labelPaint.setColor(color);
-                labelPaint.setAntiAlias(true);
-                sk_tool_utils::set_portable_typeface(&labelPaint);
-                labelPaint.setTextSize(12 * SK_Scalar1);
-                canvas->drawString(gStyles[style].fName,
-                                   0, rect.height() + 15 * SK_Scalar1,
-                                   labelPaint);
-                canvas->drawString(gFills[fill].fName,
-                                   0, rect.height() + 28 * SK_Scalar1,
-                                   labelPaint);
+                SkFont labelFont(sk_tool_utils::create_portable_typeface(), 12);
+                canvas->drawString(gStyles[style].fName, 0, rect.height() + 15.0f,
+                                   labelFont, labelPaint);
+                canvas->drawString(gFills[fill].fName, 0, rect.height() + 28.0f,
+                                   labelFont, labelPaint);
             }
         }
         canvas->restore();
diff --git a/gm/gammatext.cpp b/gm/gammatext.cpp
index e248f58db0..1d944de1bb 100644
--- a/gm/gammatext.cpp
+++ b/gm/gammatext.cpp
@@ -61,12 +61,10 @@ protected:
         };
 
         const char* text = "Hamburgefons";
-        size_t len = strlen(text);
 
         SkPaint paint;
-        paint.setTextSize(SkIntToScalar(16));
-        paint.setAntiAlias(true);
-        paint.setLCDRenderText(true);
+        SkFont font(nullptr, 16);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
 
         SkScalar x = SkIntToScalar(10);
         for (size_t i = 0; i < SK_ARRAY_COUNT(fg); ++i) {
@@ -75,8 +73,8 @@ protected:
             SkScalar y = SkIntToScalar(40);
             SkScalar stopy = SkIntToScalar(HEIGHT);
             while (y < stopy) {
-                canvas->drawText(text, len, x, y, paint);
-                y += paint.getTextSize() * 2;
+                canvas->drawString(text, x, y, font, paint);
+                y += font.getSize() * 2;
             }
             x += SkIntToScalar(1024) / SK_ARRAY_COUNT(fg);
         }
@@ -98,20 +96,16 @@ static sk_sp<SkShader> make_gradient(SkColor c) {
     return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
 }
 
-static void set_face(SkPaint* paint) {
-    paint->setTypeface(SkTypeface::MakeFromName("serif", SkFontStyle::Italic()));
-}
-
-static void draw_pair(SkCanvas* canvas, SkPaint* paint, const sk_sp<SkShader>& shader) {
-    const char text[] = "Now is the time for all good";
-    const size_t len = strlen(text);
-
-    paint->setShader(nullptr);
-    canvas->drawText(text, len, 10, 20, *paint);
-    paint->setShader(SkShader::MakeColorShader(paint->getColor()));
-    canvas->drawText(text, len, 10, 40, *paint);
-    paint->setShader(shader);
-    canvas->drawText(text, len, 10, 60, *paint);
+static void draw_pair(SkCanvas* canvas, const SkFont& font, SkColor color,
+                      const sk_sp<SkShader>& shader) {
+    static const char text[] = "Now is the time for all good";
+    SkPaint paint;
+    paint.setColor(color);
+    canvas->drawString(text, 10, 20, font, paint);
+    paint.setShader(SkShader::MakeColorShader(paint.getColor()));
+    canvas->drawString(text, 10, 40, font, paint);
+    paint.setShader(shader);
+    canvas->drawString(text, 10, 60, font, paint);
 }
 
 class GammaShaderTextGM : public skiagm::GM {
@@ -143,14 +137,11 @@ protected:
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
-        paint.setAntiAlias(true);
-        paint.setLCDRenderText(true);
-        paint.setTextSize(18);
-        set_face(&paint);
+        SkFont font(SkTypeface::MakeFromName("serif", SkFontStyle::Italic()), 18);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(fShaders); ++i) {
-            paint.setColor(fColors[i]);
-            draw_pair(canvas, &paint, fShaders[i]);
+            draw_pair(canvas, font, fColors[i], fShaders[i]);
             canvas->translate(0, 80);
         }
     }
diff --git a/gm/gm.cpp b/gm/gm.cpp
index a9cc3bc351..8deba84f2b 100644
--- a/gm/gm.cpp
+++ b/gm/gm.cpp
@@ -81,13 +81,10 @@ void GM::DrawGpuOnlyMessage(SkCanvas* canvas) {
     bmp.allocN32Pixels(128, 64);
     SkCanvas bmpCanvas(bmp);
     bmpCanvas.drawColor(SK_ColorWHITE);
+    SkFont font(sk_tool_utils::create_portable_typeface(), 20);
     SkPaint paint;
-    paint.setAntiAlias(true);
-    paint.setTextSize(20);
     paint.setColor(SK_ColorRED);
-    sk_tool_utils::set_portable_typeface(&paint);
-    constexpr char kTxt[] = "GPU Only";
-    bmpCanvas.drawString(kTxt, 20, 40, paint);
+    bmpCanvas.drawString("GPU Only", 20, 40, font, paint);
     SkMatrix localM;
     localM.setRotate(35.f);
     localM.postTranslate(10.f, 0.f);
diff --git a/gm/gradtext.cpp b/gm/gradtext.cpp
index 7bece0248d..b9cdb12ae7 100644
--- a/gm/gradtext.cpp
+++ b/gm/gradtext.cpp
@@ -95,74 +95,39 @@ private:
     typedef GM INHERITED;
 };
 
-
-
-class GradTextGM : public GM {
-public:
-    GradTextGM () {}
-
-protected:
-    SkString onShortName() override {
-        return SkString("gradtext");
-    }
-
-    SkISize onISize() override { return SkISize::Make(500, 480); }
-
-    static void draw_text(SkCanvas* canvas, const SkPaint& paint) {
-        const char* text = "When in the course of human events";
-        size_t len = strlen(text);
-        canvas->drawText(text, len, 0, 0, paint);
-    }
-
-    static void draw_text3(SkCanvas* canvas, const SkPaint& paint) {
-        SkPaint p(paint);
-
-        p.setAntiAlias(false);
-        draw_text(canvas, p);
-        p.setAntiAlias(true);
-        canvas->translate(0, paint.getTextSize() * 4/3);
-        draw_text(canvas, p);
-        p.setLCDRenderText(true);
-        canvas->translate(0, paint.getTextSize() * 4/3);
-        draw_text(canvas, p);
-    }
-
-    void onDraw(SkCanvas* canvas) override {
-        SkPaint paint;
-        sk_tool_utils::set_portable_typeface(&paint);
-        paint.setTextSize(SkIntToScalar(26));
-
-        const SkISize& size = this->getISize();
-        SkRect r = SkRect::MakeWH(SkIntToScalar(size.width()),
-                                  SkIntToScalar(size.height()) / 2);
-        canvas->drawRect(r, paint);
-
-        canvas->translate(SkIntToScalar(20), paint.getTextSize());
-
-        for (int i = 0; i < 2; ++i) {
-            paint.setShader(make_grad(SkIntToScalar(80)));
-            draw_text3(canvas, paint);
-
-            canvas->translate(0, paint.getTextSize() * 2);
-
-            paint.setShader(make_grad2(SkIntToScalar(80)));
-            draw_text3(canvas, paint);
-
-            canvas->translate(0, paint.getTextSize() * 2);
-        }
-    }
-
-private:
-    typedef GM INHERITED;
-};
-
 //////////////////////////////////////////////////////////////////////////////
 
-static GM* MyFactory(void*) { return new GradTextGM; }
 static GM* CMyFactory(void*) { return new ChromeGradTextGM1; }
 static GM* CMyFactory2(void*) { return new ChromeGradTextGM2; }
 
-static GMRegistry reg(MyFactory);
 static GMRegistry Creg(CMyFactory);
 static GMRegistry Creg2(CMyFactory2);
 }
+
+DEF_SIMPLE_GM(gradtext, canvas, 500, 480) {
+    static constexpr float kTextSize = 26.0f;
+    SkFont font(sk_tool_utils::create_portable_typeface(), kTextSize);
+
+    canvas->drawRect({0, 0, 500, 240}, SkPaint());
+    canvas->translate(20.0f, kTextSize);
+
+    SkPaint paints[2];
+    paints[0].setShader(make_grad(80.0f));
+    paints[1].setShader(make_grad2(80.0f));
+
+    static const SkFont::Edging edgings[3] = {
+        SkFont::Edging::kAlias,
+        SkFont::Edging::kAntiAlias,
+        SkFont::Edging::kSubpixelAntiAlias,
+    };
+    for (int i = 0; i < 2; ++i) {
+        for (const SkPaint& paint : paints) {
+            for (SkFont::Edging edging : edgings) {
+                font.setEdging(edging);
+                canvas->drawString("When in the course of human events", 0, 0, font, paint);
+                canvas->translate(0, kTextSize * 4/3);
+            }
+            canvas->translate(0, kTextSize * 2/3);
+        }
+    }
+}
diff --git a/gm/image.cpp b/gm/image.cpp
index 13ba10131e..f1afa941f3 100644
--- a/gm/image.cpp
+++ b/gm/image.cpp
@@ -113,34 +113,19 @@ protected:
     void onDraw(SkCanvas* canvas) override {
         canvas->scale(2, 2);
 
-        const char* kLabel1 = "Original Img";
-        const char* kLabel2 = "Modified Img";
-        const char* kLabel3 = "Cur Surface";
-        const char* kLabel4 = "Full Crop";
-        const char* kLabel5 = "Over-crop";
-        const char* kLabel6 = "Upper-left";
-        const char* kLabel7 = "No Crop";
-
-        const char* kLabel8 = "Pre-Alloc Img";
-        const char* kLabel9 = "New Alloc Img";
-        const char* kLabel10 = "GPU";
-
-        SkPaint textPaint;
-        textPaint.setAntiAlias(true);
-        sk_tool_utils::set_portable_typeface(&textPaint);
-        textPaint.setTextSize(8);
-
-        canvas->drawString(kLabel1, 10,  60, textPaint);
-        canvas->drawString(kLabel2, 10, 140, textPaint);
-        canvas->drawString(kLabel3, 10, 220, textPaint);
-        canvas->drawString(kLabel4, 10, 300, textPaint);
-        canvas->drawString(kLabel5, 10, 380, textPaint);
-        canvas->drawString(kLabel6, 10, 460, textPaint);
-        canvas->drawString(kLabel7, 10, 540, textPaint);
-
-        canvas->drawString(kLabel8, 80, 10, textPaint);
-        canvas->drawString(kLabel9, 160, 10, textPaint);
-        canvas->drawString(kLabel10, 265, 10, textPaint);
+        SkFont font(sk_tool_utils::create_portable_typeface(), 8);
+
+        canvas->drawString("Original Img",  10,  60, font, SkPaint());
+        canvas->drawString("Modified Img",  10, 140, font, SkPaint());
+        canvas->drawString("Cur Surface",   10, 220, font, SkPaint());
+        canvas->drawString("Full Crop",     10, 300, font, SkPaint());
+        canvas->drawString("Over-crop",     10, 380, font, SkPaint());
+        canvas->drawString("Upper-left",    10, 460, font, SkPaint());
+        canvas->drawString("No Crop",       10, 540, font, SkPaint());
+
+        canvas->drawString("Pre-Alloc Img", 80,  10, font, SkPaint());
+        canvas->drawString("New Alloc Img", 160, 10, font, SkPaint());
+        canvas->drawString( "GPU",          265, 10, font, SkPaint());
 
         canvas->translate(80, 20);
 
diff --git a/gm/imageblur2.cpp b/gm/imageblur2.cpp
index b6f9ff5026..4cb94c95fa 100644
--- a/gm/imageblur2.cpp
+++ b/gm/imageblur2.cpp
@@ -12,82 +12,48 @@
 
 // TODO deprecate imageblur
 
-#define WIDTH 500
-#define HEIGHT 500
+constexpr int kWidth  = 500;
+constexpr int kHeight = 500;
 
-constexpr float kBlurSigmas[] = {
-        0.0, 0.3f, 0.5f, 2.0f, 32.0f, 80.0f };
-
-const char* kTestStrings[] = {
+DEF_SIMPLE_GM(imageblur2, canvas, kWidth, kHeight) {
+    constexpr float kBlurSigmas[] = { 0.0, 0.3f, 0.5f, 2.0f, 32.0f, 80.0f };
+    const char* kTestStrings[] = {
         "The quick`~",
         "brown fox[]",
         "jumped over",
         "the lazy@#$",
         "dog.{}!%^&",
         "*()+=-\\'\"/",
-};
-
-namespace skiagm {
-
-class BlurImageFilter : public GM {
-public:
-    BlurImageFilter() {
-        this->setBGColor(0xFFFFFFFF);
-        fName.printf("imageblur2");
-    }
-
-protected:
-
-    SkString onShortName() override {
-        return fName;
-    }
-
-    SkISize onISize() override {
-        return SkISize::Make(WIDTH, HEIGHT);
-    }
-
-    void onDraw(SkCanvas* canvas) override {
-        const int sigmaCount = SK_ARRAY_COUNT(kBlurSigmas);
-        const int testStringCount = SK_ARRAY_COUNT(kTestStrings);
-        SkScalar dx = WIDTH / sigmaCount;
-        SkScalar dy = HEIGHT / sigmaCount;
-        const SkScalar textSize = 12;
-
-        for (int x = 0; x < sigmaCount; x++) {
-            SkScalar sigmaX = kBlurSigmas[x];
-            for (int y = 0; y < sigmaCount; y++) {
-                SkScalar sigmaY = kBlurSigmas[y];
-
-                SkPaint paint;
-                paint.setImageFilter(SkBlurImageFilter::Make(sigmaX, sigmaY, nullptr));
-                canvas->saveLayer(nullptr, &paint);
-
-                SkRandom rand;
-                SkPaint textPaint;
-                textPaint.setAntiAlias(false);
-                textPaint.setColor(sk_tool_utils::color_to_565(rand.nextBits(24) | 0xFF000000));
-                sk_tool_utils::set_portable_typeface(&textPaint);
-                textPaint.setTextSize(textSize);
-
-                for (int i = 0; i < testStringCount; i++) {
-                    canvas->drawString(kTestStrings[i],
-                                       SkIntToScalar(x * dx),
-                                       SkIntToScalar(y * dy + textSize * i + textSize),
-                                       textPaint);
-                }
-                canvas->restore();
+    };
+    constexpr int sigmaCount = SK_ARRAY_COUNT(kBlurSigmas);
+    constexpr int testStringCount = SK_ARRAY_COUNT(kTestStrings);
+    constexpr SkScalar dx = kWidth / sigmaCount;
+    constexpr SkScalar dy = kHeight / sigmaCount;
+    constexpr SkScalar textSize = 12;
+
+    SkFont font(sk_tool_utils::create_portable_typeface(), textSize);
+    font.setEdging(SkFont::Edging::kAlias);
+
+    for (int x = 0; x < sigmaCount; x++) {
+        SkScalar sigmaX = kBlurSigmas[x];
+        for (int y = 0; y < sigmaCount; y++) {
+            SkScalar sigmaY = kBlurSigmas[y];
+
+            SkPaint paint;
+            paint.setImageFilter(SkBlurImageFilter::Make(sigmaX, sigmaY, nullptr));
+            canvas->saveLayer(nullptr, &paint);
+
+            SkRandom rand;
+            SkPaint textPaint;
+            textPaint.setColor(sk_tool_utils::color_to_565(rand.nextBits(24) | 0xFF000000));
+            for (int i = 0; i < testStringCount; i++) {
+                canvas->drawString(kTestStrings[i],
+                                   SkIntToScalar(x * dx),
+                                   SkIntToScalar(y * dy + textSize * i + textSize),
+                                   font,
+                                   textPaint);
             }
+            canvas->restore();
         }
     }
-
-private:
-    SkString fName;
-
-    typedef GM INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_GM(return new BlurImageFilter;)
-
 }
diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp
index dad869e054..40bb810442 100644
--- a/gm/imagefiltersbase.cpp
+++ b/gm/imagefiltersbase.cpp
@@ -235,20 +235,18 @@ protected:
 
     SkISize onISize() override { return SkISize::Make(512, 342); }
 
-    void drawWaterfall(SkCanvas* canvas, const SkPaint& origPaint) {
-        const uint32_t flags[] = {
-            0,
-            SkPaint::kAntiAlias_Flag,
-            SkPaint::kAntiAlias_Flag | SkPaint::kLCDRenderText_Flag,
+    void drawWaterfall(SkCanvas* canvas, const SkPaint& paint) {
+        static const SkFont::Edging kEdgings[3] = {
+            SkFont::Edging::kAlias,
+            SkFont::Edging::kAntiAlias,
+            SkFont::Edging::kSubpixelAntiAlias,
         };
-        SkPaint paint(origPaint);
-        sk_tool_utils::set_portable_typeface(&paint);
-        paint.setTextSize(30);
+        SkFont font(sk_tool_utils::create_portable_typeface(), 30);
 
         SkAutoCanvasRestore acr(canvas, true);
-        for (size_t i = 0; i < SK_ARRAY_COUNT(flags); ++i) {
-            paint.setFlags(flags[i]);
-            canvas->drawString("Hamburgefon", 0, 0, paint);
+        for (SkFont::Edging edging : kEdgings) {
+            font.setEdging(edging);
+            canvas->drawString("Hamburgefon", 0, 0, font, paint);
             canvas->translate(0, 40);
         }
     }
diff --git a/gm/imagemagnifier.cpp b/gm/imagemagnifier.cpp
index 2585ea763c..8fbc58d11c 100644
--- a/gm/imagemagnifier.cpp
+++ b/gm/imagemagnifier.cpp
@@ -27,16 +27,14 @@ DEF_SIMPLE_GM_BG(imagemagnifier, canvas, WIDTH, HEIGHT, SK_ColorBLACK) {
         canvas->saveLayer(nullptr, &filterPaint);
         const char* str = "The quick brown fox jumped over the lazy dog.";
         SkRandom rand;
+        SkFont font(sk_tool_utils::create_portable_typeface());
         for (int i = 0; i < 25; ++i) {
             int x = rand.nextULessThan(WIDTH);
             int y = rand.nextULessThan(HEIGHT);
             SkPaint paint;
-            sk_tool_utils::set_portable_typeface(&paint);
             paint.setColor(sk_tool_utils::color_to_565(rand.nextBits(24) | 0xFF000000));
-            paint.setTextSize(rand.nextRangeScalar(0, 300));
-            paint.setAntiAlias(true);
-            canvas->drawString(str, SkIntToScalar(x),
-                             SkIntToScalar(y), paint);
+            font.setSize(rand.nextRangeScalar(0, 300));
+            canvas->drawString(str, SkIntToScalar(x), SkIntToScalar(y), font, paint);
         }
         canvas->restore();
 }
diff --git a/gm/imageresizetiled.cpp b/gm/imageresizetiled.cpp
index 257e0b259c..c242cc50e7 100644
--- a/gm/imageresizetiled.cpp
+++ b/gm/imageresizetiled.cpp
@@ -22,6 +22,8 @@ DEF_SIMPLE_GM(imageresizetiled, canvas, WIDTH, HEIGHT) {
         paint.setImageFilter(SkImageFilter::MakeMatrixFilter(matrix,
                                                              kNone_SkFilterQuality,
                                                              nullptr));
+
+        SkFont font(sk_tool_utils::create_portable_typeface(), 100);
         const SkScalar tile_size = SkIntToScalar(100);
         for (SkScalar y = 0; y < HEIGHT; y += tile_size) {
             for (SkScalar x = 0; x < WIDTH; x += tile_size) {
@@ -36,15 +38,10 @@ DEF_SIMPLE_GM(imageresizetiled, canvas, WIDTH, HEIGHT) {
                     "jumped over",
                     "the lazy dog.",
                 };
-                SkPaint textPaint;
-                textPaint.setAntiAlias(true);
-                sk_tool_utils::set_portable_typeface(&textPaint);
-                textPaint.setTextSize(SkIntToScalar(100));
-                int posY = 0;
+                float posY = 0;
                 for (unsigned i = 0; i < SK_ARRAY_COUNT(str); i++) {
-                    posY += 100;
-                    canvas->drawString(str[i], SkIntToScalar(0),
-                                     SkIntToScalar(posY), textPaint);
+                    posY += 100.0f;
+                    canvas->drawString(str[i], 0.0f, posY, font, SkPaint());
                 }
                 canvas->restore();
                 canvas->restore();
diff --git a/gm/lcdtext.cpp b/gm/lcdtext.cpp
index a5e6d695a7..e605ac0c57 100644
--- a/gm/lcdtext.cpp
+++ b/gm/lcdtext.cpp
@@ -53,12 +53,14 @@ protected:
         SkPaint paint;
         paint.setColor(SK_ColorBLACK);
         paint.setDither(true);
-        paint.setAntiAlias(true);
-        paint.setSubpixelText(subpixelTextEnabled);
-        paint.setLCDRenderText(lcdRenderTextEnabled);
-        paint.setTextSize(textHeight);
-
-        canvas->drawString(string, 0, y, paint);
+        SkFont font(nullptr, textHeight);
+        if (subpixelTextEnabled) {
+            font.setSubpixel(true);
+        }
+        if (lcdRenderTextEnabled) {
+            font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+        }
+        canvas->drawString(string, 0, y, font, paint);
         y += textHeight;
     }
 
@@ -98,10 +100,6 @@ protected:
         const char* lcd_text = "LCD";
         const char* gray_text = "GRAY";
 
-        SkPaint paint;
-        paint.setAntiAlias(true);
-        paint.setLCDRenderText(true);
-
         const struct {
             SkPoint     fLoc;
             SkScalar    fTextSize;
@@ -118,9 +116,11 @@ protected:
             const SkPoint loc = rec[i].fLoc;
             SkAutoCanvasRestore acr(canvas, true);
 
-            paint.setTextSize(rec[i].fTextSize);
+            SkFont font(nullptr, rec[i].fTextSize);
+            font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+
             ScaleAbout(canvas, rec[i].fScale, rec[i].fScale, loc.x(), loc.y());
-            canvas->drawString(rec[i].fText, loc.x(), loc.y(), paint);
+            canvas->drawString(rec[i].fText, loc.x(), loc.y(), font, SkPaint());
         }
     }
 
diff --git a/gm/lightingshader2.cpp b/gm/lightingshader2.cpp
index 982e46a655..62d9c2a71a 100644
--- a/gm/lightingshader2.cpp
+++ b/gm/lightingshader2.cpp
@@ -143,9 +143,8 @@ protected:
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint labelPaint;
-        labelPaint.setTypeface(sk_tool_utils::create_portable_typeface("sans-serif",SkFontStyle()));
-        labelPaint.setAntiAlias(true);
-        labelPaint.setTextSize(kLabelSize);
+        SkFont font(
+                sk_tool_utils::create_portable_typeface("sans-serif", SkFontStyle()), kLabelSize);
 
         int gridNum = 0;
 
@@ -170,25 +169,25 @@ protected:
                             canvas->translate(0.0f, kLabelSize);
                             SkString label;
                             label.appendf("useNormalSource: %d", useNormalSource);
-                            canvas->drawString(label, 0.0f, 0.0f, labelPaint);
+                            canvas->drawString(label, 0.0f, 0.0f, font, labelPaint);
                         }
                         {
                             canvas->translate(0.0f, kLabelSize);
                             SkString label;
                             label.appendf("useDiffuseShader: %d", useDiffuseShader);
-                            canvas->drawString(label, 0.0f, 0.0f, labelPaint);
+                            canvas->drawString(label, 0.0f, 0.0f, font, labelPaint);
                         }
                         {
                             canvas->translate(0.0f, kLabelSize);
                             SkString label;
                             label.appendf("useTranslucentPaint: %d", useTranslucentPaint);
-                            canvas->drawString(label, 0.0f, 0.0f, labelPaint);
+                            canvas->drawString(label, 0.0f, 0.0f, font, labelPaint);
                         }
                         {
                             canvas->translate(0.0f, kLabelSize);
                             SkString label;
                             label.appendf("useTranslucentShader: %d", useTranslucentShader);
-                            canvas->drawString(label, 0.0f, 0.0f, labelPaint);
+                            canvas->drawString(label, 0.0f, 0.0f, font, labelPaint);
                         }
 
                         canvas->restore();