diff --git a/gn/samples.gni b/gn/samples.gni
index 2e7362f..693283d 100644
--- a/gn/samples.gni
+++ b/gn/samples.gni
@@ -73,7 +73,6 @@
   "$_samplecode/SampleStrokeRect.cpp",
   "$_samplecode/SampleStrokeVerb.cpp",
   "$_samplecode/SampleTextBox.cpp",
-  "$_samplecode/SampleTextEffects.cpp",
   "$_samplecode/SampleTextureUpload.cpp",
   "$_samplecode/SampleThinAA.cpp",
   "$_samplecode/SampleTiming.cpp",
diff --git a/include/effects/Sk1DPathEffect.h b/include/effects/Sk1DPathEffect.h
index 68b2576..070fc33 100644
--- a/include/effects/Sk1DPathEffect.h
+++ b/include/effects/Sk1DPathEffect.h
@@ -8,37 +8,9 @@
 #ifndef Sk1DPathEffect_DEFINED
 #define Sk1DPathEffect_DEFINED
 
-#include "include/core/SkFlattenable.h"
-#include "include/core/SkPath.h"
 #include "include/core/SkPathEffect.h"
 
-class SkPathMeasure;
-
-// This class is not exported to java.
-class SK_API Sk1DPathEffect : public SkPathEffect {
-public:
-protected:
-    bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override;
-
-    /** Called at the start of each contour, returns the initial offset
-        into that contour.
-    */
-    virtual SkScalar begin(SkScalar contourLength) const = 0;
-    /** Called with the current distance along the path, with the current matrix
-        for the point/tangent at the specified distance.
-        Return the distance to travel for the next call. If return <= 0, then that
-        contour is done.
-    */
-    virtual SkScalar next(SkPath* dst, SkScalar dist, SkPathMeasure&) const = 0;
-
-private:
-    // For simplicity, assume fast bounds cannot be computed
-    bool computeFastBounds(SkRect*) const override { return false; }
-
-    using INHERITED = SkPathEffect;
-};
-
-class SK_API SkPath1DPathEffect : public Sk1DPathEffect {
+class SK_API SkPath1DPathEffect {
 public:
     enum Style {
         kTranslate_Style,   // translate the shape to each position
@@ -57,24 +29,7 @@
     */
     static sk_sp<SkPathEffect> Make(const SkPath& path, SkScalar advance, SkScalar phase, Style);
 
-protected:
-    SkPath1DPathEffect(const SkPath& path, SkScalar advance, SkScalar phase, Style);
-    void flatten(SkWriteBuffer&) const override;
-    bool onFilterPath(SkPath*, const SkPath&, SkStrokeRec*, const SkRect*) const override;
-
-    // overrides from Sk1DPathEffect
-    SkScalar begin(SkScalar contourLength) const override;
-    SkScalar next(SkPath*, SkScalar, SkPathMeasure&) const override;
-
-private:
-    SK_FLATTENABLE_HOOKS(SkPath1DPathEffect)
-
-    SkPath      fPath;          // copied from constructor
-    SkScalar    fAdvance;       // copied from constructor
-    SkScalar    fInitialOffset; // computed from phase
-    Style       fStyle;         // copied from constructor
-
-    using INHERITED = Sk1DPathEffect;
+    static void RegisterFlattenables();
 };
 
 #endif
diff --git a/include/effects/Sk2DPathEffect.h b/include/effects/Sk2DPathEffect.h
index 2f02105..96481ca 100644
--- a/include/effects/Sk2DPathEffect.h
+++ b/include/effects/Sk2DPathEffect.h
@@ -8,101 +8,23 @@
 #ifndef Sk2DPathEffect_DEFINED
 #define Sk2DPathEffect_DEFINED
 
-#include "include/core/SkFlattenable.h"
-#include "include/core/SkMatrix.h"
-#include "include/core/SkPath.h"
 #include "include/core/SkPathEffect.h"
 
-class SK_API Sk2DPathEffect : public SkPathEffect {
-protected:
-    /** New virtual, to be overridden by subclasses.
-        This is called once from filterPath, and provides the
-        uv parameter bounds for the path. Subsequent calls to
-        next() will receive u and v values within these bounds,
-        and then a call to end() will signal the end of processing.
-    */
-    virtual void begin(const SkIRect& uvBounds, SkPath* dst) const;
-    virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) const;
-    virtual void end(SkPath* dst) const;
+class SkMatrix;
+class SkPath;
 
-    /** Low-level virtual called per span of locations in the u-direction.
-        The default implementation calls next() repeatedly with each
-        location.
-    */
-    virtual void nextSpan(int u, int v, int ucount, SkPath* dst) const;
+class SK_API SkLine2DPathEffect {
+public:
+    static sk_sp<SkPathEffect> Make(SkScalar width, const SkMatrix& matrix);
 
-    const SkMatrix& getMatrix() const { return fMatrix; }
-
-    // protected so that subclasses can call this during unflattening
-    explicit Sk2DPathEffect(const SkMatrix& mat);
-    void flatten(SkWriteBuffer&) const override;
-    bool onFilterPath(SkPath*, const SkPath&, SkStrokeRec*, const SkRect*) const override;
-
-private:
-    SkMatrix    fMatrix, fInverse;
-    bool        fMatrixIsInvertible;
-
-    // For simplicity, assume fast bounds cannot be computed
-    bool computeFastBounds(SkRect*) const override { return false; }
-
-    // illegal
-    Sk2DPathEffect(const Sk2DPathEffect&);
-    Sk2DPathEffect& operator=(const Sk2DPathEffect&);
-
-    friend class Sk2DPathEffectBlitter;
-    using INHERITED = SkPathEffect;
+    static void RegisterFlattenables();
 };
 
-class SK_API SkLine2DPathEffect : public Sk2DPathEffect {
+class SK_API SkPath2DPathEffect {
 public:
-    static sk_sp<SkPathEffect> Make(SkScalar width, const SkMatrix& matrix) {
-        if (!(width >= 0)) {
-            return nullptr;
-        }
-        return sk_sp<SkPathEffect>(new SkLine2DPathEffect(width, matrix));
-    }
+    static sk_sp<SkPathEffect> Make(const SkMatrix& matrix, const SkPath& path);
 
-
-protected:
-    SkLine2DPathEffect(SkScalar width, const SkMatrix& matrix)
-        : Sk2DPathEffect(matrix), fWidth(width) {
-            SkASSERT(width >= 0);
-        }
-    void flatten(SkWriteBuffer&) const override;
-    bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override;
-
-    void nextSpan(int u, int v, int ucount, SkPath*) const override;
-
-private:
-    SK_FLATTENABLE_HOOKS(SkLine2DPathEffect)
-
-    SkScalar fWidth;
-
-    using INHERITED = Sk2DPathEffect;
-};
-
-class SK_API SkPath2DPathEffect : public Sk2DPathEffect {
-public:
-    /**
-     *  Stamp the specified path to fill the shape, using the matrix to define
-     *  the latice.
-     */
-    static sk_sp<SkPathEffect> Make(const SkMatrix& matrix, const SkPath& path) {
-        return sk_sp<SkPathEffect>(new SkPath2DPathEffect(matrix, path));
-    }
-
-protected:
-    SkPath2DPathEffect(const SkMatrix&, const SkPath&);
-    void flatten(SkWriteBuffer&) const override;
-
-    void next(const SkPoint&, int u, int v, SkPath*) const override;
-
-private:
-    SK_FLATTENABLE_HOOKS(SkPath2DPathEffect)
-
-    SkPath  fPath;
-
-    using INHERITED = Sk2DPathEffect;
+    static void RegisterFlattenables();
 };
 
 #endif
diff --git a/samplecode/SampleTextEffects.cpp b/samplecode/SampleTextEffects.cpp
deleted file mode 100644
index 5bc1416..0000000
--- a/samplecode/SampleTextEffects.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * Copyright 2011 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColorFilter.h"
-#include "include/core/SkColorPriv.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkRegion.h"
-#include "include/core/SkShader.h"
-#include "include/core/SkStrokeRec.h"
-#include "include/core/SkTypeface.h"
-#include "include/effects/SkGradientShader.h"
-#include "include/utils/SkTextUtils.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkReadBuffer.h"
-#include "src/core/SkWriteBuffer.h"
-#include "src/utils/SkUTF.h"
-
-#include "include/effects/SkGradientShader.h"
-
-#include "include/effects/Sk2DPathEffect.h"
-
-class Dot2DPathEffect : public Sk2DPathEffect {
-public:
-    Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix,
-                    SkTDArray<SkPoint>* pts)
-    : Sk2DPathEffect(matrix), fRadius(radius), fPts(pts) {}
-
-    SK_FLATTENABLE_HOOKS(Dot2DPathEffect)
-protected:
-    void begin(const SkIRect& uvBounds, SkPath* dst) const override {
-        if (fPts) {
-            fPts->reset();
-        }
-        this->INHERITED::begin(uvBounds, dst);
-    }
-
-    void next(const SkPoint& loc, int u, int v, SkPath* dst) const override {
-        if (fPts) {
-            *fPts->append() = loc;
-        }
-        dst->addCircle(loc.fX, loc.fY, fRadius);
-    }
-
-    void flatten(SkWriteBuffer& buffer) const override {
-        buffer.writeMatrix(this->getMatrix());
-        buffer.writeScalar(fRadius);
-    }
-
-private:
-
-    SkScalar fRadius;
-    SkTDArray<SkPoint>* fPts;
-
-    using INHERITED = Sk2DPathEffect;
-};
-
-// Register this path effect as deserializable before main().
-namespace {
-    static struct Initializer {
-        Initializer() {
-            SK_REGISTER_FLATTENABLE(Dot2DPathEffect);
-        }
-    } initializer;
-}  // namespace
-
-
-sk_sp<SkFlattenable> Dot2DPathEffect::CreateProc(SkReadBuffer& buffer) {
-    SkMatrix matrix;
-    buffer.readMatrix(&matrix);
-    return sk_make_sp<Dot2DPathEffect>(buffer.readScalar(), matrix, nullptr);
-}
-
-class InverseFillPE : public SkPathEffect {
-public:
-    InverseFillPE() {}
-    bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override {
-        *dst = src;
-        dst->setFillType(SkPathFillType::kInverseWinding);
-        return true;
-    }
-
-private:
-    SK_FLATTENABLE_HOOKS(InverseFillPE)
-
-    bool computeFastBounds(SkRect* bounds) const override { return false; }
-
-    using INHERITED = SkPathEffect;
-};
-
-sk_sp<SkFlattenable> InverseFillPE::CreateProc(SkReadBuffer& buffer) {
-    return sk_make_sp<InverseFillPE>();
-}
-
-static sk_sp<SkPathEffect> makepe(float interp, SkTDArray<SkPoint>* pts) {
-    SkMatrix    lattice;
-    SkScalar    rad = 3 + SkIntToScalar(4) * (1 - interp);
-    lattice.setScale(rad*2, rad*2, 0, 0);
-    lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
-    return sk_make_sp<Dot2DPathEffect>(rad, lattice, pts);
-}
-
-class TextEffectsView : public Sample {
-    sk_sp<SkTypeface> fFace;
-    SkScalar fInterp;
-    SkScalar fDx;
-
-public:
-    TextEffectsView() {
-        fFace = SkTypeface::MakeFromFile("/Users/reed/Downloads/p052024l.pfb");
-        fInterp = 0;
-        fDx = SK_Scalar1/64;
-    }
-
-protected:
-    SkString name() override { return SkString("Text Effects"); }
-
-    void drawBG(SkCanvas* canvas) {
-        canvas->drawColor(SK_ColorWHITE);
-    }
-
-    void drawdots(SkCanvas* canvas, SkString s, SkScalar x, SkScalar y, const SkFont& font) {
-        SkTDArray<SkPoint> pts;
-        auto pe = makepe(fInterp, &pts);
-
-        SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
-        SkPath path, dstPath;
-        SkTextUtils::GetPath(s.c_str(), s.size(), SkTextEncoding::kUTF8, x, y, font, &path);
-        pe->filterPath(&dstPath, path, &rec, nullptr);
-
-        SkPaint paint;
-        paint.setAntiAlias(true);
-        paint.setStrokeWidth(10);
-        paint.setColor(SK_ColorRED);
-        canvas->drawPoints(SkCanvas::kPoints_PointMode, pts.count(), pts.begin(), paint);
-    }
-
-    void onDrawContent(SkCanvas* canvas) override {
-        this->drawBG(canvas);
-
-        SkScalar x = SkIntToScalar(20);
-        SkScalar y = SkIntToScalar(300);
-
-        SkFont font(SkTypeface::MakeFromName("sans-serif", SkFontStyle::Bold()), 240);
-
-        SkString str("9");
-
-        canvas->drawString(str, x, y, font, SkPaint());
-        drawdots(canvas, str, x, y, font);
-
-        if (false) {
-            fInterp += fDx;
-            if (fInterp > 1) {
-                fInterp = 1;
-                fDx = -fDx;
-            } else if (fInterp < 0) {
-                fInterp = 0;
-                fDx = -fDx;
-            }
-        }
-    }
-
-private:
-    using INHERITED = Sample;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new TextEffectsView(); )
diff --git a/src/effects/Sk1DPathEffect.cpp b/src/effects/Sk1DPathEffect.cpp
index 24288c0..00fa542 100644
--- a/src/effects/Sk1DPathEffect.cpp
+++ b/src/effects/Sk1DPathEffect.cpp
@@ -16,68 +16,119 @@
 // Put in a governor to limit crash values from looping too long (and allocating too much ram).
 #define MAX_REASONABLE_ITERATIONS   100000
 
-bool Sk1DPathEffect::onFilterPath(SkPath* dst, const SkPath& src,
-                                  SkStrokeRec*, const SkRect*) const {
-    SkPathMeasure   meas(src, false);
-    do {
-        int governor = MAX_REASONABLE_ITERATIONS;
-        SkScalar    length = meas.getLength();
-        SkScalar    distance = this->begin(length);
-        while (distance < length && --governor >= 0) {
-            SkScalar delta = this->next(dst, distance, meas);
-            if (delta <= 0) {
-                break;
+class Sk1DPathEffect : public SkPathEffect {
+public:
+protected:
+    bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override {
+        SkPathMeasure   meas(src, false);
+        do {
+            int governor = MAX_REASONABLE_ITERATIONS;
+            SkScalar    length = meas.getLength();
+            SkScalar    distance = this->begin(length);
+            while (distance < length && --governor >= 0) {
+                SkScalar delta = this->next(dst, distance, meas);
+                if (delta <= 0) {
+                    break;
+                }
+                distance += delta;
             }
-            distance += delta;
-        }
-    } while (meas.nextContour());
-    return true;
-}
+        } while (meas.nextContour());
+        return true;
+    }
+
+    /** Called at the start of each contour, returns the initial offset
+        into that contour.
+    */
+    virtual SkScalar begin(SkScalar contourLength) const = 0;
+    /** Called with the current distance along the path, with the current matrix
+        for the point/tangent at the specified distance.
+        Return the distance to travel for the next call. If return <= 0, then that
+        contour is done.
+    */
+    virtual SkScalar next(SkPath* dst, SkScalar dist, SkPathMeasure&) const = 0;
+
+private:
+    // For simplicity, assume fast bounds cannot be computed
+    bool computeFastBounds(SkRect*) const override { return false; }
+
+    using INHERITED = SkPathEffect;
+};
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPath1DPathEffect::SkPath1DPathEffect(const SkPath& path, SkScalar advance, SkScalar phase,
-                                       Style style) : fPath(path) {
-    SkASSERT(advance > 0 && !path.isEmpty());
-    SkASSERT((unsigned)style <= kMorph_Style);
+class SkPath1DPathEffectImpl : public Sk1DPathEffect {
+public:
+    SkPath1DPathEffectImpl(const SkPath& path, SkScalar advance, SkScalar phase,
+                           SkPath1DPathEffect::Style style) : fPath(path) {
+        SkASSERT(advance > 0 && !path.isEmpty());
 
-    // Make the path thread-safe.
-    fPath.updateBoundsCache();
-    (void)fPath.getGenerationID();
+        // Make the path thread-safe.
+        fPath.updateBoundsCache();
+        (void)fPath.getGenerationID();
 
-    // cleanup their phase parameter, inverting it so that it becomes an
-    // offset along the path (to match the interpretation in PostScript)
-    if (phase < 0) {
-        phase = -phase;
-        if (phase > advance) {
-            phase = SkScalarMod(phase, advance);
+        // cleanup their phase parameter, inverting it so that it becomes an
+        // offset along the path (to match the interpretation in PostScript)
+        if (phase < 0) {
+            phase = -phase;
+            if (phase > advance) {
+                phase = SkScalarMod(phase, advance);
+            }
+        } else {
+            if (phase > advance) {
+                phase = SkScalarMod(phase, advance);
+            }
+            phase = advance - phase;
         }
-    } else {
-        if (phase > advance) {
-            phase = SkScalarMod(phase, advance);
+        // now catch the edge case where phase == advance (within epsilon)
+        if (phase >= advance) {
+            phase = 0;
         }
-        phase = advance - phase;
-    }
-    // now catch the edge case where phase == advance (within epsilon)
-    if (phase >= advance) {
-        phase = 0;
-    }
-    SkASSERT(phase >= 0);
+        SkASSERT(phase >= 0);
 
-    fAdvance = advance;
-    fInitialOffset = phase;
-
-    if ((unsigned)style > kMorph_Style) {
-        SkDEBUGF("SkPath1DPathEffect style enum out of range %d\n", style);
+        fAdvance = advance;
+        fInitialOffset = phase;
+        fStyle = style;
     }
-    fStyle = style;
-}
 
-bool SkPath1DPathEffect::onFilterPath(SkPath* dst, const SkPath& src,
-                                      SkStrokeRec* rec, const SkRect* cullRect) const {
-    rec->setFillStyle();
-    return this->INHERITED::onFilterPath(dst, src, rec, cullRect);
-}
+    bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec,
+                      const SkRect* cullRect) const override {
+        rec->setFillStyle();
+        return this->INHERITED::onFilterPath(dst, src, rec, cullRect);
+    }
+
+    SkScalar begin(SkScalar contourLength) const override {
+        return fInitialOffset;
+    }
+
+    SkScalar next(SkPath*, SkScalar, SkPathMeasure&) const override;
+
+    static sk_sp<SkFlattenable> CreateProc(SkReadBuffer& buffer) {
+        SkScalar advance = buffer.readScalar();
+        SkPath path;
+        buffer.readPath(&path);
+        SkScalar phase = buffer.readScalar();
+        SkPath1DPathEffect::Style style = buffer.read32LE(SkPath1DPathEffect::kLastEnum_Style);
+        return buffer.isValid() ? SkPath1DPathEffect::Make(path, advance, phase, style) : nullptr;
+    }
+
+    void flatten(SkWriteBuffer& buffer) const override {
+        buffer.writeScalar(fAdvance);
+        buffer.writePath(fPath);
+        buffer.writeScalar(fInitialOffset);
+        buffer.writeUInt(fStyle);
+    }
+
+    Factory getFactory() const override { return CreateProc; }
+    const char* getTypeName() const override { return "SkPath1DPathEffect"; }
+
+private:
+    SkPath                      fPath;          // copied from constructor
+    SkScalar                    fAdvance;       // copied from constructor
+    SkScalar                    fInitialOffset; // computed from phase
+    SkPath1DPathEffect::Style   fStyle;         // copied from constructor
+
+    using INHERITED = Sk1DPathEffect;
+};
 
 static bool morphpoints(SkPoint dst[], const SkPoint src[], int count,
                         SkPathMeasure& meas, SkScalar dist) {
@@ -153,52 +204,29 @@
     }
 }
 
-SkScalar SkPath1DPathEffect::begin(SkScalar contourLength) const {
-    return fInitialOffset;
-}
-
-sk_sp<SkFlattenable> SkPath1DPathEffect::CreateProc(SkReadBuffer& buffer) {
-    SkScalar advance = buffer.readScalar();
-    SkPath path;
-    buffer.readPath(&path);
-    SkScalar phase = buffer.readScalar();
-    Style style = buffer.read32LE(kLastEnum_Style);
-    return buffer.isValid() ? SkPath1DPathEffect::Make(path, advance, phase, style) : nullptr;
-}
-
-void SkPath1DPathEffect::flatten(SkWriteBuffer& buffer) const {
-    buffer.writeScalar(fAdvance);
-    buffer.writePath(fPath);
-    buffer.writeScalar(fInitialOffset);
-    buffer.writeUInt(fStyle);
-}
-
-SkScalar SkPath1DPathEffect::next(SkPath* dst, SkScalar distance,
-                                  SkPathMeasure& meas) const {
+SkScalar SkPath1DPathEffectImpl::next(SkPath* dst, SkScalar distance,
+                                      SkPathMeasure& meas) const {
 #if defined(SK_BUILD_FOR_FUZZER)
     if (dst->countPoints() > 100000) {
         return fAdvance;
     }
 #endif
     switch (fStyle) {
-        case kTranslate_Style: {
+        case SkPath1DPathEffect::kTranslate_Style: {
             SkPoint pos;
             if (meas.getPosTan(distance, &pos, nullptr)) {
                 dst->addPath(fPath, pos.fX, pos.fY);
             }
         } break;
-        case kRotate_Style: {
+        case SkPath1DPathEffect::kRotate_Style: {
             SkMatrix matrix;
             if (meas.getMatrix(distance, &matrix)) {
                 dst->addPath(fPath, matrix);
             }
         } break;
-        case kMorph_Style:
+        case SkPath1DPathEffect::kMorph_Style:
             morphpath(dst, fPath, meas, distance);
             break;
-        default:
-            SkDEBUGFAIL("unknown Style enum");
-            break;
     }
     return fAdvance;
 }
@@ -210,5 +238,9 @@
     if (advance <= 0 || !SkScalarIsFinite(advance) || !SkScalarIsFinite(phase) || path.isEmpty()) {
         return nullptr;
     }
-    return sk_sp<SkPathEffect>(new SkPath1DPathEffect(path, advance, phase, style));
+    return sk_sp<SkPathEffect>(new SkPath1DPathEffectImpl(path, advance, phase, style));
+}
+
+void SkPath1DPathEffect::RegisterFlattenables() {
+    SK_REGISTER_FLATTENABLE(SkPath1DPathEffectImpl);
 }
diff --git a/src/effects/Sk2DPathEffect.cpp b/src/effects/Sk2DPathEffect.cpp
index 7374077..3c17bed 100644
--- a/src/effects/Sk2DPathEffect.cpp
+++ b/src/effects/Sk2DPathEffect.cpp
@@ -5,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-
 #include "include/core/SkPath.h"
 #include "include/core/SkRegion.h"
 #include "include/core/SkStrokeRec.h"
@@ -13,128 +12,199 @@
 #include "src/core/SkReadBuffer.h"
 #include "src/core/SkWriteBuffer.h"
 
-Sk2DPathEffect::Sk2DPathEffect(const SkMatrix& mat) : fMatrix(mat) {
-    // Calling invert will set the type mask on both matrices, making them thread safe.
-    fMatrixIsInvertible = fMatrix.invert(&fInverse);
-}
+class Sk2DPathEffect : public SkPathEffect {
+public:
+    Sk2DPathEffect(const SkMatrix& mat) : fMatrix(mat) {
+        // Calling invert will set the type mask on both matrices, making them thread safe.
+        fMatrixIsInvertible = fMatrix.invert(&fInverse);
+    }
 
-bool Sk2DPathEffect::onFilterPath(SkPath* dst, const SkPath& src,
-                                  SkStrokeRec*, const SkRect*) const {
-    if (!fMatrixIsInvertible) {
+protected:
+    /** New virtual, to be overridden by subclasses.
+        This is called once from filterPath, and provides the
+        uv parameter bounds for the path. Subsequent calls to
+        next() will receive u and v values within these bounds,
+        and then a call to end() will signal the end of processing.
+    */
+    virtual void begin(const SkIRect& uvBounds, SkPath* dst) const {}
+    virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) const {}
+    virtual void end(SkPath* dst) const {}
+
+    /** Low-level virtual called per span of locations in the u-direction.
+        The default implementation calls next() repeatedly with each
+        location.
+    */
+    virtual void nextSpan(int x, int y, int ucount, SkPath* path) const {
+        if (!fMatrixIsInvertible) {
+            return;
+        }
+    #if defined(SK_BUILD_FOR_FUZZER)
+        if (count > 100) {
+            return;
+        }
+    #endif
+
+        const SkMatrix& mat = this->getMatrix();
+        SkPoint src, dst;
+
+        src.set(SkIntToScalar(x) + SK_ScalarHalf, SkIntToScalar(y) + SK_ScalarHalf);
+        do {
+            mat.mapPoints(&dst, &src, 1);
+            this->next(dst, x++, y, path);
+            src.fX += SK_Scalar1;
+        } while (--ucount > 0);
+    }
+
+    const SkMatrix& getMatrix() const { return fMatrix; }
+
+    void flatten(SkWriteBuffer& buffer) const override {
+        this->INHERITED::flatten(buffer);
+        buffer.writeMatrix(fMatrix);
+    }
+
+    bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec,
+                      const SkRect* cullRect) const override {
+        if (!fMatrixIsInvertible) {
+            return false;
+        }
+
+        SkPath  tmp;
+        SkIRect ir;
+
+        src.transform(fInverse, &tmp);
+        tmp.getBounds().round(&ir);
+        if (!ir.isEmpty()) {
+            this->begin(ir, dst);
+
+            SkRegion rgn;
+            rgn.setPath(tmp, SkRegion(ir));
+            SkRegion::Iterator iter(rgn);
+            for (; !iter.done(); iter.next()) {
+                const SkIRect& rect = iter.rect();
+                for (int y = rect.fTop; y < rect.fBottom; ++y) {
+                    this->nextSpan(rect.fLeft, y, rect.width(), dst);
+                }
+            }
+
+            this->end(dst);
+        }
+        return true;
+    }
+
+private:
+    SkMatrix    fMatrix, fInverse;
+    bool        fMatrixIsInvertible;
+
+    // For simplicity, assume fast bounds cannot be computed
+    bool computeFastBounds(SkRect*) const override { return false; }
+
+    friend class Sk2DPathEffectBlitter;
+    using INHERITED = SkPathEffect;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class SkLine2DPathEffectImpl : public Sk2DPathEffect {
+public:
+    SkLine2DPathEffectImpl(SkScalar width, const SkMatrix& matrix)
+        : Sk2DPathEffect(matrix)
+        , fWidth(width)
+    {
+        SkASSERT(width >= 0);
+    }
+
+    bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec,
+                      const SkRect* cullRect) const override {
+        if (this->INHERITED::onFilterPath(dst, src, rec, cullRect)) {
+            rec->setStrokeStyle(fWidth);
+            return true;
+        }
         return false;
     }
 
-    SkPath  tmp;
-    SkIRect ir;
+    void nextSpan(int u, int v, int ucount, SkPath* dst) const override {
+        if (ucount > 1) {
+            SkPoint    src[2], dstP[2];
 
-    src.transform(fInverse, &tmp);
-    tmp.getBounds().round(&ir);
-    if (!ir.isEmpty()) {
-        this->begin(ir, dst);
+            src[0].set(SkIntToScalar(u) + SK_ScalarHalf, SkIntToScalar(v) + SK_ScalarHalf);
+            src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf, SkIntToScalar(v) + SK_ScalarHalf);
+            this->getMatrix().mapPoints(dstP, src, 2);
 
-        SkRegion rgn;
-        rgn.setPath(tmp, SkRegion(ir));
-        SkRegion::Iterator iter(rgn);
-        for (; !iter.done(); iter.next()) {
-            const SkIRect& rect = iter.rect();
-            for (int y = rect.fTop; y < rect.fBottom; ++y) {
-                this->nextSpan(rect.fLeft, y, rect.width(), dst);
-            }
+            dst->moveTo(dstP[0]);
+            dst->lineTo(dstP[1]);
         }
-
-        this->end(dst);
     }
-    return true;
-}
 
-void Sk2DPathEffect::nextSpan(int x, int y, int count, SkPath* path) const {
-    if (!fMatrixIsInvertible) {
-        return;
+    static sk_sp<SkFlattenable> CreateProc(SkReadBuffer& buffer) {
+        SkMatrix matrix;
+        buffer.readMatrix(&matrix);
+        SkScalar width = buffer.readScalar();
+        return SkLine2DPathEffect::Make(width, matrix);
     }
-#if defined(SK_BUILD_FOR_FUZZER)
-    if (count > 100) {
-        return;
+
+    void flatten(SkWriteBuffer &buffer) const override {
+        buffer.writeMatrix(this->getMatrix());
+        buffer.writeScalar(fWidth);
     }
-#endif
 
-    const SkMatrix& mat = this->getMatrix();
-    SkPoint src, dst;
+    Factory getFactory() const override { return CreateProc; }
+    const char* getTypeName() const override { return "SkLine2DPathEffect"; }
 
-    src.set(SkIntToScalar(x) + SK_ScalarHalf, SkIntToScalar(y) + SK_ScalarHalf);
-    do {
-        mat.mapPoints(&dst, &src, 1);
-        this->next(dst, x++, y, path);
-        src.fX += SK_Scalar1;
-    } while (--count > 0);
-}
+private:
+    SkScalar fWidth;
 
-void Sk2DPathEffect::begin(const SkIRect& uvBounds, SkPath* dst) const {}
-void Sk2DPathEffect::next(const SkPoint& loc, int u, int v, SkPath* dst) const {}
-void Sk2DPathEffect::end(SkPath* dst) const {}
+    using INHERITED = Sk2DPathEffect;
+};
 
-///////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Sk2DPathEffect::flatten(SkWriteBuffer& buffer) const {
-    this->INHERITED::flatten(buffer);
-    buffer.writeMatrix(fMatrix);
-}
+class SK_API SkPath2DPathEffectImpl : public Sk2DPathEffect {
+public:
+    SkPath2DPathEffectImpl(const SkMatrix& m, const SkPath& p) : INHERITED(m), fPath(p) {}
 
-///////////////////////////////////////////////////////////////////////////////
-
-bool SkLine2DPathEffect::onFilterPath(SkPath* dst, const SkPath& src,
-                                      SkStrokeRec* rec, const SkRect* cullRect) const {
-    if (this->INHERITED::onFilterPath(dst, src, rec, cullRect)) {
-        rec->setStrokeStyle(fWidth);
-        return true;
+    void next(const SkPoint& loc, int u, int v, SkPath* dst) const override {
+        dst->addPath(fPath, loc.fX, loc.fY);
     }
-    return false;
-}
 
-void SkLine2DPathEffect::nextSpan(int u, int v, int ucount, SkPath* dst) const {
-    if (ucount > 1) {
-        SkPoint    src[2], dstP[2];
-
-        src[0].set(SkIntToScalar(u) + SK_ScalarHalf, SkIntToScalar(v) + SK_ScalarHalf);
-        src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf, SkIntToScalar(v) + SK_ScalarHalf);
-        this->getMatrix().mapPoints(dstP, src, 2);
-
-        dst->moveTo(dstP[0]);
-        dst->lineTo(dstP[1]);
+    static sk_sp<SkFlattenable> CreateProc(SkReadBuffer& buffer) {
+        SkMatrix matrix;
+        buffer.readMatrix(&matrix);
+        SkPath path;
+        buffer.readPath(&path);
+        return SkPath2DPathEffect::Make(matrix, path);
     }
+
+    void flatten(SkWriteBuffer& buffer) const override {
+        buffer.writeMatrix(this->getMatrix());
+        buffer.writePath(fPath);
+    }
+
+    Factory getFactory() const override { return CreateProc; }
+    const char* getTypeName() const override { return "SkPath2DPathEffect"; }
+
+private:
+    SkPath  fPath;
+
+    using INHERITED = Sk2DPathEffect;
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+sk_sp<SkPathEffect> SkLine2DPathEffect::Make(SkScalar width, const SkMatrix& matrix) {
+    if (!(width >= 0)) {
+        return nullptr;
+    }
+    return sk_sp<SkPathEffect>(new SkLine2DPathEffectImpl(width, matrix));
 }
 
-sk_sp<SkFlattenable> SkLine2DPathEffect::CreateProc(SkReadBuffer& buffer) {
-    SkMatrix matrix;
-    buffer.readMatrix(&matrix);
-    SkScalar width = buffer.readScalar();
-    return SkLine2DPathEffect::Make(width, matrix);
+sk_sp<SkPathEffect> SkPath2DPathEffect::Make(const SkMatrix& matrix, const SkPath& path) {
+    return sk_sp<SkPathEffect>(new SkPath2DPathEffectImpl(matrix, path));
 }
 
-void SkLine2DPathEffect::flatten(SkWriteBuffer &buffer) const {
-    buffer.writeMatrix(this->getMatrix());
-    buffer.writeScalar(fWidth);
+void SkLine2DPathEffect::RegisterFlattenables() {
+    SK_REGISTER_FLATTENABLE(SkLine2DPathEffectImpl);
 }
 
-///////////////////////////////////////////////////////////////////////////////
-
-SkPath2DPathEffect::SkPath2DPathEffect(const SkMatrix& m, const SkPath& p)
-    : INHERITED(m), fPath(p) {
-}
-
-sk_sp<SkFlattenable> SkPath2DPathEffect::CreateProc(SkReadBuffer& buffer) {
-    SkMatrix matrix;
-    buffer.readMatrix(&matrix);
-    SkPath path;
-    buffer.readPath(&path);
-    return SkPath2DPathEffect::Make(matrix, path);
-}
-
-void SkPath2DPathEffect::flatten(SkWriteBuffer& buffer) const {
-    buffer.writeMatrix(this->getMatrix());
-    buffer.writePath(fPath);
-}
-
-void SkPath2DPathEffect::next(const SkPoint& loc, int u, int v,
-                              SkPath* dst) const {
-    dst->addPath(fPath, loc.fX, loc.fY);
+void SkPath2DPathEffect::RegisterFlattenables() {
+    SK_REGISTER_FLATTENABLE(SkPath2DPathEffectImpl);
 }
diff --git a/src/ports/SkGlobalInitialization_default.cpp b/src/ports/SkGlobalInitialization_default.cpp
index b2f7607..97f4bfb 100644
--- a/src/ports/SkGlobalInitialization_default.cpp
+++ b/src/ports/SkGlobalInitialization_default.cpp
@@ -89,11 +89,11 @@
         SK_REGISTER_FLATTENABLE(SkCornerPathEffect);
         SK_REGISTER_FLATTENABLE(SkDashImpl);
         SK_REGISTER_FLATTENABLE(SkDiscretePathEffect);
-        SK_REGISTER_FLATTENABLE(SkLine2DPathEffect);
+        SkLine2DPathEffect::RegisterFlattenables();
+        SkPath2DPathEffect::RegisterFlattenables();
         SK_REGISTER_FLATTENABLE(SkMatrixPE);
         SK_REGISTER_FLATTENABLE(SkOpPE);
-        SK_REGISTER_FLATTENABLE(SkPath1DPathEffect);
-        SK_REGISTER_FLATTENABLE(SkPath2DPathEffect);
+        SkPath1DPathEffect::RegisterFlattenables();
         SK_REGISTER_FLATTENABLE(SkStrokePE);
         SK_REGISTER_FLATTENABLE(SkStrokeAndFillPE);
         SK_REGISTER_FLATTENABLE(SkTrimPE);