diff --git a/bench/AlternatingColorPatternBench.cpp b/bench/AlternatingColorPatternBench.cpp
index 57ff25a..639f1f6 100644
--- a/bench/AlternatingColorPatternBench.cpp
+++ b/bench/AlternatingColorPatternBench.cpp
@@ -53,10 +53,10 @@
     SkPaint     paint;
 
     paint.setShader(SkGradientShader::MakeLinear(kPts0, kColors0, kPos, SK_ARRAY_COUNT(kColors0),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas.drawPaint(paint);
     paint.setShader(SkGradientShader::MakeLinear(kPts1, kColors1, kPos, SK_ARRAY_COUNT(kColors1),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas.drawPaint(paint);
 }
 
@@ -113,9 +113,7 @@
         int w = 40;
         int h = 40;
         makebm(&fBmp, w, h);
-        fBmShader = SkShader::MakeBitmapShader(fBmp,
-                                                 SkShader::kRepeat_TileMode,
-                                                 SkShader::kRepeat_TileMode);
+        fBmShader = SkShader::MakeBitmapShader(fBmp, SkTileMode::kRepeat, SkTileMode::kRepeat);
         int offset = 2;
         int count = 0;
         for (int j = 0; j < NY; ++j) {
diff --git a/bench/ClearBench.cpp b/bench/ClearBench.cpp
index 952e5dd..2fbfd8f 100644
--- a/bench/ClearBench.cpp
+++ b/bench/ClearBench.cpp
@@ -23,7 +23,7 @@
 static sk_sp<SkShader> make_shader() {
     static const SkPoint kPts[] = {{0, 0}, {10, 10}};
     static const SkColor kColors[] = {SK_ColorBLUE, SK_ColorWHITE};
-    return SkGradientShader::MakeLinear(kPts, kColors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(kPts, kColors, nullptr, 2, SkTileMode::kClamp);
 }
 
 class ClearBench : public Benchmark {
diff --git a/bench/GameBench.cpp b/bench/GameBench.cpp
index 4d34fc1..ef1595f 100644
--- a/bench/GameBench.cpp
+++ b/bench/GameBench.cpp
@@ -141,9 +141,7 @@
         SkPaint p2;         // for drawVertices path
         p2.setColor(0xFF000000);
         p2.setFilterQuality(kLow_SkFilterQuality);
-        p2.setShader(SkShader::MakeBitmapShader(fAtlas,
-                                                SkShader::kClamp_TileMode,
-                                                SkShader::kClamp_TileMode));
+        p2.setShader(SkShader::MakeBitmapShader(fAtlas, SkTileMode::kClamp, SkTileMode::kClamp));
 
         for (int i = 0; i < loops; ++i, ++fNumSaved) {
             if (0 == i % kNumBeforeClear) {
diff --git a/bench/GradientBench.cpp b/bench/GradientBench.cpp
index e6c02d3..4f28b6e 100644
--- a/bench/GradientBench.cpp
+++ b/bench/GradientBench.cpp
@@ -48,12 +48,12 @@
 
 /// Ignores scale
 static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data,
-                                  SkShader::TileMode tm, float scale) {
+                                  SkTileMode tm, float scale) {
     return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
 static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data,
-                                  SkShader::TileMode tm, float scale) {
+                                  SkTileMode tm, float scale) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -63,7 +63,7 @@
 
 /// Ignores scale
 static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data,
-                                 SkShader::TileMode tm, float scale) {
+                                 SkTileMode tm, float scale) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -72,7 +72,7 @@
 
 /// Ignores scale
 static sk_sp<SkShader> MakeConical(const SkPoint pts[2], const GradData& data,
-                                   SkShader::TileMode tm, float scale) {
+                                   SkTileMode tm, float scale) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -85,7 +85,7 @@
 
 /// Ignores scale
 static sk_sp<SkShader> MakeConicalZeroRad(const SkPoint pts[2], const GradData& data,
-                                          SkShader::TileMode tm, float scale) {
+                                          SkTileMode tm, float scale) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -98,7 +98,7 @@
 
 /// Ignores scale
 static sk_sp<SkShader> MakeConicalOutside(const SkPoint pts[2], const GradData& data,
-                                          SkShader::TileMode tm, float scale) {
+                                          SkTileMode tm, float scale) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -112,7 +112,7 @@
 
 /// Ignores scale
 static sk_sp<SkShader> MakeConicalOutsideZeroRad(const SkPoint pts[2], const GradData& data,
-                                                 SkShader::TileMode tm, float scale) {
+                                                 SkTileMode tm, float scale) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -125,7 +125,7 @@
 }
 
 typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                                     SkShader::TileMode tm, float scale);
+                                     SkTileMode tm, float scale);
 
 static const struct {
     GradMaker   fMaker;
@@ -155,18 +155,18 @@
     kOval_GeomType
 };
 
-static const char* tilemodename(SkShader::TileMode tm) {
+static const char* tilemodename(SkTileMode tm) {
     switch (tm) {
-        case SkShader::kClamp_TileMode:
+        case SkTileMode::kClamp:
             return "clamp";
-        case SkShader::kRepeat_TileMode:
+        case SkTileMode::kRepeat:
             return "repeat";
-        case SkShader::kMirror_TileMode:
+        case SkTileMode::kMirror:
             return "mirror";
-        default:
-            SkDEBUGFAIL("unknown tilemode");
-            return "error";
+        case SkTileMode::kDecal:
+            return "decal";
     }
+    return "";
 }
 
 static const char* geomtypename(GeomType gt) {
@@ -187,7 +187,7 @@
 public:
     GradientBench(GradType gradType,
                   GradData data = gGradData[0],
-                  SkShader::TileMode tm = SkShader::kClamp_TileMode,
+                  SkTileMode tm = SkTileMode::kClamp,
                   GeomType geomType = kRect_GeomType,
                   float scale = 1.0f)
         : fGeomType(geomType) {
@@ -211,7 +211,7 @@
     GradientBench(GradType gradType, GradData data, bool dither)
         : fGeomType(kRect_GeomType) {
 
-        const char *tmname = tilemodename(SkShader::kClamp_TileMode);
+        const char *tmname = tilemodename(SkTileMode::kClamp);
         fName.printf("gradient_%s_%s", gGrads[gradType].fName, tmname);
         fName.append(data.fName);
 
@@ -220,7 +220,7 @@
         }
 
         this->setupPaint(&fPaint);
-        fPaint.setShader(MakeShader(gradType, data, SkShader::kClamp_TileMode, 1.0f));
+        fPaint.setShader(MakeShader(gradType, data, SkTileMode::kClamp, 1.0f));
         fPaint.setDither(dither);
     }
 
@@ -252,7 +252,7 @@
     typedef Benchmark INHERITED;
 
     sk_sp<SkShader> MakeShader(GradType gradType, GradData data,
-                               SkShader::TileMode tm, float scale) {
+                               SkTileMode tm, float scale) {
         const SkPoint pts[2] = {
             { 0, 0 },
             { SkIntToScalar(kSize), SkIntToScalar(kSize) }
@@ -272,26 +272,26 @@
 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2]); )
 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[4]); )
-DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kRepeat_TileMode); )
-DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kRepeat_TileMode); )
-DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kRepeat_TileMode); )
-DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kMirror_TileMode); )
-DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kMirror_TileMode); )
-DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkTileMode::kRepeat); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkTileMode::kRepeat); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkTileMode::kRepeat); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkTileMode::kMirror); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkTileMode::kMirror); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkTileMode::kMirror); )
 
 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0]); )
 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[2]); )
 // Draw a radial gradient of radius 1/2 on a rectangle; half the lines should
 // be completely pinned, the other half should pe partially pinned
-DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkTileMode::kClamp, kRect_GeomType, 0.5f); )
 
 // Draw a radial gradient on a circle of equal size; all the lines should
 // hit the unpinned fast path (so long as GradientBench.W == H)
-DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kOval_GeomType); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkTileMode::kClamp, kOval_GeomType); )
 
-DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kMirror_TileMode); )
-DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kRepeat_TileMode); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkTileMode::kMirror); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkTileMode::kRepeat); )
 DEF_BENCH( return new GradientBench(kSweep_GradType); )
 DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[2]); )
@@ -354,7 +354,7 @@
                 SK_ColorWHITE };
             paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr,
                                                          SK_ARRAY_COUNT(colors),
-                                                         SkShader::kClamp_TileMode));
+                                                         SkTileMode::kClamp));
             canvas->drawRect(r, paint);
         }
     }
diff --git a/bench/HardStopGradientBench_ScaleNumColors.cpp b/bench/HardStopGradientBench_ScaleNumColors.cpp
index cedbd72..b1f6267 100644
--- a/bench/HardStopGradientBench_ScaleNumColors.cpp
+++ b/bench/HardStopGradientBench_ScaleNumColors.cpp
@@ -14,23 +14,23 @@
 #include "SkColor.h"
 #include "SkPaint.h"
 
-static const char* get_tilemode_name(SkShader::TileMode tilemode) {
+static const char* get_tilemode_name(SkTileMode tilemode) {
     switch (tilemode) {
-        case SkShader::kClamp_TileMode:
+        case SkTileMode::kClamp:
             return "clamp";
-        case SkShader::kRepeat_TileMode:
+        case SkTileMode::kRepeat:
             return "repeat";
-        case SkShader::kMirror_TileMode:
+        case SkTileMode::kMirror:
             return "mirror";
-        default:
-            SkDEBUGFAIL("Unknown tilemode");
-            return "error";
+        case SkTileMode::kDecal:
+            return "decal";
     }
+    return "";
 }
 
 class HardStopGradientBench_ScaleNumColors : public Benchmark {
 public:
-    HardStopGradientBench_ScaleNumColors(SkShader::TileMode tilemode, int count) {
+    HardStopGradientBench_ScaleNumColors(SkTileMode tilemode, int count) {
         fName.printf("hardstop_scale_num_colors_%s_%03d_colors", get_tilemode_name(tilemode), count);
 
         fTileMode   = tilemode;
@@ -103,37 +103,37 @@
 private:
     static const int kSize = 500;
 
-    SkShader::TileMode  fTileMode;
-    SkString            fName;
-    int                 fColorCount;
-    SkPaint             fPaint;
+    SkTileMode  fTileMode;
+    SkString    fName;
+    int         fColorCount;
+    SkPaint     fPaint;
 
     typedef Benchmark INHERITED;
 };
 
 // Clamp
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kClamp_TileMode,   3);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kClamp_TileMode,   4);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kClamp_TileMode,   5);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kClamp_TileMode,  10);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kClamp_TileMode,  25);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kClamp_TileMode,  50);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kClamp_TileMode, 100);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kClamp,   3);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kClamp,   4);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kClamp,   5);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kClamp,  10);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kClamp,  25);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kClamp,  50);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kClamp, 100);)
 
 // Repeat
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kRepeat_TileMode,   3);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kRepeat_TileMode,   4);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kRepeat_TileMode,   5);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kRepeat_TileMode,  10);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kRepeat_TileMode,  25);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kRepeat_TileMode,  50);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kRepeat_TileMode, 100);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kRepeat,   3);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kRepeat,   4);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kRepeat,   5);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kRepeat,  10);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kRepeat,  25);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kRepeat,  50);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kRepeat, 100);)
 
 // Mirror
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kMirror_TileMode,   3);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kMirror_TileMode,   4);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kMirror_TileMode,   5);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kMirror_TileMode,  10);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kMirror_TileMode,  25);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kMirror_TileMode,  50);)
-DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkShader::kMirror_TileMode, 100);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kMirror,   3);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kMirror,   4);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kMirror,   5);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kMirror,  10);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kMirror,  25);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kMirror,  50);)
+DEF_BENCH(return new HardStopGradientBench_ScaleNumColors(SkTileMode::kMirror, 100);)
diff --git a/bench/HardStopGradientBench_ScaleNumHardStops.cpp b/bench/HardStopGradientBench_ScaleNumHardStops.cpp
index 843bb72..b1ea306 100644
--- a/bench/HardStopGradientBench_ScaleNumHardStops.cpp
+++ b/bench/HardStopGradientBench_ScaleNumHardStops.cpp
@@ -72,7 +72,7 @@
                                                       colors.get(),
                                                       positions.get(),
                                                       fColorCount,
-                                                      SkShader::kClamp_TileMode,
+                                                      SkTileMode::kClamp,
                                                       0,
                                                       nullptr));
     }
diff --git a/bench/HardStopGradientBench_SpecialHardStops.cpp b/bench/HardStopGradientBench_SpecialHardStops.cpp
index e987901..607080a 100644
--- a/bench/HardStopGradientBench_SpecialHardStops.cpp
+++ b/bench/HardStopGradientBench_SpecialHardStops.cpp
@@ -93,7 +93,7 @@
                                                       colors,
                                                       positions,
                                                       count,
-                                                      SkShader::kClamp_TileMode,
+                                                      SkTileMode::kClamp,
                                                       0,
                                                       nullptr));
     }
diff --git a/bench/ImageFilterCollapse.cpp b/bench/ImageFilterCollapse.cpp
index ce27f06..286f324 100644
--- a/bench/ImageFilterCollapse.cpp
+++ b/bench/ImageFilterCollapse.cpp
@@ -62,7 +62,7 @@
             SK_ColorRED, 0, SK_ColorBLUE, SK_ColorWHITE
         };
         paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                                     SkShader::kClamp_TileMode));
+                                                     SkTileMode::kClamp));
         canvas.drawPaint(paint);
     }
 };
diff --git a/bench/PDFBench.cpp b/bench/PDFBench.cpp
index 7720e21..fc4d2c9 100644
--- a/bench/PDFBench.cpp
+++ b/bench/PDFBench.cpp
@@ -210,7 +210,7 @@
         };
         fShader = SkGradientShader::MakeLinear(
                 pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                SkShader::kClamp_TileMode);
+                SkTileMode::kClamp);
     }
     void onDraw(int loops, SkCanvas*) final {
         SkASSERT(fShader);
diff --git a/bench/PatchBench.cpp b/bench/PatchBench.cpp
index 375560e..064db69 100644
--- a/bench/PatchBench.cpp
+++ b/bench/PatchBench.cpp
@@ -77,7 +77,7 @@
         const SkPoint pts[] = { { 200.f / 4.f, 0.f }, { 3.f * 200.f / 4, 200.f } };
 
         return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                            SkShader::kMirror_TileMode);
+                                            SkTileMode::kMirror);
     }
 
 protected:
diff --git a/bench/RectBench.cpp b/bench/RectBench.cpp
index 4e6bdc9..4dcb3b7 100644
--- a/bench/RectBench.cpp
+++ b/bench/RectBench.cpp
@@ -171,7 +171,7 @@
         // Create the shader once, so that isn't included in the timing
         SkPoint pts[2] = { {0.f, 0.f}, {50.f, 50.f} };
         SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
-        fShader = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+        fShader = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
     }
 
     void setupPaint(SkPaint* paint) override {
@@ -295,8 +295,8 @@
             srcBM.allocN32Pixels(10, 1);
             srcBM.eraseColor(0xFF00FF00);
 
-            paint.setShader(SkShader::MakeBitmapShader(srcBM, SkShader::kClamp_TileMode,
-                                                       SkShader::kClamp_TileMode));
+            paint.setShader(SkShader::MakeBitmapShader(srcBM,
+                                                       SkTileMode::kClamp, SkTileMode::kClamp));
         }
         for (int loop = 0; loop < loops; loop++) {
             for (size_t i = 0; i < sizes; i++) {
diff --git a/bench/RepeatTileBench.cpp b/bench/RepeatTileBench.cpp
index cebe797..ccea88d 100644
--- a/bench/RepeatTileBench.cpp
+++ b/bench/RepeatTileBench.cpp
@@ -60,8 +60,8 @@
         draw_into_bitmap(fBitmap);
 
         fPaint.setShader(SkShader::MakeBitmapShader(fBitmap,
-                                                    SkShader::kRepeat_TileMode,
-                                                    SkShader::kRepeat_TileMode));
+                                                    SkTileMode::kRepeat,
+                                                    SkTileMode::kRepeat));
     }
 
 
diff --git a/bench/RotatedRectBench.cpp b/bench/RotatedRectBench.cpp
index 7623715..db4a792 100644
--- a/bench/RotatedRectBench.cpp
+++ b/bench/RotatedRectBench.cpp
@@ -101,7 +101,7 @@
             SkPoint pts[2] = { {0.0f, 0.0f}, {kRectW, kRectH} };
             SkColor colors[] = { color, SK_ColorBLUE };
             paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                         SkShader::kClamp_TileMode));
+                                                         SkTileMode::kClamp));
         }
 
         SkMatrix rotate;
diff --git a/bench/ShaderMaskFilterBench.cpp b/bench/ShaderMaskFilterBench.cpp
index 4de5f47..164d5dd 100644
--- a/bench/ShaderMaskFilterBench.cpp
+++ b/bench/ShaderMaskFilterBench.cpp
@@ -21,8 +21,7 @@
     auto surface = SkSurface::MakeRasterN32Premul(100, 100);
     surface->getCanvas()->drawCircle(50, 50, 50, p);
 
-    return surface->makeImageSnapshot()->makeShader(SkShader::kRepeat_TileMode,
-                                                    SkShader::kRepeat_TileMode);
+    return surface->makeImageSnapshot()->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat);
 }
 
 static sk_sp<SkShader> make_picture_shader() {
@@ -33,8 +32,7 @@
     SkPictureRecorder recorder;
     recorder.beginRecording(100, 100)->drawCircle(50, 50, 50, p);
 
-    return recorder.finishRecordingAsPicture()->makeShader(SkTileMode::kRepeat,
-                                                           SkTileMode::kRepeat);
+    return recorder.finishRecordingAsPicture()->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat);
 }
 
 class ShaderMFBench final : public Benchmark {
diff --git a/bench/TileBench.cpp b/bench/TileBench.cpp
index 4a69ccb..0ce19ae 100644
--- a/bench/TileBench.cpp
+++ b/bench/TileBench.cpp
@@ -36,8 +36,8 @@
     static const int kHeight = 300;
 
 public:
-    ConstXTileBench(SkShader::TileMode xTile,
-                    SkShader::TileMode yTile,
+    ConstXTileBench(SkTileMode xTile,
+                    SkTileMode yTile,
                     bool doFilter,
                     bool doTrans,
                     bool doScale)
@@ -55,9 +55,9 @@
 
         fName.printf("constXTile_");
 
-        static const char* gTileModeStr[SkShader::kTileModeCount] = { "C", "R", "M" };
-        fName.append(gTileModeStr[xTile]);
-        fName.append(gTileModeStr[yTile]);
+        static const char* gTileModeStr[kSkTileModeCount] = { "C", "R", "M", "D" };
+        fName.append(gTileModeStr[(unsigned)xTile]);
+        fName.append(gTileModeStr[(unsigned)yTile]);
 
         if (doFilter) {
             fName.append("_filter");
@@ -114,18 +114,18 @@
 // Scaled benches are trending towards free.  Seems like caching.
 // TODO(mtklein, reed): fix and reenable
 
-//DEF_BENCH(return new ConstXTileBench(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, false, false, true))
-DEF_BENCH(return new ConstXTileBench(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, false, false, false))
-//DEF_BENCH(return new ConstXTileBench(SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, false, false, true))
+//DEF_BENCH(return new ConstXTileBench(SkTileMode::kRepeat, SkTileMode::kRepeat, false, false, true))
+DEF_BENCH(return new ConstXTileBench(SkTileMode::kClamp, SkTileMode::kClamp, false, false, false))
+//DEF_BENCH(return new ConstXTileBench(SkTileMode::kMirror, SkTileMode::kMirror, false, false, true))
 
-DEF_BENCH(return new ConstXTileBench(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, true, false, false))
-//DEF_BENCH(return new ConstXTileBench(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, true, false, true))
-DEF_BENCH(return new ConstXTileBench(SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, true, false, false))
+DEF_BENCH(return new ConstXTileBench(SkTileMode::kRepeat, SkTileMode::kRepeat, true, false, false))
+//DEF_BENCH(return new ConstXTileBench(SkTileMode::kClamp, SkTileMode::kClamp, true, false, true))
+DEF_BENCH(return new ConstXTileBench(SkTileMode::kMirror, SkTileMode::kMirror, true, false, false))
 
-//DEF_BENCH(return new ConstXTileBench(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, false, true, true))
-DEF_BENCH(return new ConstXTileBench(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, false, true, false))
-//DEF_BENCH(return new ConstXTileBench(SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, false, true, true))
+//DEF_BENCH(return new ConstXTileBench(SkTileMode::kRepeat, SkTileMode::kRepeat, false, true, true))
+DEF_BENCH(return new ConstXTileBench(SkTileMode::kClamp, SkTileMode::kClamp, false, true, false))
+//DEF_BENCH(return new ConstXTileBench(SkTileMode::kMirror, SkTileMode::kMirror, false, true, true))
 
-DEF_BENCH(return new ConstXTileBench(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, true, true, false))
-//DEF_BENCH(return new ConstXTileBench(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, true, true, true))
-DEF_BENCH(return new ConstXTileBench(SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, true, true, false))
+DEF_BENCH(return new ConstXTileBench(SkTileMode::kRepeat, SkTileMode::kRepeat, true, true, false))
+//DEF_BENCH(return new ConstXTileBench(SkTileMode::kClamp, SkTileMode::kClamp, true, true, true))
+DEF_BENCH(return new ConstXTileBench(SkTileMode::kMirror, SkTileMode::kMirror, true, true, false))
diff --git a/docs/examples/Bitmap_readPixels.cpp b/docs/examples/Bitmap_readPixels.cpp
index ac63ad0..98dd888 100644
--- a/docs/examples/Bitmap_readPixels.cpp
+++ b/docs/examples/Bitmap_readPixels.cpp
@@ -11,7 +11,7 @@
     SkPoint  gradPoints[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr,
-                    SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode));
+                    SK_ARRAY_COUNT(gradColors), SkTileMode::kClamp));
     SkBitmap bitmap;
     bitmap.allocPixels(srcInfo);
     SkCanvas srcCanvas(bitmap);
diff --git a/docs/examples/Canvas_drawOval.cpp b/docs/examples/Canvas_drawOval.cpp
index a98b44c..3e254ca 100644
--- a/docs/examples/Canvas_drawOval.cpp
+++ b/docs/examples/Canvas_drawOval.cpp
@@ -13,7 +13,7 @@
     SkPaint paint;
     paint.setAntiAlias(true);
     paint.setShader(SkGradientShader::MakeLinear(g1Points, g1Colors, pos, SK_ARRAY_COUNT(g1Colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawOval(bounds , paint);
 }
 }  // END FIDDLE
diff --git a/docs/examples/Canvas_drawPatch.cpp b/docs/examples/Canvas_drawPatch.cpp
index 504baf5..b888fd4 100644
--- a/docs/examples/Canvas_drawPatch.cpp
+++ b/docs/examples/Canvas_drawPatch.cpp
@@ -14,8 +14,8 @@
                       /* { 1, 5 }, */ { 2, 4 }, { 1, 3 }, /* { 3, 1 } */ };
     SkColor colors[] = { 0xbfff0000, 0xbf0000ff, 0xbfff00ff, 0xbf00ffff };
     SkPoint texCoords[] = { { -30, -30 }, { 162, -30}, { 162, 162}, { -30, 162} };
-    paint.setShader(SkShader::MakeBitmapShader(source, SkShader::kClamp_TileMode,
-                                                       SkShader::kClamp_TileMode, nullptr));
+    paint.setShader(SkShader::MakeBitmapShader(source, SkTileMode::kClamp,
+                                                       SkTileMode::kClamp, nullptr));
     canvas->scale(15, 15);
     for (auto blend : { SkBlendMode::kSrcOver, SkBlendMode::kModulate, SkBlendMode::kXor } ) {
         canvas->drawPatch(cubics, colors, texCoords, blend, paint);
diff --git a/docs/examples/Canvas_drawPatch_2_b.cpp b/docs/examples/Canvas_drawPatch_2_b.cpp
index 3e77d7a..5863303 100644
--- a/docs/examples/Canvas_drawPatch_2_b.cpp
+++ b/docs/examples/Canvas_drawPatch_2_b.cpp
@@ -13,8 +13,7 @@
                       /* { 5, 7 }, */ { 4, 6 }, { 3, 7 },    { 1, 5 },
                       /* { 1, 5 }, */ { 2, 4 }, { 1, 3 }, /* { 3, 1 } */ };
     SkPoint texCoords[] = { { 0, 0 }, { 0, 62}, { 62, 62}, { 62, 0 } };
-    paint.setShader(SkShader::MakeBitmapShader(source, SkShader::kClamp_TileMode,
-                                                       SkShader::kClamp_TileMode, nullptr));
+    paint.setShader(SkShader::MakeBitmapShader(source, SkTileMode::kClamp, SkTileMode::kClamp));
     canvas->scale(30, 30);
     canvas->drawPatch(cubics, nullptr, texCoords, paint);
 }
diff --git a/docs/examples/Canvas_drawVertices_2.cpp b/docs/examples/Canvas_drawVertices_2.cpp
index 81d6583..9a5a841 100644
--- a/docs/examples/Canvas_drawVertices_2.cpp
+++ b/docs/examples/Canvas_drawVertices_2.cpp
@@ -8,8 +8,7 @@
     SkPoint points[] = { { 0, 0 }, { 250, 0 }, { 100, 100 }, { 0, 250 } };
     SkPoint texs[] = { { 0, 0 }, { 0, 250 }, { 250, 250 }, { 250, 0 } };
     SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorYELLOW, SK_ColorCYAN };
-    paint.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 4,
-            SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 4, SkTileMode::kClamp));
     auto vertices = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode,
             SK_ARRAY_COUNT(points), points, texs, colors);
     canvas->drawVertices(vertices, SkBlendMode::kDarken, paint);
diff --git a/docs/examples/Clear.cpp b/docs/examples/Clear.cpp
index 62cdd56..45df306 100644
--- a/docs/examples/Clear.cpp
+++ b/docs/examples/Clear.cpp
@@ -10,7 +10,7 @@
     for (auto color : { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN } ) {
         SkColor colors[] = { color, SkColorSetA(color, 0) };
         paint.setShader(SkGradientShader::MakeRadial({ 64, 64}, 100,
-                colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+                colors, nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
         canvas->drawCircle(64, 64, 100, paint);
         canvas->translate(64, 64);
     }
diff --git a/docs/examples/Darken.cpp b/docs/examples/Darken.cpp
index 2e2a258..be738c9 100644
--- a/docs/examples/Darken.cpp
+++ b/docs/examples/Darken.cpp
@@ -9,7 +9,7 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     paint.setBlendMode(SkBlendMode::kDarken);
     canvas->drawPaint(paint);
 }
diff --git a/docs/examples/Difference.cpp b/docs/examples/Difference.cpp
index 3b08cb0..8ad5dcc 100644
--- a/docs/examples/Difference.cpp
+++ b/docs/examples/Difference.cpp
@@ -13,7 +13,7 @@
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(0x80bb9977, SkBlendMode::kDifference);
diff --git a/docs/examples/Dither_b.cpp b/docs/examples/Dither_b.cpp
index 1313bc5..0300b3d 100644
--- a/docs/examples/Dither_b.cpp
+++ b/docs/examples/Dither_b.cpp
@@ -13,7 +13,7 @@
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(
                      points, colors, nullptr, SK_ARRAY_COUNT(colors),
-                     SkShader::kClamp_TileMode, 0, nullptr));
+                     SkTileMode::kClamp));
     paint.setDither(true);
     c32.drawPaint(paint);
     canvas->scale(12, 12);
diff --git a/docs/examples/Dst_Atop.cpp b/docs/examples/Dst_Atop.cpp
index 0061e27..e6d82b1 100644
--- a/docs/examples/Dst_Atop.cpp
+++ b/docs/examples/Dst_Atop.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstATop);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kSrcATop);
diff --git a/docs/examples/Dst_In.cpp b/docs/examples/Dst_In.cpp
index e6d9c83..c4f0abd 100644
--- a/docs/examples/Dst_In.cpp
+++ b/docs/examples/Dst_In.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstIn);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kDstIn);
diff --git a/docs/examples/Dst_Out.cpp b/docs/examples/Dst_Out.cpp
index 4717281..7378f73 100644
--- a/docs/examples/Dst_Out.cpp
+++ b/docs/examples/Dst_Out.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstIn);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kDstOut);
diff --git a/docs/examples/Dst_Over.cpp b/docs/examples/Dst_Over.cpp
index 36ea783..d8e7d86 100644
--- a/docs/examples/Dst_Over.cpp
+++ b/docs/examples/Dst_Over.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstIn);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kDstOver);
diff --git a/docs/examples/Exclusion.cpp b/docs/examples/Exclusion.cpp
index 2e8b35c..30a7e4f 100644
--- a/docs/examples/Exclusion.cpp
+++ b/docs/examples/Exclusion.cpp
@@ -13,7 +13,7 @@
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(0x80bb9977, SkBlendMode::kExclusion);
diff --git a/docs/examples/Hard_Light.cpp b/docs/examples/Hard_Light.cpp
index 13f981c..eb6f307 100644
--- a/docs/examples/Hard_Light.cpp
+++ b/docs/examples/Hard_Light.cpp
@@ -9,7 +9,7 @@
     SkPaint paint;
     paint.setBlendMode(SkBlendMode::kHardLight);
     paint.setShader(SkGradientShader::MakeRadial({ 128, 128}, 100, colors,
-         nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+         nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
     canvas->clipRect({0, 128, 256, 256});
     canvas->drawPaint(paint);
 }
diff --git a/docs/examples/ImageInfo_MakeS32.cpp b/docs/examples/ImageInfo_MakeS32.cpp
index 978b1a1..1033014 100644
--- a/docs/examples/ImageInfo_MakeS32.cpp
+++ b/docs/examples/ImageInfo_MakeS32.cpp
@@ -11,7 +11,7 @@
     SkPoint  gradPoints[] = { { 0, 0 }, { width, 0 } };
     SkPaint gradPaint;
     gradPaint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr,
-                    SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode));
+                    SK_ARRAY_COUNT(gradColors), SkTileMode::kClamp));
     SkBitmap bitmap;
     bitmap.allocPixels(SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType));
     SkCanvas offScreen(bitmap);
diff --git a/docs/examples/Image_makeShader.cpp b/docs/examples/Image_makeShader.cpp
index 383c871..0f4611d 100644
--- a/docs/examples/Image_makeShader.cpp
+++ b/docs/examples/Image_makeShader.cpp
@@ -7,8 +7,7 @@
     SkMatrix matrix;
     matrix.setRotate(45);
     SkPaint paint;
-    paint.setShader(image->makeShader(SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode,
-                                      &matrix));
+    paint.setShader(image->makeShader(SkTileMode::kRepeat, SkTileMode::kMirror, &matrix));
     canvas->drawPaint(paint);
 }
 }  // END FIDDLE
diff --git a/docs/examples/Lighten.cpp b/docs/examples/Lighten.cpp
index cebe7f6..f02a2ea 100644
--- a/docs/examples/Lighten.cpp
+++ b/docs/examples/Lighten.cpp
@@ -9,7 +9,7 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     paint.setBlendMode(SkBlendMode::kLighten);
     canvas->drawPaint(paint);
 }
diff --git a/docs/examples/Modulate.cpp b/docs/examples/Modulate.cpp
index ba7807c..7290577 100644
--- a/docs/examples/Modulate.cpp
+++ b/docs/examples/Modulate.cpp
@@ -9,7 +9,7 @@
         const SkPoint horz[] = { { 0, 0 }, { 128, 0 } };
         SkPaint paint;
         paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-                SkShader::kClamp_TileMode));
+                SkTileMode::kClamp));
         paint.setBlendMode(mode);
         canvas->translate(dx, dy);
         canvas->drawRect({0, 0, 128, 128}, paint);
diff --git a/docs/examples/Multiply.cpp b/docs/examples/Multiply.cpp
index 07d5f3b..5a9a1b6 100644
--- a/docs/examples/Multiply.cpp
+++ b/docs/examples/Multiply.cpp
@@ -13,7 +13,7 @@
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(0x80bb9977, SkBlendMode::kMultiply);
diff --git a/docs/examples/Overlay.cpp b/docs/examples/Overlay.cpp
index ec74ffe..95c77ac 100644
--- a/docs/examples/Overlay.cpp
+++ b/docs/examples/Overlay.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstATop);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kOverlay);
diff --git a/docs/examples/Pixmap_readPixels.cpp b/docs/examples/Pixmap_readPixels.cpp
index 6717187..23c7c5e 100644
--- a/docs/examples/Pixmap_readPixels.cpp
+++ b/docs/examples/Pixmap_readPixels.cpp
@@ -14,7 +14,7 @@
     SkPoint  gradPoints[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr,
-                    SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode));
+                    SK_ARRAY_COUNT(gradColors), SkTileMode::kClamp));
     SkBitmap bitmap;
     bitmap.installPixels(srcPixmap);
     SkCanvas srcCanvas(bitmap);
diff --git a/docs/examples/Plus.cpp b/docs/examples/Plus.cpp
index c47c94f..9289c80 100644
--- a/docs/examples/Plus.cpp
+++ b/docs/examples/Plus.cpp
@@ -11,7 +11,7 @@
         SkColor colors[] = { color, SkColorSetA(color, 192), SkColorSetA(color, 128),
                              SkColorSetA(color, 0) };
         paint.setShader(SkGradientShader::MakeRadial({ 64, 64}, 100,
-                colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+                colors, nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
         canvas->drawCircle(64, 64, 100, paint);
         canvas->translate(64, 64);
     }
diff --git a/docs/examples/Screen.cpp b/docs/examples/Screen.cpp
index ca21fad..edbb97d 100644
--- a/docs/examples/Screen.cpp
+++ b/docs/examples/Screen.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstATop);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kScreen);
diff --git a/docs/examples/Shader_Methods_a.cpp b/docs/examples/Shader_Methods_a.cpp
index c4a07ea..70ee642 100644
--- a/docs/examples/Shader_Methods_a.cpp
+++ b/docs/examples/Shader_Methods_a.cpp
@@ -9,7 +9,7 @@
    SkScalar radius = 50;
    const SkColor colors[] = { 0xFFFFFFFF, 0xFF000000 };
    paint.setShader(SkGradientShader::MakeRadial(center, radius, colors,
-        nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+        nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
    for (SkScalar a : { 0.3f, 0.6f, 1.0f } ) {
        paint.setAlpha((int) (a * 255));
        canvas->drawCircle(center.fX, center.fY, radius, paint);
diff --git a/docs/examples/Shader_Methods_b.cpp b/docs/examples/Shader_Methods_b.cpp
index 9500078..98885aa 100644
--- a/docs/examples/Shader_Methods_b.cpp
+++ b/docs/examples/Shader_Methods_b.cpp
@@ -9,8 +9,7 @@
    bitmap.setInfo(SkImageInfo::MakeA8(5, 1), 5);  // bitmap only contains alpha
    uint8_t pixels[5] = { 0x22, 0x55, 0x88, 0xBB, 0xFF };
    bitmap.setPixels(pixels);
-   paint.setShader(SkShader::MakeBitmapShader(bitmap,
-            SkShader::kMirror_TileMode, SkShader::kMirror_TileMode));
+   paint.setShader(SkShader::MakeBitmapShader(bitmap, SkTileMode::kMirror, SkTileMode::kMirror));
    for (SkColor c : { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN } ) {
        paint.setColor(c);  // all components in color affect shader
        canvas->drawCircle(50, 50, 50, paint);
diff --git a/docs/examples/Soft_Light.cpp b/docs/examples/Soft_Light.cpp
index a73de75..a97b75a 100644
--- a/docs/examples/Soft_Light.cpp
+++ b/docs/examples/Soft_Light.cpp
@@ -8,7 +8,7 @@
     SkPaint paint;
     paint.setBlendMode(SkBlendMode::kSoftLight);
     paint.setShader(SkGradientShader::MakeRadial({ 128, 128}, 100, colors,
-         nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+         nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
     canvas->drawImage(image, 0, 0);
     canvas->drawCircle(128, 128, 100, paint);
 }
diff --git a/docs/examples/Src_Atop.cpp b/docs/examples/Src_Atop.cpp
index 6fd7582..4560f95 100644
--- a/docs/examples/Src_Atop.cpp
+++ b/docs/examples/Src_Atop.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstIn);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kSrcATop);
diff --git a/docs/examples/Src_In.cpp b/docs/examples/Src_In.cpp
index 48ecd4f..2dbbe79 100644
--- a/docs/examples/Src_In.cpp
+++ b/docs/examples/Src_In.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstIn);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kSrcIn);
diff --git a/docs/examples/Src_Out.cpp b/docs/examples/Src_Out.cpp
index 69833e2..f7cdb0a 100644
--- a/docs/examples/Src_Out.cpp
+++ b/docs/examples/Src_Out.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstIn);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kSrcOut);
diff --git a/docs/examples/Src_Over.cpp b/docs/examples/Src_Over.cpp
index 1381150..e0c9fb3 100644
--- a/docs/examples/Src_Over.cpp
+++ b/docs/examples/Src_Over.cpp
@@ -8,13 +8,13 @@
     SkPoint horz[] = { { 0, 0 }, { 256, 0 } };
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeLinear(horz, colors, nullptr, SK_ARRAY_COUNT(colors),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     paint.setBlendMode(SkBlendMode::kDstIn);
     SkColor alphas[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
     SkPoint vert[] = { { 0, 0 }, { 0, 256 } };
     paint.setShader(SkGradientShader::MakeLinear(vert, alphas, nullptr, SK_ARRAY_COUNT(alphas),
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
     canvas->drawPaint(paint);
     canvas->clipRect( { 30, 30, 226, 226 } );
     canvas->drawColor(SkColorSetA(SK_ColorGREEN, 128), SkBlendMode::kSrcOver);
diff --git a/docs/examples/Xor.cpp b/docs/examples/Xor.cpp
index 8b2a49e..9a9af87 100644
--- a/docs/examples/Xor.cpp
+++ b/docs/examples/Xor.cpp
@@ -10,7 +10,7 @@
         SkColor colors[] = { color, SkColorSetA(color, 192), SkColorSetA(color, 128),
                              SkColorSetA(color, 0) };
         paint.setShader(SkGradientShader::MakeRadial({ 64, 64}, 100,
-                colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+                colors, nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
         canvas->drawCircle(64, 64, 100, paint);
         canvas->translate(64, 64);
     }
diff --git a/example/HelloWorld.cpp b/example/HelloWorld.cpp
index 5439fb4..6d88af9 100644
--- a/example/HelloWorld.cpp
+++ b/example/HelloWorld.cpp
@@ -72,7 +72,7 @@
         SkPoint linearPoints[] = { { 0, 0 }, { 300, 300 } };
         SkColor linearColors[] = { SK_ColorGREEN, SK_ColorBLACK };
         paint.setShader(SkGradientShader::MakeLinear(linearPoints, linearColors, nullptr, 2,
-                                                     SkShader::kMirror_TileMode));
+                                                     SkTileMode::kMirror));
         paint.setAntiAlias(true);
 
         canvas->drawCircle(200, 200, 64, paint);
diff --git a/experimental/svg/model/SkSVGGradient.cpp b/experimental/svg/model/SkSVGGradient.cpp
index 5718aac..a591522 100644
--- a/experimental/svg/model/SkSVGGradient.cpp
+++ b/experimental/svg/model/SkSVGGradient.cpp
@@ -86,13 +86,13 @@
     //       * href attribute inheritance (not just color stops)
     //       * objectBoundingBox units support
 
-    static_assert(static_cast<SkShader::TileMode>(SkSVGSpreadMethod::Type::kPad) ==
-                  SkShader::kClamp_TileMode, "SkSVGSpreadMethod::Type is out of sync");
-    static_assert(static_cast<SkShader::TileMode>(SkSVGSpreadMethod::Type::kRepeat) ==
-                  SkShader::kRepeat_TileMode, "SkSVGSpreadMethod::Type is out of sync");
-    static_assert(static_cast<SkShader::TileMode>(SkSVGSpreadMethod::Type::kReflect) ==
-                  SkShader::kMirror_TileMode, "SkSVGSpreadMethod::Type is out of sync");
-    const auto tileMode = static_cast<SkShader::TileMode>(fSpreadMethod.type());
+    static_assert(static_cast<SkTileMode>(SkSVGSpreadMethod::Type::kPad) ==
+                  SkTileMode::kClamp, "SkSVGSpreadMethod::Type is out of sync");
+    static_assert(static_cast<SkTileMode>(SkSVGSpreadMethod::Type::kRepeat) ==
+                  SkTileMode::kRepeat, "SkSVGSpreadMethod::Type is out of sync");
+    static_assert(static_cast<SkTileMode>(SkSVGSpreadMethod::Type::kReflect) ==
+                  SkTileMode::kMirror, "SkSVGSpreadMethod::Type is out of sync");
+    const auto tileMode = static_cast<SkTileMode>(fSpreadMethod.type());
 
     paint->setShader(this->onMakeShader(ctx, colors.begin(), pos.begin(), colors.count(), tileMode,
                                         fGradientTransform.value()));
diff --git a/experimental/svg/model/SkSVGGradient.h b/experimental/svg/model/SkSVGGradient.h
index 75ffba9..1c6efa1 100644
--- a/experimental/svg/model/SkSVGGradient.h
+++ b/experimental/svg/model/SkSVGGradient.h
@@ -32,7 +32,7 @@
 
     virtual sk_sp<SkShader> onMakeShader(const SkSVGRenderContext&,
                                          const SkColor*, const SkScalar*, int count,
-                                         SkShader::TileMode, const SkMatrix& localMatrix) const = 0;
+                                         SkTileMode, const SkMatrix& localMatrix) const = 0;
 
 private:
     using StopPositionArray = SkSTArray<2, SkScalar, true>;
diff --git a/experimental/svg/model/SkSVGLinearGradient.cpp b/experimental/svg/model/SkSVGLinearGradient.cpp
index 14939d1..63aeebb 100644
--- a/experimental/svg/model/SkSVGLinearGradient.cpp
+++ b/experimental/svg/model/SkSVGLinearGradient.cpp
@@ -57,7 +57,7 @@
 
 sk_sp<SkShader> SkSVGLinearGradient::onMakeShader(const SkSVGRenderContext& ctx,
                                                   const SkColor* colors, const SkScalar* pos,
-                                                  int count, SkShader::TileMode tm,
+                                                  int count, SkTileMode tm,
                                                   const SkMatrix& localMatrix) const {
     const auto& lctx = ctx.lengthContext();
     const auto x1 = lctx.resolve(fX1, SkSVGLengthContext::LengthType::kHorizontal);
diff --git a/experimental/svg/model/SkSVGLinearGradient.h b/experimental/svg/model/SkSVGLinearGradient.h
index e878baf..923c79b 100644
--- a/experimental/svg/model/SkSVGLinearGradient.h
+++ b/experimental/svg/model/SkSVGLinearGradient.h
@@ -28,7 +28,7 @@
 
     sk_sp<SkShader> onMakeShader(const SkSVGRenderContext&,
                                  const SkColor*, const SkScalar*, int count,
-                                 SkShader::TileMode, const SkMatrix&) const override;
+                                 SkTileMode, const SkMatrix&) const override;
 private:
     SkSVGLinearGradient();
 
diff --git a/experimental/svg/model/SkSVGPattern.cpp b/experimental/svg/model/SkSVGPattern.cpp
index ef334d7..ffed054 100644
--- a/experimental/svg/model/SkSVGPattern.cpp
+++ b/experimental/svg/model/SkSVGPattern.cpp
@@ -161,9 +161,9 @@
     // Cannot call into INHERITED:: because SkSVGHiddenContainer skips rendering.
     contentNode->SkSVGContainer::onRender(recordingContext);
 
-    paint->setShader(SkShader::MakePictureShader(recorder.finishRecordingAsPicture(),
-                                                 SkShader::kRepeat_TileMode,
-                                                 SkShader::kRepeat_TileMode,
+    paint->setShader(recorder.finishRecordingAsPicture()->makeShader(
+                                                 SkTileMode::kRepeat,
+                                                 SkTileMode::kRepeat,
                                                  patternTransform,
                                                  &tile));
     return true;
diff --git a/experimental/svg/model/SkSVGRadialGradient.cpp b/experimental/svg/model/SkSVGRadialGradient.cpp
index c719693..b1011a2 100644
--- a/experimental/svg/model/SkSVGRadialGradient.cpp
+++ b/experimental/svg/model/SkSVGRadialGradient.cpp
@@ -66,7 +66,7 @@
 
 sk_sp<SkShader> SkSVGRadialGradient::onMakeShader(const SkSVGRenderContext& ctx,
                                                   const SkColor* colors, const SkScalar* pos,
-                                                  int count, SkShader::TileMode tm,
+                                                  int count, SkTileMode tm,
                                                   const SkMatrix& m) const {
     const auto&  lctx = ctx.lengthContext();
     const auto      r = lctx.resolve(fR , SkSVGLengthContext::LengthType::kOther);
diff --git a/experimental/svg/model/SkSVGRadialGradient.h b/experimental/svg/model/SkSVGRadialGradient.h
index f277b65..e71947a 100644
--- a/experimental/svg/model/SkSVGRadialGradient.h
+++ b/experimental/svg/model/SkSVGRadialGradient.h
@@ -29,7 +29,7 @@
 
     sk_sp<SkShader> onMakeShader(const SkSVGRenderContext&,
                                  const SkColor*, const SkScalar*, int count,
-                                 SkShader::TileMode, const SkMatrix&) const override;
+                                 SkTileMode, const SkMatrix&) const override;
 private:
     SkSVGRadialGradient();
 
diff --git a/fuzz/FuzzCanvas.cpp b/fuzz/FuzzCanvas.cpp
index 54b9b20..c88fddf 100644
--- a/fuzz/FuzzCanvas.cpp
+++ b/fuzz/FuzzCanvas.cpp
@@ -190,7 +190,7 @@
     sk_sp<SkColorFilter> colorFilter(nullptr);
     SkBitmap bitmap;
     sk_sp<SkImage> img;
-    SkShader::TileMode tmX, tmY;
+    SkTileMode tmX, tmY;
     bool useMatrix;
     SkColor color;
     SkMatrix matrix;
@@ -210,8 +210,8 @@
             return SkShader::MakeColorShader(color);
         case 3:
             img = make_fuzz_image(fuzz);
-            fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
-            fuzz->nextRange(&tmY, 0, SkShader::TileMode::kLast_TileMode);
+            fuzz->nextRange(&tmX, 0, SkTileMode::kLastTileMode);
+            fuzz->nextRange(&tmY, 0, SkTileMode::kLastTileMode);
             fuzz->next(&useMatrix);
             if (useMatrix) {
                 FuzzNiceMatrix(fuzz, &matrix);
@@ -219,8 +219,8 @@
             return img->makeShader(tmX, tmY, useMatrix ? &matrix : nullptr);
         case 4:
             bitmap = make_fuzz_bitmap(fuzz);
-            fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
-            fuzz->nextRange(&tmY, 0, SkShader::TileMode::kLast_TileMode);
+            fuzz->nextRange(&tmX, 0, SkTileMode::kLastTileMode);
+            fuzz->nextRange(&tmY, 0, SkTileMode::kLastTileMode);
             fuzz->next(&useMatrix);
             if (useMatrix) {
                 FuzzNiceMatrix(fuzz, &matrix);
@@ -243,8 +243,8 @@
             auto pic = make_fuzz_picture(fuzz, depth - 1);
             bool useTile;
             SkRect tile;
-            fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
-            fuzz->nextRange(&tmY, 0, SkShader::TileMode::kLast_TileMode);
+            fuzz->nextRange(&tmX, 0, SkTileMode::kLastTileMode);
+            fuzz->nextRange(&tmY, 0, SkTileMode::kLastTileMode);
             fuzz->next(&useMatrix, &useTile);
             if (useMatrix) {
                 FuzzNiceMatrix(fuzz, &matrix);
@@ -252,9 +252,7 @@
             if (useTile) {
                 fuzz->next(&tile);
             }
-            return SkShader::MakePictureShader(std::move(pic), tmX, tmY,
-                                               useMatrix ? &matrix : nullptr,
-                                               useTile ? &tile : nullptr);
+            return pic->makeShader(tmX, tmY, useMatrix ? &matrix : nullptr, useTile ? &tile : nullptr);
         }
         // EFFECTS:
         case 9:
@@ -270,7 +268,7 @@
             fuzz->nextN(pts, 2);
             fuzz->nextRange(&colorCount, 2, kMaxColors);
             fuzz->nextN(colors, colorCount);
-            fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
+            fuzz->nextRange(&tmX, 0, SkTileMode::kLastTileMode);
             fuzz->next(&useMatrix, &usePos);
             if (useMatrix) {
                 FuzzNiceMatrix(fuzz, &matrix);
@@ -289,7 +287,7 @@
             bool usePos;
             SkColor colors[kMaxColors];
             SkScalar pos[kMaxColors];
-            fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
+            fuzz->nextRange(&tmX, 0, SkTileMode::kLastTileMode);
             fuzz->next(&useMatrix, &usePos, &center, &radius);
             fuzz->nextRange(&colorCount, 2, kMaxColors);
             fuzz->nextN(colors, colorCount);
@@ -310,7 +308,7 @@
             bool usePos;
             SkColor colors[kMaxColors];
             SkScalar pos[kMaxColors];
-            fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
+            fuzz->nextRange(&tmX, 0, SkTileMode::kLastTileMode);
             fuzz->next(&useMatrix, &usePos, &startRadius, &endRadius, &start, &end);
             fuzz->nextRange(&colorCount, 2, kMaxColors);
             fuzz->nextN(colors, colorCount);
diff --git a/fuzz/FuzzGradients.cpp b/fuzz/FuzzGradients.cpp
index 35b623a..92ff366 100644
--- a/fuzz/FuzzGradients.cpp
+++ b/fuzz/FuzzGradients.cpp
@@ -26,7 +26,7 @@
 }
 
 void initGradientParams(Fuzz* fuzz, std::vector<SkColor>* colors,
-                        std::vector<SkScalar>* pos, SkShader::TileMode* mode) {
+                        std::vector<SkScalar>* pos, SkTileMode* mode) {
     int count;
     fuzz->nextRange(&count, 0, MAX_COUNT);
 
@@ -34,7 +34,7 @@
     // smaller, which leads to more efficient fuzzing.
     uint8_t m;
     fuzz->nextRange(&m, 0, 2);
-    *mode = static_cast<SkShader::TileMode>(m);
+    *mode = static_cast<SkTileMode>(m);
 
     colors->clear();
     pos   ->clear();
@@ -68,7 +68,7 @@
 static void logLinearGradient(const SkPoint pts[2],
                               const std::vector<SkColor>& colors,
                               const std::vector<SkScalar> pos,
-                              SkShader::TileMode mode,
+                              SkTileMode mode,
                               uint32_t flags,
                               const SkMatrix* localMatrix,
                               const SkMatrix* globalMatrix) {
@@ -96,10 +96,10 @@
     SkDebugf("]\n");
 
     static const char* gModeName[] = {
-        "kClamp_TileMode", "kRepeat_TileMode", "kMirror_TileMode"
+        "kClamp_TileMode", "kRepeat_TileMode", "kMirror_TileMode", "kDecal_TileMode"
     };
-    SkASSERT(mode < SK_ARRAY_COUNT(gModeName));
-    SkDebugf("  mode:\t\t%s\n", gModeName[mode]);
+    SkASSERT((unsigned)mode < SK_ARRAY_COUNT(gModeName));
+    SkDebugf("  mode:\t\t%s\n", gModeName[(unsigned)mode]);
     SkDebugf("  flags:\t0x%x\n", flags);
     logOptionalMatrix("local matrix", localMatrix);
     logOptionalMatrix("global matrix", globalMatrix);
@@ -113,7 +113,7 @@
 
     std::vector<SkColor> colors;
     std::vector<SkScalar> pos;
-    SkShader::TileMode mode;
+    SkTileMode mode;
     initGradientParams(fuzz, &colors, &pos, &mode);
 
     SkPaint p;
@@ -151,7 +151,7 @@
 
     std::vector<SkColor> colors;
     std::vector<SkScalar> pos;
-    SkShader::TileMode mode;
+    SkTileMode mode;
     initGradientParams(fuzz, &colors, &pos, &mode);
 
     SkPaint p;
@@ -189,7 +189,7 @@
 
     std::vector<SkColor> colors;
     std::vector<SkScalar> pos;
-    SkShader::TileMode mode;
+    SkTileMode mode;
     initGradientParams(fuzz, &colors, &pos, &mode);
 
     SkPaint p;
@@ -223,7 +223,7 @@
 
     std::vector<SkColor> colors;
     std::vector<SkScalar> pos;
-    SkShader::TileMode mode;
+    SkTileMode mode;
     initGradientParams(fuzz, &colors, &pos, &mode);
 
     SkPaint p;
diff --git a/gm/aarectmodes.cpp b/gm/aarectmodes.cpp
index b9fa25d..dbb6afb 100644
--- a/gm/aarectmodes.cpp
+++ b/gm/aarectmodes.cpp
@@ -111,8 +111,7 @@
                                                              0xCF, 0xCE);
 
     const SkMatrix m = SkMatrix::MakeScale(SkIntToScalar(6), SkIntToScalar(6));
-    return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode,
-                                      &m);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
 }
 
 DEF_SIMPLE_GM(aarectmodes, canvas, 640, 480) {
diff --git a/gm/alphagradients.cpp b/gm/alphagradients.cpp
index fa9d3e2..f739f02 100644
--- a/gm/alphagradients.cpp
+++ b/gm/alphagradients.cpp
@@ -29,7 +29,7 @@
         SkPaint paint;
         uint32_t flags = doPreMul ? SkGradientShader::kInterpolateColorsInPremul_Flag : 0;
         paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                     SkShader::kClamp_TileMode, flags, nullptr));
+                                                     SkTileMode::kClamp, flags, nullptr));
         canvas->drawRect(r, paint);
 
         paint.setShader(nullptr);
diff --git a/gm/analytic_gradients.cpp b/gm/analytic_gradients.cpp
index df84b19..aeb17f3 100644
--- a/gm/analytic_gradients.cpp
+++ b/gm/analytic_gradients.cpp
@@ -162,7 +162,7 @@
                                 colors.get(),
                                 positions.get(),
                                 colorCount,
-                                SkShader::kClamp_TileMode,
+                                SkTileMode::kClamp,
                                 0,
                                 nullptr);
 
diff --git a/gm/arithmode.cpp b/gm/arithmode.cpp
index 7832be8..7ab5044 100644
--- a/gm/arithmode.cpp
+++ b/gm/arithmode.cpp
@@ -31,7 +31,7 @@
         SK_ColorRED, SK_ColorMAGENTA, SK_ColorWHITE,
     };
     paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas->drawPaint(paint);
     return surface->makeImageSnapshot();
 }
@@ -47,7 +47,7 @@
         SK_ColorGRAY,
     };
     paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas->drawPaint(paint);
     return surface->makeImageSnapshot();
 }
diff --git a/gm/badpaint.cpp b/gm/badpaint.cpp
index 85eaa1e..a1010b4 100644
--- a/gm/badpaint.cpp
+++ b/gm/badpaint.cpp
@@ -32,13 +32,13 @@
 
         // Empty bitmap.
         fPaints.push_back().setColor(SK_ColorGREEN);
-        fPaints.back().setShader(SkShader::MakeBitmapShader(emptyBmp, SkShader::kClamp_TileMode,
-                                                            SkShader::kClamp_TileMode));
+        fPaints.back().setShader(SkShader::MakeBitmapShader(emptyBmp, SkTileMode::kClamp,
+                                                            SkTileMode::kClamp));
 
         // Non-invertible local matrix.
         fPaints.push_back().setColor(SK_ColorGREEN);
-        fPaints.back().setShader(SkShader::MakeBitmapShader(blueBmp, SkShader::kClamp_TileMode,
-                                                            SkShader::kClamp_TileMode, &badMatrix));
+        fPaints.back().setShader(SkShader::MakeBitmapShader(blueBmp, SkTileMode::kClamp,
+                                                            SkTileMode::kClamp, &badMatrix));
     }
 
     void onDraw(SkCanvas* canvas) override {
diff --git a/gm/bigmatrix.cpp b/gm/bigmatrix.cpp
index ca62cc3..fc2ea95 100644
--- a/gm/bigmatrix.cpp
+++ b/gm/bigmatrix.cpp
@@ -54,8 +54,7 @@
     SkMatrix s;
     s.reset();
     s.setScale(SK_Scalar1 / 1000, SK_Scalar1 / 1000);
-    paint.setShader(SkShader::MakeBitmapShader(
-            bmp, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &s));
+    paint.setShader(SkShader::MakeBitmapShader(bmp, SkTileMode::kRepeat, SkTileMode::kRepeat, &s));
     paint.setAntiAlias(false);
     paint.setFilterQuality(kLow_SkFilterQuality);
     rect.setLTRB(pt.fX - small, pt.fY - small, pt.fX + small, pt.fY + small);
diff --git a/gm/bitmaprect.cpp b/gm/bitmaprect.cpp
index 190fb0d..67fdd53 100644
--- a/gm/bitmaprect.cpp
+++ b/gm/bitmaprect.cpp
@@ -23,8 +23,7 @@
     paint.setAntiAlias(true);
     const SkPoint pts[] = { { 0, 0 }, { 64, 64 } };
     const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
     canvas.drawCircle(32, 32, 32, paint);
 }
 
diff --git a/gm/bitmapshader.cpp b/gm/bitmapshader.cpp
index ce226f2..98c864b 100644
--- a/gm/bitmapshader.cpp
+++ b/gm/bitmapshader.cpp
@@ -67,8 +67,8 @@
             }
 
             canvas->save();
-            paint.setShader(SkShader::MakeBitmapShader(fBitmap, SkShader::kClamp_TileMode,
-                                                       SkShader::kClamp_TileMode, &s));
+            paint.setShader(SkShader::MakeBitmapShader(fBitmap, SkTileMode::kClamp,
+                                                       SkTileMode::kClamp, &s));
 
             // draw the shader with a bitmap mask
             canvas->drawBitmap(fMask, 0, 0, &paint);
@@ -90,8 +90,8 @@
 
             canvas->translate(0, 25);
 
-            paint.setShader(SkShader::MakeBitmapShader(fMask, SkShader::kRepeat_TileMode,
-                                                       SkShader::kRepeat_TileMode, &s));
+            paint.setShader(SkShader::MakeBitmapShader(fMask, SkTileMode::kRepeat,
+                                                       SkTileMode::kRepeat, &s));
             paint.setColor(SK_ColorRED);
 
             // draw the mask using the shader and a color
@@ -129,8 +129,7 @@
     }
     bitmap.setPixels(pixels);
 
-    paint.setShader(SkShader::MakeBitmapShader(bitmap,
-             SkShader::kMirror_TileMode, SkShader::kMirror_TileMode));
+    paint.setShader(SkShader::MakeBitmapShader(bitmap, SkTileMode::kMirror, SkTileMode::kMirror));
     paint.setColor(SK_ColorRED);
     paint.setAntiAlias(true);
     canvas->drawCircle(50, 50, 50, paint);
diff --git a/gm/bleed.cpp b/gm/bleed.cpp
index ab7ca99..485a3d8 100644
--- a/gm/bleed.cpp
+++ b/gm/bleed.cpp
@@ -157,7 +157,7 @@
 static sk_sp<SkShader> make_shader() {
     constexpr SkPoint pts[] = { {0, 0}, {20, 20} };
     constexpr SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kMirror);
 }
 
 static sk_sp<SkShader> make_null_shader() { return nullptr; }
diff --git a/gm/blurrect.cpp b/gm/blurrect.cpp
index c2724bd..2000f08 100644
--- a/gm/blurrect.cpp
+++ b/gm/blurrect.cpp
@@ -64,7 +64,7 @@
         { 0, 0 },
         { SkIntToScalar(100), SkIntToScalar(100) }
     };
-    SkShader::TileMode tm = SkShader::kClamp_TileMode;
+    SkTileMode tm = SkTileMode::kClamp;
     const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, };
     const SkScalar pos[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
     SkMatrix scale;
diff --git a/gm/blurroundrect.cpp b/gm/blurroundrect.cpp
index b7d0800..f6fb832 100644
--- a/gm/blurroundrect.cpp
+++ b/gm/blurroundrect.cpp
@@ -93,7 +93,7 @@
         { 0, 0 },
         { SkIntToScalar(100), SkIntToScalar(100) }
     };
-    SkShader::TileMode tm = SkShader::kClamp_TileMode;
+    SkTileMode tm = SkTileMode::kClamp;
     const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, };
     const SkScalar pos[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
     SkMatrix scale;
diff --git a/gm/bmpfilterqualityrepeat.cpp b/gm/bmpfilterqualityrepeat.cpp
index ee4529f..071b319 100644
--- a/gm/bmpfilterqualityrepeat.cpp
+++ b/gm/bmpfilterqualityrepeat.cpp
@@ -73,7 +73,7 @@
         SkAutoCanvasRestore acr(canvas, true);
 
         for (size_t q = 0; q < SK_ARRAY_COUNT(kQualities); ++q) {
-            constexpr SkShader::TileMode kTM = SkShader::kRepeat_TileMode;
+            constexpr SkTileMode kTM = SkTileMode::kRepeat;
             bmpPaint.setShader(SkShader::MakeBitmapShader(fBmp, kTM, kTM, &lm));
             bmpPaint.setFilterQuality(kQualities[q].fQuality);
             canvas->drawRect(rect, bmpPaint);
diff --git a/gm/bug6643.cpp b/gm/bug6643.cpp
index abe79fa..c30d898 100644
--- a/gm/bug6643.cpp
+++ b/gm/bug6643.cpp
@@ -21,9 +21,8 @@
     SkPictureRecorder recorder;
     recorder.beginRecording(200, 200)->drawPaint(p);
 
-    p.setShader(SkShader::MakePictureShader(recorder.finishRecordingAsPicture(),
-                                            SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode,
-                                            nullptr, nullptr));
+    p.setShader(recorder.finishRecordingAsPicture()->makeShader(
+                                            SkTileMode::kRepeat, SkTileMode::kRepeat));
     canvas->drawColor(SK_ColorWHITE);
     canvas->drawPaint(p);
 }
diff --git a/gm/bug6783.cpp b/gm/bug6783.cpp
index 5b54e1c..ba8b77b 100644
--- a/gm/bug6783.cpp
+++ b/gm/bug6783.cpp
@@ -42,6 +42,6 @@
     p.setFilterQuality(kLow_SkFilterQuality);
 
     // It's only important to repeat or mirror in x to show off the bug.
-    p.setShader(img->makeShader(SkShader::kRepeat_TileMode, SkShader::kClamp_TileMode, &m));
+    p.setShader(img->makeShader(SkTileMode::kRepeat, SkTileMode::kClamp, &m));
     canvas->drawPaint(p);
 }
diff --git a/gm/circles.cpp b/gm/circles.cpp
index 9127c0a..01bf851 100644
--- a/gm/circles.cpp
+++ b/gm/circles.cpp
@@ -66,7 +66,7 @@
         SkColor colors[] = { SK_ColorBLUE, SK_ColorRED, SK_ColorGREEN };
         SkScalar pos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
         p.setShader(SkGradientShader::MakeRadial(center, 20, colors, pos, SK_ARRAY_COUNT(colors),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
         fPaints.push_back(p);
         }
 
diff --git a/gm/clippedbitmapshaders.cpp b/gm/clippedbitmapshaders.cpp
index b421800..583abb7 100644
--- a/gm/clippedbitmapshaders.cpp
+++ b/gm/clippedbitmapshaders.cpp
@@ -42,28 +42,29 @@
 
 class ClippedBitmapShadersGM : public GM {
 public:
-    ClippedBitmapShadersGM(SkShader::TileMode mode, bool hq=false)
+    ClippedBitmapShadersGM(SkTileMode mode, bool hq=false)
     : fMode(mode), fHQ(hq) {
     }
 
 protected:
-    SkShader::TileMode fMode;
+    SkTileMode fMode;
     bool fHQ;
 
     virtual SkString onShortName() {
         SkString descriptor;
         switch (fMode) {
-            case SkShader::kRepeat_TileMode:
+            case SkTileMode::kRepeat:
                 descriptor = "tile";
             break;
-            case SkShader::kMirror_TileMode:
+            case SkTileMode::kMirror:
                 descriptor = "mirror";
             break;
-            case SkShader::kClamp_TileMode:
+            case SkTileMode::kClamp:
                 descriptor = "clamp";
             break;
-            default:
-                SkASSERT(false);
+            case SkTileMode::kDecal:
+                descriptor = "decal";
+                break;
         }
         descriptor.prepend("clipped-bitmap-shaders-");
         if (fHQ) {
@@ -113,13 +114,13 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-DEF_GM( return new ClippedBitmapShadersGM(SkShader::kRepeat_TileMode); )
-DEF_GM( return new ClippedBitmapShadersGM(SkShader::kMirror_TileMode); )
-DEF_GM( return new ClippedBitmapShadersGM(SkShader::kClamp_TileMode); )
+DEF_GM( return new ClippedBitmapShadersGM(SkTileMode::kRepeat); )
+DEF_GM( return new ClippedBitmapShadersGM(SkTileMode::kMirror); )
+DEF_GM( return new ClippedBitmapShadersGM(SkTileMode::kClamp); )
 
-DEF_GM( return new ClippedBitmapShadersGM(SkShader::kRepeat_TileMode, true); )
-DEF_GM( return new ClippedBitmapShadersGM(SkShader::kMirror_TileMode, true); )
-DEF_GM( return new ClippedBitmapShadersGM(SkShader::kClamp_TileMode, true); )
+DEF_GM( return new ClippedBitmapShadersGM(SkTileMode::kRepeat, true); )
+DEF_GM( return new ClippedBitmapShadersGM(SkTileMode::kMirror, true); )
+DEF_GM( return new ClippedBitmapShadersGM(SkTileMode::kClamp, true); )
 
 
 }
diff --git a/gm/coloremoji.cpp b/gm/coloremoji.cpp
index a64ca07..d393cdc 100644
--- a/gm/coloremoji.cpp
+++ b/gm/coloremoji.cpp
@@ -27,7 +27,7 @@
     constexpr SkScalar    kPos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
     constexpr SkColor kColors[] = {0x80F00080, 0xF0F08000, 0x800080F0 };
     return SkGradientShader::MakeLinear(kPts, kColors, kPos, SK_ARRAY_COUNT(kColors),
-                                        SkShader::kClamp_TileMode);
+                                        SkTileMode::kClamp);
 }
 
 static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) {
diff --git a/gm/coloremoji_blendmodes.cpp b/gm/coloremoji_blendmodes.cpp
index 57febb9..b3f3f13 100644
--- a/gm/coloremoji_blendmodes.cpp
+++ b/gm/coloremoji_blendmodes.cpp
@@ -108,8 +108,7 @@
         const SkScalar h = SkIntToScalar(H);
         SkMatrix m;
         m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-        auto s = SkShader::MakeBitmapShader(fBG, SkShader::kRepeat_TileMode,
-                                            SkShader::kRepeat_TileMode, &m);
+        auto s = SkShader::MakeBitmapShader(fBG, SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
 
         SkFont labelFont(ToolUtils::create_portable_typeface());
 
diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp
index e83d228..0559715 100644
--- a/gm/colorfilterimagefilter.cpp
+++ b/gm/colorfilterimagefilter.cpp
@@ -59,13 +59,13 @@
 static sk_sp<SkShader> sh_make_lineargradient0() {
     const SkPoint pts[] = { { 0, 0 }, { 100, 100 } };
     const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkShader::kRepeat_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkTileMode::kRepeat);
 }
 
 static sk_sp<SkShader> sh_make_lineargradient1() {
     const SkPoint pts[] = { { 0, 0 }, { 100, 100 } };
     const SkColor colors[] = { SK_ColorRED, 0x0000FF00, SK_ColorBLUE };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkShader::kRepeat_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkTileMode::kRepeat);
 }
 
 static sk_sp<SkShader> sh_make_image() {
@@ -73,7 +73,7 @@
     if (!image) {
         return nullptr;
     }
-    return image->makeShader(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
+    return image->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat);
 }
 
 static void sk_gm_get_shaders(SkTDArray<SkShader*>* array) {
@@ -205,7 +205,7 @@
     const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
     *shaders.append() = SkGradientShader::MakeTwoPointConical({0, 0}, 50, {0, 0}, 150,
                                                               colors, nullptr, 2,
-                                                              SkShader::kClamp_TileMode).release();
+                                                              SkTileMode::kClamp).release();
 
     SkPaint paint;
     SkRect r = SkRect::MakeWH(120, 120);
@@ -228,11 +228,11 @@
 }
 
 template <typename Maker> void do_mixershader(SkCanvas* canvas, Maker&& maker) {
-    auto shaderA = GetResourceAsImage("images/mandrill_128.png")->makeShader(SkShader::kClamp_TileMode,
-                                                                             SkShader::kClamp_TileMode);
+    auto shaderA = GetResourceAsImage("images/mandrill_128.png")->makeShader(SkTileMode::kClamp,
+                                                                             SkTileMode::kClamp);
     const SkColor colors[] = { SK_ColorGREEN, 0 };
     auto shaderB = SkGradientShader::MakeRadial({60, 60}, 55, colors, nullptr, 2,
-                                                SkShader::kClamp_TileMode,
+                                                SkTileMode::kClamp,
                                                 SkGradientShader::kInterpolateColorsInPremul_Flag,
                                                 nullptr);
     const SkBlendMode modes[] = {
diff --git a/gm/colorfilters.cpp b/gm/colorfilters.cpp
index 2accf53..b0d529a 100644
--- a/gm/colorfilters.cpp
+++ b/gm/colorfilters.cpp
@@ -20,7 +20,7 @@
         SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW,
     };
     return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                        SkShader::kClamp_TileMode);
+                                        SkTileMode::kClamp);
 }
 
 typedef void (*InstallPaint)(SkPaint*, uint32_t, uint32_t);
diff --git a/gm/colormatrix.cpp b/gm/colormatrix.cpp
index cd49168..c2dccfe 100644
--- a/gm/colormatrix.cpp
+++ b/gm/colormatrix.cpp
@@ -68,7 +68,7 @@
         SkColor colors[] = {0x00000000, 0xFFFFFFFF};
         SkPaint paint;
         paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                     SkShader::kClamp_TileMode));
+                                                     SkTileMode::kClamp));
         canvas.drawRect(SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)), paint);
         return SkImage::MakeFromBitmap(bm);
     }
diff --git a/gm/composeshader.cpp b/gm/composeshader.cpp
index 621b0bf..53003d0 100644
--- a/gm/composeshader.cpp
+++ b/gm/composeshader.cpp
@@ -24,13 +24,13 @@
     pts[1].set(SkIntToScalar(100), 0);
     colors[0] = SK_ColorRED;
     colors[1] = SK_ColorBLUE;
-    auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 
     pts[0].set(0, 0);
     pts[1].set(0, SkIntToScalar(100));
     colors[0] = SK_ColorBLACK;
     colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
-    auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 
     return SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB), mode);
 }
@@ -147,7 +147,7 @@
     pts[1].set(SkIntToScalar(length), 0);
     colors[0] = SK_ColorBLUE;
     colors[1] = SkColorSetARGB(0, 0, 0, 0xFF);
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 
@@ -161,10 +161,10 @@
         draw_alpha8_bm(&fAlpha8Bitmap, squareLength);
         SkMatrix s;
         s.reset();
-        fColorBitmapShader = SkShader::MakeBitmapShader(fColorBitmap, SkShader::kRepeat_TileMode,
-                                                        SkShader::kRepeat_TileMode, &s);
-        fAlpha8BitmapShader = SkShader::MakeBitmapShader(fAlpha8Bitmap, SkShader::kRepeat_TileMode,
-                                                         SkShader::kRepeat_TileMode, &s);
+        fColorBitmapShader = SkShader::MakeBitmapShader(fColorBitmap, SkTileMode::kRepeat,
+                                                        SkTileMode::kRepeat, &s);
+        fAlpha8BitmapShader = SkShader::MakeBitmapShader(fAlpha8Bitmap, SkTileMode::kRepeat,
+                                                         SkTileMode::kRepeat, &s);
         fLinearGradientShader = make_linear_gradient_shader(squareLength);
     }
 
@@ -263,13 +263,13 @@
 static sk_sp<SkShader> make_src_shader(SkScalar size) {
     const SkPoint pts[] = { { 0, 0 }, { 0, size } };
     const SkColor colors[] = { 0xFF0000FF, 0x000000FF };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 static sk_sp<SkShader> make_dst_shader(SkScalar size) {
     const SkPoint pts[] = { { 0, 0 }, { size, 0 } };
     const SkColor colors[] = { SK_ColorRED, 0x00FF0000 };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 const SkScalar gCellSize = 100;
diff --git a/gm/compositor_quads.cpp b/gm/compositor_quads.cpp
index f7d7479..44f127a 100644
--- a/gm/compositor_quads.cpp
+++ b/gm/compositor_quads.cpp
@@ -976,7 +976,7 @@
     static constexpr SkPoint kPts[] = { {0.f, 0.f}, {0.25f * kTileWidth, 0.25f * kTileHeight} };
     static constexpr SkColor kColors[] = { SK_ColorBLUE, SK_ColorWHITE };
     auto gradient = SkGradientShader::MakeLinear(kPts, kColors, nullptr, 2,
-                                                 SkShader::kMirror_TileMode);
+                                                 SkTileMode::kMirror);
 
     auto info = SkImageInfo::Make(1, 1, kAlpha_8_SkColorType, kOpaque_SkAlphaType);
     SkBitmap bm;
@@ -1012,7 +1012,7 @@
     static constexpr SkColor kAlphas[] = { SK_ColorTRANSPARENT, SK_ColorBLACK };
     auto alphaGradient = SkGradientShader::MakeRadial(
             {0.5f * kTileWidth * kColCount, 0.5f * kTileHeight * kRowCount},
-            0.25f * kTileWidth * kColCount, kAlphas, nullptr, 2, SkShader::kClamp_TileMode);
+            0.25f * kTileWidth * kColCount, kAlphas, nullptr, 2, SkTileMode::kClamp);
     sk_sp<SkMaskFilter> maskFilter = SkShaderMaskFilter::Make(std::move(alphaGradient));
 
     SkTArray<sk_sp<ClipTileRenderer>> renderers;
diff --git a/gm/constcolorprocessor.cpp b/gm/constcolorprocessor.cpp
index 2fbfb15..98b5446 100644
--- a/gm/constcolorprocessor.cpp
+++ b/gm/constcolorprocessor.cpp
@@ -41,7 +41,7 @@
         SkColor colors[] = { 0xFFFF0000, 0x2000FF00, 0xFF0000FF};
         SkPoint pts[] = { SkPoint::Make(0, 0), SkPoint::Make(kRectSize, kRectSize) };
         fShader = SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                               SkShader::kClamp_TileMode);
+                                               SkTileMode::kClamp);
     }
 
     void onDraw(GrContext* context, GrRenderTargetContext* renderTargetContext,
diff --git a/gm/convexpolyclip.cpp b/gm/convexpolyclip.cpp
index e18de26..d531b66 100644
--- a/gm/convexpolyclip.cpp
+++ b/gm/convexpolyclip.cpp
@@ -50,7 +50,7 @@
                         pt, radius,
                         colors, pos,
                         SK_ARRAY_COUNT(colors),
-                        SkShader::kRepeat_TileMode,
+                        SkTileMode::kRepeat,
                         0, &mat));
         canvas.drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
diff --git a/gm/crbug_938592.cpp b/gm/crbug_938592.cpp
index fdd6504..0284cd9 100644
--- a/gm/crbug_938592.cpp
+++ b/gm/crbug_938592.cpp
@@ -22,7 +22,7 @@
     static constexpr SkColor c1 = SK_ColorRED;
     static constexpr SkColor c2 = SK_ColorGREEN;
     static constexpr SkColor colors[] = {c0, c0, c1, c1, c2, c2};
-    auto grad = SkGradientShader::MakeLinear(pts, colors, pos, 6, SkShader::kClamp_TileMode);
+    auto grad = SkGradientShader::MakeLinear(pts, colors, pos, 6, SkTileMode::kClamp);
     SkPaint paint;
     paint.setShader(grad);
     static constexpr int kMirrorX = 400;
diff --git a/gm/drawatlas.cpp b/gm/drawatlas.cpp
index 5ee6d39..ec9ef05 100644
--- a/gm/drawatlas.cpp
+++ b/gm/drawatlas.cpp
@@ -157,7 +157,7 @@
 static sk_sp<SkShader> make_shader() {
     SkPoint pts[2] = {{0, 0}, {220, 0}};
     SkColor colors[2] = {SK_ColorRED, SK_ColorBLUE};
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kMirror);
 }
 
 static void drawTextPath(SkCanvas* canvas, bool doStroke) {
diff --git a/gm/drawbitmaprect.cpp b/gm/drawbitmaprect.cpp
index 4d4204c..ebc768e 100644
--- a/gm/drawbitmaprect.cpp
+++ b/gm/drawbitmaprect.cpp
@@ -67,7 +67,7 @@
                         pt, radius,
                         colors, pos,
                         SK_ARRAY_COUNT(colors),
-                        SkShader::kRepeat_TileMode,
+                        SkTileMode::kRepeat,
                         0, &mat));
         canvas->drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
diff --git a/gm/drawimageset.cpp b/gm/drawimageset.cpp
index edd27b1..e204cbb 100644
--- a/gm/drawimageset.cpp
+++ b/gm/drawimageset.cpp
@@ -26,7 +26,7 @@
     SkPaint paint;
 
     SkPoint pts1[] = {{0.f, 0.f}, {(SkScalar)w, (SkScalar)h}};
-    auto grad = SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    auto grad = SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkTileMode::kClamp);
     paint.setShader(std::move(grad));
     paint.setAntiAlias(true);
     paint.setStyle(SkPaint::kStroke_Style);
@@ -39,7 +39,7 @@
     }
 
     SkPoint pts2[] = {{0.f, (SkScalar)h}, {(SkScalar)w, 0.f}};
-    grad = SkGradientShader::MakeLinear(pts2, colors + 2, nullptr, 2, SkShader::kClamp_TileMode);
+    grad = SkGradientShader::MakeLinear(pts2, colors + 2, nullptr, 2, SkTileMode::kClamp);
     paint.setShader(std::move(grad));
     paint.setBlendMode(SkBlendMode::kMultiply);
     stripePts[0] = {-w - kStripeW, h + kStripeW};
diff --git a/gm/drawminibitmaprect.cpp b/gm/drawminibitmaprect.cpp
index be842dc..c8a875d 100644
--- a/gm/drawminibitmaprect.cpp
+++ b/gm/drawminibitmaprect.cpp
@@ -48,7 +48,7 @@
                         pt, radius,
                         colors, pos,
                         SK_ARRAY_COUNT(colors),
-                        SkShader::kRepeat_TileMode,
+                        SkTileMode::kRepeat,
                         0, &mat));
         canvas->drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
diff --git a/gm/drawquadset.cpp b/gm/drawquadset.cpp
index e198bdc..8b22fc5 100644
--- a/gm/drawquadset.cpp
+++ b/gm/drawquadset.cpp
@@ -33,7 +33,7 @@
 
     GrContext* context = canvas->getGrContext();
 
-    auto gradient = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
+    auto gradient = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kMirror);
     SkPaint paint;
     paint.setShader(gradient);
 
diff --git a/gm/drawregionmodes.cpp b/gm/drawregionmodes.cpp
index 0a8a2ba..d0ecfb4 100644
--- a/gm/drawregionmodes.cpp
+++ b/gm/drawregionmodes.cpp
@@ -68,7 +68,7 @@
         SkPoint points[] = { SkPoint::Make(50.0f, 50.0f), SkPoint::Make(150.0f, 150.0f) };
         SkColor colors[] = { SK_ColorBLUE, SK_ColorYELLOW };
         paint.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 2,
-                                                     SkShader::kClamp_TileMode));
+                                                     SkTileMode::kClamp));
         canvas->drawRegion(fRegion, paint);
     }
 
diff --git a/gm/filltypespersp.cpp b/gm/filltypespersp.cpp
index 01c930d..10ca319 100644
--- a/gm/filltypespersp.cpp
+++ b/gm/filltypespersp.cpp
@@ -60,7 +60,7 @@
                                                      colors,
                                                      pos,
                                                      SK_ARRAY_COUNT(colors),
-                                                     SkShader::kClamp_TileMode));
+                                                     SkTileMode::kClamp));
         paint.setAntiAlias(aa);
 
         showPath(canvas,   0,   0, SkPath::kWinding_FillType,
@@ -89,7 +89,7 @@
                                                       colors,
                                                       pos,
                                                       SK_ARRAY_COUNT(colors),
-                                                      SkShader::kClamp_TileMode));
+                                                      SkTileMode::kClamp));
         canvas->save();
             canvas->translate(SkIntToScalar(100), SkIntToScalar(100));
             SkMatrix mat;
diff --git a/gm/gamma.cpp b/gm/gamma.cpp
index e211db6..534f518 100644
--- a/gm/gamma.cpp
+++ b/gm/gamma.cpp
@@ -18,7 +18,7 @@
     const int szInt = SkScalarTruncToInt(sz);
     const SkScalar tx = sz + 15.0f;
     const SkRect r = SkRect::MakeXYWH(0, 0, sz, sz);
-    SkShader::TileMode rpt = SkShader::kRepeat_TileMode;
+    SkTileMode rpt = SkTileMode::kRepeat;
     auto srgbColorSpace = SkColorSpace::MakeSRGB();
 
     SkBitmap ditherBmp;
@@ -141,8 +141,7 @@
             SkPoint::Make(sz + (sz * 10), 0)
         };
         SkColor colors[2] = { SK_ColorBLACK, SK_ColorWHITE };
-        p.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+        p.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 2, SkTileMode::kClamp));
         nextRect("Gradient", "Interpolation");
     }
 
@@ -154,8 +153,7 @@
             SkPoint::Make(sz, 0)
         };
         SkColor colors[2] = { 0xffbbbbbb, 0xffbdbdbd };
-        p.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+        p.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 2, SkTileMode::kClamp));
         nextRect("Gradient", "Endpoints");
     }
 
@@ -167,8 +165,7 @@
             SkPoint::Make(sz, 0)
         };
         SkColor colors[3] = { 0xffbbbbbb, 0xffbdbdbd, 0xffbbbbbb };
-        p.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 3,
-                                                 SkShader::kClamp_TileMode));
+        p.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 3, SkTileMode::kClamp));
         nextRect("Gradient", "3-Stop");
     }
 
@@ -180,8 +177,7 @@
             SkPoint::Make(sz, 0)
         };
         SkColor colors[5] = { 0xffbbbbbb, 0xffbdbdbd, 0xffbbbbbb, 0xffbdbdbd, 0xffbbbbbb };
-        p.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 5,
-                                                 SkShader::kClamp_TileMode));
+        p.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 5, SkTileMode::kClamp));
         nextRect("Gradient", "Texture");
     }
 
diff --git a/gm/gammatext.cpp b/gm/gammatext.cpp
index ef1c8b9..ce20219 100644
--- a/gm/gammatext.cpp
+++ b/gm/gammatext.cpp
@@ -15,8 +15,7 @@
 static sk_sp<SkShader> make_heatGradient(const SkPoint pts[2]) {
     const SkColor bw[] = { SK_ColorBLACK, SK_ColorWHITE };
 
-    return SkGradientShader::MakeLinear(pts, bw, nullptr, SK_ARRAY_COUNT(bw),
-                                        SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, bw, nullptr, SK_ARRAY_COUNT(bw), SkTileMode::kClamp);
 }
 
 /**
@@ -91,7 +90,7 @@
     SkColor colors[2];
     colors[0] = c;
     colors[1] = SkColorSetA(c, 0);
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 static void draw_pair(SkCanvas* canvas, const SkFont& font, SkColor color,
diff --git a/gm/giantbitmap.cpp b/gm/giantbitmap.cpp
index 37b76a6..03a6b5d 100644
--- a/gm/giantbitmap.cpp
+++ b/gm/giantbitmap.cpp
@@ -20,7 +20,7 @@
 
 class GiantBitmapGM : public skiagm::GM {
     SkBitmap* fBM;
-    SkShader::TileMode fMode;
+    SkTileMode fMode;
     bool fDoFilter;
     bool fDoRotate;
 
@@ -60,7 +60,7 @@
     }
 
 public:
-    GiantBitmapGM(SkShader::TileMode mode, bool doFilter, bool doRotate) : fBM(nullptr) {
+    GiantBitmapGM(SkTileMode mode, bool doFilter, bool doRotate) : fBM(nullptr) {
         fMode = mode;
         fDoFilter = doFilter;
         fDoRotate = doRotate;
@@ -73,15 +73,18 @@
     SkString onShortName() override {
         SkString str("giantbitmap_");
         switch (fMode) {
-            case SkShader::kClamp_TileMode:
+            case SkTileMode::kClamp:
                 str.append("clamp");
                 break;
-            case SkShader::kRepeat_TileMode:
+            case SkTileMode::kRepeat:
                 str.append("repeat");
                 break;
-            case SkShader::kMirror_TileMode:
+            case SkTileMode::kMirror:
                 str.append("mirror");
                 break;
+            case SkTileMode::kDecal:
+                str.append("decal");
+                break;
             default:
                 break;
         }
@@ -120,16 +123,16 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_GM( return new GiantBitmapGM(SkShader::kClamp_TileMode, false, false); )
-DEF_GM( return new GiantBitmapGM(SkShader::kRepeat_TileMode, false, false); )
-DEF_GM( return new GiantBitmapGM(SkShader::kMirror_TileMode, false, false); )
-DEF_GM( return new GiantBitmapGM(SkShader::kClamp_TileMode, true, false); )
-DEF_GM( return new GiantBitmapGM(SkShader::kRepeat_TileMode, true, false); )
-DEF_GM( return new GiantBitmapGM(SkShader::kMirror_TileMode, true, false); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kClamp, false, false); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kRepeat, false, false); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kMirror, false, false); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kClamp, true, false); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kRepeat, true, false); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kMirror, true, false); )
 
-DEF_GM( return new GiantBitmapGM(SkShader::kClamp_TileMode, false, true); )
-DEF_GM( return new GiantBitmapGM(SkShader::kRepeat_TileMode, false, true); )
-DEF_GM( return new GiantBitmapGM(SkShader::kMirror_TileMode, false, true); )
-DEF_GM( return new GiantBitmapGM(SkShader::kClamp_TileMode, true, true); )
-DEF_GM( return new GiantBitmapGM(SkShader::kRepeat_TileMode, true, true); )
-DEF_GM( return new GiantBitmapGM(SkShader::kMirror_TileMode, true, true); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kClamp, false, true); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kRepeat, false, true); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kMirror, false, true); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kClamp, true, true); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kRepeat, true, true); )
+DEF_GM( return new GiantBitmapGM(SkTileMode::kMirror, true, true); )
diff --git a/gm/gm.cpp b/gm/gm.cpp
index a3c8f05..59983a1 100644
--- a/gm/gm.cpp
+++ b/gm/gm.cpp
@@ -46,7 +46,7 @@
     localM.setRotate(35.f);
     localM.postTranslate(10.f, 0.f);
     paint.setShader(SkShader::MakeBitmapShader(
-            bmp, SkShader::kMirror_TileMode, SkShader::kMirror_TileMode, &localM));
+            bmp, SkTileMode::kMirror, SkTileMode::kMirror, &localM));
     paint.setFilterQuality(kMedium_SkFilterQuality);
     canvas->drawPaint(paint);
 }
diff --git a/gm/gradientDirtyLaundry.cpp b/gm/gradientDirtyLaundry.cpp
index b7f78d3..f2e17fb 100644
--- a/gm/gradientDirtyLaundry.cpp
+++ b/gm/gradientDirtyLaundry.cpp
@@ -34,22 +34,22 @@
     //  { 2, gCol2, nullptr },
 };
 
-static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     const SkPoint pt{ SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY) };
     return SkGradientShader::MakeRadial(pt, pt.fX, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode) {
+static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkTileMode) {
     const SkPoint pt{ SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY) };
     return SkGradientShader::MakeSweep(pt.fX, pt.fY, data.fColors, data.fPos, data.fCount);
 }
 
 
-typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData&, SkShader::TileMode);
+typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData&, SkTileMode);
 
 constexpr GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep,
@@ -71,7 +71,7 @@
         SkPoint pts[2] = { { 0, 0 },
                            { SkIntToScalar(100), SkIntToScalar(100) }
         };
-        SkShader::TileMode tm = SkShader::kClamp_TileMode;
+        SkTileMode tm = SkTileMode::kClamp;
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
         SkPaint paint;
         paint.setAntiAlias(true);
diff --git a/gm/gradient_matrix.cpp b/gm/gradient_matrix.cpp
index 22cd316..6f33502 100644
--- a/gm/gradient_matrix.cpp
+++ b/gm/gradient_matrix.cpp
@@ -63,7 +63,7 @@
 
 static sk_sp<SkShader> make_linear_gradient(const SkPoint pts[2], const SkMatrix& localMatrix) {
     return SkGradientShader::MakeLinear(pts, gColors, nullptr, SK_ARRAY_COUNT(gColors),
-                                        SkShader::kClamp_TileMode, 0, &localMatrix);
+                                        SkTileMode::kClamp, 0, &localMatrix);
 }
 
 static sk_sp<SkShader> make_radial_gradient(const SkPoint pts[2], const SkMatrix& localMatrix) {
@@ -72,7 +72,7 @@
                SkScalarAve(pts[0].fY, pts[1].fY));
     float radius = (center - pts[0]).length();
     return SkGradientShader::MakeRadial(center, radius, gColors, nullptr, SK_ARRAY_COUNT(gColors),
-                                        SkShader::kClamp_TileMode, 0, &localMatrix);
+                                        SkTileMode::kClamp, 0, &localMatrix);
 }
 
 static void draw_gradients(SkCanvas* canvas,
diff --git a/gm/gradients.cpp b/gm/gradients.cpp
index 0b195ee..5f97111 100644
--- a/gm/gradients.cpp
+++ b/gm/gradients.cpp
@@ -53,20 +53,20 @@
 };
 
 static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data,
-                                  SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                  SkTileMode tm, const SkMatrix& localMatrix) {
     return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm, 0,
                                         &localMatrix);
 }
 
 static sk_sp<SkShader> MakeLinear4f(const SkPoint pts[2], const GradData& data,
-                                    SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                    SkTileMode tm, const SkMatrix& localMatrix) {
     auto srgb = SkColorSpace::MakeSRGB();
     return SkGradientShader::MakeLinear(pts, data.fColors4f, srgb, data.fPos, data.fCount, tm, 0,
                                         &localMatrix);
 }
 
 static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data,
-                                  SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                  SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -75,7 +75,7 @@
 }
 
 static sk_sp<SkShader> MakeRadial4f(const SkPoint pts[2], const GradData& data,
-                                    SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                    SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -85,7 +85,7 @@
 }
 
 static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data,
-                                 SkShader::TileMode, const SkMatrix& localMatrix) {
+                                 SkTileMode, const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -94,7 +94,7 @@
 }
 
 static sk_sp<SkShader> MakeSweep4f(const SkPoint pts[2], const GradData& data,
-                                   SkShader::TileMode, const SkMatrix& localMatrix) {
+                                   SkTileMode, const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -104,7 +104,7 @@
 }
 
 static sk_sp<SkShader> Make2Radial(const SkPoint pts[2], const GradData& data,
-                                   SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                   SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -117,7 +117,7 @@
 }
 
 static sk_sp<SkShader> Make2Radial4f(const SkPoint pts[2], const GradData& data,
-                                     SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                     SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -131,7 +131,7 @@
 }
 
 static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data,
-                                    SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                    SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -143,7 +143,7 @@
 }
 
 static sk_sp<SkShader> Make2Conical4f(const SkPoint pts[2], const GradData& data,
-                                      SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                      SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -156,7 +156,7 @@
 }
 
 typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                                     SkShader::TileMode tm, const SkMatrix& localMatrix);
+                                     SkTileMode tm, const SkMatrix& localMatrix);
 constexpr GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical
 };
@@ -186,7 +186,7 @@
             { 0, 0 },
             { SkIntToScalar(100), SkIntToScalar(100) }
         };
-        SkShader::TileMode tm = SkShader::kClamp_TileMode;
+        SkTileMode tm = SkTileMode::kClamp;
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
         SkPaint paint;
         paint.setAntiAlias(true);
@@ -242,7 +242,7 @@
             { 0, 0 },
             { SkIntToScalar(100), SkIntToScalar(100) }
         };
-        SkShader::TileMode tm = SkShader::kClamp_TileMode;
+        SkTileMode tm = SkTileMode::kClamp;
         SkRect r ={ 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
         SkPaint paint;
         paint.setAntiAlias(true);
@@ -300,7 +300,7 @@
             { 0, 0 },
             { SkIntToScalar(100), SkIntToScalar(100) }
         };
-        SkShader::TileMode tm = SkShader::kClamp_TileMode;
+        SkTileMode tm = SkTileMode::kClamp;
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
         SkPaint paint;
         paint.setAntiAlias(true);
@@ -407,7 +407,7 @@
         SkPaint paint;
         paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors,
                                                               pos, SK_ARRAY_COUNT(pos),
-                                                              SkShader::kClamp_TileMode));
+                                                              SkTileMode::kClamp));
         paint.setDither(fDither);
         canvas->drawPaint(paint);
     }
@@ -451,7 +451,7 @@
     canvas->drawRect(SkRect::MakeWH(100, 150), paint);
     paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors, pos,
                                                           SK_ARRAY_COUNT(pos),
-                                                          SkShader::kClamp_TileMode));
+                                                          SkTileMode::kClamp));
     canvas->drawRect(SkRect::MakeWH(100, 150), paint);
 }
 
@@ -487,7 +487,7 @@
         paint.setShader(SkGradientShader::MakeRadial(
             SkPoint(center),
             SkIntToScalar(200), gColors, nullptr, 5,
-            SkShader::kClamp_TileMode));
+            SkTileMode::kClamp));
         canvas->drawRect(r, paint);
     }
 
@@ -529,7 +529,7 @@
                              1.0f };
         paint.setShader(SkGradientShader::MakeRadial(center, radius, colors, pos,
                                                      SK_ARRAY_COUNT(pos),
-                                                     SkShader::kClamp_TileMode));
+                                                     SkTileMode::kClamp));
         SkRect r = {
             0, 0, SkIntToScalar(dim.width()), SkIntToScalar(dim.height())
         };
@@ -581,11 +581,11 @@
                                                          flags[i], nullptr));
             paint2.setShader(SkGradientShader::MakeRadial(center, radius, colors1,
                                                           nullptr, SK_ARRAY_COUNT(colors1),
-                                                          SkShader::kClamp_TileMode,
+                                                          SkTileMode::kClamp,
                                                           flags[i], nullptr));
             paint3.setShader(SkGradientShader::MakeRadial(center, radius, colors2,
                                                           nullptr, SK_ARRAY_COUNT(colors2),
-                                                          SkShader::kClamp_TileMode,
+                                                          SkTileMode::kClamp,
                                                           flags[i], nullptr));
             paint1.setDither(fDither);
             paint2.setDither(fDither);
@@ -626,7 +626,7 @@
         const SkScalar kRadius = 3000;
         const SkColor gColors[] = { 0xFFFFFFFF, 0xFF000000 };
         fShader = SkGradientShader::MakeRadial(center, kRadius, gColors, nullptr, 2,
-                                               SkShader::kClamp_TileMode);
+                                               SkTileMode::kClamp);
     }
 
     void onDraw(SkCanvas* canvas) override {
@@ -663,7 +663,7 @@
                 SK_ColorRED };
         const SkScalar pos[] = { 0, .4f, .4f, .8f, .8f, 1 };
         fShader = SkGradientShader::MakeRadial(center, kRadius, colors, pos,
-                                               SK_ARRAY_COUNT(gColors), SkShader::kClamp_TileMode);
+                                               SK_ARRAY_COUNT(gColors), SkTileMode::kClamp);
     }
 
     void onDraw(SkCanvas* canvas) override {
@@ -711,7 +711,7 @@
                 pos[inner] = unitPos[inner] / (kMinWidth + index * kWidthBump);
             }
             fShader[index] = SkGradientShader::MakeLinear(pts, colors, pos,
-                    SK_ARRAY_COUNT(gColors), SkShader::kClamp_TileMode);
+                    SK_ARRAY_COUNT(gColors), SkTileMode::kClamp);
         }
     }
 
@@ -780,7 +780,7 @@
         for (unsigned i = 0; i < SK_ARRAY_COUNT(configs); ++i) {
             SkAutoCanvasRestore acr(canvas, true);
             paint.setShader(SkGradientShader::MakeLinear(configs[i].pts, colors, configs[i].pos,
-                                                         kStopCount, SkShader::kClamp_TileMode,
+                                                         kStopCount, SkTileMode::kClamp,
                                                          fFlags, nullptr));
             canvas->translate(kRectSize * ((i % 4) * 1.5f + 0.25f),
                               kRectSize * ((i / 4) * 1.5f + 0.25f));
@@ -808,25 +808,25 @@
 
 #define SIZE 121
 
-static sk_sp<SkShader> make_linear(const GradRun& run, SkShader::TileMode mode) {
+static sk_sp<SkShader> make_linear(const GradRun& run, SkTileMode mode) {
     const SkPoint pts[] { { 30, 30 }, { SIZE - 30, SIZE - 30 } };
     return SkGradientShader::MakeLinear(pts, run.fColors, run.fPos, run.fCount, mode);
 }
 
-static sk_sp<SkShader> make_radial(const GradRun& run, SkShader::TileMode mode) {
+static sk_sp<SkShader> make_radial(const GradRun& run, SkTileMode mode) {
     const SkScalar half = SIZE * 0.5f;
     return SkGradientShader::MakeRadial({half,half}, half - 10, run.fColors, run.fPos,
                                         run.fCount, mode);
 }
 
-static sk_sp<SkShader> make_conical(const GradRun& run, SkShader::TileMode mode) {
+static sk_sp<SkShader> make_conical(const GradRun& run, SkTileMode mode) {
     const SkScalar half = SIZE * 0.5f;
     const SkPoint center { half, half };
     return SkGradientShader::MakeTwoPointConical(center, 20, center, half - 10,
                                                  run.fColors, run.fPos, run.fCount, mode);
 }
 
-static sk_sp<SkShader> make_sweep(const GradRun& run, SkShader::TileMode) {
+static sk_sp<SkShader> make_sweep(const GradRun& run, SkTileMode) {
     const SkScalar half = SIZE * 0.5f;
     return SkGradientShader::MakeSweep(half, half, run.fColors, run.fPos, run.fCount);
 }
@@ -866,14 +866,14 @@
             4,
         },
     };
-    sk_sp<SkShader> (*factories[])(const GradRun&, SkShader::TileMode) {
+    sk_sp<SkShader> (*factories[])(const GradRun&, SkTileMode) {
         make_linear, make_radial, make_conical, make_sweep
     };
 
     const SkRect rect = SkRect::MakeWH(SIZE, SIZE);
     const SkScalar dx = SIZE + 20;
     const SkScalar dy = SIZE + 20;
-    const SkShader::TileMode mode = SkShader::kClamp_TileMode;
+    const SkTileMode mode = SkTileMode::kClamp;
 
     SkPaint paint;
     canvas->translate(10, 10 - dy);
@@ -905,7 +905,7 @@
 
     SkPaint p;
     p.setShader(SkGradientShader::MakeLinear(
-        pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+        pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
 
     canvas->drawRect(SkRect::MakeXYWH(0, 0, 500, 500), p);
 }
@@ -951,19 +951,19 @@
 
         SkPoint pts1[] = { { 0, 0 }, { kTileSize, kTileSize }};
         p.setShader(SkGradientShader::MakeLinear(pts1, colors1, pos, SK_ARRAY_COUNT(colors1),
-                                                 SkShader::kClamp_TileMode, 0, nullptr));
+                                                 SkTileMode::kClamp, 0, nullptr));
         recorder.getRecordingCanvas()->drawPaint(p);
 
         SkPoint pts2[] = { { 0, kTileSize }, { kTileSize, 0 }};
         p.setShader(SkGradientShader::MakeLinear(pts2, colors2, pos, SK_ARRAY_COUNT(colors2),
-                                                 SkShader::kClamp_TileMode, 0, nullptr));
+                                                 SkTileMode::kClamp, 0, nullptr));
         recorder.getRecordingCanvas()->drawPaint(p);
 
         SkMatrix m = SkMatrix::I();
         m.preRotate(45);
-        return SkShader::MakePictureShader(recorder.finishRecordingAsPicture(),
-                                           SkShader::kRepeat_TileMode,
-                                           SkShader::kRepeat_TileMode, &m, nullptr);
+        return recorder.finishRecordingAsPicture()->makeShader(
+                                           SkTileMode::kRepeat,
+                                           SkTileMode::kRepeat, &m, nullptr);
     });
 
     draw_circle_shader(canvas, 400, 150, 100, []() -> sk_sp<SkShader> {
@@ -982,9 +982,9 @@
         SkPictureRecorder recorder;
         recorder.beginRecording(SkRect::MakeWH(kTileSize, kTileSize))->drawPaint(p);
 
-        return SkShader::MakePictureShader(recorder.finishRecordingAsPicture(),
-                                           SkShader::kRepeat_TileMode,
-                                           SkShader::kRepeat_TileMode, nullptr, nullptr);
+        return recorder.finishRecordingAsPicture()->makeShader(
+                                           SkTileMode::kRepeat,
+                                           SkTileMode::kRepeat);
     });
 
     draw_circle_shader(canvas, 650, 150, 100, []() -> sk_sp<SkShader> {
@@ -1015,7 +1015,7 @@
                                            SkGradientShader::MakeRadial(center, 100, colors,
                                                                         radialPos,
                                                                         SK_ARRAY_COUNT(radialPos),
-                                                                        SkShader::kClamp_TileMode),
+                                                                        SkTileMode::kClamp),
                                            SkBlendMode::kExclusion);
     });
 }
@@ -1026,9 +1026,9 @@
     static constexpr SkScalar   pos[] = { 0, .25f, .50f };
     static_assert(SK_ARRAY_COUNT(colors) == SK_ARRAY_COUNT(pos), "size mismatch");
 
-    static constexpr SkShader::TileMode modes[] = { SkShader::kClamp_TileMode,
-                                                    SkShader::kRepeat_TileMode,
-                                                    SkShader::kMirror_TileMode };
+    static constexpr SkTileMode modes[] = { SkTileMode::kClamp,
+                                            SkTileMode::kRepeat,
+                                            SkTileMode::kMirror };
 
     static const struct {
         SkScalar start, end;
@@ -1083,10 +1083,10 @@
         { colors4, hardCenter, 4 }, // kSingleHardStop_ColorType
     };
 
-    static const SkShader::TileMode modes[] = {
-        SkShader::kClamp_TileMode,
-        SkShader::kRepeat_TileMode,
-        SkShader::kMirror_TileMode,
+    static const SkTileMode modes[] = {
+        SkTileMode::kClamp,
+        SkTileMode::kRepeat,
+        SkTileMode::kMirror,
     };
 
     static constexpr SkScalar size = 200;
diff --git a/gm/gradients_2pt_conical.cpp b/gm/gradients_2pt_conical.cpp
index 81549e3..27a1eef 100644
--- a/gm/gradients_2pt_conical.cpp
+++ b/gm/gradients_2pt_conical.cpp
@@ -38,7 +38,7 @@
 };
 
 static sk_sp<SkShader> Make2ConicalOutside(const SkPoint pts[2], const GradData& data,
-                                           SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                           SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -49,7 +49,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalOutsideStrip(const SkPoint pts[2], const GradData& data,
-                                                SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                                SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius = (pts[1].fX - pts[0].fX) / 3;
     center0.set(pts[0].fX, pts[0].fY);
@@ -59,7 +59,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalOutsideFlip(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                             SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -70,7 +70,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalInside(const SkPoint pts[2], const GradData& data,
-                                          SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                          SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -83,7 +83,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalInsideFlip(const SkPoint pts[2], const GradData& data,
-                                              SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                              SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -96,7 +96,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalInsideCenter(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                             SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -107,7 +107,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalInsideCenterReversed(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                             SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -118,7 +118,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalZeroRad(const SkPoint pts[2], const GradData& data,
-                                           SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                           SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -131,7 +131,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalZeroRadFlip(const SkPoint pts[2], const GradData& data,
-                                               SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                               SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -144,7 +144,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalZeroRadCenter(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                             SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -156,7 +156,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalZeroRadOutside(const SkPoint pts[2], const GradData& data,
-                                                  SkShader::TileMode tm,
+                                                  SkTileMode tm,
                                                   const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = 0.f;
@@ -169,7 +169,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalZeroRadFlipOutside(const SkPoint pts[2], const GradData& data,
-                                                      SkShader::TileMode tm,
+                                                      SkTileMode tm,
                                                       const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = 0.f;
@@ -181,7 +181,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalEdgeX(const SkPoint pts[2], const GradData& data,
-                                         SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                         SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 7;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -193,7 +193,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalEdgeY(const SkPoint pts[2], const GradData& data,
-                                         SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                         SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 7;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -205,7 +205,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalZeroRadEdgeX(const SkPoint pts[2], const GradData& data,
-                                                SkShader::TileMode tm,
+                                                SkTileMode tm,
                                                 const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = 0.f;
@@ -218,7 +218,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalZeroRadEdgeY(const SkPoint pts[2], const GradData& data,
-                                                SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                                SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = 0.f;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -230,7 +230,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalTouchX(const SkPoint pts[2], const GradData& data,
-                                          SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                          SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 7;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -242,7 +242,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalTouchY(const SkPoint pts[2], const GradData& data,
-                                          SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                                          SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 7;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -254,7 +254,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalInsideSmallRad(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
+                             SkTileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -267,7 +267,7 @@
 }
 
 typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                                     SkShader::TileMode tm, const SkMatrix& localMatrix);
+                                     SkTileMode tm, const SkMatrix& localMatrix);
 
 constexpr GradMaker gGradMakersOutside[] = {
     Make2ConicalOutside, Make2ConicalOutsideFlip,
@@ -310,7 +310,7 @@
 class ConicalGradientsGM : public GM {
 public:
     ConicalGradientsGM(GradCaseType gradCaseType, bool dither,
-                       SkShader::TileMode mode = SkShader::kClamp_TileMode)
+                       SkTileMode mode = SkTileMode::kClamp)
         : fGradCaseType(gradCaseType)
         , fDither(dither)
         , fMode(mode) {
@@ -318,10 +318,10 @@
         fName.printf("gradients_2pt_conical_%s%s", gGradCases[gradCaseType].fName,
                      fDither ? "" : "_nodither");
         switch (mode) {
-        case SkShader::kRepeat_TileMode:
+        case SkTileMode::kRepeat:
             fName.appendf("_repeat");
             break;
-        case SkShader::kMirror_TileMode:
+        case SkTileMode::kMirror:
             fName.appendf("_mirror");
             break;
         default:
@@ -377,7 +377,7 @@
     GradCaseType fGradCaseType;
     SkString fName;
     bool fDither;
-    SkShader::TileMode fMode;
+    SkTileMode fMode;
 };
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -385,13 +385,13 @@
 DEF_GM( return new ConicalGradientsGM(kOutside_GradCaseType, true); )
 DEF_GM( return new ConicalGradientsGM(kEdge_GradCaseType, true); )
 
-DEF_GM( return new ConicalGradientsGM(kInside_GradCaseType, true, SkShader::kRepeat_TileMode); )
-DEF_GM( return new ConicalGradientsGM(kOutside_GradCaseType, true, SkShader::kRepeat_TileMode); )
-DEF_GM( return new ConicalGradientsGM(kEdge_GradCaseType, true, SkShader::kRepeat_TileMode); )
+DEF_GM( return new ConicalGradientsGM(kInside_GradCaseType, true, SkTileMode::kRepeat); )
+DEF_GM( return new ConicalGradientsGM(kOutside_GradCaseType, true, SkTileMode::kRepeat); )
+DEF_GM( return new ConicalGradientsGM(kEdge_GradCaseType, true, SkTileMode::kRepeat); )
 
-DEF_GM( return new ConicalGradientsGM(kInside_GradCaseType, true, SkShader::kMirror_TileMode); )
-DEF_GM( return new ConicalGradientsGM(kOutside_GradCaseType, true, SkShader::kMirror_TileMode); )
-DEF_GM( return new ConicalGradientsGM(kEdge_GradCaseType, true, SkShader::kMirror_TileMode); )
+DEF_GM( return new ConicalGradientsGM(kInside_GradCaseType, true, SkTileMode::kMirror); )
+DEF_GM( return new ConicalGradientsGM(kOutside_GradCaseType, true, SkTileMode::kMirror); )
+DEF_GM( return new ConicalGradientsGM(kEdge_GradCaseType, true, SkTileMode::kMirror); )
 
 DEF_GM( return new ConicalGradientsGM(kInside_GradCaseType, false); )
 DEF_GM( return new ConicalGradientsGM(kOutside_GradCaseType, false); )
diff --git a/gm/gradients_degenerate.cpp b/gm/gradients_degenerate.cpp
index e6a3f87..97ccc49 100644
--- a/gm/gradients_degenerate.cpp
+++ b/gm/gradients_degenerate.cpp
@@ -17,10 +17,10 @@
 static const SkScalar POS[] = { 0.0, 0.0, 0.5, 1.0, 1.0 };
 static const int COLOR_CT = SK_ARRAY_COUNT(COLORS);
 
-static const SkShader::TileMode TILE_MODES[] = { SkShader::kDecal_TileMode,
-                                                 SkShader::kRepeat_TileMode,
-                                                 SkShader::kMirror_TileMode,
-                                                 SkShader::kClamp_TileMode };
+static const SkTileMode TILE_MODES[] = { SkTileMode::kDecal,
+                                         SkTileMode::kRepeat,
+                                         SkTileMode::kMirror,
+                                         SkTileMode::kClamp };
 static const char* TILE_NAMES[] = { "decal", "repeat", "mirror", "clamp" };
 static const int TILE_MODE_CT = SK_ARRAY_COUNT(TILE_MODES);
 
@@ -29,7 +29,7 @@
 
 static const SkPoint CENTER = SkPoint::Make(TILE_SIZE / 2, TILE_SIZE / 2);
 
-typedef sk_sp<SkShader> (*GradientFactory)(SkShader::TileMode tm);
+typedef sk_sp<SkShader> (*GradientFactory)(SkTileMode tm);
 
 static void draw_tile_header(SkCanvas* canvas) {
     canvas->save();
@@ -72,37 +72,37 @@
     canvas->translate(0, 3 * TILE_GAP + TILE_SIZE);
 }
 
-static sk_sp<SkShader> make_linear(SkShader::TileMode mode) {
+static sk_sp<SkShader> make_linear(SkTileMode mode) {
     // Same position
     SkPoint pts[2] = {CENTER, CENTER};
     return SkGradientShader::MakeLinear(pts, COLORS, POS, COLOR_CT, mode);
 }
 
-static sk_sp<SkShader> make_radial(SkShader::TileMode mode) {
+static sk_sp<SkShader> make_radial(SkTileMode mode) {
     // Radius = 0
     return SkGradientShader::MakeRadial(CENTER, 0.0, COLORS, POS, COLOR_CT, mode);
 }
 
-static sk_sp<SkShader> make_sweep(SkShader::TileMode mode) {
+static sk_sp<SkShader> make_sweep(SkTileMode mode) {
     // Start and end angles at 45
     static constexpr SkScalar SWEEP_ANG = 45.0;
     return SkGradientShader::MakeSweep(CENTER.fX, CENTER.fY, COLORS, POS, COLOR_CT, mode,
                                        SWEEP_ANG, SWEEP_ANG, 0, nullptr);
 }
 
-static sk_sp<SkShader> make_sweep_zero_ang(SkShader::TileMode mode) {
+static sk_sp<SkShader> make_sweep_zero_ang(SkTileMode mode) {
     // Start and end angles at 0
     return SkGradientShader::MakeSweep(CENTER.fX, CENTER.fY, COLORS, POS, COLOR_CT, mode,
                                        0.0, 0.0, 0, nullptr);
 }
 
-static sk_sp<SkShader> make_2pt_conic(SkShader::TileMode mode) {
+static sk_sp<SkShader> make_2pt_conic(SkTileMode mode) {
     // Start and end radius = TILE_SIZE, same position
     return SkGradientShader::MakeTwoPointConical(CENTER, TILE_SIZE / 2, CENTER, TILE_SIZE / 2,
                                                  COLORS, POS, COLOR_CT, mode);
 }
 
-static sk_sp<SkShader> make_2pt_conic_zero_rad(SkShader::TileMode mode) {
+static sk_sp<SkShader> make_2pt_conic_zero_rad(SkTileMode mode) {
     // Start and end radius = 0, same position
     return SkGradientShader::MakeTwoPointConical(CENTER, 0.0, CENTER, 0.0, COLORS, POS,
                                                  COLOR_CT, mode);
diff --git a/gm/gradients_no_texture.cpp b/gm/gradients_no_texture.cpp
index 694642e..2814f3c 100644
--- a/gm/gradients_no_texture.cpp
+++ b/gm/gradients_no_texture.cpp
@@ -26,25 +26,25 @@
     { 4, gColors, nullptr },
 };
 
-static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::MakeRadial(center, center.fX, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode) {
+static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkTileMode) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static sk_sp<SkShader> Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> Make2Radial(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -56,7 +56,7 @@
         data.fColors, data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
@@ -69,7 +69,7 @@
 }
 
 
-typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
+typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkTileMode tm);
 
 constexpr GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical,
@@ -94,7 +94,7 @@
     void onDraw(SkCanvas* canvas) override {
         constexpr SkPoint kPts[2] = { { 0, 0 },
                                          { SkIntToScalar(50), SkIntToScalar(50) } };
-        constexpr SkShader::TileMode kTM = SkShader::kClamp_TileMode;
+        constexpr SkTileMode kTM = SkTileMode::kClamp;
         SkRect kRect = { 0, 0, SkIntToScalar(50), SkIntToScalar(50) };
         SkPaint paint;
         paint.setAntiAlias(true);
@@ -255,7 +255,7 @@
             ColorPos rec;
             procs[i](&rec);
             paint.setShader(SkGradientShader::MakeLinear(pts, rec.fColors, rec.fPos, rec.fCount,
-                                                         SkShader::kClamp_TileMode));
+                                                         SkTileMode::kClamp));
             canvas->drawRect(drawR, paint);
 
             canvas->save();
diff --git a/gm/gradtext.cpp b/gm/gradtext.cpp
index a2fce97..a4fd0b4 100644
--- a/gm/gradtext.cpp
+++ b/gm/gradtext.cpp
@@ -16,7 +16,7 @@
     SkColor colors[] = { SK_ColorRED, 0x0000FF00, SK_ColorBLUE };
     SkPoint pts[] = { { 0, 0 }, { width, 0 } };
     return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                        SkShader::kMirror_TileMode);
+                                        SkTileMode::kMirror);
 }
 
 // test opaque shader
@@ -24,13 +24,13 @@
     SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
     SkPoint pts[] = { { 0, 0 }, { width, 0 } };
     return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                        SkShader::kMirror_TileMode);
+                                        SkTileMode::kMirror);
 }
 
 static sk_sp<SkShader> make_chrome_solid() {
     SkColor colors[] = { SK_ColorGREEN, SK_ColorGREEN };
     SkPoint pts[] = { { 0, 0 }, { 1, 0 } };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 namespace skiagm {
diff --git a/gm/hairmodes.cpp b/gm/hairmodes.cpp
index 151af3e..8d946be 100644
--- a/gm/hairmodes.cpp
+++ b/gm/hairmodes.cpp
@@ -63,8 +63,7 @@
 
     SkMatrix m;
     m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-    return SkShader::MakeBitmapShader(bm,
-                                      SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &m);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
 }
 
 namespace skiagm {
diff --git a/gm/hardstop_gradients.cpp b/gm/hardstop_gradients.cpp
index 84b7ab8..64d42e8 100644
--- a/gm/hardstop_gradients.cpp
+++ b/gm/hardstop_gradients.cpp
@@ -133,10 +133,10 @@
             4,
         };
 
-        SkShader::TileMode tilemodes[NUM_COLS] = {
-            SkShader::kClamp_TileMode,
-            SkShader::kRepeat_TileMode,
-            SkShader::kMirror_TileMode,
+        SkTileMode tilemodes[NUM_COLS] = {
+            SkTileMode::kClamp,
+            SkTileMode::kRepeat,
+            SkTileMode::kMirror,
         };
 
         for (int cellRow = 0; cellRow < NUM_ROWS; cellRow++) {
diff --git a/gm/highcontrastfilter.cpp b/gm/highcontrastfilter.cpp
index 9672ffa..cc7ef28 100644
--- a/gm/highcontrastfilter.cpp
+++ b/gm/highcontrastfilter.cpp
@@ -73,14 +73,14 @@
     SkScalar    pos[] = { 0.2f, 0.8f };
     paint.setShader(SkGradientShader::MakeLinear(
         pts, colors, pos,
-        SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+        SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
     canvas->drawRect(bounds, paint);
 
     bounds = SkRect::MakeLTRB(0.1f, 0.6f, 0.9f, 0.8f);
     SkColor colors2[] = { SK_ColorGREEN, SK_ColorWHITE };
     paint.setShader(SkGradientShader::MakeLinear(
         pts, colors2, pos,
-        SK_ARRAY_COUNT(colors2), SkShader::kClamp_TileMode));
+        SK_ARRAY_COUNT(colors2), SkTileMode::kClamp));
     canvas->drawRect(bounds, paint);
 
     canvas->restore();
@@ -99,10 +99,10 @@
         fFilter = SkHighContrastFilter::Make(fConfig);
         fGr1 = SkGradientShader::MakeLinear(
             g1Points, g1Colors, pos, SK_ARRAY_COUNT(g1Colors),
-            SkShader::kClamp_TileMode);
+            SkTileMode::kClamp);
         fGr2 = SkGradientShader::MakeLinear(
             g2Points, g2Colors, pos, SK_ARRAY_COUNT(g2Colors),
-            SkShader::kClamp_TileMode);
+            SkTileMode::kClamp);
     }
 
 protected:
diff --git a/gm/image_shader.cpp b/gm/image_shader.cpp
index 5e55786..37242d5 100644
--- a/gm/image_shader.cpp
+++ b/gm/image_shader.cpp
@@ -103,7 +103,7 @@
         canvas->drawImage(image, 0, 0);
         canvas->translate(0, 120);
 
-        const SkShader::TileMode tile = SkShader::kRepeat_TileMode;
+        const SkTileMode tile = SkTileMode::kRepeat;
         const SkMatrix localM = SkMatrix::MakeTrans(-50, -50);
         SkPaint paint;
         paint.setShader(image->makeShader(tile, tile, &localM));
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index a038d7f..16a7fc6 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -38,7 +38,7 @@
     colors[1] = SK_ColorBLACK;
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr,
-        2, SkShader::kClamp_TileMode));
+        2, SkTileMode::kClamp));
     canvas->drawCircle(x, y, radius, paint);
     return surface->makeImageSnapshot();
 }
diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp
index 6b1bac2..f420654 100644
--- a/gm/imagefilterscropexpand.cpp
+++ b/gm/imagefilterscropexpand.cpp
@@ -165,7 +165,7 @@
         colors[1] = SK_ColorBLACK;
         SkPaint paint;
         paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr,
-                                                     2, SkShader::kClamp_TileMode));
+                                                     2, SkTileMode::kClamp));
         canvas->drawCircle(x, y, radius, paint);
 
         return surface->makeImageSnapshot();
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 73006af..f3d354a 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -37,7 +37,7 @@
     colors[1] = SK_ColorBLACK;
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr,
-        2, SkShader::kClamp_TileMode));
+        2, SkTileMode::kClamp));
     canvas->drawCircle(x, y, radius, paint);
 
     return surface->makeImageSnapshot();
diff --git a/gm/imagefilterstransformed.cpp b/gm/imagefilterstransformed.cpp
index 6b6fd1c..9d2ed28 100644
--- a/gm/imagefilterstransformed.cpp
+++ b/gm/imagefilterstransformed.cpp
@@ -38,7 +38,7 @@
     colors[1] = SK_ColorBLACK;
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas->drawCircle(x, y, radius, paint);
 
     return surface->makeImageSnapshot();
diff --git a/gm/imagefromyuvtextures.cpp b/gm/imagefromyuvtextures.cpp
index eb9ea5f..c984b6e 100644
--- a/gm/imagefromyuvtextures.cpp
+++ b/gm/imagefromyuvtextures.cpp
@@ -53,7 +53,7 @@
             { SK_ColorBLUE, SK_ColorYELLOW, SK_ColorGREEN, SK_ColorWHITE };
         paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(0,0), kBmpSize / 2.f, kColors,
                                                      nullptr, SK_ARRAY_COUNT(kColors),
-                                                     SkShader::kMirror_TileMode));
+                                                     SkTileMode::kMirror));
         SkBitmap rgbBmp;
         rgbBmp.allocN32Pixels(kBmpSize, kBmpSize, true);
         SkCanvas canvas(rgbBmp);
diff --git a/gm/lcdblendmodes.cpp b/gm/lcdblendmodes.cpp
index fbfe105..d875a00 100644
--- a/gm/lcdblendmodes.cpp
+++ b/gm/lcdblendmodes.cpp
@@ -32,7 +32,7 @@
         SK_ColorRED, SK_ColorGREEN,
     };
     return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                        SkShader::kRepeat_TileMode);
+                                        SkTileMode::kRepeat);
 }
 
 class LcdBlendGM : public skiagm::GM {
diff --git a/gm/lightingshader.cpp b/gm/lightingshader.cpp
index e061e83..586ed8f 100644
--- a/gm/lightingshader.cpp
+++ b/gm/lightingshader.cpp
@@ -97,9 +97,9 @@
 
         SkPaint paint;
         sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(fDiffuse,
-                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix);
+                SkTileMode::kClamp, SkTileMode::kClamp, &matrix);
         sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(fNormalMaps[mapType],
-                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix);
+                SkTileMode::kClamp, SkTileMode::kClamp, &matrix);
         sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
                                                                                ctm);
         paint.setShader(SkLightingShader::Make(std::move(diffuseShader), std::move(normalSource),
diff --git a/gm/lightingshader2.cpp b/gm/lightingshader2.cpp
index 1ad1c74..faf56f0 100644
--- a/gm/lightingshader2.cpp
+++ b/gm/lightingshader2.cpp
@@ -79,8 +79,8 @@
 
         SkBitmap opaqueDiffuseMap = ToolUtils::create_checkerboard_bitmap(
                 kTexSize, kTexSize, SK_ColorBLACK, 0xFF808080, 8);
-        fOpaqueDiffuse = SkShader::MakeBitmapShader(opaqueDiffuseMap, SkShader::kClamp_TileMode,
-                                                    SkShader::kClamp_TileMode, &matrix);
+        fOpaqueDiffuse = SkShader::MakeBitmapShader(opaqueDiffuseMap, SkTileMode::kClamp,
+                                                    SkTileMode::kClamp, &matrix);
 
         SkBitmap translucentDiffuseMap =
                 ToolUtils::create_checkerboard_bitmap(kTexSize,
@@ -89,12 +89,12 @@
                                                       SkColorSetARGB(0x55, 0x80, 0x80, 0x80),
                                                       8);
         fTranslucentDiffuse = SkShader::MakeBitmapShader(translucentDiffuseMap,
-                                                         SkShader::kClamp_TileMode,
-                                                         SkShader::kClamp_TileMode, &matrix);
+                                                         SkTileMode::kClamp,
+                                                         SkTileMode::kClamp, &matrix);
 
         SkBitmap normalMap = make_frustum_normalmap(kTexSize);
-        fNormalMapShader = SkShader::MakeBitmapShader(normalMap, SkShader::kClamp_TileMode,
-                                                      SkShader::kClamp_TileMode, &matrix);
+        fNormalMapShader = SkShader::MakeBitmapShader(normalMap, SkTileMode::kClamp,
+                                                      SkTileMode::kClamp, &matrix);
 
     }
 
diff --git a/gm/localmatriximageshader.cpp b/gm/localmatriximageshader.cpp
index 8b15679..fc5f0f2 100644
--- a/gm/localmatriximageshader.cpp
+++ b/gm/localmatriximageshader.cpp
@@ -46,7 +46,7 @@
     canvas->translate(100.0f, 0.0f);
 
     // Use isAImage() and confirm that the shaders will draw exactly the same (to the right by 100).
-    SkShader::TileMode mode[2];
+    SkTileMode mode[2];
     SkMatrix matrix;
     SkImage* image = redLocalMatrixShader->isAImage(&matrix, mode);
     paint.setShader(image->makeShader(mode[0], mode[1], &matrix));
diff --git a/gm/lumafilter.cpp b/gm/lumafilter.cpp
index ff9dc70..441986a 100644
--- a/gm/lumafilter.cpp
+++ b/gm/lumafilter.cpp
@@ -88,9 +88,9 @@
 
         fFilter = SkLumaColorFilter::Make();
         fGr1 = SkGradientShader::MakeLinear(g1Points, g1Colors, pos, SK_ARRAY_COUNT(g1Colors),
-                                            SkShader::kClamp_TileMode);
+                                            SkTileMode::kClamp);
         fGr2 = SkGradientShader::MakeLinear(g2Points, g2Colors, pos, SK_ARRAY_COUNT(g2Colors),
-                                            SkShader::kClamp_TileMode);
+                                            SkTileMode::kClamp);
     }
 
 protected:
diff --git a/gm/matrixconvolution.cpp b/gm/matrixconvolution.cpp
index 0cfb5c2..a729e3f 100644
--- a/gm/matrixconvolution.cpp
+++ b/gm/matrixconvolution.cpp
@@ -39,7 +39,7 @@
                            {0, 80.0f} };
         SkScalar pos[2] = { 0, 80.0f };
         paint.setShader(SkGradientShader::MakeLinear(
-            pts, fColors, pos, 2, SkShader::kClamp_TileMode));
+            pts, fColors, pos, 2, SkTileMode::kClamp));
         SkFont font(ToolUtils::create_portable_typeface(), 180.0f);
         canvas.drawString("e", -10.0f, 80.0f, font, paint);
     }
diff --git a/gm/mixercolorfilter.cpp b/gm/mixercolorfilter.cpp
index eb3b55b..ab14914 100644
--- a/gm/mixercolorfilter.cpp
+++ b/gm/mixercolorfilter.cpp
@@ -135,7 +135,7 @@
     SkPoint pts[] = {{0, 0}, {size*1.0f, size*1.0f}};
     SkScalar pos[] = {0, 1 - t, 1.0f};
     return SkGradientShader::MakeLinear(pts, colors, pos, SK_ARRAY_COUNT(colors),
-                                        SkShader::kClamp_TileMode);
+                                        SkTileMode::kClamp);
 }
 
 class ShaderMixerGM final : public skiagm::GM {
diff --git a/gm/modecolorfilters.cpp b/gm/modecolorfilters.cpp
index 3c51af4..8467ee4 100644
--- a/gm/modecolorfilters.cpp
+++ b/gm/modecolorfilters.cpp
@@ -20,7 +20,7 @@
     constexpr SkPoint kPts[] = {{0, 0}, {1, 1}};
     SkColor colors[] = {color, color};
 
-    return SkGradientShader::MakeLinear(kPts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(kPts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 static sk_sp<SkShader> make_solid_shader() {
@@ -49,7 +49,7 @@
                                     SkIntToScalar(checkSize), SkIntToScalar(checkSize));
     canvas.drawRect(rect1, paint);
     canvas.drawRect(rect0, paint);
-    return SkShader::MakeBitmapShader(bmp, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
+    return SkShader::MakeBitmapShader(bmp, SkTileMode::kRepeat, SkTileMode::kRepeat);
 }
 
 class ModeColorFilterGM : public GM {
diff --git a/gm/ovals.cpp b/gm/ovals.cpp
index 8549f13..d8f93ef 100644
--- a/gm/ovals.cpp
+++ b/gm/ovals.cpp
@@ -248,7 +248,7 @@
         SkColor colors[] = { SK_ColorBLUE, SK_ColorRED, SK_ColorGREEN };
         SkScalar pos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
         auto shader = SkGradientShader::MakeRadial(center, 20, colors, pos, SK_ARRAY_COUNT(colors),
-                                                   SkShader::kClamp_TileMode);
+                                                   SkTileMode::kClamp);
 
         for (int i = 0; i < fPaints.count(); ++i) {
             canvas->save();
diff --git a/gm/p3.cpp b/gm/p3.cpp
index dbf6c25..8266de2 100644
--- a/gm/p3.cpp
+++ b/gm/p3.cpp
@@ -179,8 +179,7 @@
         SkAssertResult(pm.erase({1,0,0,1} /*in p3*/));
 
         SkPaint paint;
-        paint.setShader(SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
-                                                   SkShader::kRepeat_TileMode));
+        paint.setShader(SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat));
 
         canvas->drawRect({10,10,70,70}, paint);
         compare_pixel("drawBitmapAsShader P3 red, from SkPixmap::erase",
@@ -201,7 +200,7 @@
         SkPaint paint;
         paint.setShader(SkGradientShader::MakeLinear(points, colors, p3,
                                                      nullptr, SK_ARRAY_COUNT(colors),
-                                                     SkShader::kClamp_TileMode));
+                                                     SkTileMode::kClamp));
         canvas->drawRect({10,10,70,70}, paint);
         canvas->save();
             compare_pixel("UPM P3 gradient, P3 red",
@@ -228,7 +227,7 @@
         paint.setShader(
                 SkGradientShader::MakeLinear(points, colors, p3,
                                              nullptr, SK_ARRAY_COUNT(colors),
-                                             SkShader::kClamp_TileMode,
+                                             SkTileMode::kClamp,
                                              SkGradientShader::kInterpolateColorsInPremul_Flag,
                                              nullptr/*local matrix*/));
         canvas->drawRect({10,10,70,70}, paint);
@@ -256,7 +255,7 @@
         SkPaint paint;
         paint.setShader(SkGradientShader::MakeLinear(points, colors, srgb,
                                                      nullptr, SK_ARRAY_COUNT(colors),
-                                                     SkShader::kClamp_TileMode));
+                                                     SkTileMode::kClamp));
         canvas->drawRect({10,10,70,70}, paint);
         canvas->save();
             compare_pixel("UPM sRGB gradient, P3 red",
@@ -283,7 +282,7 @@
         paint.setShader(
                 SkGradientShader::MakeLinear(points, colors, srgb,
                                              nullptr, SK_ARRAY_COUNT(colors),
-                                             SkShader::kClamp_TileMode,
+                                             SkTileMode::kClamp,
                                              SkGradientShader::kInterpolateColorsInPremul_Flag,
                                              nullptr/*local matrix*/));
         canvas->drawRect({10,10,70,70}, paint);
@@ -311,7 +310,7 @@
         paint.setShader(
                 SkGradientShader::MakeLinear(points, colors, p3,
                                              nullptr, SK_ARRAY_COUNT(colors),
-                                             SkShader::kClamp_TileMode,
+                                             SkTileMode::kClamp,
                                              SkGradientShader::kInterpolateColorsInPremul_Flag,
                                              nullptr/*local matrix*/));
         canvas->drawRect({10,10,70,70}, paint);
@@ -346,8 +345,8 @@
         SkPaint as_shader;
         as_shader.setColor4f({1,0,0,1}, p3.get());
         as_shader.setFilterQuality(kLow_SkFilterQuality);
-        as_shader.setShader(SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode
-                                                         , SkShader::kClamp_TileMode));
+        as_shader.setShader(SkShader::MakeBitmapShader(bm, SkTileMode::kClamp
+                                                         , SkTileMode::kClamp));
 
         canvas->drawBitmap(bm, 10,10, &as_bitmap);
         compare_pixel("A8 sprite bitmap P3 red",
diff --git a/gm/patch.cpp b/gm/patch.cpp
index 5cfc8b5..6f05142 100644
--- a/gm/patch.cpp
+++ b/gm/patch.cpp
@@ -19,7 +19,7 @@
     const SkPoint pts[] = { { 100.f / 4.f, 0.f }, { 3.f * 100.f / 4.f, 100.f } };
 
     return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                        SkShader::kMirror_TileMode);
+                                        SkTileMode::kMirror);
 }
 
 static void draw_control_points(SkCanvas* canvas, const SkPoint cubics[12]) {
@@ -98,7 +98,7 @@
     if (img) {
         SkScalar w = img->width();
         SkScalar h = img->height();
-        shader = img->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+        shader = img->makeShader();
         texStorage[0].set(0, 0);
         texStorage[1].set(w, 0);
         texStorage[2].set(w, h);
diff --git a/gm/perspshaders.cpp b/gm/perspshaders.cpp
index 1692726..25c3345 100644
--- a/gm/perspshaders.cpp
+++ b/gm/perspshaders.cpp
@@ -43,8 +43,7 @@
         fBitmap = ToolUtils::create_checkerboard_bitmap(
                 kCellSize, kCellSize, SK_ColorBLUE, SK_ColorYELLOW, kCellSize / 10);
 
-        fBitmapShader = SkShader::MakeBitmapShader(fBitmap, SkShader::kClamp_TileMode,
-                                                   SkShader::kClamp_TileMode);
+        fBitmapShader = SkShader::MakeBitmapShader(fBitmap, SkTileMode::kClamp, SkTileMode::kClamp);
         SkPoint pts1[] = {
             { 0, 0 },
             { SkIntToScalar(kCellSize), SkIntToScalar(kCellSize) }
@@ -59,9 +58,9 @@
         constexpr SkScalar pos[] = { 0, 0.25f, 0.5f, 0.75f, SK_Scalar1 };
 
         fLinearGrad1 = SkGradientShader::MakeLinear(pts1, colors, pos, SK_ARRAY_COUNT(colors),
-                                                    SkShader::kClamp_TileMode);
+                                                    SkTileMode::kClamp);
         fLinearGrad2 = SkGradientShader::MakeLinear(pts2, colors, pos, SK_ARRAY_COUNT(colors),
-                                                    SkShader::kClamp_TileMode);
+                                                    SkTileMode::kClamp);
 
         fPerspMatrix.reset();
         fPerspMatrix.setPerspY(SK_Scalar1 / 50);
diff --git a/gm/pictureimagegenerator.cpp b/gm/pictureimagegenerator.cpp
index dd71153..70076e0 100644
--- a/gm/pictureimagegenerator.cpp
+++ b/gm/pictureimagegenerator.cpp
@@ -74,7 +74,7 @@
     const SkColor colors1[] = { SK_ColorTRANSPARENT, SK_ColorBLACK };
     SkASSERT(SK_ARRAY_COUNT(pos1) == SK_ARRAY_COUNT(colors1));
     paint.setShader(SkGradientShader::MakeLinear(pts1, colors1, pos1, SK_ARRAY_COUNT(pos1),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas->drawRect(underlineRect, paint);
 
     const SkPoint pts2[] = { SkPoint::Make(iBox.x() - iBox.width() * kGradientPad, 0),
@@ -92,7 +92,7 @@
     };
     SkASSERT(SK_ARRAY_COUNT(pos2) == SK_ARRAY_COUNT(colors2));
     paint.setShader(SkGradientShader::MakeLinear(pts2, colors2, pos2, SK_ARRAY_COUNT(pos2),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas->drawSimpleText(kSkiaStr, textLen, kUTF8_SkTextEncoding, 0, 0, font, paint);
 }
 
diff --git a/gm/pictureshader.cpp b/gm/pictureshader.cpp
index 0dbab54..0bdbca1 100644
--- a/gm/pictureshader.cpp
+++ b/gm/pictureshader.cpp
@@ -15,12 +15,12 @@
 #include "SkShader.h"
 
 static struct {
-    SkShader::TileMode tmx;
-    SkShader::TileMode tmy;
+    SkTileMode tmx;
+    SkTileMode tmy;
 } kTileConfigs[] = {
-    { SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode },
-    { SkShader::kRepeat_TileMode, SkShader::kClamp_TileMode  },
-    { SkShader::kMirror_TileMode, SkShader::kRepeat_TileMode },
+    { SkTileMode::kRepeat, SkTileMode::kRepeat },
+    { SkTileMode::kRepeat, SkTileMode::kClamp  },
+    { SkTileMode::kMirror, SkTileMode::kRepeat },
 };
 
 class PictureShaderGM : public skiagm::GM {
@@ -151,11 +151,10 @@
         canvas->drawRect(SkRect::MakeWH(fSceneSize, fSceneSize), paint);
         canvas->drawRect(SkRect::MakeXYWH(fSceneSize * 1.1f, 0, fSceneSize, fSceneSize), paint);
 
-        auto pictureShader = SkShader::MakePictureShader(fPicture, kTileConfigs[tileMode].tmx,
-                                                         kTileConfigs[tileMode].tmy,
-                                                         fUseLocalMatrixWrapper
-                                                            ? nullptr : &localMatrix,
-                                                         nullptr);
+        auto pictureShader = fPicture->makeShader(kTileConfigs[tileMode].tmx,
+                                                  kTileConfigs[tileMode].tmy,
+                                                  fUseLocalMatrixWrapper ? nullptr : &localMatrix,
+                                                  nullptr);
         paint.setShader(fUseLocalMatrixWrapper
                             ? pictureShader->makeWithLocalMatrix(localMatrix)
                             : pictureShader);
@@ -214,8 +213,6 @@
     p.setColor(0xFFB6B6B6);  // gray
     canvas->drawPaint(p);
 
-    p.setShader(SkShader::MakePictureShader(std::move(picture), SkShader::kRepeat_TileMode,
-                                            SkShader::kRepeat_TileMode,
-                                            nullptr, nullptr));
+    p.setShader(picture->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat));
     canvas->drawPaint(p);
 }
diff --git a/gm/pictureshadercache.cpp b/gm/pictureshadercache.cpp
index e3badd8..f847732 100644
--- a/gm/pictureshadercache.cpp
+++ b/gm/pictureshadercache.cpp
@@ -54,9 +54,7 @@
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
-        paint.setShader(SkShader::MakePictureShader(fPicture, SkShader::kRepeat_TileMode,
-                                                    SkShader::kRepeat_TileMode, nullptr,
-                                                    nullptr));
+        paint.setShader(fPicture->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat));
 
         {
             // Render in a funny color space that converts green to yellow.
diff --git a/gm/pictureshadertile.cpp b/gm/pictureshadertile.cpp
index 10d5e5d..753a67b 100644
--- a/gm/pictureshadertile.cpp
+++ b/gm/pictureshadertile.cpp
@@ -124,9 +124,8 @@
                 tilePtr = nullptr;
             }
 
-            fShaders[i] = SkShader::MakePictureShader(pictureRef, SkShader::kRepeat_TileMode,
-                                                      SkShader::kRepeat_TileMode, &localMatrix,
-                                                      tilePtr);
+            fShaders[i] = pictureRef->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
+                                                 &localMatrix, tilePtr);
         }
     }
 
diff --git a/gm/radial_gradient_precision.cpp b/gm/radial_gradient_precision.cpp
index f594afe..bb4e155 100644
--- a/gm/radial_gradient_precision.cpp
+++ b/gm/radial_gradient_precision.cpp
@@ -17,6 +17,6 @@
     SkPaint p;
     p.setShader(SkGradientShader::MakeRadial(center, radius,
                                              colors, nullptr, SK_ARRAY_COUNT(colors),
-                                             SkShader::kRepeat_TileMode));
+                                             SkTileMode::kRepeat));
     canvas->drawPaint(p);
 }
diff --git a/gm/rectangletexture.cpp b/gm/rectangletexture.cpp
index 4908c75..fa92d5f 100644
--- a/gm/rectangletexture.cpp
+++ b/gm/rectangletexture.cpp
@@ -40,14 +40,12 @@
         SkCanvas canvas(bmp);
         SkPoint pts[] = { {0, 0}, {0, SkIntToScalar(height)} };
         SkColor colors0[] = { 0xFF1060B0 , 0xFF102030 };
-        paint.setShader(SkGradientShader::MakeLinear(pts, colors0, nullptr, 2,
-                                                     SkShader::kClamp_TileMode));
+        paint.setShader(SkGradientShader::MakeLinear(pts, colors0, nullptr, 2, SkTileMode::kClamp));
         canvas.drawPaint(paint);
 
         SkColor colors1[] = {0xFFA07010, 0xFFA02080};
         paint.setAntiAlias(true);
-        paint.setShader(SkGradientShader::MakeLinear(pts, colors1, nullptr, 2,
-                                                     SkShader::kClamp_TileMode));
+        paint.setShader(SkGradientShader::MakeLinear(pts, colors1, nullptr, 2, SkTileMode::kClamp));
         canvas.drawCircle(SkIntToScalar(width) / 2, SkIntToScalar(height) / 2,
                           SkIntToScalar(width + height) / 5, paint);
     }
@@ -196,8 +194,8 @@
                     // repeat/mirror shader
                     SkPaint repeatPaint;
                     repeatPaint.setFilterQuality(q);
-                    repeatPaint.setShader(rectImgs[i]->makeShader(SkShader::kRepeat_TileMode,
-                                                                  SkShader::kMirror_TileMode));
+                    repeatPaint.setShader(rectImgs[i]->makeShader(SkTileMode::kRepeat,
+                                                                  SkTileMode::kMirror));
                     canvas->drawRect(SkRect::MakeWH(1.5f * kWidth, 1.5f * kHeight), repeatPaint);
                     canvas->translate(1.5f * kWidth + kPad, 0);
 
diff --git a/gm/rects.cpp b/gm/rects.cpp
index 2786be7..b875d83 100644
--- a/gm/rects.cpp
+++ b/gm/rects.cpp
@@ -81,7 +81,7 @@
             SkScalar pos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
             p.setShader(SkGradientShader::MakeRadial(center, 20, colors, pos,
                                                      SK_ARRAY_COUNT(colors),
-                                                     SkShader::kClamp_TileMode));
+                                                     SkTileMode::kClamp));
             fPaints.push_back(p);
         }
 
diff --git a/gm/roundrects.cpp b/gm/roundrects.cpp
index ae5a4e9..dccfd36 100644
--- a/gm/roundrects.cpp
+++ b/gm/roundrects.cpp
@@ -263,7 +263,7 @@
         SkColor colors[] = { SK_ColorBLUE, SK_ColorRED, SK_ColorGREEN };
         SkScalar pos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
         auto shader = SkGradientShader::MakeRadial(center, 20, colors, pos, SK_ARRAY_COUNT(colors),
-                                                   SkShader::kClamp_TileMode);
+                                                   SkTileMode::kClamp);
 
         for (int i = 0; i < fPaints.count(); ++i) {
             canvas->save();
diff --git a/gm/rrectclipdrawpaint.cpp b/gm/rrectclipdrawpaint.cpp
index 291dc48..0636a2b 100644
--- a/gm/rrectclipdrawpaint.cpp
+++ b/gm/rrectclipdrawpaint.cpp
@@ -35,8 +35,7 @@
 
     constexpr SkPoint kPts[] = {{0.f, 0.f}, {256.f, 256.f}};
     constexpr SkColor kColors1[] = {SK_ColorCYAN, SK_ColorGREEN};
-    p.setShader(SkGradientShader::MakeLinear(kPts, kColors1, nullptr, 2,
-                                             SkShader::kClamp_TileMode));
+    p.setShader(SkGradientShader::MakeLinear(kPts, kColors1, nullptr, 2, SkTileMode::kClamp));
     canvas->concat(zoomOut);
     canvas->saveLayer(layerRect, nullptr);
     canvas->clipRRect(rrect, true);
@@ -45,7 +44,7 @@
 
     constexpr SkColor kColors2[] = {SK_ColorMAGENTA, SK_ColorGRAY};
     p.setShader(SkGradientShader::MakeRadial({128.f, 128.f}, 128.f, kColors2, nullptr, 2,
-                                             SkShader::kClamp_TileMode));
+                                             SkTileMode::kClamp));
     canvas->concat(zoomOut);
     canvas->saveLayer(layerRect, nullptr);
     canvas->clipRRect(rrect, false);
diff --git a/gm/samplerstress.cpp b/gm/samplerstress.cpp
index a2ea141..22404b9 100644
--- a/gm/samplerstress.cpp
+++ b/gm/samplerstress.cpp
@@ -72,8 +72,7 @@
 
         createTexture();
 
-        fShader = SkShader::MakeBitmapShader(fTexture, SkShader::kRepeat_TileMode,
-                                             SkShader::kRepeat_TileMode);
+        fShader = SkShader::MakeBitmapShader(fTexture, SkTileMode::kRepeat, SkTileMode::kRepeat);
     }
 
     void createMaskFilter() {
diff --git a/gm/savelayer.cpp b/gm/savelayer.cpp
index a116006..537bf86 100644
--- a/gm/savelayer.cpp
+++ b/gm/savelayer.cpp
@@ -140,7 +140,7 @@
     canvas->drawPaint(paint);
 
     paint.setShader(SkGradientShader::MakeRadial({cx, cy}, size / 4, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas->drawCircle(cx, cy, size / 4, paint);
 }
 
@@ -305,7 +305,7 @@
     // draw the treatment
     const SkPoint pts[] = { {r.fLeft,0}, {r.fRight, 0} };
     const SkColor colors[] = { 0x88000000, 0x0 };
-    auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
     p.setShader(sh);
     p.setBlendMode(SkBlendMode::kDstIn);
     canvas->drawRect(r, p);
diff --git a/gm/shadermaskfilter.cpp b/gm/shadermaskfilter.cpp
index 9925448..362a46a 100644
--- a/gm/shadermaskfilter.cpp
+++ b/gm/shadermaskfilter.cpp
@@ -39,7 +39,7 @@
         { r.fLeft, r.fTop }, { r.fRight, r.fBottom },
     };
     const SkColor colors[] = { 0, SK_ColorWHITE };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kRepeat_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kRepeat);
 }
 
 DEF_SIMPLE_GM(shadermaskfilter_gradient, canvas, 512, 512) {
@@ -96,9 +96,8 @@
 
     SkPictureRecorder recorder;
     recorder.beginRecording(1000, 1000)->drawPath(path, paint);
-    auto shader = SkShader::MakePictureShader(recorder.finishRecordingAsPicture(),
-                                              SkShader::kClamp_TileMode, SkShader::kClamp_TileMode,
-                                              nullptr, nullptr);
+    auto shader = recorder.finishRecordingAsPicture()->makeShader(SkTileMode::kClamp,
+                                                                  SkTileMode::kClamp);
     return SkShaderMaskFilter::Make(shader);
 }
 
@@ -245,14 +244,14 @@
                         ToolUtils::makeSurface(canvas, SkImageInfo::MakeN32Premul(kSize, kSize));
                 draw_mask(surface->getCanvas());
                 return surface->makeImageSnapshot()->makeShader(
-                        SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &lm);
+                        SkTileMode::kClamp, SkTileMode::kClamp, &lm);
             },
             [](SkCanvas*, const SkMatrix& lm) -> sk_sp<SkShader> {
                 SkPictureRecorder recorder;
                 draw_mask(recorder.beginRecording(kSize, kSize));
-                return SkShader::MakePictureShader(recorder.finishRecordingAsPicture(),
-                                                   SkShader::kClamp_TileMode,
-                                                   SkShader::kClamp_TileMode,
+                return recorder.finishRecordingAsPicture()->makeShader(
+                                                   SkTileMode::kClamp,
+                                                   SkTileMode::kClamp,
                                                    &lm,
                                                    nullptr);
             },
diff --git a/gm/shadertext3.cpp b/gm/shadertext3.cpp
index 83975ab..eeab37e 100644
--- a/gm/shadertext3.cpp
+++ b/gm/shadertext3.cpp
@@ -28,10 +28,10 @@
     SkPaint     paint;
 
     paint.setShader(SkGradientShader::MakeLinear(kPts0, kColors0, kPos,
-                    SK_ARRAY_COUNT(kColors0), SkShader::kClamp_TileMode));
+                    SK_ARRAY_COUNT(kColors0), SkTileMode::kClamp));
     canvas.drawPaint(paint);
     paint.setShader(SkGradientShader::MakeLinear(kPts1, kColors1, kPos,
-                    SK_ARRAY_COUNT(kColors1), SkShader::kClamp_TileMode));
+                    SK_ARRAY_COUNT(kColors1), SkTileMode::kClamp));
     canvas.drawPaint(paint);
 }
 
@@ -80,9 +80,9 @@
         // draw glyphs scaled up
         canvas->scale(2.f, 2.f);
 
-        constexpr SkShader::TileMode kTileModes[] = {
-            SkShader::kRepeat_TileMode,
-            SkShader::kMirror_TileMode,
+        constexpr SkTileMode kTileModes[] = {
+            SkTileMode::kRepeat,
+            SkTileMode::kMirror,
         };
 
         // position the baseline of the first run
diff --git a/gm/shadows.cpp b/gm/shadows.cpp
index 1160e49..1688f83 100644
--- a/gm/shadows.cpp
+++ b/gm/shadows.cpp
@@ -109,8 +109,8 @@
 
             canvas->translate(0, 40);
             paint.setShader(SkShader::MakeBitmapShader(
-                                          fBitmap, SkShader::kRepeat_TileMode,
-                                          SkShader::kRepeat_TileMode));
+                                          fBitmap, SkTileMode::kRepeat,
+                                          SkTileMode::kRepeat));
 
             // see bug.skia.org/562 (shows bug as reported)
             paint.setStyle(SkPaint::kFill_Style);
diff --git a/gm/shallowgradient.cpp b/gm/shallowgradient.cpp
index d2336ab..2cca3c1 100644
--- a/gm/shallowgradient.cpp
+++ b/gm/shallowgradient.cpp
@@ -12,19 +12,19 @@
 
 static sk_sp<SkShader> shader_linear(const SkColor colors[], int count, const SkSize& size) {
     SkPoint pts[] = { { 0, 0 }, { size.width(), size.height() } };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, count, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, count, SkTileMode::kClamp);
 }
 
 static sk_sp<SkShader> shader_radial(const SkColor colors[], int count, const SkSize& size) {
     SkPoint center = { size.width()/2, size.height()/2 };
     return SkGradientShader::MakeRadial(center, size.width()/2, colors, nullptr, count,
-                                        SkShader::kClamp_TileMode);
+                                        SkTileMode::kClamp);
 }
 
 static sk_sp<SkShader> shader_conical(const SkColor colors[], int count, const SkSize& size) {
     SkPoint center = { size.width()/2, size.height()/2 };
     return SkGradientShader::MakeTwoPointConical(center, size.width()/64, center, size.width()/2,
-                                                colors, nullptr, count, SkShader::kClamp_TileMode);
+                                                colors, nullptr, count, SkTileMode::kClamp);
 }
 
 static sk_sp<SkShader> shader_sweep(const SkColor colors[], int count, const SkSize& size) {
diff --git a/gm/skbug_257.cpp b/gm/skbug_257.cpp
index 919e980..f74ec62 100644
--- a/gm/skbug_257.cpp
+++ b/gm/skbug_257.cpp
@@ -24,8 +24,7 @@
     matrix.setScale(0.75f, 0.75f);
     matrix.preRotate(30.0f);
     paint->setShader(
-            SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode,
-                                       &matrix));
+            SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat, &matrix));
 }
 
 static void exercise_draw_pos_text(SkCanvas* canvas,
diff --git a/gm/srcmode.cpp b/gm/srcmode.cpp
index 88e9e42..fb9b434 100644
--- a/gm/srcmode.cpp
+++ b/gm/srcmode.cpp
@@ -25,7 +25,7 @@
     const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
     const SkPoint pts[] = { { 0, 0 }, { W, H } };
     paint->setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                                  SkShader::kClamp_TileMode));
+                                                  SkTileMode::kClamp));
 }
 
 typedef void (*Proc)(SkCanvas*, const SkPaint&, const SkFont&);
diff --git a/gm/stroke_rect_shader.cpp b/gm/stroke_rect_shader.cpp
index 1826f62..4833741 100644
--- a/gm/stroke_rect_shader.cpp
+++ b/gm/stroke_rect_shader.cpp
@@ -19,7 +19,7 @@
     constexpr SkColor kColors[] {SK_ColorRED, SK_ColorBLUE};
     SkPaint paint;
     sk_sp<SkShader> shader = SkGradientShader::MakeLinear(kPts, kColors, nullptr, 2,
-                                                          SkShader::kClamp_TileMode);
+                                                          SkTileMode::kClamp);
     paint.setShader(std::move(shader));
     paint.setStyle(SkPaint::kStroke_Style);
     // Do a large initial translate so that local coords disagree with device coords significantly
diff --git a/gm/strokedlines.cpp b/gm/strokedlines.cpp
index f14a95a..2eac0f2 100644
--- a/gm/strokedlines.cpp
+++ b/gm/strokedlines.cpp
@@ -127,8 +127,7 @@
             SkPoint pts[] = { {-kRadius-kPad, -kRadius-kPad }, { kRadius+kPad, kRadius+kPad } };
 
             SkPaint p;
-            p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                     SkShader::kClamp_TileMode, 0, nullptr));
+            p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
 
             fPaints.push_back(p);
         }
@@ -155,8 +154,8 @@
 
             SkPaint p;
             p.setShader(SkShader::MakeBitmapShader(bm,
-                                                   SkShader::kRepeat_TileMode,
-                                                   SkShader::kRepeat_TileMode,
+                                                   SkTileMode::kRepeat,
+                                                   SkTileMode::kRepeat,
                                                    &m));
             fPaints.push_back(p);
         }
diff --git a/gm/subsetshader.cpp b/gm/subsetshader.cpp
index 00f2687..5b49083 100644
--- a/gm/subsetshader.cpp
+++ b/gm/subsetshader.cpp
@@ -29,7 +29,7 @@
     SkMatrix matrix;
     matrix.setScale(0.75f, 0.75f);
     matrix.preRotate(30.0f);
-    SkShader::TileMode tm = SkShader::kRepeat_TileMode;
+    SkTileMode tm = SkTileMode::kRepeat;
     SkPaint paint;
     paint.setShader(SkShader::MakeBitmapShader(leftBitmap, tm, tm, &matrix));
     canvas->drawRect(SkRect::MakeWH(256.0f, 128.0f), paint);
diff --git a/gm/surface.cpp b/gm/surface.cpp
index 98c8abd..8606206 100644
--- a/gm/surface.cpp
+++ b/gm/surface.cpp
@@ -20,7 +20,7 @@
     int b = 0xBB;
     SkPoint pts[] = { { 0, 0 }, { W, H } };
     SkColor colors[] = { SkColorSetRGB(a, a, a), SkColorSetRGB(b, b, b) };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 static sk_sp<SkSurface> make_surface(GrContext* ctx, const SkImageInfo& info, SkPixelGeometry geo) {
@@ -196,7 +196,7 @@
     {
         SkPoint pts[] = {{0, 0}, {40, 50}};
         SkColor colors[] = {SK_ColorRED, SK_ColorBLUE};
-        auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kRepeat_TileMode);
+        auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kRepeat);
         SkPaint paint;
         paint.setShader(sh);
         surf->getCanvas()->drawPaint(paint);
@@ -225,7 +225,7 @@
     {
         SkPoint pts[] = {{SkIntToScalar(subset.left()), 0}, {SkIntToScalar(subset.right()), 0}};
         SkColor colors[] = {0xFF000000, 0};
-        auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+        auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
         SkPaint paint;
         paint.setShader(sh);
         paint.setBlendMode(SkBlendMode::kDstIn);
diff --git a/gm/tablecolorfilter.cpp b/gm/tablecolorfilter.cpp
index 44d690d..168c0b9 100644
--- a/gm/tablecolorfilter.cpp
+++ b/gm/tablecolorfilter.cpp
@@ -18,7 +18,7 @@
         SK_ColorRED, 0, SK_ColorBLUE, SK_ColorWHITE
     };
     return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                        SkShader::kClamp_TileMode);
+                                        SkTileMode::kClamp);
 }
 static void make_bm0(SkBitmap* bm) {
     int W = 120;
@@ -38,7 +38,7 @@
         SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE,
     };
     return SkGradientShader::MakeRadial(SkPoint::Make(cx, cy), cx, colors, nullptr,
-                                        SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode);
+                                        SK_ARRAY_COUNT(colors), SkTileMode::kClamp);
 }
 static void make_bm1(SkBitmap* bm) {
     int W = 120;
diff --git a/gm/testgradient.cpp b/gm/testgradient.cpp
index f871064..b2a4508 100644
--- a/gm/testgradient.cpp
+++ b/gm/testgradient.cpp
@@ -44,8 +44,7 @@
         SkColor colors[2] = {SK_ColorBLUE, SK_ColorYELLOW};
         SkPaint newPaint(paint);
         newPaint.setShader(SkGradientShader::MakeLinear(
-                points, colors, nullptr, 2,
-                SkShader::kClamp_TileMode, 0, nullptr));
+                points, colors, nullptr, 2, SkTileMode::kClamp));
         canvas->drawRect(rect, newPaint);
 
         SkRRect oval;
diff --git a/gm/textbloblooper.cpp b/gm/textbloblooper.cpp
index 73628f9..23b726c 100644
--- a/gm/textbloblooper.cpp
+++ b/gm/textbloblooper.cpp
@@ -87,7 +87,7 @@
         SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW,
     };
     return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                        SkShader::kClamp_TileMode);
+                                        SkTileMode::kClamp);
 }
 
 static void color_filter(SkPaint* paint) {
diff --git a/gm/textblobshader.cpp b/gm/textblobshader.cpp
index a4808e0..358005a 100644
--- a/gm/textblobshader.cpp
+++ b/gm/textblobshader.cpp
@@ -73,7 +73,7 @@
                                                SkIntToScalar(sz.height() / 2)),
                                                sz.width() * .66f, colors, pos,
                                                SK_ARRAY_COUNT(colors),
-                                               SkShader::kRepeat_TileMode);
+                                               SkTileMode::kRepeat);
     }
 
     SkString onShortName() override {
diff --git a/gm/tiledscaledbitmap.cpp b/gm/tiledscaledbitmap.cpp
index 78c54fd..8550805 100644
--- a/gm/tiledscaledbitmap.cpp
+++ b/gm/tiledscaledbitmap.cpp
@@ -62,8 +62,8 @@
         mat.setScale(121.f/360.f, 93.f/288.f);
         mat.postTranslate(-72, -72);
 
-        paint.setShader(SkShader::MakeBitmapShader(fBitmap, SkShader::kRepeat_TileMode,
-                                                   SkShader::kRepeat_TileMode, &mat));
+        paint.setShader(SkShader::MakeBitmapShader(fBitmap, SkTileMode::kRepeat,
+                                                   SkTileMode::kRepeat, &mat));
         canvas->drawRect({ 8, 8, 1008, 608 }, paint);
     }
 
diff --git a/gm/tilemodes.cpp b/gm/tilemodes.cpp
index fe5ae48..73d8cac 100644
--- a/gm/tilemodes.cpp
+++ b/gm/tilemodes.cpp
@@ -31,12 +31,12 @@
 
     paint.setDither(true);
     paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, SK_ARRAY_COUNT(colors),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas.drawPaint(paint);
 }
 
 static void setup(SkPaint* paint, const SkBitmap& bm, bool filter,
-                  SkShader::TileMode tmx, SkShader::TileMode tmy) {
+                  SkTileMode tmx, SkTileMode tmy) {
     paint->setShader(SkShader::MakeBitmapShader(bm, tmx, tmy));
     paint->setFilterQuality(filter ? kLow_SkFilterQuality : kNone_SkFilterQuality);
 }
@@ -91,8 +91,8 @@
         constexpr bool gFilters[] = { false, true };
         static const char* gFilterNames[] = { "point", "bilinear" };
 
-        constexpr SkShader::TileMode gModes[] = {
-            SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode };
+        constexpr SkTileMode gModes[] = {
+            SkTileMode::kClamp, SkTileMode::kRepeat, SkTileMode::kMirror };
         static const char* gModeNames[] = { "C", "R", "M" };
 
         SkScalar y = SkIntToScalar(24);
@@ -156,13 +156,13 @@
 constexpr int gWidth = 32;
 constexpr int gHeight = 32;
 
-static sk_sp<SkShader> make_bm(SkShader::TileMode tx, SkShader::TileMode ty) {
+static sk_sp<SkShader> make_bm(SkTileMode tx, SkTileMode ty) {
     SkBitmap bm;
     makebm(&bm, kN32_SkColorType, gWidth, gHeight);
     return SkShader::MakeBitmapShader(bm, tx, ty);
 }
 
-static sk_sp<SkShader> make_grad(SkShader::TileMode tx, SkShader::TileMode ty) {
+static sk_sp<SkShader> make_grad(SkTileMode tx, SkTileMode ty) {
     SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(gWidth), SkIntToScalar(gHeight)} };
     SkPoint center = { SkIntToScalar(gWidth)/2, SkIntToScalar(gHeight)/2 };
     SkScalar rad = SkIntToScalar(gWidth)/2;
@@ -181,7 +181,7 @@
     return nullptr;
 }
 
-typedef sk_sp<SkShader> (*ShaderProc)(SkShader::TileMode, SkShader::TileMode);
+typedef sk_sp<SkShader> (*ShaderProc)(SkTileMode, SkTileMode);
 
 class Tiling2GM : public skiagm::GM {
     ShaderProc fProc;
@@ -206,8 +206,8 @@
         const SkScalar h = SkIntToScalar(gHeight);
         SkRect r = { -w, -h, w*2, h*2 };
 
-        constexpr SkShader::TileMode gModes[] = {
-            SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode
+        constexpr SkTileMode gModes[] = {
+            SkTileMode::kClamp, SkTileMode::kRepeat, SkTileMode::kMirror
         };
         const char* gModeNames[] = {
             "Clamp", "Repeat", "Mirror"
@@ -268,30 +268,30 @@
     SkRect r = { -20, -20, img->width() + 20.0f, img->height() + 20.0f };
     canvas->translate(45, 45);
 
-    std::function<void(SkPaint*, SkShader::TileMode, SkShader::TileMode)> shader_procs[] = {
-        [img](SkPaint* paint, SkShader::TileMode tx, SkShader::TileMode ty) {
+    std::function<void(SkPaint*, SkTileMode, SkTileMode)> shader_procs[] = {
+        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
             // Test no filtering with decal mode
             paint->setShader(img->makeShader(tx, ty));
             paint->setFilterQuality(kNone_SkFilterQuality);
         },
-        [img](SkPaint* paint, SkShader::TileMode tx, SkShader::TileMode ty) {
+        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
             // Test bilerp approximation for decal mode (or clamp to border HW)
             paint->setShader(img->makeShader(tx, ty));
             paint->setFilterQuality(kLow_SkFilterQuality);
         },
-        [img](SkPaint* paint, SkShader::TileMode tx, SkShader::TileMode ty) {
+        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
             // Test bicubic filter with decal mode
             paint->setShader(img->makeShader(tx, ty));
             paint->setFilterQuality(kHigh_SkFilterQuality);
         },
-        [img](SkPaint* paint, SkShader::TileMode tx, SkShader::TileMode ty) {
+        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
             SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
             const SkPoint pts[] = {{ 0, 0 }, {img->width()*1.0f, img->height()*1.0f }};
             const SkScalar* pos = nullptr;
             const int count = SK_ARRAY_COUNT(colors);
             paint->setShader(SkGradientShader::MakeLinear(pts, colors, pos, count, tx));
         },
-        [img](SkPaint* paint, SkShader::TileMode tx, SkShader::TileMode ty) {
+        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
             SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
             const SkScalar* pos = nullptr;
             const int count = SK_ARRAY_COUNT(colors);
@@ -301,13 +301,13 @@
     };
 
     const struct XY {
-        SkShader::TileMode  fX;
-        SkShader::TileMode  fY;
+        SkTileMode  fX;
+        SkTileMode  fY;
     } pairs[] = {
-        { SkShader::kClamp_TileMode,    SkShader::kClamp_TileMode },
-        { SkShader::kClamp_TileMode,    SkShader::kDecal_TileMode },
-        { SkShader::kDecal_TileMode,    SkShader::kClamp_TileMode },
-        { SkShader::kDecal_TileMode,    SkShader::kDecal_TileMode },
+        { SkTileMode::kClamp,    SkTileMode::kClamp },
+        { SkTileMode::kClamp,    SkTileMode::kDecal },
+        { SkTileMode::kDecal,    SkTileMode::kClamp },
+        { SkTileMode::kDecal,    SkTileMode::kDecal },
     };
     for (const auto& p : pairs) {
         SkPaint paint;
diff --git a/gm/tilemodes_scaled.cpp b/gm/tilemodes_scaled.cpp
index 28e7949..0a5aec0 100644
--- a/gm/tilemodes_scaled.cpp
+++ b/gm/tilemodes_scaled.cpp
@@ -30,12 +30,12 @@
 
     paint.setDither(true);
     paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos,
-                SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+                SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
     canvas.drawPaint(paint);
 }
 
 static void setup(SkPaint* paint, const SkBitmap& bm, SkFilterQuality filter_level,
-                  SkShader::TileMode tmx, SkShader::TileMode tmy) {
+                  SkTileMode tmx, SkTileMode tmy) {
     paint->setShader(SkShader::MakeBitmapShader(bm, tmx, tmy));
     paint->setFilterQuality(filter_level);
 }
@@ -95,8 +95,8 @@
               kHigh_SkFilterQuality };
         const char* gFilterNames[] = { "None", "Low", "Medium", "High" };
 
-        constexpr SkShader::TileMode gModes[] = {
-            SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode };
+        constexpr SkTileMode gModes[] = {
+            SkTileMode::kClamp, SkTileMode::kRepeat, SkTileMode::kMirror };
         const char* gModeNames[] = { "C", "R", "M" };
 
         SkScalar y = SkIntToScalar(24);
@@ -156,13 +156,13 @@
 constexpr int gWidth = 32;
 constexpr int gHeight = 32;
 
-static sk_sp<SkShader> make_bm(SkShader::TileMode tx, SkShader::TileMode ty) {
+static sk_sp<SkShader> make_bm(SkTileMode tx, SkTileMode ty) {
     SkBitmap bm;
     makebm(&bm, kN32_SkColorType, gWidth, gHeight);
     return SkShader::MakeBitmapShader(bm, tx, ty);
 }
 
-static sk_sp<SkShader> make_grad(SkShader::TileMode tx, SkShader::TileMode ty) {
+static sk_sp<SkShader> make_grad(SkTileMode tx, SkTileMode ty) {
     SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(gWidth), SkIntToScalar(gHeight)} };
     SkPoint center = { SkIntToScalar(gWidth)/2, SkIntToScalar(gHeight)/2 };
     SkScalar rad = SkIntToScalar(gWidth)/2;
@@ -181,7 +181,7 @@
     return nullptr;
 }
 
-typedef sk_sp<SkShader> (*ShaderProc)(SkShader::TileMode, SkShader::TileMode);
+typedef sk_sp<SkShader> (*ShaderProc)(SkTileMode, SkTileMode);
 
 class ScaledTiling2GM : public skiagm::GM {
     ShaderProc fProc;
@@ -206,8 +206,8 @@
         const SkScalar h = SkIntToScalar(gHeight);
         SkRect r = { -w, -h, w*2, h*2 };
 
-        constexpr SkShader::TileMode gModes[] = {
-            SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode
+        constexpr SkTileMode gModes[] = {
+            SkTileMode::kClamp, SkTileMode::kRepeat, SkTileMode::kMirror
         };
         const char* gModeNames[] = {
             "Clamp", "Repeat", "Mirror"
diff --git a/gm/tinybitmap.cpp b/gm/tinybitmap.cpp
index 856d288..75e5e75 100644
--- a/gm/tinybitmap.cpp
+++ b/gm/tinybitmap.cpp
@@ -37,8 +37,7 @@
         SkBitmap bm = make_bitmap();
         SkPaint paint;
         paint.setAlphaf(0.5f);
-        paint.setShader(SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
-                                                   SkShader::kMirror_TileMode));
+        paint.setShader(SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kMirror));
         canvas->drawPaint(paint);
     }
 
diff --git a/gm/transparency.cpp b/gm/transparency.cpp
index 1b008fe..8a27572 100644
--- a/gm/transparency.cpp
+++ b/gm/transparency.cpp
@@ -30,8 +30,7 @@
         shaderColors[0] = SK_AlphaTRANSPARENT;
         shaderColors[1] = kColors[i];
         SkPaint p;
-        p.setShader(SkGradientShader::MakeLinear(pts, shaderColors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+        p.setShader(SkGradientShader::MakeLinear(pts, shaderColors, nullptr, 2, SkTileMode::kClamp));
         canvas->drawRect(SkRect::MakeXYWH(0, i * kRowHeight, width, kRowHeight), p);
     }
 }
@@ -43,7 +42,7 @@
     bm.eraseColor(c1);
     bm.eraseArea(SkIRect::MakeLTRB(0, 0, size, size), c2);
     bm.eraseArea(SkIRect::MakeLTRB(size, size, 2 * size, 2 * size), c2);
-    return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat);
 }
 
 // http://crrev.com/834303005
diff --git a/gm/vertices.cpp b/gm/vertices.cpp
index 3d348eb..1592715 100644
--- a/gm/vertices.cpp
+++ b/gm/vertices.cpp
@@ -24,7 +24,7 @@
 
     sk_sp<SkShader> grad = SkGradientShader::MakeLinear(pts, colors, nullptr,
                                                         SK_ARRAY_COUNT(colors),
-                                                        SkShader::kMirror_TileMode, 0,
+                                                        SkTileMode::kMirror, 0,
                                                         &localMatrix);
     // Throw in a couple of local matrix wrappers for good measure.
     return shaderScale == 1
diff --git a/gm/verylargebitmap.cpp b/gm/verylargebitmap.cpp
index 158a103..d6e3d96 100644
--- a/gm/verylargebitmap.cpp
+++ b/gm/verylargebitmap.cpp
@@ -17,7 +17,7 @@
     const SkScalar radius = 40;
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeRadial(center, radius, colors, nullptr, 2,
-                                                 SkShader::kMirror_TileMode));
+                                                 SkTileMode::kMirror));
     paint.setBlendMode(SkBlendMode::kSrc);
     canvas->drawPaint(paint);
 }
diff --git a/gm/xfermodes.cpp b/gm/xfermodes.cpp
index 239555b..542e9d3 100644
--- a/gm/xfermodes.cpp
+++ b/gm/xfermodes.cpp
@@ -222,8 +222,7 @@
         const SkScalar h = SkIntToScalar(H);
         SkMatrix m;
         m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-        auto s = SkShader::MakeBitmapShader(fBG, SkShader::kRepeat_TileMode,
-                                            SkShader::kRepeat_TileMode, &m);
+        auto s = SkShader::MakeBitmapShader(fBG, SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
 
         SkPaint labelP;
         labelP.setAntiAlias(true);
diff --git a/gm/xfermodes2.cpp b/gm/xfermodes2.cpp
index ebc0db1..0088436 100644
--- a/gm/xfermodes2.cpp
+++ b/gm/xfermodes2.cpp
@@ -95,8 +95,7 @@
 
         SkMatrix lm;
         lm.setScale(SkIntToScalar(16), SkIntToScalar(16));
-        fBG = SkShader::MakeBitmapShader(bg, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode,
-                                         &lm);
+        fBG = SkShader::MakeBitmapShader(bg, SkTileMode::kRepeat, SkTileMode::kRepeat, &lm);
 
         SkBitmap srcBmp;
         srcBmp.allocN32Pixels(kSize, kSize);
@@ -109,8 +108,7 @@
                 pixels[kSize * y + x] = rowColor;
             }
         }
-        fSrc = SkShader::MakeBitmapShader(srcBmp, SkShader::kClamp_TileMode,
-                                          SkShader::kClamp_TileMode);
+        fSrc = SkShader::MakeBitmapShader(srcBmp, SkTileMode::kClamp, SkTileMode::kClamp);
         SkBitmap dstBmp;
         dstBmp.allocN32Pixels(kSize, kSize);
         pixels = reinterpret_cast<SkPMColor*>(dstBmp.getPixels());
@@ -122,8 +120,7 @@
                 pixels[kSize * y + x] = colColor;
             }
         }
-        fDst = SkShader::MakeBitmapShader(dstBmp, SkShader::kClamp_TileMode,
-                                          SkShader::kClamp_TileMode);
+        fDst = SkShader::MakeBitmapShader(dstBmp, SkTileMode::kClamp, SkTileMode::kClamp);
     }
 
     enum {
diff --git a/gm/xfermodes3.cpp b/gm/xfermodes3.cpp
index ec0bba9..c7bbe44 100644
--- a/gm/xfermodes3.cpp
+++ b/gm/xfermodes3.cpp
@@ -169,8 +169,7 @@
 
         SkMatrix lm;
         lm.setScale(SkIntToScalar(kCheckSize), SkIntToScalar(kCheckSize));
-        fBGShader = SkShader::MakeBitmapShader(bg, SkShader::kRepeat_TileMode,
-                                               SkShader::kRepeat_TileMode, &lm);
+        fBGShader = SkShader::MakeBitmapShader(bg, SkTileMode::kRepeat, SkTileMode::kRepeat, &lm);
 
         SkPaint bmpPaint;
         const SkPoint kCenter = { SkIntToScalar(kSize) / 2, SkIntToScalar(kSize) / 2 };
@@ -179,7 +178,7 @@
         };
         bmpPaint.setShader(SkGradientShader::MakeRadial(kCenter, 3 * SkIntToScalar(kSize) / 4,
                                                         kColors, nullptr, SK_ARRAY_COUNT(kColors),
-                                                        SkShader::kRepeat_TileMode));
+                                                        SkTileMode::kRepeat));
 
         SkBitmap bmp;
         bmp.allocN32Pixels(kSize, kSize);
@@ -190,8 +189,7 @@
                         7 * SkIntToScalar(kSize) / 8, 7 * SkIntToScalar(kSize) / 8};
         bmpCanvas.drawRect(rect, bmpPaint);
 
-        fBmpShader = SkShader::MakeBitmapShader(bmp, SkShader::kClamp_TileMode,
-                                                SkShader::kClamp_TileMode);
+        fBmpShader = SkShader::MakeBitmapShader(bmp, SkTileMode::kClamp, SkTileMode::kClamp);
     }
 
     enum {
diff --git a/include/core/SkImage.h b/include/core/SkImage.h
index 3cd8efe..020c8c2 100644
--- a/include/core/SkImage.h
+++ b/include/core/SkImage.h
@@ -681,12 +681,13 @@
     */
     sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy,
                                const SkMatrix* localMatrix = nullptr) const;
-    // DEPRECATED. Use SkTileMode
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
     sk_sp<SkShader> makeShader(SkShader::TileMode tmx, SkShader::TileMode tmy,
                                const SkMatrix* localMatrix = nullptr) const {
         return this->makeShader(static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy),
                                 localMatrix);
     }
+#endif
 
     /** Creates SkShader from SkImage. SkShader dimensions are taken from SkImage. SkShader uses
         SkShader::kClamp_TileMode to fill drawn area outside SkImage. localMatrix permits
diff --git a/include/core/SkShader.h b/include/core/SkShader.h
index 3ab87f0..927417f 100644
--- a/include/core/SkShader.h
+++ b/include/core/SkShader.h
@@ -28,6 +28,10 @@
 class GrContext;
 class GrFragmentProcessor;
 
+#ifndef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+#define SK_SUPPORT_LEGACY_TILEMODE_ENUM
+#endif
+
 /** \class SkShader
  *
  *  Shaders specify the source color(s) for what is being drawn. If a paint
@@ -40,6 +44,7 @@
  */
 class SK_API SkShader : public SkFlattenable {
 public:
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
     enum TileMode {
         /**
          *  Replicate the edge color if the shader draws outside of its
@@ -67,6 +72,7 @@
     };
 
     static constexpr int kTileModeCount = kLast_TileMode + 1;
+#endif
 
     /**
      *  Returns the local matrix.
@@ -88,10 +94,15 @@
      *  Iff this shader is backed by a single SkImage, return its ptr (the caller must ref this
      *  if they want to keep it longer than the lifetime of the shader). If not, return nullptr.
      */
-    SkImage* isAImage(SkMatrix* localMatrix, TileMode xy[2]) const;
+    SkImage* isAImage(SkMatrix* localMatrix, SkTileMode xy[2]) const;
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    SkImage* isAImage(SkMatrix* localMatrix, TileMode xy[2]) const {
+        return this->isAImage(localMatrix, (SkTileMode*)xy);
+    }
+#endif
 
     bool isAImage() const {
-        return this->isAImage(nullptr, nullptr) != nullptr;
+        return this->isAImage(nullptr, (SkTileMode*)nullptr) != nullptr;
     }
 
     /**
@@ -142,7 +153,11 @@
         SkScalar*   fColorOffsets;  //!< The unit offset for color transitions.
         SkPoint     fPoint[2];      //!< Type specific, see above.
         SkScalar    fRadius[2];     //!< Type specific, see above.
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
         TileMode    fTileMode;      //!< The tile mode used.
+#else
+        SkTileMode  fTileMode;
+#endif
         uint32_t    fGradientFlags; //!< see SkGradientShader::Flags
     };
 
@@ -224,15 +239,13 @@
     */
     static sk_sp<SkShader> MakeBitmapShader(const SkBitmap& src, SkTileMode tmx, SkTileMode tmy,
                                             const SkMatrix* localMatrix = nullptr);
-    // DEPRECATED. Use SkTileMode
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
     static sk_sp<SkShader> MakeBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy,
                                             const SkMatrix* localMatrix = nullptr) {
         return MakeBitmapShader(src, static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy),
                                 localMatrix);
     }
 
-    // NOTE: You can create an SkImage Shader with SkImage::newShader().
-
     /** DEPRECATED: call picture->makeShader(...)
      *  Call this to create a new shader that will draw with the specified picture.
      *
@@ -250,6 +263,7 @@
     */
     static sk_sp<SkShader> MakePictureShader(sk_sp<SkPicture> src, TileMode tmx, TileMode tmy,
                                              const SkMatrix* localMatrix, const SkRect* tile);
+#endif
 
     /** DEPRECATED. skbug.com/8941
      *  If this shader can be represented by another shader + a localMatrix, return that shader and
diff --git a/include/effects/SkGradientShader.h b/include/effects/SkGradientShader.h
index 3b537a5..2706eb1 100644
--- a/include/effects/SkGradientShader.h
+++ b/include/effects/SkGradientShader.h
@@ -69,13 +69,26 @@
     */
     static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
                                       const SkColor colors[], const SkScalar pos[], int count,
-                                      SkShader::TileMode mode,
+                                      SkTileMode mode,
                                       uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
                                       const SkColor colors[], const SkScalar pos[], int count,
+                                      SkTileMode mode) {
+        return MakeLinear(pts, colors, pos, count, mode, 0, nullptr);
+    }
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
+                                      const SkColor colors[], const SkScalar pos[], int count,
+                                      SkShader::TileMode mode,
+                                      uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeLinear(pts, colors, pos, count, (SkTileMode)mode, flags, localMatrix);
+    }
+    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
+                                      const SkColor colors[], const SkScalar pos[], int count,
                                       SkShader::TileMode mode) {
         return MakeLinear(pts, colors, pos, count, mode, 0, nullptr);
     }
+#endif
 
     /** Returns a shader that generates a linear gradient between the two specified points.
         <p />
@@ -91,13 +104,26 @@
     */
     static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
                                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
-                                      const SkScalar pos[], int count, SkShader::TileMode mode,
+                                      const SkScalar pos[], int count, SkTileMode mode,
                                       uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
                                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
+                                      const SkScalar pos[], int count, SkTileMode mode) {
+        return MakeLinear(pts, colors, std::move(colorSpace), pos, count, mode, 0, nullptr);
+    }
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
+                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
+                                      const SkScalar pos[], int count, SkShader::TileMode mode,
+                                      uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeLinear(pts, colors, colorSpace, pos, count, (SkTileMode)mode, flags, localMatrix);
+    }
+    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
+                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
                                       const SkScalar pos[], int count, SkShader::TileMode mode) {
         return MakeLinear(pts, colors, std::move(colorSpace), pos, count, mode, 0, nullptr);
     }
+#endif
 
     /** Returns a shader that generates a radial gradient given the center and radius.
         <p />
@@ -114,13 +140,26 @@
     */
     static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
                                       const SkColor colors[], const SkScalar pos[], int count,
-                                      SkShader::TileMode mode,
+                                      SkTileMode mode,
                                       uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
                                       const SkColor colors[], const SkScalar pos[], int count,
+                                      SkTileMode mode) {
+        return MakeRadial(center, radius, colors, pos, count, mode, 0, nullptr);
+    }
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
+                                      const SkColor colors[], const SkScalar pos[], int count,
+                                      SkShader::TileMode mode,
+                                      uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeRadial(center, radius, colors, pos, count, (SkTileMode)mode, flags, localMatrix);
+    }
+    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
+                                      const SkColor colors[], const SkScalar pos[], int count,
                                       SkShader::TileMode mode) {
         return MakeRadial(center, radius, colors, pos, count, mode, 0, nullptr);
     }
+#endif
 
     /** Returns a shader that generates a radial gradient given the center and radius.
         <p />
@@ -137,14 +176,29 @@
     */
     static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
                                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
-                                      const SkScalar pos[], int count, SkShader::TileMode mode,
+                                      const SkScalar pos[], int count, SkTileMode mode,
                                       uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
                                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
+                                      const SkScalar pos[], int count, SkTileMode mode) {
+        return MakeRadial(center, radius, colors, std::move(colorSpace), pos, count, mode,
+                          0, nullptr);
+    }
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
+                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
+                                      const SkScalar pos[], int count, SkShader::TileMode mode,
+                                      uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeRadial(center, radius, colors, colorSpace, pos, count, (SkTileMode)mode,
+                          flags, localMatrix);
+    }
+    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
+                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
                                       const SkScalar pos[], int count, SkShader::TileMode mode) {
         return MakeRadial(center, radius, colors, std::move(colorSpace), pos, count, mode,
                           0, nullptr);
     }
+#endif
 
     /**
      *  Returns a shader that generates a conical gradient given two circles, or
@@ -155,15 +209,32 @@
     static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
                                                const SkPoint& end, SkScalar endRadius,
                                                const SkColor colors[], const SkScalar pos[],
-                                               int count, SkShader::TileMode mode,
+                                               int count, SkTileMode mode,
                                                uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
                                                const SkPoint& end, SkScalar endRadius,
                                                const SkColor colors[], const SkScalar pos[],
+                                               int count, SkTileMode mode) {
+        return MakeTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode,
+                                   0, nullptr);
+    }
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
+                                               const SkPoint& end, SkScalar endRadius,
+                                               const SkColor colors[], const SkScalar pos[],
+                                               int count, SkShader::TileMode mode,
+                                               uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeTwoPointConical(start, startRadius, end, endRadius, colors, pos, count,
+                                   (SkTileMode)mode, flags, localMatrix);
+    }
+    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
+                                               const SkPoint& end, SkScalar endRadius,
+                                               const SkColor colors[], const SkScalar pos[],
                                                int count, SkShader::TileMode mode) {
         return MakeTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode,
                                    0, nullptr);
     }
+#endif
 
     /**
      *  Returns a shader that generates a conical gradient given two circles, or
@@ -175,16 +246,35 @@
                                                const SkPoint& end, SkScalar endRadius,
                                                const SkColor4f colors[],
                                                sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
-                                               int count, SkShader::TileMode mode,
+                                               int count, SkTileMode mode,
                                                uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
                                                const SkPoint& end, SkScalar endRadius,
                                                const SkColor4f colors[],
                                                sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
+                                               int count, SkTileMode mode) {
+        return MakeTwoPointConical(start, startRadius, end, endRadius, colors,
+                                   std::move(colorSpace), pos, count, mode, 0, nullptr);
+    }
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
+                                               const SkPoint& end, SkScalar endRadius,
+                                               const SkColor4f colors[],
+                                               sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
+                                               int count, SkShader::TileMode mode,
+                                               uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeTwoPointConical(start, startRadius, end, endRadius, colors, colorSpace, pos,
+                                   count, (SkTileMode)mode, flags, localMatrix);
+    }
+    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
+                                               const SkPoint& end, SkScalar endRadius,
+                                               const SkColor4f colors[],
+                                               sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
                                                int count, SkShader::TileMode mode) {
         return MakeTwoPointConical(start, startRadius, end, endRadius, colors,
                                    std::move(colorSpace), pos, count, mode, 0, nullptr);
     }
+#endif
 
     /** Returns a shader that generates a sweep gradient given a center.
         <p />
@@ -204,19 +294,29 @@
     */
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
                                      const SkColor colors[], const SkScalar pos[], int count,
-                                     SkShader::TileMode mode,
+                                     SkTileMode mode,
                                      SkScalar startAngle, SkScalar endAngle,
                                      uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
                                      const SkColor colors[], const SkScalar pos[], int count,
                                      uint32_t flags, const SkMatrix* localMatrix) {
-        return MakeSweep(cx, cy, colors, pos, count, SkShader::kClamp_TileMode, 0, 360, flags,
+        return MakeSweep(cx, cy, colors, pos, count, SkTileMode::kClamp, 0, 360, flags,
                          localMatrix);
     }
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
                                      const SkColor colors[], const SkScalar pos[], int count) {
         return MakeSweep(cx, cy, colors, pos, count, 0, nullptr);
     }
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
+                                     const SkColor colors[], const SkScalar pos[], int count,
+                                     SkShader::TileMode mode,
+                                     SkScalar startAngle, SkScalar endAngle,
+                                     uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeSweep(cx, cy, colors, pos, count, (SkTileMode)mode, startAngle, endAngle,
+                         flags, localMatrix);
+    }
+#endif
 
     /** Returns a shader that generates a sweep gradient given a center.
         <p />
@@ -237,7 +337,7 @@
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
                                      const SkScalar pos[], int count,
-                                     SkShader::TileMode mode,
+                                     SkTileMode mode,
                                      SkScalar startAngle, SkScalar endAngle,
                                      uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
@@ -245,13 +345,24 @@
                                      const SkScalar pos[], int count,
                                      uint32_t flags, const SkMatrix* localMatrix) {
         return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count,
-                         SkShader::kClamp_TileMode, 0, 360, flags, localMatrix);
+                         SkTileMode::kClamp, 0, 360, flags, localMatrix);
     }
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
                                      const SkScalar pos[], int count) {
         return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count, 0, nullptr);
     }
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
+                                     const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
+                                     const SkScalar pos[], int count,
+                                     SkShader::TileMode mode,
+                                     SkScalar startAngle, SkScalar endAngle,
+                                     uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeSweep(cx, cy, colors, colorSpace, pos, count, (SkTileMode)mode, startAngle,
+                         endAngle, flags, localMatrix);
+    }
+#endif
 
     static void RegisterFlattenables();
 };
diff --git a/modules/sksg/include/SkSGGradient.h b/modules/sksg/include/SkSGGradient.h
index 1950726..c58b77d 100644
--- a/modules/sksg/include/SkSGGradient.h
+++ b/modules/sksg/include/SkSGGradient.h
@@ -34,7 +34,7 @@
     };
 
     SG_ATTRIBUTE(ColorStops, std::vector<ColorStop>, fColorStops)
-    SG_ATTRIBUTE(TileMode  , SkShader::TileMode    , fTileMode  )
+    SG_ATTRIBUTE(TileMode  , SkTileMode            , fTileMode  )
 
 protected:
     sk_sp<SkShader> onRevalidateShader() final;
@@ -47,7 +47,7 @@
 
 private:
     std::vector<ColorStop> fColorStops;
-    SkShader::TileMode     fTileMode = SkShader::kClamp_TileMode;
+    SkTileMode             fTileMode = SkTileMode::kClamp;
 
     using INHERITED = Shader;
 };
diff --git a/samplecode/PerlinPatch.cpp b/samplecode/PerlinPatch.cpp
index 8bac913..c67f0f0 100644
--- a/samplecode/PerlinPatch.cpp
+++ b/samplecode/PerlinPatch.cpp
@@ -104,7 +104,7 @@
                                                   colors,
                                                   nullptr,
                                                   3,
-                                                  SkShader::kMirror_TileMode,
+                                                  SkTileMode::kMirror,
                                                   0,
                                                   nullptr);
     }
diff --git a/samplecode/Sample2PtRadial.cpp b/samplecode/Sample2PtRadial.cpp
index 8d1fcc4..5a93bd0 100644
--- a/samplecode/Sample2PtRadial.cpp
+++ b/samplecode/Sample2PtRadial.cpp
@@ -33,7 +33,7 @@
         SkPaint paint;
         paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors,
                                                              nullptr, 2,
-                                                             SkShader::kClamp_TileMode));
+                                                             SkTileMode::kClamp));
         canvas->drawPaint(paint);
     }
 
diff --git a/samplecode/SampleAARectModes.cpp b/samplecode/SampleAARectModes.cpp
index b10a9ef..3b9bb76 100644
--- a/samplecode/SampleAARectModes.cpp
+++ b/samplecode/SampleAARectModes.cpp
@@ -65,10 +65,7 @@
     SkMatrix m;
     m.setScale(SkIntToScalar(6), SkIntToScalar(6));
 
-    return SkShader::MakeBitmapShader(bm,
-                                      SkShader::kRepeat_TileMode,
-                                      SkShader::kRepeat_TileMode,
-                                      &m);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
 }
 
 class AARectsModesView : public Sample {
diff --git a/samplecode/SampleAARects.cpp b/samplecode/SampleAARects.cpp
index 211b411..d909af3 100644
--- a/samplecode/SampleAARects.cpp
+++ b/samplecode/SampleAARects.cpp
@@ -59,8 +59,8 @@
         SkPaint bluePaint;
         bluePaint.setARGB(0xff, 0x0, 0x0, 0xff);
         SkPaint bmpPaint;
-        bmpPaint.setShader(SkShader::MakeBitmapShader(fBitmap, SkShader::kRepeat_TileMode,
-                                                      SkShader::kRepeat_TileMode));
+        bmpPaint.setShader(SkShader::MakeBitmapShader(fBitmap, SkTileMode::kRepeat,
+                                                      SkTileMode::kRepeat));
         bluePaint.setStrokeWidth(3);
         bmpPaint.setStrokeWidth(3);
 
diff --git a/samplecode/SampleBigGradient.cpp b/samplecode/SampleBigGradient.cpp
index c921c37..dbfc332 100644
--- a/samplecode/SampleBigGradient.cpp
+++ b/samplecode/SampleBigGradient.cpp
@@ -1,4 +1,4 @@
-﻿/*
+/*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
@@ -13,7 +13,7 @@
 static sk_sp<SkShader> make_grad(SkScalar w, SkScalar h) {
     SkColor colors[] = { 0xFF000000, 0xFF333333 };
     SkPoint pts[] = { { 0, 0 }, { w, h } };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 class BigGradientView : public Sample {
diff --git a/samplecode/SampleBitmapRect.cpp b/samplecode/SampleBitmapRect.cpp
index d5261ad..0d9b7f8 100644
--- a/samplecode/SampleBitmapRect.cpp
+++ b/samplecode/SampleBitmapRect.cpp
@@ -36,8 +36,7 @@
     paint.setAntiAlias(true);
     const SkPoint pts[] = { { 0, 0 }, { SCALAR_SIZE, SCALAR_SIZE } };
     const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                   SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
     canvas.drawCircle(SCALAR_SIZE/2, SCALAR_SIZE/2, SCALAR_SIZE/2, paint);
 }
 
diff --git a/samplecode/SampleCamera.cpp b/samplecode/SampleCamera.cpp
index ec30606..e3aca05 100644
--- a/samplecode/SampleCamera.cpp
+++ b/samplecode/SampleCamera.cpp
@@ -40,9 +40,9 @@
                 matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
 
                 fShaders.push_back(SkShader::MakeBitmapShader(bm,
-                                                           SkShader::kClamp_TileMode,
-                                                           SkShader::kClamp_TileMode,
-                                                           &matrix));
+                                                              SkTileMode::kClamp,
+                                                              SkTileMode::kClamp,
+                                                              &matrix));
             } else {
                 break;
             }
diff --git a/samplecode/SampleDegenerateTwoPtRadials.cpp b/samplecode/SampleDegenerateTwoPtRadials.cpp
index eb04d22..6721669 100644
--- a/samplecode/SampleDegenerateTwoPtRadials.cpp
+++ b/samplecode/SampleDegenerateTwoPtRadials.cpp
@@ -30,7 +30,7 @@
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors,
                                                           pos, SK_ARRAY_COUNT(pos),
-                                                          SkShader::kClamp_TileMode));
+                                                          SkTileMode::kClamp));
     canvas->drawRect(rect, paint);
 }
 
diff --git a/samplecode/SampleEffects.cpp b/samplecode/SampleEffects.cpp
index 4540cd7..31a4d37 100644
--- a/samplecode/SampleEffects.cpp
+++ b/samplecode/SampleEffects.cpp
@@ -36,7 +36,7 @@
     SkColor colors[] = { SK_ColorRED, COLOR, SK_ColorBLUE };
     SkPoint pts[] = { { 3, 0 }, { 7, 5 } };
     paint->setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                                  SkShader::kMirror_TileMode));
+                                                  SkTileMode::kMirror));
 }
 
 static void paint_proc5(SkPaint* paint) {
diff --git a/samplecode/SampleGradients.cpp b/samplecode/SampleGradients.cpp
index 2ec26a5..a0ae5d4 100644
--- a/samplecode/SampleGradients.cpp
+++ b/samplecode/SampleGradients.cpp
@@ -11,7 +11,7 @@
 static sk_sp<SkShader> setgrad(const SkRect& r, SkColor c0, SkColor c1) {
     SkColor colors[] = { c0, c1 };
     SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fTop } };
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 }
 
 static void test_alphagradients(SkCanvas* canvas) {
@@ -61,11 +61,11 @@
     { 5, gColors, gPos2 }
 };
 
-static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -73,14 +73,14 @@
                                         data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -93,7 +93,7 @@
 }
 
 static sk_sp<SkShader> Make2ConicalConcentric(const SkPoint pts[2], const GradData& data,
-                                       SkShader::TileMode tm) {
+                                       SkTileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -103,7 +103,7 @@
                             data.fColors, data.fPos, data.fCount, tm);
 }
 
-typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
+typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkTileMode tm);
 
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Conical, Make2ConicalConcentric
@@ -138,12 +138,12 @@
         canvas->save();
         canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
 
-        for (int tm = 0; tm < SkShader::kTileModeCount; ++tm) {
+        for (int tm = 0; tm < kSkTileModeCount; ++tm) {
             canvas->save();
             for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
                 canvas->save();
                 for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
-                    paint.setShader(gGradMakers[j](pts, gGradData[i], (SkShader::TileMode)tm));
+                    paint.setShader(gGradMakers[j](pts, gGradData[i], (SkTileMode)tm));
                     canvas->drawRect(r, paint);
                     canvas->translate(0, SkIntToScalar(120));
                 }
diff --git a/samplecode/SampleHairModes.cpp b/samplecode/SampleHairModes.cpp
index d162bba..3885bf2 100644
--- a/samplecode/SampleHairModes.cpp
+++ b/samplecode/SampleHairModes.cpp
@@ -64,8 +64,7 @@
     SkMatrix m;
     m.setScale(SkIntToScalar(6), SkIntToScalar(6));
 
-    return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
-                                      SkShader::kRepeat_TileMode, &m);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
 }
 
 class HairModesView : public Sample {
diff --git a/samplecode/SampleLayers.cpp b/samplecode/SampleLayers.cpp
index 6b77e97..b4b51a9 100644
--- a/samplecode/SampleLayers.cpp
+++ b/samplecode/SampleLayers.cpp
@@ -27,7 +27,7 @@
     SkColor colors[] = { 0, SK_ColorWHITE };
     SkPoint pts[] = { { 0, 0 }, { 0, SK_Scalar1*20 } };
     paint->setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                  SkShader::kClamp_TileMode, 0, &localMatrix));
+                                                  SkTileMode::kClamp, 0, &localMatrix));
     paint->setBlendMode(SkBlendMode::kDstIn);
 }
 
diff --git a/samplecode/SampleLighting.cpp b/samplecode/SampleLighting.cpp
index 28bdea3..a3dc621 100644
--- a/samplecode/SampleLighting.cpp
+++ b/samplecode/SampleLighting.cpp
@@ -39,9 +39,7 @@
             fRect = SkRect::MakeIWH(diffuseBitmap.width(), diffuseBitmap.height());
 
             fDiffuseShader = SkShader::MakeBitmapShader(diffuseBitmap,
-                                                        SkShader::kClamp_TileMode,
-                                                        SkShader::kClamp_TileMode,
-                                                        nullptr);
+                                                        SkTileMode::kClamp, SkTileMode::kClamp);
         }
 
         {
@@ -49,9 +47,8 @@
             SkAssertResult(GetResourceAsBitmap("images/brickwork_normal-map.jpg", &normalBitmap));
 
             sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(normalBitmap,
-                                                                   SkShader::kClamp_TileMode,
-                                                                   SkShader::kClamp_TileMode,
-                                                                   nullptr);
+                                                                   SkTileMode::kClamp,
+                                                                   SkTileMode::kClamp);
             fNormalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap), SkMatrix::I());
         }
     }
diff --git a/samplecode/SampleLitAtlas.cpp b/samplecode/SampleLitAtlas.cpp
index 2142aff..a9e5762 100644
--- a/samplecode/SampleLitAtlas.cpp
+++ b/samplecode/SampleLitAtlas.cpp
@@ -132,12 +132,12 @@
             SkMatrix m;
             m.setRSXform(xforms[i]);
 
-            sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(fAtlas, SkShader::kClamp_TileMode,
-                    SkShader::kClamp_TileMode, &normalMat);
+            sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(fAtlas, SkTileMode::kClamp,
+                    SkTileMode::kClamp, &normalMat);
             sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(
                     std::move(normalMap), m);
             sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(fAtlas,
-                    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &diffMat);
+                    SkTileMode::kClamp, SkTileMode::kClamp, &diffMat);
             paint.setShader(SkLightingShader::Make(std::move(diffuseShader),
                     std::move(normalSource), fLights));
 
diff --git a/samplecode/SamplePatch.cpp b/samplecode/SamplePatch.cpp
index 4503381..b7f5f36 100644
--- a/samplecode/SamplePatch.cpp
+++ b/samplecode/SamplePatch.cpp
@@ -33,8 +33,7 @@
 //    decode_file("/skimages/progressivejpg.jpg", &bm);
     decode_file("/skimages/logo.png", &bm);
     size->set(bm.width(), bm.height());
-    return SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode,
-                                       SkShader::kClamp_TileMode);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kClamp, SkTileMode::kClamp);
 }
 
 static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
@@ -42,7 +41,7 @@
                       { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
     SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
     return SkGradientShader::MakeLinear(pts, colors, nullptr,
-                    SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode);
+                    SK_ARRAY_COUNT(colors), SkTileMode::kMirror);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/samplecode/SampleRegion.cpp b/samplecode/SampleRegion.cpp
index c5eaf00..47e46af 100644
--- a/samplecode/SampleRegion.cpp
+++ b/samplecode/SampleRegion.cpp
@@ -81,7 +81,7 @@
     const SkScalar pos[] = { 0, 0.9f, SK_Scalar1 };
 
     SkPaint p;
-    p.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 3, SkShader::kClamp_TileMode));
+    p.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 3, SkTileMode::kClamp));
     p.setBlendMode(SkBlendMode::kDstIn);
     canvas->drawRect(bounds, p);
 
@@ -109,7 +109,7 @@
     const SkScalar pos[] = { 0, 0.9f, 1 };
     paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos,
                                                  SK_ARRAY_COUNT(colors),
-                                                 SkShader::kClamp_TileMode));
+                                                 SkTileMode::kClamp));
     canvas->drawSimpleText(str, len, kUTF8_SkTextEncoding, x, y, font, paint);
 
     y += 20;
diff --git a/samplecode/SampleRepeatTile.cpp b/samplecode/SampleRepeatTile.cpp
index 7eff1c7..f2d51de 100644
--- a/samplecode/SampleRepeatTile.cpp
+++ b/samplecode/SampleRepeatTile.cpp
@@ -31,7 +31,7 @@
     canvas.drawLine(0, 0, SkIntToScalar(W), 0, paint);
 }
 
-static void make_paint(SkPaint* paint, SkShader::TileMode tm) {
+static void make_paint(SkPaint* paint, SkTileMode tm) {
     SkBitmap bm;
     make_bitmap(&bm);
 
@@ -55,7 +55,7 @@
 
     void onDrawContent(SkCanvas* canvas) override {
         SkPaint paint;
-        make_paint(&paint, SkShader::kRepeat_TileMode);
+        make_paint(&paint, SkTileMode::kRepeat);
 
 //        canvas->scale(SK_Scalar1*2, SK_Scalar1);
         canvas->translate(SkIntToScalar(100), SkIntToScalar(100));
diff --git a/samplecode/SampleShaders.cpp b/samplecode/SampleShaders.cpp
index bf64888..65dbe07b 100644
--- a/samplecode/SampleShaders.cpp
+++ b/samplecode/SampleShaders.cpp
@@ -27,10 +27,9 @@
     pts[1].set(0, SkIntToScalar(bm.height()));
     colors[0] = SK_ColorBLACK;
     colors[1] = SkColorSetARGB(0, 0, 0, 0);
-    auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 
-    auto shaderB = SkShader::MakeBitmapShader(bm,
-                                              SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    auto shaderB = SkShader::MakeBitmapShader(bm, SkTileMode::kClamp, SkTileMode::kClamp);
 
     return SkShader::MakeComposeShader(std::move(shaderB), std::move(shaderA), SkBlendMode::kDstIn);
 }
@@ -50,13 +49,13 @@
         pts[1].set(SkIntToScalar(100), 0);
         colors[0] = SK_ColorRED;
         colors[1] = SK_ColorBLUE;
-        auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+        auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 
         pts[0].set(0, 0);
         pts[1].set(0, SkIntToScalar(100));
         colors[0] = SK_ColorBLACK;
         colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
-        auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+        auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 
         fShader = SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB),
                                               SkBlendMode::kDstIn);
diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp
index 9e65a63..a69bead 100644
--- a/samplecode/SampleSlides.cpp
+++ b/samplecode/SampleSlides.cpp
@@ -175,11 +175,11 @@
 { 5, gColors, gPos2 }
 };
 
-static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
@@ -187,14 +187,14 @@
                                           data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -205,7 +205,7 @@
                                                   data.fColors, data.fPos, data.fCount, tm);
 }
 
-typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData&, SkShader::TileMode);
+typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData&, SkTileMode);
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Conical
 };
@@ -215,7 +215,7 @@
         { 0, 0 },
         { SkIntToScalar(100), SkIntToScalar(100) }
     };
-    SkShader::TileMode tm = SkShader::kClamp_TileMode;
+    SkTileMode tm = SkTileMode::kClamp;
     SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
     SkPaint paint;
     paint.setAntiAlias(true);
@@ -246,8 +246,7 @@
 
     decode_file("/skimages/logo.gif", &bm);
     size->set(bm.width(), bm.height());
-    return SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode,
-                                        SkShader::kClamp_TileMode);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kClamp, SkTileMode::kClamp);
 }
 
 static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
@@ -255,7 +254,7 @@
                       { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
     SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
     return SkGradientShader::MakeLinear(pts, colors, nullptr,
-                                          SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode);
+                                          SK_ARRAY_COUNT(colors), SkTileMode::kMirror);
 }
 
 class Rec {
diff --git a/samplecode/SampleTiling.cpp b/samplecode/SampleTiling.cpp
index 14e40c4..169c5b7 100644
--- a/samplecode/SampleTiling.cpp
+++ b/samplecode/SampleTiling.cpp
@@ -37,12 +37,11 @@
 
     paint.setDither(true);
     paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos,
-                SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+                SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
     canvas.drawPaint(paint);
 }
 
-static void setup(SkPaint* paint, const SkBitmap& bm, bool filter,
-                  SkShader::TileMode tmx, SkShader::TileMode tmy) {
+static void setup(SkPaint* paint, const SkBitmap& bm, bool filter, SkTileMode tmx, SkTileMode tmy) {
     paint->setShader(SkShader::MakeBitmapShader(bm, tmx, tmy));
     paint->setFilterQuality(filter ? kLow_SkFilterQuality : kNone_SkFilterQuality);
 }
@@ -89,8 +88,8 @@
         static const bool           gFilters[] = { false, true };
         static const char*          gFilterNames[] = {     "point",                     "bilinear" };
 
-        static const SkShader::TileMode gModes[] = { SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode };
-        static const char*          gModeNames[] = {    "C",                    "R",                   "M" };
+        static const SkTileMode gModes[] = { SkTileMode::kClamp, SkTileMode::kRepeat, SkTileMode::kMirror };
+        static const char*  gModeNames[] = {    "C",                    "R",                   "M" };
 
         SkScalar y = SkIntToScalar(24);
         SkScalar x = SkIntToScalar(10);
diff --git a/samplecode/SampleVertices.cpp b/samplecode/SampleVertices.cpp
index 2b86334..0435f3e 100644
--- a/samplecode/SampleVertices.cpp
+++ b/samplecode/SampleVertices.cpp
@@ -34,7 +34,7 @@
     pixels[0] = pixels[2] = color0;
     pixels[1] = pixels[3] = color1;
 
-    return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat);
 }
 
 static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
@@ -42,7 +42,7 @@
                       { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
     SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
     return SkGradientShader::MakeLinear(pts, colors, nullptr,
-                    SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode);
+                    SK_ARRAY_COUNT(colors), SkTileMode::kMirror);
 }
 
 class VerticesView : public Sample {
diff --git a/samplecode/SampleXfer.cpp b/samplecode/SampleXfer.cpp
index 849b585..7f05e01 100644
--- a/samplecode/SampleXfer.cpp
+++ b/samplecode/SampleXfer.cpp
@@ -85,7 +85,7 @@
         const SkColor colors[] = { 0, c };
         fPaint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(size/2, size/2), size/2,
                                                                      colors, nullptr, 2,
-                                                                     SkShader::kClamp_TileMode));
+                                                                     SkTileMode::kClamp));
         fBounds = SkRect::MakeWH(size, size);
     }
 
diff --git a/samplecode/SampleXfermodesBlur.cpp b/samplecode/SampleXfermodesBlur.cpp
index 75ad9d1..e5a0d89 100644
--- a/samplecode/SampleXfermodesBlur.cpp
+++ b/samplecode/SampleXfermodesBlur.cpp
@@ -104,8 +104,7 @@
         const SkScalar h = SkIntToScalar(H);
         SkMatrix m;
         m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-        auto s = SkShader::MakeBitmapShader(fBG, SkShader::kRepeat_TileMode,
-                                            SkShader::kRepeat_TileMode, &m);
+        auto s = SkShader::MakeBitmapShader(fBG, SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
 
         SkFont font;
         font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
diff --git a/src/c/sk_effects.cpp b/src/c/sk_effects.cpp
index 860709a..b18f80f 100644
--- a/src/c/sk_effects.cpp
+++ b/src/c/sk_effects.cpp
@@ -19,14 +19,14 @@
 
 const struct {
     sk_shader_tilemode_t    fC;
-    SkShader::TileMode      fSK;
+    SkTileMode              fSK;
 } gTileModeMap[] = {
-    { CLAMP_SK_SHADER_TILEMODE,     SkShader::kClamp_TileMode },
-    { REPEAT_SK_SHADER_TILEMODE,    SkShader::kRepeat_TileMode },
-    { MIRROR_SK_SHADER_TILEMODE,    SkShader::kMirror_TileMode  },
+    { CLAMP_SK_SHADER_TILEMODE,     SkTileMode::kClamp },
+    { REPEAT_SK_SHADER_TILEMODE,    SkTileMode::kRepeat },
+    { MIRROR_SK_SHADER_TILEMODE,    SkTileMode::kMirror  },
 };
 
-static bool from_c_tilemode(sk_shader_tilemode_t cMode, SkShader::TileMode* skMode) {
+static bool from_c_tilemode(sk_shader_tilemode_t cMode, SkTileMode* skMode) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(gTileModeMap); ++i) {
         if (cMode == gTileModeMap[i].fC) {
             if (skMode) {
@@ -52,7 +52,7 @@
                                            int colorCount,
                                            sk_shader_tilemode_t cmode,
                                            const sk_matrix_t* cmatrix) {
-    SkShader::TileMode mode;
+    SkTileMode mode;
     if (!from_c_tilemode(cmode, &mode)) {
         return nullptr;
     }
@@ -79,7 +79,7 @@
                                            int colorCount,
                                            sk_shader_tilemode_t cmode,
                                            const sk_matrix_t* cmatrix) {
-    SkShader::TileMode mode;
+    SkTileMode mode;
     if (!from_c_tilemode(cmode, &mode)) {
         return nullptr;
     }
@@ -123,7 +123,7 @@
                                                       int colorCount,
                                                       sk_shader_tilemode_t cmode,
                                                       const sk_matrix_t* cmatrix) {
-    SkShader::TileMode mode;
+    SkTileMode mode;
     if (!from_c_tilemode(cmode, &mode)) {
         return nullptr;
     }
diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index 48f58bf..ed284ce 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -566,8 +566,8 @@
         draw.fMatrix = &SkMatrix::I();
         draw.fRC = &fRCStack.rc();
         SkPaint paint(origPaint);
-        paint.setShader(SkShader::MakeBitmapShader(src->fBitmap, SkShader::kClamp_TileMode,
-                                                   SkShader::kClamp_TileMode, nullptr));
+        paint.setShader(SkShader::MakeBitmapShader(src->fBitmap, SkTileMode::kClamp,
+                                                   SkTileMode::kClamp, nullptr));
         draw.drawBitmap(*src->fCoverage.get(),
                         SkMatrix::MakeTrans(SkIntToScalar(x),SkIntToScalar(y)), nullptr, paint);
     } else {
diff --git a/src/core/SkBitmapProcState.cpp b/src/core/SkBitmapProcState.cpp
index bb959d1..8db130c 100644
--- a/src/core/SkBitmapProcState.cpp
+++ b/src/core/SkBitmapProcState.cpp
@@ -120,7 +120,7 @@
 }
 
 SkBitmapProcInfo::SkBitmapProcInfo(const SkBitmapProvider& provider,
-                                   SkShader::TileMode tmx, SkShader::TileMode tmy)
+                                   SkTileMode tmx, SkTileMode tmy)
     : fProvider(provider)
     , fTileModeX(tmx)
     , fTileModeY(tmy)
@@ -196,8 +196,7 @@
         // We don't do this if we're either trivial (can ignore the matrix) or clamping
         // in both X and Y since clamping to width,height is just as easy as to 0xFFFF.
 
-        if (fTileModeX != SkShader::kClamp_TileMode ||
-            fTileModeY != SkShader::kClamp_TileMode) {
+        if (fTileModeX != SkTileMode::kClamp || fTileModeY != SkTileMode::kClamp) {
             fInvMatrix.postIDiv(fPixmap.width(), fPixmap.height());
         }
 
@@ -247,7 +246,7 @@
     SkASSERT(fPixmap.alphaType() == kPremul_SkAlphaType ||
              fPixmap.alphaType() == kOpaque_SkAlphaType);
     SkASSERT(fTileModeX == fTileModeY);
-    SkASSERT(fTileModeX != SkShader::kDecal_TileMode);
+    SkASSERT(fTileModeX != SkTileMode::kDecal);
     SkASSERT(fFilterQuality < kHigh_SkFilterQuality);
 
     fInvProc            = SkMatrixPriv::GetMapXYProc(fInvMatrix);
@@ -272,7 +271,7 @@
     // TODO: move this one into chooseShaderProc32() or pull all that in here.
     if (fAlphaScale == 256
             && fFilterQuality == kNone_SkFilterQuality
-            && SkShader::kClamp_TileMode == fTileModeX) {
+            && SkTileMode::kClamp == fTileModeX) {
         fShaderProc32 = Clamp_S32_opaque_D32_nofilter_DX_shaderproc;
     } else {
         fShaderProc32 = this->chooseShaderProc32();
@@ -431,8 +430,7 @@
             // chooseProcs multiples the inverse matrix by the inverse of the
             // bitmap's width and height. Since this method is going to do
             // its own tiling and sampling we need to undo that here.
-            if (SkShader::kClamp_TileMode != s.fTileModeX ||
-                SkShader::kClamp_TileMode != s.fTileModeY) {
+            if (SkTileMode::kClamp != s.fTileModeX || SkTileMode::kClamp != s.fTileModeY) {
                 yTemp = SkFractionalIntToInt(mapper.fractionalIntY() * s.fPixmap.height());
             } else {
                 yTemp = mapper.intY();
@@ -443,13 +441,13 @@
 
         const int stopY = s.fPixmap.height();
         switch (s.fTileModeY) {
-            case SkShader::kClamp_TileMode:
+            case SkTileMode::kClamp:
                 iY0 = SkClampMax(yTemp, stopY-1);
                 break;
-            case SkShader::kRepeat_TileMode:
+            case SkTileMode::kRepeat:
                 iY0 = sk_int_mod(yTemp, stopY);
                 break;
-            case SkShader::kMirror_TileMode:
+            case SkTileMode::kMirror:
             default:
                 iY0 = sk_int_mirror(yTemp, stopY);
                 break;
@@ -461,21 +459,20 @@
             int iY2;
 
             if (s.fInvType > SkMatrix::kTranslate_Mask &&
-                (SkShader::kClamp_TileMode != s.fTileModeX ||
-                 SkShader::kClamp_TileMode != s.fTileModeY)) {
+                (SkTileMode::kClamp != s.fTileModeX || SkTileMode::kClamp != s.fTileModeY)) {
                 iY2 = SkFractionalIntToInt(mapper.fractionalIntY() * s.fPixmap.height());
             } else {
                 iY2 = mapper.intY();
             }
 
             switch (s.fTileModeY) {
-            case SkShader::kClamp_TileMode:
+            case SkTileMode::kClamp:
                 iY2 = SkClampMax(iY2, stopY-1);
                 break;
-            case SkShader::kRepeat_TileMode:
+            case SkTileMode::kRepeat:
                 iY2 = sk_int_mod(iY2, stopY);
                 break;
-            case SkShader::kMirror_TileMode:
+            case SkTileMode::kMirror:
             default:
                 iY2 = sk_int_mirror(iY2, stopY);
                 break;
@@ -559,16 +556,16 @@
         return nullptr;
     }
 
-    SkShader::TileMode tx = (SkShader::TileMode)fTileModeX;
-    SkShader::TileMode ty = (SkShader::TileMode)fTileModeY;
+    SkTileMode tx = fTileModeX;
+    SkTileMode ty = fTileModeY;
 
-    if (SkShader::kClamp_TileMode == tx && SkShader::kClamp_TileMode == ty) {
+    if (SkTileMode::kClamp == tx && SkTileMode::kClamp == ty) {
         if (this->setupForTranslate()) {
             return Clamp_S32_D32_nofilter_trans_shaderproc;
         }
         return DoNothing_shaderproc;
     }
-    if (SkShader::kRepeat_TileMode == tx && SkShader::kRepeat_TileMode == ty) {
+    if (SkTileMode::kRepeat == tx && SkTileMode::kRepeat == ty) {
         if (this->setupForTranslate()) {
             return Repeat_S32_D32_nofilter_trans_shaderproc;
         }
diff --git a/src/core/SkBitmapProcState.h b/src/core/SkBitmapProcState.h
index b24157b..013c5f6 100644
--- a/src/core/SkBitmapProcState.h
+++ b/src/core/SkBitmapProcState.h
@@ -29,20 +29,20 @@
 class SkPaint;
 
 struct SkBitmapProcInfo {
-    SkBitmapProcInfo(const SkBitmapProvider&, SkShader::TileMode tmx, SkShader::TileMode tmy);
+    SkBitmapProcInfo(const SkBitmapProvider&, SkTileMode tmx, SkTileMode tmy);
     ~SkBitmapProcInfo();
 
-    const SkBitmapProvider        fProvider;
+    const SkBitmapProvider  fProvider;
 
-    SkPixmap                      fPixmap;
-    SkMatrix                      fInvMatrix;         // This changes based on tile mode.
+    SkPixmap                fPixmap;
+    SkMatrix                fInvMatrix;         // This changes based on tile mode.
     // TODO: combine fInvMatrix and fRealInvMatrix.
-    SkMatrix                      fRealInvMatrix;     // The actual inverse matrix.
-    SkColor                       fPaintColor;
-    SkShader::TileMode            fTileModeX;
-    SkShader::TileMode            fTileModeY;
-    SkFilterQuality               fFilterQuality;
-    SkMatrix::TypeMask            fInvType;
+    SkMatrix                fRealInvMatrix;     // The actual inverse matrix.
+    SkColor                 fPaintColor;
+    SkTileMode              fTileModeX;
+    SkTileMode              fTileModeY;
+    SkFilterQuality         fFilterQuality;
+    SkMatrix::TypeMask      fInvType;
 
     bool init(const SkMatrix& inverse, const SkPaint&);
 
@@ -55,7 +55,7 @@
 };
 
 struct SkBitmapProcState : public SkBitmapProcInfo {
-    SkBitmapProcState(const SkBitmapProvider& prov, SkShader::TileMode tmx, SkShader::TileMode tmy)
+    SkBitmapProcState(const SkBitmapProvider& prov, SkTileMode tmx, SkTileMode tmy)
         : SkBitmapProcInfo(prov, tmx, tmy) {}
 
     bool setup(const SkMatrix& inv, const SkPaint& paint) {
diff --git a/src/core/SkBitmapProcState_matrixProcs.cpp b/src/core/SkBitmapProcState_matrixProcs.cpp
index 2207f37..bf53d88 100644
--- a/src/core/SkBitmapProcState_matrixProcs.cpp
+++ b/src/core/SkBitmapProcState_matrixProcs.cpp
@@ -795,22 +795,22 @@
 SkBitmapProcState::MatrixProc SkBitmapProcState::chooseMatrixProc(bool translate_only_matrix) {
     SkASSERT(fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask));
     SkASSERT(fTileModeX == fTileModeY);
-    SkASSERT(fTileModeX != SkShader::kDecal_TileMode);
+    SkASSERT(fTileModeX != SkTileMode::kDecal);
 
     // Check for our special case translate methods when there is no scale/affine/perspective.
     if (translate_only_matrix && kNone_SkFilterQuality == fFilterQuality) {
         switch (fTileModeX) {
             default: SkASSERT(false);
-            case SkShader::kClamp_TileMode:  return  clampx_nofilter_trans;
-            case SkShader::kRepeat_TileMode: return repeatx_nofilter_trans;
-            case SkShader::kMirror_TileMode: return mirrorx_nofilter_trans;
+            case SkTileMode::kClamp:  return  clampx_nofilter_trans;
+            case SkTileMode::kRepeat: return repeatx_nofilter_trans;
+            case SkTileMode::kMirror: return mirrorx_nofilter_trans;
         }
     }
 
     // The arrays are all [ nofilter, filter ].
     int index = fFilterQuality > kNone_SkFilterQuality ? 1 : 0;
 
-    if (fTileModeX == SkShader::kClamp_TileMode) {
+    if (fTileModeX == SkTileMode::kClamp) {
         // clamp gets special version of filterOne, working in non-normalized space (allowing decal)
         fFilterOneX = SK_Fixed1;
         fFilterOneY = SK_Fixed1;
@@ -821,7 +821,7 @@
     fFilterOneX = SK_Fixed1 / fPixmap.width();
     fFilterOneY = SK_Fixed1 / fPixmap.height();
 
-    if (fTileModeX == SkShader::kRepeat_TileMode) {
+    if (fTileModeX == SkTileMode::kRepeat) {
         return RepeatX_RepeatY_Procs[index];
     }
 
diff --git a/src/effects/imagefilters/SkTileImageFilter.cpp b/src/effects/imagefilters/SkTileImageFilter.cpp
index a9a2c48..edd9f67 100644
--- a/src/effects/imagefilters/SkTileImageFilter.cpp
+++ b/src/effects/imagefilters/SkTileImageFilter.cpp
@@ -108,7 +108,7 @@
 
     SkPaint paint;
     paint.setBlendMode(SkBlendMode::kSrc);
-    paint.setShader(subset->makeShader(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode));
+    paint.setShader(subset->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat));
     canvas->translate(-dstRect.fLeft, -dstRect.fTop);
     canvas->drawRect(dstRect, paint);
     offset->fX = dstIRect.fLeft;
diff --git a/src/gpu/gradients/GrGradientShader.cpp b/src/gpu/gradients/GrGradientShader.cpp
index 43cf8ae..f8fd4a5 100644
--- a/src/gpu/gradients/GrGradientShader.cpp
+++ b/src/gpu/gradients/GrGradientShader.cpp
@@ -207,15 +207,15 @@
     // All tile modes are supported (unless something was added to SkShader)
     std::unique_ptr<GrFragmentProcessor> master;
     switch(shader.getTileMode()) {
-        case SkShader::kRepeat_TileMode:
+        case SkTileMode::kRepeat:
             master = GrTiledGradientEffect::Make(std::move(colorizer), std::move(layout),
                                                  /* mirror */ false, makePremul, allOpaque);
             break;
-        case SkShader::kMirror_TileMode:
+        case SkTileMode::kMirror:
             master = GrTiledGradientEffect::Make(std::move(colorizer), std::move(layout),
                                                  /* mirror */ true, makePremul, allOpaque);
             break;
-        case SkShader::kClamp_TileMode:
+        case SkTileMode::kClamp:
             // For the clamped mode, the border colors are the first and last colors, corresponding
             // to t=0 and t=1, because SkGradientShaderBase enforces that by adding color stops as
             // appropriate. If there is a hard stop, this grabs the expected outer colors for the
@@ -223,7 +223,7 @@
             master = GrClampedGradientEffect::Make(std::move(colorizer), std::move(layout),
                     colors[0], colors[shader.fColorCount - 1], makePremul, allOpaque);
             break;
-        case SkShader::kDecal_TileMode:
+        case SkTileMode::kDecal:
             // Even if the gradient colors are opaque, the decal borders are transparent so
             // disable that optimization
             master = GrClampedGradientEffect::Make(std::move(colorizer), std::move(layout),
@@ -296,7 +296,7 @@
             stop = i < fColorCount - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f;
         }
     }
-    fTileMode = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount));
+    fTileMode = static_cast<SkTileMode>(random->nextULessThan(kSkTileModeCount));
 }
 #endif
 
diff --git a/src/gpu/gradients/GrGradientShader.h b/src/gpu/gradients/GrGradientShader.h
index e74f562..0200e17 100644
--- a/src/gpu/gradients/GrGradientShader.h
+++ b/src/gpu/gradients/GrGradientShader.h
@@ -54,7 +54,7 @@
         SkColor4f fColors4f[kMaxRandomGradientColors];
         sk_sp<SkColorSpace> fColorSpace;
         SkScalar fStopStorage[kMaxRandomGradientColors];
-        SkShader::TileMode fTileMode;
+        SkTileMode fTileMode;
         int fColorCount;
         SkScalar* fStops;
     };
diff --git a/src/pdf/SkPDFGradientShader.cpp b/src/pdf/SkPDFGradientShader.cpp
index 92ff8b3..f23b9a3 100644
--- a/src/pdf/SkPDFGradientShader.cpp
+++ b/src/pdf/SkPDFGradientShader.cpp
@@ -292,15 +292,14 @@
 }
 
 /* Map a value of t on the stack into [0, 1) for Repeat or Mirror tile mode. */
-static void tileModeCode(SkShader::TileMode mode,
-                         SkDynamicMemoryWStream* result) {
-    if (mode == SkShader::kRepeat_TileMode) {
+static void tileModeCode(SkTileMode mode, SkDynamicMemoryWStream* result) {
+    if (mode == SkTileMode::kRepeat) {
         result->writeText("dup truncate sub\n");  // Get the fractional part.
         result->writeText("dup 0 le {1 add} if\n");  // Map (-1,0) => (0,1)
         return;
     }
 
-    if (mode == SkShader::kMirror_TileMode) {
+    if (mode == SkTileMode::kMirror) {
         // Map t mod 2 into [0, 1, 1, 0].
         //               Code                     Stack
         result->writeText("abs "                 // Map negative to positive.
@@ -371,7 +370,7 @@
     apply_perspective_to_coordinates(perspectiveRemover, function);
 
     function->writeText("pop\n");  // Just ditch the y value.
-    tileModeCode(info.fTileMode, function);
+    tileModeCode((SkTileMode)info.fTileMode, function);
     gradient_function_code(info, function);
     function->writeText("}");
 }
@@ -392,7 +391,7 @@
                     "add "      // y^2+x^2
                     "sqrt\n");  // sqrt(y^2+x^2)
 
-    tileModeCode(info.fTileMode, function);
+    tileModeCode((SkTileMode)info.fTileMode, function);
     gradient_function_code(info, function);
     function->writeText("}");
 }
@@ -504,7 +503,7 @@
 
     // if the pixel is in the cone, proceed to compute a color
     function->writeText("{");
-    tileModeCode(info.fTileMode, function);
+    tileModeCode((SkTileMode)info.fTileMode, function);
     gradient_function_code(info, function);
 
     // otherwise, just write black
@@ -515,7 +514,7 @@
                           const SkMatrix& perspectiveRemover,
                           SkDynamicMemoryWStream* function) {
     function->writeText("{exch atan 360 div\n");
-    tileModeCode(info.fTileMode, function);
+    tileModeCode((SkTileMode)info.fTileMode, function);
     gradient_function_code(info, function);
     function->writeText("}");
 }
@@ -595,8 +594,8 @@
     bool doStitchFunctions = (state.fType == SkShader::kLinear_GradientType ||
                               state.fType == SkShader::kRadial_GradientType ||
                               state.fType == SkShader::kConical_GradientType) &&
-                             info.fTileMode == SkShader::kClamp_TileMode &&
-                             !finalMatrix.hasPerspective();
+                              (SkTileMode)info.fTileMode == SkTileMode::kClamp &&
+                              !finalMatrix.hasPerspective();
 
     int32_t shadingType = 1;
     auto pdfShader = SkPDFMakeDict();
@@ -874,7 +873,13 @@
                                          const SkIRect& bbox) {
     SkPDFGradientShader::Key key = {
          SkShader::kNone_GradientType,
-         {0, nullptr, nullptr, {{0, 0}, {0, 0}}, {0, 0}, SkShader::kClamp_TileMode, 0},
+         {0, nullptr, nullptr, {{0, 0}, {0, 0}}, {0, 0},
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+             SkShader::kClamp_TileMode,
+#else
+             SkTileMode::kClamp,
+#endif
+             0},
          nullptr,
          nullptr,
          canvasTransform,
diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp
index 5301be7..407ac73 100644
--- a/src/pdf/SkPDFShader.cpp
+++ b/src/pdf/SkPDFShader.cpp
@@ -61,11 +61,10 @@
     // otherwise the bitmap gets clipped out and the shader is empty and awful.
     // For clamp modes, we're only interested in the clip region, whether
     // or not the main bitmap is in it.
-    SkShader::TileMode tileModes[2];
+    SkTileMode tileModes[2];
     tileModes[0] = key.fImageTileModes[0];
     tileModes[1] = key.fImageTileModes[1];
-    if (tileModes[0] != SkShader::kClamp_TileMode ||
-            tileModes[1] != SkShader::kClamp_TileMode) {
+    if (tileModes[0] != SkTileMode::kClamp || tileModes[1] != SkTileMode::kClamp) {
         deviceBounds.join(bitmapBounds);
     }
 
@@ -93,22 +92,21 @@
     SkPaint paint;
     paint.setColor(key.fPaintColor);
     // Tiling is implied.  First we handle mirroring.
-    if (tileModes[0] == SkShader::kMirror_TileMode) {
+    if (tileModes[0] == SkTileMode::kMirror) {
         SkMatrix xMirror;
         xMirror.setScale(-1, 1);
         xMirror.postTranslate(2 * width, 0);
         draw_image_matrix(&canvas, image, xMirror, paint);
         patternBBox.fRight += width;
     }
-    if (tileModes[1] == SkShader::kMirror_TileMode) {
+    if (tileModes[1] == SkTileMode::kMirror) {
         SkMatrix yMirror;
         yMirror.setScale(SK_Scalar1, -SK_Scalar1);
         yMirror.postTranslate(0, 2 * height);
         draw_image_matrix(&canvas, image, yMirror, paint);
         patternBBox.fBottom += height;
     }
-    if (tileModes[0] == SkShader::kMirror_TileMode &&
-            tileModes[1] == SkShader::kMirror_TileMode) {
+    if (tileModes[0] == SkTileMode::kMirror && tileModes[1] == SkTileMode::kMirror) {
         SkMatrix mirror;
         mirror.setScale(-1, -1);
         mirror.postTranslate(2 * width, 2 * height);
@@ -119,8 +117,7 @@
     // cover the entire surfaceBBox.
 
     SkBitmap bitmap;
-    if (tileModes[0] == SkShader::kClamp_TileMode ||
-        tileModes[1] == SkShader::kClamp_TileMode) {
+    if (tileModes[0] == SkTileMode::kClamp || tileModes[1] == SkTileMode::kClamp) {
         // For now, the easiest way to access the colors in the corners and sides is
         // to just make a bitmap from the image.
         if (!SkPDFUtils::ToBitmap(image, &bitmap)) {
@@ -131,8 +128,7 @@
 
     // If both x and y are in clamp mode, we start by filling in the corners.
     // (Which are just a rectangles of the corner colors.)
-    if (tileModes[0] == SkShader::kClamp_TileMode &&
-            tileModes[1] == SkShader::kClamp_TileMode) {
+    if (tileModes[0] == SkTileMode::kClamp && tileModes[1] == SkTileMode::kClamp) {
         SkASSERT(!bitmap.drawsNothing());
         SkPaint paint;
         SkRect rect;
@@ -166,7 +162,7 @@
     }
 
     // Then expand the left, right, top, then bottom.
-    if (tileModes[0] == SkShader::kClamp_TileMode) {
+    if (tileModes[0] == SkTileMode::kClamp) {
         SkASSERT(!bitmap.drawsNothing());
         SkIRect subset = SkIRect::MakeXYWH(0, 0, 1, bitmap.height());
         if (deviceBounds.left() < 0) {
@@ -178,7 +174,7 @@
             leftMatrix.postTranslate(deviceBounds.left(), 0);
             draw_bitmap_matrix(&canvas, left, leftMatrix, paint);
 
-            if (tileModes[1] == SkShader::kMirror_TileMode) {
+            if (tileModes[1] == SkTileMode::kMirror) {
                 leftMatrix.postScale(SK_Scalar1, -SK_Scalar1);
                 leftMatrix.postTranslate(0, 2 * height);
                 draw_bitmap_matrix(&canvas, left, leftMatrix, paint);
@@ -196,7 +192,7 @@
             rightMatrix.postTranslate(width, 0);
             draw_bitmap_matrix(&canvas, right, rightMatrix, paint);
 
-            if (tileModes[1] == SkShader::kMirror_TileMode) {
+            if (tileModes[1] == SkTileMode::kMirror) {
                 rightMatrix.postScale(SK_Scalar1, -SK_Scalar1);
                 rightMatrix.postTranslate(0, 2 * height);
                 draw_bitmap_matrix(&canvas, right, rightMatrix, paint);
@@ -205,7 +201,7 @@
         }
     }
 
-    if (tileModes[1] == SkShader::kClamp_TileMode) {
+    if (tileModes[1] == SkTileMode::kClamp) {
         SkASSERT(!bitmap.drawsNothing());
         SkIRect subset = SkIRect::MakeXYWH(0, 0, bitmap.width(), 1);
         if (deviceBounds.top() < 0) {
@@ -217,7 +213,7 @@
             topMatrix.postTranslate(0, deviceBounds.top());
             draw_bitmap_matrix(&canvas, top, topMatrix, paint);
 
-            if (tileModes[0] == SkShader::kMirror_TileMode) {
+            if (tileModes[0] == SkTileMode::kMirror) {
                 topMatrix.postScale(-1, 1);
                 topMatrix.postTranslate(2 * width, 0);
                 draw_bitmap_matrix(&canvas, top, topMatrix, paint);
@@ -235,7 +231,7 @@
             bottomMatrix.postTranslate(0, height);
             draw_bitmap_matrix(&canvas, bottom, bottomMatrix, paint);
 
-            if (tileModes[0] == SkShader::kMirror_TileMode) {
+            if (tileModes[0] == SkTileMode::kMirror) {
                 bottomMatrix.postScale(-1, 1);
                 bottomMatrix.postTranslate(2 * width, 0);
                 draw_bitmap_matrix(&canvas, bottom, bottomMatrix, paint);
@@ -270,7 +266,7 @@
         SkMatrix::I(),
         surfaceBBox,
         {{0, 0, 0, 0}, 0},  // don't need the key; won't de-dup.
-        {SkShader::kClamp_TileMode, SkShader::kClamp_TileMode},
+        {SkTileMode::kClamp, SkTileMode::kClamp},
         paintColor};
 
     key.fShaderTransform = shader->getLocalMatrix();
@@ -316,7 +312,7 @@
 }
 
 static SkColor adjust_color(SkShader* shader, SkColor paintColor) {
-    if (SkImage* img = shader->isAImage(nullptr, nullptr)) {
+    if (SkImage* img = shader->isAImage(nullptr, (SkTileMode*)nullptr)) {
         if (img->isAlphaOnly()) {
             return paintColor;
         }
@@ -344,7 +340,7 @@
         SkMatrix::I(),
         surfaceBBox,
         {{0, 0, 0, 0}, 0},
-        {SkShader::kClamp_TileMode, SkShader::kClamp_TileMode},
+        {SkTileMode::kClamp, SkTileMode::kClamp},
         adjust_color(shader, paintColor)};
 
     SkASSERT(shader->asAGradient(nullptr) == SkShader::kNone_GradientType) ;
diff --git a/src/pdf/SkPDFShader.h b/src/pdf/SkPDFShader.h
index 3d12686..7220395 100644
--- a/src/pdf/SkPDFShader.h
+++ b/src/pdf/SkPDFShader.h
@@ -50,7 +50,7 @@
     SkMatrix fShaderTransform;
     SkIRect fBBox;
     SkBitmapKey fBitmapKey;
-    SkShader::TileMode fImageTileModes[2];
+    SkTileMode fImageTileModes[2];
     SkColor fPaintColor;
 };
 SK_END_REQUIRE_DENSE
diff --git a/src/shaders/SkBitmapProcShader.cpp b/src/shaders/SkBitmapProcShader.cpp
index 402fa2f..e141f51 100644
--- a/src/shaders/SkBitmapProcShader.cpp
+++ b/src/shaders/SkBitmapProcShader.cpp
@@ -93,7 +93,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkShaderBase::Context* SkBitmapProcLegacyShader::MakeContext(
-    const SkShaderBase& shader, TileMode tmx, TileMode tmy,
+    const SkShaderBase& shader, SkTileMode tmx, SkTileMode tmy,
     const SkBitmapProvider& provider, const ContextRec& rec, SkArenaAlloc* alloc)
 {
     SkMatrix totalInverse;
diff --git a/src/shaders/SkBitmapProcShader.h b/src/shaders/SkBitmapProcShader.h
index 7c5cdcf..05640a5 100644
--- a/src/shaders/SkBitmapProcShader.h
+++ b/src/shaders/SkBitmapProcShader.h
@@ -16,7 +16,7 @@
 private:
     friend class SkImageShader;
 
-    static Context* MakeContext(const SkShaderBase&, TileMode tmx, TileMode tmy,
+    static Context* MakeContext(const SkShaderBase&, SkTileMode tmx, SkTileMode tmy,
                                 const SkBitmapProvider&, const ContextRec&, SkArenaAlloc* alloc);
 
     typedef SkShaderBase INHERITED;
diff --git a/src/shaders/SkColorShader.cpp b/src/shaders/SkColorShader.cpp
index 286d9c3..5a9b43d 100644
--- a/src/shaders/SkColorShader.cpp
+++ b/src/shaders/SkColorShader.cpp
@@ -34,7 +34,11 @@
             info->fColors[0] = fColor;
         }
         info->fColorCount = 1;
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
         info->fTileMode = SkShader::kRepeat_TileMode;
+#else
+        info->fTileMode = SkTileMode::kRepeat;
+#endif
     }
     return kColor_GradientType;
 }
diff --git a/src/shaders/SkImageShader.cpp b/src/shaders/SkImageShader.cpp
index c65a0d0..9bc4ddc 100644
--- a/src/shaders/SkImageShader.cpp
+++ b/src/shaders/SkImageShader.cpp
@@ -21,14 +21,14 @@
 /**
  *  We are faster in clamp, so always use that tiling when we can.
  */
-static SkShader::TileMode optimize(SkTileMode tm, int dimension) {
+static SkTileMode optimize(SkTileMode tm, int dimension) {
     SkASSERT(dimension > 0);
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     // need to update frameworks/base/libs/hwui/tests/unit/SkiaBehaviorTests.cpp:55 to allow
     // for transforming to clamp.
-    return static_cast<SkShader::TileMode>(tm);
+    return tm;
 #else
-    return dimension == 1 ? SkShader::kClamp_TileMode : static_cast<SkShader::TileMode>(tm);
+    return dimension == 1 ? SkTileMode::kClamp : tm;
 #endif
 }
 
@@ -59,15 +59,16 @@
 }
 
 void SkImageShader::flatten(SkWriteBuffer& buffer) const {
-    buffer.writeUInt(fTileModeX);
-    buffer.writeUInt(fTileModeY);
+    buffer.writeUInt((unsigned)fTileModeX);
+    buffer.writeUInt((unsigned)fTileModeY);
     buffer.writeMatrix(this->getLocalMatrix());
     buffer.writeImage(fImage.get());
     SkASSERT(fClampAsIfUnpremul == false);
 }
 
 bool SkImageShader::isOpaque() const {
-    return fImage->isOpaque() && fTileModeX != kDecal_TileMode && fTileModeY != kDecal_TileMode;
+    return fImage->isOpaque() &&
+           fTileModeX != SkTileMode::kDecal && fTileModeY != SkTileMode::kDecal;
 }
 
 #ifdef SK_ENABLE_LEGACY_SHADERCONTEXT
@@ -104,7 +105,7 @@
     if (fTileModeX != fTileModeY) {
         return nullptr;
     }
-    if (fTileModeX == kDecal_TileMode || fTileModeY == kDecal_TileMode) {
+    if (fTileModeX == SkTileMode::kDecal || fTileModeY == SkTileMode::kDecal) {
         return nullptr;
     }
 
@@ -138,13 +139,13 @@
 }
 #endif
 
-SkImage* SkImageShader::onIsAImage(SkMatrix* texM, TileMode xy[]) const {
+SkImage* SkImageShader::onIsAImage(SkMatrix* texM, SkTileMode xy[]) const {
     if (texM) {
         *texM = this->getLocalMatrix();
     }
     if (xy) {
-        xy[0] = (TileMode)fTileModeX;
-        xy[1] = (TileMode)fTileModeY;
+        xy[0] = fTileModeX;
+        xy[1] = fTileModeY;
     }
     return const_cast<SkImage*>(fImage.get());
 }
@@ -171,15 +172,15 @@
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrSimpleTextureEffect.h"
 
-static GrSamplerState::WrapMode tile_mode_to_wrap_mode(const SkShader::TileMode tileMode) {
+static GrSamplerState::WrapMode tile_mode_to_wrap_mode(const SkTileMode tileMode) {
     switch (tileMode) {
-        case SkShader::TileMode::kClamp_TileMode:
+        case SkTileMode::kClamp:
             return GrSamplerState::WrapMode::kClamp;
-        case SkShader::TileMode::kRepeat_TileMode:
+        case SkTileMode::kRepeat:
             return GrSamplerState::WrapMode::kRepeat;
-        case SkShader::TileMode::kMirror_TileMode:
+        case SkTileMode::kMirror:
             return GrSamplerState::WrapMode::kMirrorRepeat;
-        case SkShader::kDecal_TileMode:
+        case SkTileMode::kDecal:
             return GrSamplerState::WrapMode::kClampToBorder;
     }
     SK_ABORT("Unknown tile mode.");
@@ -347,8 +348,8 @@
     limit_y->invScale = 1.0f / pm.height();
 
     SkRasterPipeline_DecalTileCtx* decal_ctx = nullptr;
-    bool decal_x_and_y = fTileModeX == kDecal_TileMode && fTileModeY == kDecal_TileMode;
-    if (fTileModeX == kDecal_TileMode || fTileModeY == kDecal_TileMode) {
+    bool decal_x_and_y = fTileModeX == SkTileMode::kDecal && fTileModeY == SkTileMode::kDecal;
+    if (fTileModeX == SkTileMode::kDecal || fTileModeY == SkTileMode::kDecal) {
         decal_ctx = alloc->make<SkRasterPipeline_DecalTileCtx>();
         decal_ctx->limit_x = limit_x->scale;
         decal_ctx->limit_y = limit_y->scale;
@@ -359,16 +360,16 @@
             p->append(SkRasterPipeline::decal_x_and_y,  decal_ctx);
         } else {
             switch (fTileModeX) {
-                case kClamp_TileMode:  /* The gather_xxx stage will clamp for us. */     break;
-                case kMirror_TileMode: p->append(SkRasterPipeline::mirror_x, limit_x);   break;
-                case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_x, limit_x);   break;
-                case kDecal_TileMode:  p->append(SkRasterPipeline::decal_x,  decal_ctx); break;
+                case SkTileMode::kClamp:  /* The gather_xxx stage will clamp for us. */     break;
+                case SkTileMode::kMirror: p->append(SkRasterPipeline::mirror_x, limit_x);   break;
+                case SkTileMode::kRepeat: p->append(SkRasterPipeline::repeat_x, limit_x);   break;
+                case SkTileMode::kDecal:  p->append(SkRasterPipeline::decal_x,  decal_ctx); break;
             }
             switch (fTileModeY) {
-                case kClamp_TileMode:  /* The gather_xxx stage will clamp for us. */     break;
-                case kMirror_TileMode: p->append(SkRasterPipeline::mirror_y, limit_y);   break;
-                case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_y, limit_y);   break;
-                case kDecal_TileMode:  p->append(SkRasterPipeline::decal_y,  decal_ctx); break;
+                case SkTileMode::kClamp:  /* The gather_xxx stage will clamp for us. */     break;
+                case SkTileMode::kMirror: p->append(SkRasterPipeline::mirror_y, limit_y);   break;
+                case SkTileMode::kRepeat: p->append(SkRasterPipeline::repeat_y, limit_y);   break;
+                case SkTileMode::kDecal:  p->append(SkRasterPipeline::decal_y,  decal_ctx); break;
             }
         }
 
@@ -442,8 +443,7 @@
     if (true
         && (ct == kRGBA_8888_SkColorType || ct == kBGRA_8888_SkColorType)
         && quality == kLow_SkFilterQuality
-        && fTileModeX == SkShader::kClamp_TileMode
-        && fTileModeY == SkShader::kClamp_TileMode) {
+        && fTileModeX == SkTileMode::kClamp && fTileModeY == SkTileMode::kClamp) {
 
         p->append(SkRasterPipeline::bilerp_clamp_8888, gather);
         if (ct == kBGRA_8888_SkColorType) {
diff --git a/src/shaders/SkImageShader.h b/src/shaders/SkImageShader.h
index de45f29..d851b1c 100644
--- a/src/shaders/SkImageShader.h
+++ b/src/shaders/SkImageShader.h
@@ -39,14 +39,14 @@
 #ifdef SK_ENABLE_LEGACY_SHADERCONTEXT
     Context* onMakeContext(const ContextRec&, SkArenaAlloc* storage) const override;
 #endif
-    SkImage* onIsAImage(SkMatrix*, SkShader::TileMode*) const override;
+    SkImage* onIsAImage(SkMatrix*, SkTileMode*) const override;
 
     bool onAppendStages(const SkStageRec&) const override;
 
-    sk_sp<SkImage>           fImage;
-    const SkShader::TileMode fTileModeX;
-    const SkShader::TileMode fTileModeY;
-    const bool               fClampAsIfUnpremul;
+    sk_sp<SkImage>   fImage;
+    const SkTileMode fTileModeX;
+    const SkTileMode fTileModeY;
+    const bool       fClampAsIfUnpremul;
 
     friend class SkShaderBase;
     typedef SkShaderBase INHERITED;
diff --git a/src/shaders/SkLocalMatrixShader.cpp b/src/shaders/SkLocalMatrixShader.cpp
index bcbb3d3..aae1f1f 100644
--- a/src/shaders/SkLocalMatrixShader.cpp
+++ b/src/shaders/SkLocalMatrixShader.cpp
@@ -51,7 +51,7 @@
 }
 #endif
 
-SkImage* SkLocalMatrixShader::onIsAImage(SkMatrix* outMatrix, enum TileMode* mode) const {
+SkImage* SkLocalMatrixShader::onIsAImage(SkMatrix* outMatrix, SkTileMode* mode) const {
     SkMatrix imageMatrix;
     SkImage* image = fProxyShader->isAImage(&imageMatrix, mode);
     if (image && outMatrix) {
diff --git a/src/shaders/SkLocalMatrixShader.h b/src/shaders/SkLocalMatrixShader.h
index 8730247f..1d81f8d 100644
--- a/src/shaders/SkLocalMatrixShader.h
+++ b/src/shaders/SkLocalMatrixShader.h
@@ -44,7 +44,7 @@
     Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 #endif
 
-    SkImage* onIsAImage(SkMatrix* matrix, TileMode* mode) const override;
+    SkImage* onIsAImage(SkMatrix* matrix, SkTileMode* mode) const override;
 
     bool onAppendStages(const SkStageRec&) const override;
 
diff --git a/src/shaders/SkPictureShader.cpp b/src/shaders/SkPictureShader.cpp
index cf7dd41..3d10c21 100644
--- a/src/shaders/SkPictureShader.cpp
+++ b/src/shaders/SkPictureShader.cpp
@@ -118,7 +118,7 @@
 
 } // namespace
 
-SkPictureShader::SkPictureShader(sk_sp<SkPicture> picture, TileMode tmx, TileMode tmy,
+SkPictureShader::SkPictureShader(sk_sp<SkPicture> picture, SkTileMode tmx, SkTileMode tmy,
                                  const SkMatrix* localMatrix, const SkRect* tile)
     : INHERITED(localMatrix)
     , fPicture(std::move(picture))
@@ -139,10 +139,7 @@
     if (!picture || picture->cullRect().isEmpty() || (tile && tile->isEmpty())) {
         return SkShader::MakeEmptyShader();
     }
-    return sk_sp<SkShader>(new SkPictureShader(std::move(picture),
-                                               static_cast<TileMode>(tmx),
-                                               static_cast<TileMode>(tmy),
-                                               localMatrix, tile));
+    return sk_sp<SkShader>(new SkPictureShader(std::move(picture), tmx, tmy, localMatrix, tile));
 }
 
 sk_sp<SkFlattenable> SkPictureShader::CreateProc(SkReadBuffer& buffer) {
@@ -164,8 +161,8 @@
 
 void SkPictureShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeMatrix(this->getLocalMatrix());
-    buffer.write32(fTmx);
-    buffer.write32(fTmy);
+    buffer.write32((unsigned)fTmx);
+    buffer.write32((unsigned)fTmy);
     buffer.writeRect(fTile);
 
     buffer.writeBool(true);
diff --git a/src/shaders/SkPictureShader.h b/src/shaders/SkPictureShader.h
index 0c69de2..aeeb74e 100644
--- a/src/shaders/SkPictureShader.h
+++ b/src/shaders/SkPictureShader.h
@@ -44,7 +44,7 @@
 private:
     SK_FLATTENABLE_HOOKS(SkPictureShader)
 
-    SkPictureShader(sk_sp<SkPicture>, TileMode, TileMode, const SkMatrix*, const SkRect*);
+    SkPictureShader(sk_sp<SkPicture>, SkTileMode, SkTileMode, const SkMatrix*, const SkRect*);
 
     sk_sp<SkShader> refBitmapShader(const SkMatrix&, SkTCopyOnFirstWrite<SkMatrix>* localMatrix,
                                     SkColorType dstColorType, SkColorSpace* dstColorSpace,
@@ -68,7 +68,7 @@
 
     sk_sp<SkPicture>    fPicture;
     SkRect              fTile;
-    TileMode            fTmx, fTmy;
+    SkTileMode          fTmx, fTmy;
 
     const uint32_t            fUniqueID;
     mutable std::atomic<bool> fAddedToCache;
diff --git a/src/shaders/SkShader.cpp b/src/shaders/SkShader.cpp
index d2d72dc..d565027 100644
--- a/src/shaders/SkShader.cpp
+++ b/src/shaders/SkShader.cpp
@@ -118,7 +118,7 @@
     return as_SB(this)->getLocalMatrix();
 }
 
-SkImage* SkShader::isAImage(SkMatrix* localMatrix, TileMode xy[2]) const {
+SkImage* SkShader::isAImage(SkMatrix* localMatrix, SkTileMode xy[2]) const {
     return as_SB(this)->onIsAImage(localMatrix, xy);
 }
 
@@ -148,13 +148,13 @@
     return SkMakeBitmapShader(src, tmx, tmy, localMatrix, kIfMutable_SkCopyPixelsMode);
 }
 
-// deprecated
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
 sk_sp<SkShader> SkShader::MakePictureShader(sk_sp<SkPicture> src, TileMode tmx, TileMode tmy,
                                             const SkMatrix* localMatrix, const SkRect* tile) {
-    return src ? src->makeShader(static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy),
-                                 localMatrix, tile)
+    return src ? src->makeShader((SkTileMode)tmx, (SkTileMode)tmy, localMatrix, tile)
                : MakeEmptyShader();
 }
+#endif
 
 bool SkShaderBase::appendStages(const SkStageRec& rec) const {
     return this->onAppendStages(rec);
diff --git a/src/shaders/SkShaderBase.h b/src/shaders/SkShaderBase.h
index ec88625..fc3a8d9 100644
--- a/src/shaders/SkShaderBase.h
+++ b/src/shaders/SkShaderBase.h
@@ -164,7 +164,7 @@
     SkTCopyOnFirstWrite<SkMatrix> totalLocalMatrix(const SkMatrix* preLocalMatrix,
                                                    const SkMatrix* postLocalMatrix = nullptr) const;
 
-    virtual SkImage* onIsAImage(SkMatrix*, TileMode[2]) const {
+    virtual SkImage* onIsAImage(SkMatrix*, SkTileMode[2]) const {
         return nullptr;
     }
 
diff --git a/src/shaders/gradients/Sk4fGradientBase.cpp b/src/shaders/gradients/Sk4fGradientBase.cpp
index 18c5d26..a554691 100644
--- a/src/shaders/gradients/Sk4fGradientBase.cpp
+++ b/src/shaders/gradients/Sk4fGradientBase.cpp
@@ -138,7 +138,7 @@
 }
 
 void Sk4fGradientIntervalBuffer::init(const SkGradientShaderBase& shader, SkColorSpace* dstCS,
-                                      SkShader::TileMode tileMode, bool premulColors,
+                                      SkTileMode tileMode, bool premulColors,
                                       SkScalar alpha, bool reverse) {
     // The main job here is to build a specialized interval list: a different
     // representation of the color stops data, optimized for efficient scan line
@@ -198,14 +198,14 @@
     // Transform all of the colors to destination color space
     SkColor4fXformer xformedColors(shader.fOrigColors4f, count, shader.fColorSpace.get(), dstCS);
 
-    if (tileMode == SkShader::kClamp_TileMode) {
+    if (tileMode == SkTileMode::kClamp) {
         // synthetic edge interval: -/+inf .. P0
         const Sk4f clamp_color = pack_color(xformedColors.fColors[first_index],
                                             premulColors, componentScale);
         const SkScalar clamp_pos = reverse ? SK_ScalarInfinity : SK_ScalarNegativeInfinity;
         fIntervals.emplace_back(clamp_color, clamp_pos,
                                 clamp_color, first_pos);
-    } else if (tileMode == SkShader::kMirror_TileMode && reverse) {
+    } else if (tileMode == SkTileMode::kMirror && reverse) {
         // synthetic mirror intervals injected before main intervals: (2 .. 1]
         addMirrorIntervals(shader, xformedColors.fColors, componentScale, premulColors, false,
                            &fIntervals);
@@ -220,14 +220,14 @@
                                 pack_color(c1, premulColors, componentScale), t1);
     });
 
-    if (tileMode == SkShader::kClamp_TileMode) {
+    if (tileMode == SkTileMode::kClamp) {
         // synthetic edge interval: Pn .. +/-inf
         const Sk4f clamp_color = pack_color(xformedColors.fColors[last_index],
                                             premulColors, componentScale);
         const SkScalar clamp_pos = reverse ? SK_ScalarNegativeInfinity : SK_ScalarInfinity;
         fIntervals.emplace_back(clamp_color, last_pos,
                                 clamp_color, clamp_pos);
-    } else if (tileMode == SkShader::kMirror_TileMode && !reverse) {
+    } else if (tileMode == SkTileMode::kMirror && !reverse) {
         // synthetic mirror intervals injected after main intervals: [1 .. 2)
         addMirrorIntervals(shader, xformedColors.fColors, componentScale, premulColors, true,
                            &fIntervals);
diff --git a/src/shaders/gradients/Sk4fGradientBase.h b/src/shaders/gradients/Sk4fGradientBase.h
index 8c28d60..b5711e4 100644
--- a/src/shaders/gradients/Sk4fGradientBase.h
+++ b/src/shaders/gradients/Sk4fGradientBase.h
@@ -36,7 +36,7 @@
 
 class Sk4fGradientIntervalBuffer {
 public:
-    void init(const SkGradientShaderBase&, SkColorSpace* dstCS, SkShader::TileMode tileMode,
+    void init(const SkGradientShaderBase&, SkColorSpace* dstCS, SkTileMode tileMode,
               bool premulColors, SkScalar alpha, bool reverse);
 
     const Sk4fGradientInterval* find(SkScalar t) const;
diff --git a/src/shaders/gradients/Sk4fLinearGradient.cpp b/src/shaders/gradients/Sk4fLinearGradient.cpp
index 29dfab6..aa2a56b 100644
--- a/src/shaders/gradients/Sk4fLinearGradient.cpp
+++ b/src/shaders/gradients/Sk4fLinearGradient.cpp
@@ -46,16 +46,16 @@
     }
 }
 
-template<SkShader::TileMode>
+template<SkTileMode>
 SkScalar pinFx(SkScalar);
 
 template<>
-SkScalar pinFx<SkShader::kClamp_TileMode>(SkScalar fx) {
+SkScalar pinFx<SkTileMode::kClamp>(SkScalar fx) {
     return fx;
 }
 
 template<>
-SkScalar pinFx<SkShader::kRepeat_TileMode>(SkScalar fx) {
+SkScalar pinFx<SkTileMode::kRepeat>(SkScalar fx) {
     SkScalar f = SkScalarIsFinite(fx) ? SkScalarFraction(fx) : 0;
     if (f < 0) {
         f = SkTMin(f + 1, nextafterf(1, 0));
@@ -66,7 +66,7 @@
 }
 
 template<>
-SkScalar pinFx<SkShader::kMirror_TileMode>(SkScalar fx) {
+SkScalar pinFx<SkTileMode::kMirror>(SkScalar fx) {
     SkScalar f = SkScalarIsFinite(fx) ? SkScalarMod(fx, 2.0f) : 0;
     if (f < 0) {
         f = SkTMin(f + 2, nextafterf(2, 0));
@@ -189,22 +189,22 @@
                                          float bias0, float bias1) const {
     const SkLinearGradient& shader = static_cast<const SkLinearGradient&>(fShader);
     switch (shader.fTileMode) {
-    case kDecal_TileMode:
+        case SkTileMode::kDecal:
         SkASSERT(false);    // decal only supported via stages
         // fall-through
-    case kClamp_TileMode:
-        this->shadeSpanInternal<premul, kClamp_TileMode >(x, y, dst, count, bias0, bias1);
+        case SkTileMode::kClamp:
+            this->shadeSpanInternal<premul, SkTileMode::kClamp >(x, y, dst, count, bias0, bias1);
         break;
-    case kRepeat_TileMode:
-        this->shadeSpanInternal<premul, kRepeat_TileMode>(x, y, dst, count, bias0, bias1);
+        case SkTileMode::kRepeat:
+            this->shadeSpanInternal<premul, SkTileMode::kRepeat>(x, y, dst, count, bias0, bias1);
         break;
-    case kMirror_TileMode:
-        this->shadeSpanInternal<premul, kMirror_TileMode>(x, y, dst, count, bias0, bias1);
+        case SkTileMode::kMirror:
+            this->shadeSpanInternal<premul, SkTileMode::kMirror>(x, y, dst, count, bias0, bias1);
         break;
     }
 }
 
-template<ApplyPremul premul, SkShader::TileMode tileMode>
+template<ApplyPremul premul, SkTileMode tileMode>
 void SkLinearGradient::
 LinearGradient4fContext::shadeSpanInternal(int x, int y, SkPMColor dst[], int count,
                                            float bias0, float bias1) const {
@@ -254,7 +254,7 @@
     }
 }
 
-template<ApplyPremul premul, SkShader::TileMode tileMode>
+template<ApplyPremul premul, SkTileMode tileMode>
 class SkLinearGradient::
 LinearGradient4fContext::LinearIntervalProcessor {
 public:
@@ -274,7 +274,7 @@
         SkASSERT(fAdvX >= 0);
         SkASSERT(firstInterval <= lastInterval);
 
-        if (tileMode != kClamp_TileMode && !is_vertical) {
+        if (tileMode != SkTileMode::kClamp && !is_vertical) {
             const auto spanX = (lastInterval->fT1 - firstInterval->fT0) / dx;
             SkASSERT(spanX >= 0);
 
@@ -350,7 +350,7 @@
         SkASSERT(i <= fLastInterval);
         i++;
 
-        if (tileMode == kClamp_TileMode) {
+        if (tileMode == SkTileMode::kClamp) {
             SkASSERT(i <= fLastInterval);
             return i;
         }
diff --git a/src/shaders/gradients/Sk4fLinearGradient.h b/src/shaders/gradients/Sk4fLinearGradient.h
index 885b589..2ba36ca 100644
--- a/src/shaders/gradients/Sk4fLinearGradient.h
+++ b/src/shaders/gradients/Sk4fLinearGradient.h
@@ -21,14 +21,14 @@
 private:
     using INHERITED = GradientShaderBase4fContext;
 
-    template<ApplyPremul, TileMode>
+    template<ApplyPremul, SkTileMode>
     class LinearIntervalProcessor;
 
     template <ApplyPremul premul>
     void shadePremulSpan(int x, int y, SkPMColor dst[], int count,
                          float bias0, float bias1) const;
 
-    template <ApplyPremul premul, SkShader::TileMode tileMode>
+    template <ApplyPremul premul, SkTileMode tileMode>
     void shadeSpanInternal(int x, int y, SkPMColor dst[], int count,
                            float bias0, float bias1) const;
 
diff --git a/src/shaders/gradients/SkGradientShader.cpp b/src/shaders/gradients/SkGradientShader.cpp
index 01b0d14..2d614bb 100644
--- a/src/shaders/gradients/SkGradientShader.cpp
+++ b/src/shaders/gradients/SkGradientShader.cpp
@@ -50,7 +50,7 @@
         flags |= kHasColorSpace_GSF;
     }
     SkASSERT(static_cast<uint32_t>(fTileMode) <= kTileModeMask_GSF);
-    flags |= (fTileMode << kTileModeShift_GSF);
+    flags |= ((unsigned)fTileMode << kTileModeShift_GSF);
     SkASSERT(fGradFlags <= kGradFlagsMask_GSF);
     flags |= (fGradFlags << kGradFlagsShift_GSF);
 
@@ -82,7 +82,7 @@
     // New gradient format. Includes floating point color, color space, densely packed flags
     uint32_t flags = buffer.readUInt();
 
-    fTileMode = (SkShader::TileMode)((flags >> kTileModeShift_GSF) & kTileModeMask_GSF);
+    fTileMode = (SkTileMode)((flags >> kTileModeShift_GSF) & kTileModeMask_GSF);
     fGradFlags = (flags >> kGradFlagsShift_GSF) & kGradFlagsMask_GSF;
 
     fCount = buffer.getArrayCount();
@@ -130,7 +130,7 @@
 
     fGradFlags = static_cast<uint8_t>(desc.fGradFlags);
 
-    SkASSERT((unsigned)desc.fTileMode < SkShader::kTileModeCount);
+    SkASSERT((unsigned)desc.fTileMode < kSkTileModeCount);
     fTileMode = desc.fTileMode;
 
     /*  Note: we let the caller skip the first and/or last position.
@@ -288,15 +288,15 @@
     this->appendGradientStages(alloc, p, &postPipeline);
 
     switch(fTileMode) {
-        case kMirror_TileMode: p->append(SkRasterPipeline::mirror_x_1); break;
-        case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_x_1); break;
-        case kDecal_TileMode:
+        case SkTileMode::kMirror: p->append(SkRasterPipeline::mirror_x_1); break;
+        case SkTileMode::kRepeat: p->append(SkRasterPipeline::repeat_x_1); break;
+        case SkTileMode::kDecal:
             decal_ctx = alloc->make<SkRasterPipeline_DecalTileCtx>();
             decal_ctx->limit_x = SkBits2Float(SkFloat2Bits(1.0f) + 1);
             // reuse mask + limit_x stage, or create a custom decal_1 that just stores the mask
             p->append(SkRasterPipeline::decal_x, decal_ctx);
             // fall-through to clamp
-        case kClamp_TileMode:
+        case SkTileMode::kClamp:
             if (!fOrigPos) {
                 // We clamp only when the stops are evenly spaced.
                 // If not, there may be hard stops, and clamping ruins hard stops at 0 and/or 1.
@@ -416,7 +416,7 @@
 
 
 bool SkGradientShaderBase::isOpaque() const {
-    return fColorsAreOpaque && (this->getTileMode() != SkShader::kDecal_TileMode);
+    return fColorsAreOpaque && (this->getTileMode() != SkTileMode::kDecal);
 }
 
 static unsigned rounded_divide(unsigned numer, unsigned denom) {
@@ -473,7 +473,11 @@
             }
         }
         info->fColorCount = fColorCount;
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
+        info->fTileMode = (SkShader::TileMode)fTileMode;
+#else
         info->fTileMode = fTileMode;
+#endif
         info->fGradientFlags = fGradFlags;
     }
 }
@@ -484,14 +488,14 @@
 // Return true if these parameters are valid/legal/safe to construct a gradient
 //
 static bool valid_grad(const SkColor4f colors[], const SkScalar pos[], int count,
-                       unsigned tileMode) {
-    return nullptr != colors && count >= 1 && tileMode < (unsigned)SkShader::kTileModeCount;
+                       SkTileMode tileMode) {
+    return nullptr != colors && count >= 1 && (unsigned)tileMode < kSkTileModeCount;
 }
 
 static void desc_init(SkGradientShaderBase::Descriptor* desc,
                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
                       const SkScalar pos[], int colorCount,
-                      SkShader::TileMode mode, uint32_t flags, const SkMatrix* localMatrix) {
+                      SkTileMode mode, uint32_t flags, const SkMatrix* localMatrix) {
     SkASSERT(colorCount > 1);
 
     desc->fColors       = colors;
@@ -552,27 +556,26 @@
 // clamped conditions separately, this will always return the last color for clamped gradients.
 static sk_sp<SkShader> make_degenerate_gradient(const SkColor4f colors[], const SkScalar pos[],
                                                 int colorCount, sk_sp<SkColorSpace> colorSpace,
-                                                SkShader::TileMode mode) {
+                                                SkTileMode mode) {
     switch(mode) {
-        case SkShader::kDecal_TileMode:
+        case SkTileMode::kDecal:
             // normally this would reject the area outside of the interpolation region, so since
             // inside region is empty when the radii are equal, the entire draw region is empty
             return SkShader::MakeEmptyShader();
-        case SkShader::kRepeat_TileMode:
-        case SkShader::kMirror_TileMode:
+        case SkTileMode::kRepeat:
+        case SkTileMode::kMirror:
             // repeat and mirror are treated the same: the border colors are never visible,
             // but approximate the final color as infinite repetitions of the colors, so
             // it can be represented as the average color of the gradient.
             return SkShader::MakeColorShader(
                     average_gradient_color(colors, pos, colorCount), std::move(colorSpace));
-        case SkShader::kClamp_TileMode:
+        case SkTileMode::kClamp:
             // Depending on how the gradient shape degenerates, there may be a more specialized
             // fallback representation for the factories to use, but this is a reasonable default.
             return SkShader::MakeColorShader(colors[colorCount - 1], std::move(colorSpace));
-        default:
-            SkDEBUGFAIL("Should not be reached");
-            return nullptr;
     }
+    SkDEBUGFAIL("Should not be reached");
+    return nullptr;
 }
 
 // assumes colors is SkColor4f* and pos is SkScalar*
@@ -588,8 +591,7 @@
      } while (0)
 
 struct ColorStopOptimizer {
-    ColorStopOptimizer(const SkColor4f* colors, const SkScalar* pos,
-                       int count, SkShader::TileMode mode)
+    ColorStopOptimizer(const SkColor4f* colors, const SkScalar* pos, int count, SkTileMode mode)
         : fColors(colors)
         , fPos(pos)
         , fCount(count) {
@@ -602,8 +604,7 @@
                 SkScalarNearlyEqual(pos[1], 0.0f) &&
                 SkScalarNearlyEqual(pos[2], 1.0f)) {
 
-                if (SkShader::kRepeat_TileMode == mode ||
-                    SkShader::kMirror_TileMode == mode ||
+                if (SkTileMode::kRepeat == mode || SkTileMode::kMirror == mode ||
                     colors[0] == colors[1]) {
 
                     // Ignore the leftmost color/pos.
@@ -615,8 +616,7 @@
                        SkScalarNearlyEqual(pos[1], 1.0f) &&
                        SkScalarNearlyEqual(pos[2], 1.0f)) {
 
-                if (SkShader::kRepeat_TileMode == mode ||
-                    SkShader::kMirror_TileMode == mode ||
+                if (SkTileMode::kRepeat == mode || SkTileMode::kMirror == mode ||
                     colors[1] == colors[2]) {
 
                     // Ignore the rightmost color/pos.
@@ -648,7 +648,7 @@
 sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2],
                                              const SkColor colors[],
                                              const SkScalar pos[], int colorCount,
-                                             SkShader::TileMode mode,
+                                             SkTileMode mode,
                                              uint32_t flags,
                                              const SkMatrix* localMatrix) {
     ColorConverter converter(colors, colorCount);
@@ -660,7 +660,7 @@
                                              const SkColor4f colors[],
                                              sk_sp<SkColorSpace> colorSpace,
                                              const SkScalar pos[], int colorCount,
-                                             SkShader::TileMode mode,
+                                             SkTileMode mode,
                                              uint32_t flags,
                                              const SkMatrix* localMatrix) {
     if (!pts || !SkScalarIsFinite((pts[1] - pts[0]).length())) {
@@ -695,7 +695,7 @@
 sk_sp<SkShader> SkGradientShader::MakeRadial(const SkPoint& center, SkScalar radius,
                                              const SkColor colors[],
                                              const SkScalar pos[], int colorCount,
-                                             SkShader::TileMode mode,
+                                             SkTileMode mode,
                                              uint32_t flags,
                                              const SkMatrix* localMatrix) {
     ColorConverter converter(colors, colorCount);
@@ -707,7 +707,7 @@
                                              const SkColor4f colors[],
                                              sk_sp<SkColorSpace> colorSpace,
                                              const SkScalar pos[], int colorCount,
-                                             SkShader::TileMode mode,
+                                             SkTileMode mode,
                                              uint32_t flags,
                                              const SkMatrix* localMatrix) {
     if (radius < 0) {
@@ -743,7 +743,7 @@
                                                       const SkColor colors[],
                                                       const SkScalar pos[],
                                                       int colorCount,
-                                                      SkShader::TileMode mode,
+                                                      SkTileMode mode,
                                                       uint32_t flags,
                                                       const SkMatrix* localMatrix) {
     ColorConverter converter(colors, colorCount);
@@ -759,7 +759,7 @@
                                                       sk_sp<SkColorSpace> colorSpace,
                                                       const SkScalar pos[],
                                                       int colorCount,
-                                                      SkShader::TileMode mode,
+                                                      SkTileMode mode,
                                                       uint32_t flags,
                                                       const SkMatrix* localMatrix) {
     if (startRadius < 0 || endRadius < 0) {
@@ -776,7 +776,7 @@
             // Degenerate case, where the interpolation region area approaches zero. The proper
             // behavior depends on the tile mode, which is consistent with the default degenerate
             // gradient behavior, except when mode = clamp and the radii > 0.
-            if (mode == SkShader::TileMode::kClamp_TileMode && endRadius > kDegenerateThreshold) {
+            if (mode == SkTileMode::kClamp && endRadius > kDegenerateThreshold) {
                 // The interpolation region becomes an infinitely thin ring at the radius, so the
                 // final gradient will be the first color repeated from p=0 to 1, and then a hard
                 // stop switching to the last color at p=1.
@@ -816,7 +816,7 @@
                                             const SkColor colors[],
                                             const SkScalar pos[],
                                             int colorCount,
-                                            SkShader::TileMode mode,
+                                            SkTileMode mode,
                                             SkScalar startAngle,
                                             SkScalar endAngle,
                                             uint32_t flags,
@@ -831,7 +831,7 @@
                                             sk_sp<SkColorSpace> colorSpace,
                                             const SkScalar pos[],
                                             int colorCount,
-                                            SkShader::TileMode mode,
+                                            SkTileMode mode,
                                             SkScalar startAngle,
                                             SkScalar endAngle,
                                             uint32_t flags,
@@ -852,7 +852,7 @@
     if (SkScalarNearlyEqual(startAngle, endAngle, kDegenerateThreshold)) {
         // Degenerate gradient, which should follow default degenerate behavior unless it is
         // clamped and the angle is greater than 0.
-        if (mode == SkShader::kClamp_TileMode && endAngle > kDegenerateThreshold) {
+        if (mode == SkTileMode::kClamp && endAngle > kDegenerateThreshold) {
             // In this case, the first color is repeated from 0 to the angle, then a hardstop
             // switches to the last color (all other colors are compressed to the infinitely thin
             // interpolation region).
@@ -867,7 +867,7 @@
 
     if (startAngle <= 0 && endAngle >= 360) {
         // If the t-range includes [0,1], then we can always use clamping (presumably faster).
-        mode = SkShader::kClamp_TileMode;
+        mode = SkTileMode::kClamp;
     }
 
     ColorStopOptimizer opt(colors, pos, colorCount, mode);
diff --git a/src/shaders/gradients/SkGradientShaderPriv.h b/src/shaders/gradients/SkGradientShaderPriv.h
index b13b9fe..913b7c8 100644
--- a/src/shaders/gradients/SkGradientShaderPriv.h
+++ b/src/shaders/gradients/SkGradientShaderPriv.h
@@ -26,7 +26,7 @@
     struct Descriptor {
         Descriptor() {
             sk_bzero(this, sizeof(*this));
-            fTileMode = SkShader::kClamp_TileMode;
+            fTileMode = SkTileMode::kClamp;
         }
 
         const SkMatrix*     fLocalMatrix;
@@ -34,7 +34,7 @@
         sk_sp<SkColorSpace> fColorSpace;
         const SkScalar*     fPos;
         int                 fCount;
-        SkShader::TileMode  fTileMode;
+        SkTileMode          fTileMode;
         uint32_t            fGradFlags;
 
         void flatten(SkWriteBuffer&) const;
@@ -91,7 +91,7 @@
     }
 
     const SkMatrix fPtsToUnit;
-    TileMode       fTileMode;
+    SkTileMode      fTileMode;
     uint8_t        fGradFlags;
 
 public:
@@ -120,7 +120,7 @@
 
     bool colorsAreOpaque() const { return fColorsAreOpaque; }
 
-    TileMode getTileMode() const { return fTileMode; }
+    SkTileMode getTileMode() const { return fTileMode; }
 
 private:
     // Reserve inline space for up to 4 stops.
diff --git a/src/shaders/gradients/SkLinearGradient.cpp b/src/shaders/gradients/SkLinearGradient.cpp
index aa9084e..cbc1161 100644
--- a/src/shaders/gradients/SkLinearGradient.cpp
+++ b/src/shaders/gradients/SkLinearGradient.cpp
@@ -64,7 +64,7 @@
         return nullptr;
     }
 
-    return fTileMode != kDecal_TileMode
+    return fTileMode != SkTileMode::kDecal
         ? CheckedMakeContext<LinearGradient4fContext>(alloc, *this, rec)
         : nullptr;
 }
@@ -72,7 +72,7 @@
 SkShaderBase::Context* SkLinearGradient::onMakeBurstPipelineContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const {
 
-    if (fTileMode == SkShader::kDecal_TileMode) {
+    if (fTileMode == SkTileMode::kDecal) {
         // we only support decal w/ stages
         return nullptr;
     }
diff --git a/src/svg/SkSVGDevice.cpp b/src/svg/SkSVGDevice.cpp
index 14c0451..b1570f2 100644
--- a/src/svg/SkSVGDevice.cpp
+++ b/src/svg/SkSVGDevice.cpp
@@ -116,14 +116,14 @@
   if (!shader)
     return false;
 
-  SkShader::TileMode xy[2];
+  SkTileMode xy[2];
   SkImage* image = shader->isAImage(nullptr, xy);
 
   if (!image)
     return false;
 
   for (int i = 0; i < 2; i++) {
-    if (xy[i] == SkShader::kRepeat_TileMode)
+    if (xy[i] == SkTileMode::kRepeat)
       return true;
   }
   return false;
@@ -442,7 +442,7 @@
                                                        Resources* resources) {
     SkMatrix outMatrix;
 
-    SkShader::TileMode xy[2];
+    SkTileMode xy[2];
     SkImage* image = shader->isAImage(&outMatrix, xy);
     SkASSERT(image);
 
@@ -456,7 +456,7 @@
     for (int i = 0; i < 2; i++) {
         int imageDimension = i == 0 ? imageSize.width() : imageSize.height();
         switch (xy[i]) {
-            case SkShader::kRepeat_TileMode:
+            case SkTileMode::kRepeat:
                 patternDims[i].appendScalar(imageDimension);
             break;
             default:
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index 77f7989..aef0889 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -1019,10 +1019,10 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static const char* mode2string(SkShader::TileMode mode) {
-    static const char* gNames[] = { "clamp", "repeat", "mirror" };
+static const char* mode2string(SkTileMode mode) {
+    static const char* gNames[] = { "clamp", "repeat", "mirror", "decal" };
     SkASSERT((unsigned)mode < SK_ARRAY_COUNT(gNames));
-    return gNames[mode];
+    return gNames[static_cast<int>(mode)];
 }
 
 static const char* gradtype2string(SkShader::GradientType t) {
@@ -1042,7 +1042,7 @@
     SkShader* shader = get_ref<SkShader>(L, 1);
     if (shader) {
         SkMatrix matrix;
-        SkShader::TileMode modes[2];
+        SkTileMode modes[2];
         if (SkImage* image = shader->isAImage(&matrix, modes)) {
             lua_newtable(L);
             setfield_number(L, "id", image->uniqueID());
@@ -1071,7 +1071,7 @@
 
             lua_newtable(L);
             setfield_string(L,  "type",           gradtype2string(t));
-            setfield_string(L,  "tile",           mode2string(info.fTileMode));
+            setfield_string(L,  "tile",           mode2string((SkTileMode)info.fTileMode));
             setfield_number(L,  "colorCount",     info.fColorCount);
 
             lua_newtable(L);
@@ -1525,7 +1525,7 @@
 }
 
 static int limage_newShader(lua_State* L) {
-    SkShader::TileMode tmode = SkShader::kClamp_TileMode;
+    SkTileMode tmode = SkTileMode::kClamp;
     const SkMatrix* localM = nullptr;
     push_ref(L, get_ref<SkImage>(L, 1)->makeShader(tmode, tmode, localM));
     return 1;
@@ -1832,8 +1832,7 @@
 
     SkPoint pts[] = { { x0, y0 }, { x1, y1 } };
     SkColor colors[] = { c0, c1 };
-    sk_sp<SkShader> s(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                   SkShader::kClamp_TileMode));
+    sk_sp<SkShader> s(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
     if (!s) {
         lua_pushnil(L);
     } else {
diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index 41ee427..3046c4d 100644
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -476,8 +476,7 @@
     pts[2].set(SkIntToScalar(d.fWidth), SkIntToScalar(d.fHeight));
     pts[3].set(0, SkIntToScalar(d.fHeight));
     SkPaint paint;
-    paint.setShader(SkShader::MakeBitmapShader(d.fBitmap, SkShader::kClamp_TileMode,
-                                               SkShader::kClamp_TileMode));
+    paint.setShader(SkShader::MakeBitmapShader(d.fBitmap, SkTileMode::kClamp, SkTileMode::kClamp));
     canvas->drawVertices(SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, 4, pts, pts,
                                               nullptr),
                          SkBlendMode::kModulate, paint);
diff --git a/tests/DrawBitmapRectTest.cpp b/tests/DrawBitmapRectTest.cpp
index b8fed49..0fca8ff 100644
--- a/tests/DrawBitmapRectTest.cpp
+++ b/tests/DrawBitmapRectTest.cpp
@@ -139,8 +139,8 @@
                   SkIntToScalar(239),
                   0, 0, SK_Scalar1);
     SkPaint paint;
-    paint.setShader(SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
-                                               SkShader::kRepeat_TileMode, &matrix));
+    paint.setShader(SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat,
+                                               &matrix));
 
     SkRect r = SkRect::MakeXYWH(681, 239, 695, 253);
     c.drawRect(r, paint);
diff --git a/tests/GradientTest.cpp b/tests/GradientTest.cpp
index cdc75e7..094e649 100644
--- a/tests/GradientTest.cpp
+++ b/tests/GradientTest.cpp
@@ -22,8 +22,7 @@
     const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
     const SkPoint pts[] = {{ 15, 14.7112684f }, { 0.709064007f, 12.6108112f }};
     SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
 
     SkBitmap bm;
     bm.allocN32Pixels(2000, 1);
@@ -45,7 +44,7 @@
     const SkScalar* fPos;
     const SkPoint*  fPoint;   // 2
     const SkScalar* fRadius; // 2
-    SkShader::TileMode fTileMode;
+    SkTileMode      fTileMode;
 
     void gradCheck(skiatest::Reporter* reporter, const sk_sp<SkShader>& shader,
                    SkShader::GradientInfo* info,
@@ -63,7 +62,7 @@
                         !memcmp(info->fColors, fColors, fColorCount * sizeof(SkColor)));
         REPORTER_ASSERT(reporter,
                         !memcmp(info->fColorOffsets, fPos, fColorCount * sizeof(SkScalar)));
-        REPORTER_ASSERT(reporter, fTileMode == info->fTileMode);
+        REPORTER_ASSERT(reporter, fTileMode == (SkTileMode)info->fTileMode);
     }
 };
 
@@ -143,7 +142,7 @@
     SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE };
     const SkScalar pos[] = { 0, SK_Scalar1 };
     SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkTileMode::kClamp));
     SkBitmap outBitmap;
     outBitmap.allocN32Pixels(10, 1);
     SkCanvas canvas(outBitmap);
@@ -173,7 +172,7 @@
     rec.fPos = gPos;
     rec.fPoint = gPts;
     rec.fRadius = gRad;
-    rec.fTileMode = SkShader::kClamp_TileMode;
+    rec.fTileMode = SkTileMode::kClamp;
 
     static const GradProc gProcs[] = {
         none_gradproc,
@@ -239,13 +238,13 @@
         { gC_0011, gP_0011, 4, gC_0011, gP_0011, 4, false },
     };
 
-    const SkShader::TileMode modes[] = {
-        SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode,
+    const SkTileMode modes[] = {
+        SkTileMode::kClamp, SkTileMode::kRepeat, SkTileMode::kMirror,
         // TODO: add kDecal_TileMode when it is implemented
     };
     for (size_t i = 0; i < SK_ARRAY_COUNT(gProcInfo); ++i) {
         for (auto mode : modes) {
-            if (gProcInfo[i].fIsClampRestricted && mode != SkShader::kClamp_TileMode) {
+            if (gProcInfo[i].fIsClampRestricted && mode != SkTileMode::kClamp) {
                 continue;
             }
 
@@ -254,12 +253,12 @@
                 rec.fColorCount = gTests[t].fCount;
                 rec.fColors     = gTests[t].fCol;
                 rec.fPos        = gTests[t].fPos;
-                rec.fTileMode   = static_cast<SkShader::TileMode>(mode);
+                rec.fTileMode   = mode;
                 rec.fPoint      = gPts;
                 rec.fRadius     = gRadii;
 
                 GradRec expected = rec;
-                if (!gTests[t].fRequiresNonClamp || mode != SkShader::kClamp_TileMode) {
+                if (!gTests[t].fRequiresNonClamp || mode != SkTileMode::kClamp) {
                     expected.fColorCount = gTests[t].fExpectedCount;
                     expected.fColors     = gTests[t].fExpectedCol;
                     expected.fPos        = gTests[t].fExpectedPos;
@@ -278,7 +277,7 @@
     const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
     const SkScalar pos[] = { 0, 1 };
     SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkTileMode::kClamp));
 
     surface->getCanvas()->drawPaint(paint);
 }
@@ -290,7 +289,7 @@
     const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
     const SkScalar pos[] = { 0, 1 };
     SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkTileMode::kClamp));
 
     surface->getCanvas()->drawPaint(paint);
 }
@@ -307,7 +306,7 @@
     const SkScalar pos[] = {0, 0.200000003f, 0.800000012f, 1 };
 
     SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkTileMode::kClamp));
 
     SkRect r = {0, 83, 1254, 620};
     surface->getCanvas()->drawRect(r, paint);
@@ -324,7 +323,7 @@
     p.setShader(SkGradientShader::MakeTwoPointConical(
         SkPoint::Make(2.5f, 2.5f), 0,
         SkPoint::Make(3.0f, 3.0f), 10,
-        colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+        colors, nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
     surface->getCanvas()->drawPaint(p);
 
     // r == 0 for the center pixel.
@@ -340,14 +339,14 @@
     const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
     const SkPoint pts1[] = { SkPoint::Make(1001, 1000001), SkPoint::Make(1000.99f, 1000000) };
 
-    p.setShader(SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkShader::kClamp_TileMode));
+    p.setShader(SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkTileMode::kClamp));
 
     sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
     surface->getCanvas()->scale(100, 100);
     surface->getCanvas()->drawPaint(p);
 
     const SkPoint pts2[] = { SkPoint::Make(10000.99f, 1000000), SkPoint::Make(10001, 1000001) };
-    p.setShader(SkGradientShader::MakeLinear(pts2, colors, nullptr, 2, SkShader::kClamp_TileMode));
+    p.setShader(SkGradientShader::MakeLinear(pts2, colors, nullptr, 2, SkTileMode::kClamp));
     surface->getCanvas()->drawPaint(p);
 
     // Passes if we don't trigger asserts.
@@ -362,7 +361,7 @@
         SkPoint::Make(SK_ScalarMax, 0)
     };
 
-    p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode));
+    p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
     sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
     surface->getCanvas()->drawPaint(p);
 
@@ -402,7 +401,7 @@
         const SkColor*     fColors;
         const SkScalar*    fPos;
         int                fCount;
-        SkShader::TileMode fTileMode;
+        SkTileMode         fTileMode;
         uint32_t           fFlags;
         const SkScalar*    fLocalMatrix;
         const SkScalar*    fGlobalMatrix;
@@ -412,7 +411,7 @@
             gColors0,
             nullptr,
             SK_ARRAY_COUNT(gColors0),
-            SkShader::kClamp_TileMode,
+            SkTileMode::kClamp,
             0,
             gMatrix0,
             nullptr
@@ -422,7 +421,7 @@
             gColors1,
             gPos1,
             SK_ARRAY_COUNT(gColors1),
-            SkShader::kClamp_TileMode,
+            SkTileMode::kClamp,
             0,
             nullptr,
             gMatrix1
@@ -432,7 +431,7 @@
             gColors1,
             gPos1,
             SK_ARRAY_COUNT(gColors1),
-            SkShader::kClamp_TileMode,
+            SkTileMode::kClamp,
             0,
             nullptr,
             gMatrix2
@@ -442,7 +441,7 @@
             gColors0,
             nullptr,
             SK_ARRAY_COUNT(gColors0),
-            SkShader::kClamp_TileMode,
+            SkTileMode::kClamp,
             0,
             gMatrix3,
             nullptr
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index ad6f8fe..906a96d 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -114,7 +114,7 @@
     colors[1] = SK_ColorBLACK;
     sk_sp<SkShader> shader(
         SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr, 2,
-                                       SkShader::kClamp_TileMode)
+                                       SkTileMode::kClamp)
     );
     SkPaint paint;
     paint.setShader(shader);
diff --git a/tests/ImageNewShaderTest.cpp b/tests/ImageNewShaderTest.cpp
index 092a422..d96a59f 100644
--- a/tests/ImageNewShaderTest.cpp
+++ b/tests/ImageNewShaderTest.cpp
@@ -42,8 +42,8 @@
 
     sk_sp<SkImage> sourceImage(sourceSurface->makeImageSnapshot());
     sk_sp<SkShader> sourceShader = sourceImage->makeShader(
-            SkShader::kRepeat_TileMode,
-            SkShader::kRepeat_TileMode);
+            SkTileMode::kRepeat,
+            SkTileMode::kRepeat);
 
     SkPaint paint;
     paint.setShader(sourceShader);
@@ -68,8 +68,8 @@
     matrix.setTranslate(SkIntToScalar(-1), SkIntToScalar(0));
 
     sk_sp<SkShader> sourceShaderTranslated = sourceImage->makeShader(
-            SkShader::kRepeat_TileMode,
-            SkShader::kRepeat_TileMode,
+            SkTileMode::kRepeat,
+            SkTileMode::kRepeat,
             &matrix);
 
     destinationCanvas->clear(SK_ColorTRANSPARENT);
diff --git a/tests/PaintImageFilterTest.cpp b/tests/PaintImageFilterTest.cpp
index 7ca7bc3..b9035a3 100644
--- a/tests/PaintImageFilterTest.cpp
+++ b/tests/PaintImageFilterTest.cpp
@@ -33,7 +33,7 @@
 
     SkPaint gradientPaint;
     gradientPaint.setShader(SkGradientShader::MakeRadial(
-        center, radius, colors, pos, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+        center, radius, colors, pos, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
 
     // Test using the image filter
     {
@@ -79,7 +79,7 @@
 
     SkPaint gradientPaint;
     gradientPaint.setShader(SkGradientShader::MakeRadial(
-        center, radius, colors, pos, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+        center, radius, colors, pos, SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
 
     // Test using the image filter
     {
diff --git a/tests/PictureShaderTest.cpp b/tests/PictureShaderTest.cpp
index ea2c210..bdcbc90 100644
--- a/tests/PictureShaderTest.cpp
+++ b/tests/PictureShaderTest.cpp
@@ -13,6 +13,7 @@
 #include "SkSurface.h"
 #include "Test.h"
 
+#ifdef SK_SUPPORT_LEGACY_TILEMODE_ENUM
 // Test that attempting to create a picture shader with a nullptr picture or
 // empty picture returns a shader that draws nothing.
 DEF_TEST(PictureShader_empty, reporter) {
@@ -40,6 +41,7 @@
     canvas.drawRect(SkRect::MakeWH(1,1), paint);
     REPORTER_ASSERT(reporter, *bitmap.getAddr32(0,0) == SK_ColorGREEN);
 }
+#endif
 
 // Test that the SkPictureShader cache is purged on shader deletion.
 DEF_TEST(PictureShader_caching, reporter) {
diff --git a/tests/SerialProcsTest.cpp b/tests/SerialProcsTest.cpp
index 6ed362e..2e11a0e 100644
--- a/tests/SerialProcsTest.cpp
+++ b/tests/SerialProcsTest.cpp
@@ -163,8 +163,8 @@
     // test inside effect
     p0 = make_pic([p1](SkCanvas* c) {
         SkPaint paint;
-        SkShader::TileMode tm = SkShader::kClamp_TileMode;
-        paint.setShader(SkShader::MakePictureShader(p1, tm, tm, nullptr, nullptr));
+        SkTileMode tm = SkTileMode::kClamp;
+        paint.setShader(p1->makeShader(tm, tm));
         c->drawPaint(paint);
     });
     test_pictures(reporter, p0, 1, true);
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index 4fee4e4..47a9550 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -603,12 +603,12 @@
         normals.allocN32Pixels(kTexSize, kTexSize);
 
         ToolUtils::create_frustum_normal_map(&normals, SkIRect::MakeWH(kTexSize, kTexSize));
-        sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(normals, SkShader::kClamp_TileMode,
-                SkShader::kClamp_TileMode, &matrix);
+        sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(normals, SkTileMode::kClamp,
+                SkTileMode::kClamp, &matrix);
         sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
                                                                                ctm);
         sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(diffuse,
-                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix);
+                SkTileMode::kClamp, SkTileMode::kClamp, &matrix);
 
         sk_sp<SkShader> lightingShader = SkLightingShader::Make(diffuseShader,
                                                                 normalSource,
diff --git a/tests/ShaderOpacityTest.cpp b/tests/ShaderOpacityTest.cpp
index b154446..dd25429 100644
--- a/tests/ShaderOpacityTest.cpp
+++ b/tests/ShaderOpacityTest.cpp
@@ -18,8 +18,7 @@
     bmp.setInfo(info);
 
     // test 1: bitmap without pixel data
-    auto shader = SkShader::MakeBitmapShader(bmp,
-        SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    auto shader = SkShader::MakeBitmapShader(bmp, SkTileMode::kClamp, SkTileMode::kClamp);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
 
@@ -27,22 +26,19 @@
     bmp.allocPixels(info);
 
     // test 2: not opaque by default
-    shader = SkShader::MakeBitmapShader(bmp,
-        SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    shader = SkShader::MakeBitmapShader(bmp, SkTileMode::kClamp, SkTileMode::kClamp);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
 
     // test 3: explicitly opaque
     bmp.setAlphaType(kOpaque_SkAlphaType);
-    shader = SkShader::MakeBitmapShader(bmp,
-        SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    shader = SkShader::MakeBitmapShader(bmp, SkTileMode::kClamp, SkTileMode::kClamp);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, shader->isOpaque());
 
     // test 4: explicitly not opaque
     bmp.setAlphaType(kPremul_SkAlphaType);
-    shader = SkShader::MakeBitmapShader(bmp,
-        SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    shader = SkShader::MakeBitmapShader(bmp, SkTileMode::kClamp, SkTileMode::kClamp);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
 }
@@ -54,7 +50,7 @@
     SkColor colors[2];
     SkScalar pos[2] = {SkIntToScalar(0), SkIntToScalar(1)};
     int count = 2;
-    SkShader::TileMode mode = SkShader::kClamp_TileMode;
+    SkTileMode mode = SkTileMode::kClamp;
 
     // test 1: all opaque
     colors[0] = SkColorSetARGB(0xFF, 0, 0, 0);
diff --git a/tests/ShaderTest.cpp b/tests/ShaderTest.cpp
index 650eb5d..395fcdc 100644
--- a/tests/ShaderTest.cpp
+++ b/tests/ShaderTest.cpp
@@ -17,14 +17,14 @@
 
 static void check_isaimage(skiatest::Reporter* reporter, SkShader* shader,
                            int expectedW, int expectedH,
-                           SkShader::TileMode expectedX, SkShader::TileMode expectedY,
+                           SkTileMode expectedX, SkTileMode expectedY,
                            const SkMatrix& expectedM) {
-    SkShader::TileMode tileModes[2];
+    SkTileMode tileModes[2];
     SkMatrix localM;
 
     // wack these so we don't get a false positive
     localM.setScale(9999, -9999);
-    tileModes[0] = tileModes[1] = (SkShader::TileMode)99;
+    tileModes[0] = tileModes[1] = (SkTileMode)99;
 
     SkImage* image = shader->isAImage(&localM, tileModes);
     REPORTER_ASSERT(reporter, image);
@@ -42,8 +42,8 @@
     bm.allocN32Pixels(W, H);
     auto img = SkImage::MakeFromBitmap(bm);
     const SkMatrix localM = SkMatrix::MakeScale(2, 3);
-    const SkShader::TileMode tmx = SkShader::kRepeat_TileMode;
-    const SkShader::TileMode tmy = SkShader::kMirror_TileMode;
+    const SkTileMode tmx = SkTileMode::kRepeat;
+    const SkTileMode tmy = SkTileMode::kMirror;
 
     auto shader0 = SkShader::MakeBitmapShader(bm, tmx, tmy, &localM);
     auto shader1 = SkImage::MakeFromBitmap(bm)->makeShader(tmx, tmy, &localM);
diff --git a/tests/TessellatingPathRendererTests.cpp b/tests/TessellatingPathRendererTests.cpp
index 9af45ee..6457c9f 100644
--- a/tests/TessellatingPathRendererTests.cpp
+++ b/tests/TessellatingPathRendererTests.cpp
@@ -627,7 +627,7 @@
     SkPoint pts[2] = { {0, 0}, {1, 1} };
     SkColor colors[2] = { SK_ColorGREEN, SK_ColorBLUE };
     sk_sp<SkShader> shader = SkGradientShader::MakeLinear(
-        pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode);
+        pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp);
     GrColorSpaceInfo colorSpaceInfo(nullptr, kRGBA_8888_GrPixelConfig);
     GrFPArgs args(ctx, &SkMatrix::I(), SkFilterQuality::kLow_SkFilterQuality, &colorSpaceInfo);
     return as_SB(shader)->asFragmentProcessor(args);
diff --git a/tests/TextureStripAtlasManagerTest.cpp b/tests/TextureStripAtlasManagerTest.cpp
index 0511e64..c1aeb44 100644
--- a/tests/TextureStripAtlasManagerTest.cpp
+++ b/tests/TextureStripAtlasManagerTest.cpp
@@ -33,7 +33,7 @@
                                                       gColors,
                                                       gPos,
                                                       7,
-                                                      SkShader::kClamp_TileMode));
+                                                      SkTileMode::kClamp));
 
     SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128);
     auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
diff --git a/tools/ToolUtils.cpp b/tools/ToolUtils.cpp
index 6bf7383..e9e8451 100644
--- a/tools/ToolUtils.cpp
+++ b/tools/ToolUtils.cpp
@@ -83,7 +83,7 @@
     bm.eraseColor(c1);
     bm.eraseArea(SkIRect::MakeLTRB(0, 0, size, size), c2);
     bm.eraseArea(SkIRect::MakeLTRB(size, size, 2 * size, 2 * size), c2);
-    return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
+    return SkShader::MakeBitmapShader(bm, SkTileMode::kRepeat, SkTileMode::kRepeat);
 }
 
 SkBitmap create_checkerboard_bitmap(int w, int h, SkColor c1, SkColor c2, int checkSize) {
diff --git a/tools/fiddle/draw.cpp b/tools/fiddle/draw.cpp
index bbc463c..f17380a 100644
--- a/tools/fiddle/draw.cpp
+++ b/tools/fiddle/draw.cpp
@@ -22,9 +22,7 @@
     matrix.setScale(0.75f, 0.75f);
     matrix.preRotate(frame * 30.0f * duration); // If an animation, rotate at 30 deg/s.
     SkPaint paint;
-    paint.setShader(image->makeShader(SkShader::kRepeat_TileMode,
-                                      SkShader::kRepeat_TileMode,
-                                      &matrix));
+    paint.setShader(image->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, &matrix));
     canvas->drawPaint(paint);
     SkDebugf("This is text output: %d", 2);