diff --git a/bench/TessellateBench.cpp b/bench/TessellateBench.cpp
index 25468aa..b646cfe 100644
--- a/bench/TessellateBench.cpp
+++ b/bench/TessellateBench.cpp
@@ -123,7 +123,8 @@
                                              GrPathCurveTessellator::DrawInnerFan::kNo,
                                              fTarget->caps().minPathVerbsForHwTessellation(),
                                              noVaryingsPipeline, fTarget->caps());
-    tess->prepare(fTarget.get(), SkRectPriv::MakeLargest(), gAlmostIdentity, fPath, nullptr);
+    tess->prepare(fTarget.get(), SkRectPriv::MakeLargest(), {gAlmostIdentity, fPath},
+                  fPath.countVerbs());
 }
 
 DEF_PATH_TESS_BENCH(GrPathWedgeTessellator, make_cubic_path(8), SkMatrix::I()) {
@@ -133,7 +134,8 @@
     auto tess = GrPathWedgeTessellator::Make(&arena, fMatrix, SK_PMColor4fTRANSPARENT,
                                              fTarget->caps().minPathVerbsForHwTessellation(),
                                              noVaryingsPipeline, fTarget->caps());
-    tess->prepare(fTarget.get(), SkRectPriv::MakeLargest(), gAlmostIdentity, fPath, nullptr);
+    tess->prepare(fTarget.get(), SkRectPriv::MakeLargest(), {gAlmostIdentity, fPath},
+                  fPath.countVerbs());
 }
 
 static void benchmark_wangs_formula_cubic_log2(const SkMatrix& matrix, const SkPath& path) {
diff --git a/samplecode/SamplePathTessellators.cpp b/samplecode/SamplePathTessellators.cpp
index b355592..b71aad6 100644
--- a/samplecode/SamplePathTessellators.cpp
+++ b/samplecode/SamplePathTessellators.cpp
@@ -103,7 +103,7 @@
                                                             caps);
                 break;
         }
-        fTessellator->prepare(flushState, this->bounds(), pathMatrix, fPath);
+        fTessellator->prepare(flushState, this->bounds(), {pathMatrix, fPath}, fPath.countVerbs());
         fProgram = GrTessellationShader::MakeProgram({alloc, flushState->writeView(),
                                                      &flushState->dstProxyView(),
                                                      flushState->renderPassBarriers(),
diff --git a/src/gpu/tessellate/GrCullTest.h b/src/gpu/tessellate/GrCullTest.h
index 971b1c2..37431a6 100644
--- a/src/gpu/tessellate/GrCullTest.h
+++ b/src/gpu/tessellate/GrCullTest.h
@@ -21,18 +21,24 @@
 // translation element. Instead we unapply the translation to the cull bounds ahead of time.
 class GrCullTest {
 public:
-    GrCullTest(const SkRect& devCullBounds, const SkMatrix& m)
-            // [fMatX, fMatY] maps path coordinates to the float4 [x, y, -x, -y] in device space.
-            : fMatX{m.getScaleX(), m.getSkewY(), -m.getScaleX(), -m.getSkewY()}
-            , fMatY{m.getSkewX(), m.getScaleY(), -m.getSkewX(), -m.getScaleY()}
-            // Store the cull bounds as [l, t, -r, -b] for faster math.
-            // Also subtract the matrix translate from the cull bounds ahead of time, rather than
-            // adding it to every point every time we test.
-            , fCullBounds{devCullBounds.fLeft - m.getTranslateX(),
-                          devCullBounds.fTop - m.getTranslateY(),
-                          m.getTranslateX() - devCullBounds.fRight,
-                          m.getTranslateY() - devCullBounds.fBottom} {
+    GrCullTest() = default;
+
+    GrCullTest(const SkRect& devCullBounds, const SkMatrix& m) {
+        this->set(devCullBounds, m);
+    }
+
+    void set(const SkRect& devCullBounds, const SkMatrix& m) {
         SkASSERT(!m.hasPerspective());
+        // [fMatX, fMatY] maps path coordinates to the float4 [x, y, -x, -y] in device space.
+        fMatX = {m.getScaleX(), m.getSkewY(), -m.getScaleX(), -m.getSkewY()};
+        fMatY = {m.getSkewX(), m.getScaleY(), -m.getSkewX(), -m.getScaleY()};
+        // Store the cull bounds as [l, t, -r, -b] for faster math.
+        // Also subtract the matrix translate from the cull bounds ahead of time, rather than adding
+        // it to every point every time we test.
+        fCullBounds = {devCullBounds.fLeft - m.getTranslateX(),
+                       devCullBounds.fTop - m.getTranslateY(),
+                       m.getTranslateX() - devCullBounds.fRight,
+                       m.getTranslateY() - devCullBounds.fBottom};
     }
 
     // Returns whether M*p will be in the viewport.
diff --git a/src/gpu/tessellate/GrPathCurveTessellator.cpp b/src/gpu/tessellate/GrPathCurveTessellator.cpp
index e1c48ce..3d56746 100644
--- a/src/gpu/tessellate/GrPathCurveTessellator.cpp
+++ b/src/gpu/tessellate/GrPathCurveTessellator.cpp
@@ -24,18 +24,20 @@
 // supported by the hardware.
 class CurveWriter {
 public:
-    CurveWriter(const SkRect& cullBounds,
-                const SkMatrix& totalMatrix,  // shaderMatrix * pathMatrix
-                const SkMatrix& pathMatrix,
-                int maxSegments)
-            : fCullTest(cullBounds, totalMatrix)
-            , fTotalVectorXform(totalMatrix)
-            , fPathXform(pathMatrix)
-            , fMaxSegments_pow2(maxSegments * maxSegments)
+    CurveWriter(int maxSegments)
+            : fMaxSegments_pow2(maxSegments * maxSegments)
             , fMaxSegments_pow4(fMaxSegments_pow2 * fMaxSegments_pow2) {
     }
 
-    const GrPathXform& pathXform() const { return fPathXform; }
+    void setMatrices(const SkRect& cullBounds,
+                     const SkMatrix& shaderMatrix,
+                     const SkMatrix& pathMatrix) {
+        SkMatrix totalMatrix;
+        totalMatrix.setConcat(shaderMatrix, pathMatrix);
+        fCullTest.set(cullBounds, totalMatrix);
+        fTotalVectorXform = totalMatrix;
+        fPathXform = pathMatrix;
+    }
 
     SK_ALWAYS_INLINE void writeQuadratic(const GrShaderCaps& shaderCaps,
                                          GrVertexChunkBuilder* chunker, const SkPoint p[3]) {
@@ -191,8 +193,8 @@
 
 void GrPathCurveTessellator::prepare(GrMeshDrawTarget* target,
                                      const SkRect& cullBounds,
-                                     const SkMatrix& pathMatrix,
-                                     const SkPath& path,
+                                     const PathDrawList& pathDrawList,
+                                     int totalCombinedPathVerbCnt,
                                      const BreadcrumbTriangleList* breadcrumbTriangleList) {
     SkASSERT(fVertexChunkArray.empty());
 
@@ -201,16 +203,17 @@
     // Determine how many triangles to allocate.
     int maxTriangles = 0;
     if (fDrawInnerFan) {
-        // An n-sided polygon is fanned by n-2 triangles.
-        int maxEdgesInFan = GrPathTessellator::MaxSegmentsInPath(path);
-        int maxTrianglesInFan = std::max(maxEdgesInFan - 2, 0);
-        maxTriangles += maxTrianglesInFan;
+        int maxCombinedFanEdges = MaxCombinedFanEdgesInPathDrawList(totalCombinedPathVerbCnt);
+        // A single n-sided polygon is fanned by n-2 triangles. Multiple polygons with a combined
+        // edge count of n are fanned by strictly fewer triangles.
+        int maxTrianglesInFans = std::max(maxCombinedFanEdges - 2, 0);
+        maxTriangles += maxTrianglesInFans;
     }
     if (breadcrumbTriangleList) {
         maxTriangles += breadcrumbTriangleList->count();
     }
     // Over-allocate enough curves for 1 in 4 to chop.
-    int curveAllocCount = (path.countVerbs() * 5 + 3) / 4;  // i.e., ceil(numVerbs * 5/4)
+    int curveAllocCount = (totalCombinedPathVerbCnt * 5 + 3) / 4;  // i.e., ceil(numVerbs * 5/4)
     int patchAllocCount = maxTriangles + curveAllocCount;
     if (!patchAllocCount) {
         return;
@@ -219,21 +222,6 @@
                                                                : fShader->instanceStride();
     GrVertexChunkBuilder chunker(target, &fVertexChunkArray, patchStride, patchAllocCount);
 
-    int maxSegments;
-    if (fShader->willUseTessellationShaders()) {
-        // The curve shader tessellates T=0..(1/2) on the first side of the canonical triangle and
-        // T=(1/2)..1 on the second side. This means we get double the max tessellation segments
-        // for the range T=0..1.
-        maxSegments = shaderCaps.maxTessellationSegments() * 2;
-    } else {
-        maxSegments = GrPathTessellationShader::kMaxFixedCountSegments;
-    }
-
-    CurveWriter curveWriter(cullBounds,
-                            SkMatrix::Concat(fShader->viewMatrix(), pathMatrix),
-                            pathMatrix,
-                            maxSegments);
-
     // Write out the triangles.
     if (maxTriangles) {
         GrVertexWriter vertexWriter = chunker.appendVertices(maxTriangles);
@@ -249,19 +237,30 @@
             uint32_t pad32Value = shaderCaps.infinitySupport()
                     ? GrVertexWriter::kIEEE_32_infinity
                     : sk_bit_cast<uint32_t>(GrTessellationShader::kTriangularConicCurveType);
-            int numTrianglesWritten;
-            vertexWriter = GrMiddleOutPolygonTriangulator::WritePathInnerFan(
-                    std::move(vertexWriter),
-                    pad32Count,
-                    pad32Value,
-                    curveWriter.pathXform(),
-                    path,
-                    &numTrianglesWritten);
-            numRemainingTriangles -= numTrianglesWritten;
+            for (auto [pathMatrix, path] : pathDrawList) {
+                int numTrianglesWritten;
+                vertexWriter = GrMiddleOutPolygonTriangulator::WritePathInnerFan(
+                        std::move(vertexWriter),
+                        pad32Count,
+                        pad32Value,
+                        pathMatrix,
+                        path,
+                        &numTrianglesWritten);
+                numRemainingTriangles -= numTrianglesWritten;
+            }
         }
         if (breadcrumbTriangleList) {
             int numWritten = 0;
             SkDEBUGCODE(int count = 0;)
+#ifdef SK_DEBUG
+            for (auto [pathMatrix, path] : pathDrawList) {
+                // This assert isn't actually necessary, but we currently only use breadcrumb
+                // triangles with an identity pathMatrix. If that ever changes, this assert will
+                // serve as a gentle reminder to make sure the breadcrumb triangles are also
+                // transformed on the CPU.
+                SkASSERT(pathMatrix.isIdentity());
+            }
+#endif
             for (const auto* tri = breadcrumbTriangleList->head(); tri; tri = tri->fNext) {
                 SkDEBUGCODE(++count;)
                 auto p0 = grvx::float2::Load(tri->fPts);
@@ -275,7 +274,7 @@
                     // introduce T-junctions.
                     continue;
                 }
-                curveWriter.pathXform().map3Points(&vertexWriter, tri->fPts);
+                vertexWriter.writeArray(tri->fPts, 3);
                 // Mark this instance as a triangle by setting it to a conic with w=Inf.
                 vertexWriter.fill(GrVertexWriter::kIEEE_32_infinity, 2);
                 vertexWriter.write(
@@ -289,19 +288,33 @@
         chunker.popVertices(numRemainingTriangles);
     }
 
-    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
-        switch (verb) {
-            case SkPathVerb::kQuad:
-                curveWriter.writeQuadratic(shaderCaps, &chunker, pts);
-                break;
-            case SkPathVerb::kConic:
-                curveWriter.writeConic(shaderCaps, &chunker, pts, *w);
-                break;
-            case SkPathVerb::kCubic:
-                curveWriter.writeCubic(shaderCaps, &chunker, pts);
-                break;
-            default:
-                break;
+    int maxSegments;
+    if (fShader->willUseTessellationShaders()) {
+        // The curve shader tessellates T=0..(1/2) on the first side of the canonical triangle and
+        // T=(1/2)..1 on the second side. This means we get double the max tessellation segments
+        // for the range T=0..1.
+        maxSegments = shaderCaps.maxTessellationSegments() * 2;
+    } else {
+        maxSegments = GrPathTessellationShader::kMaxFixedCountSegments;
+    }
+
+    CurveWriter curveWriter(maxSegments);
+    for (auto [pathMatrix, path] : pathDrawList) {
+        curveWriter.setMatrices(cullBounds, fShader->viewMatrix(), pathMatrix);
+        for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
+            switch (verb) {
+                case SkPathVerb::kQuad:
+                    curveWriter.writeQuadratic(shaderCaps, &chunker, pts);
+                    break;
+                case SkPathVerb::kConic:
+                    curveWriter.writeConic(shaderCaps, &chunker, pts, *w);
+                    break;
+                case SkPathVerb::kCubic:
+                    curveWriter.writeCubic(shaderCaps, &chunker, pts);
+                    break;
+                default:
+                    break;
+            }
         }
     }
 
diff --git a/src/gpu/tessellate/GrPathCurveTessellator.h b/src/gpu/tessellate/GrPathCurveTessellator.h
index 7d2601c..a7b77bc 100644
--- a/src/gpu/tessellate/GrPathCurveTessellator.h
+++ b/src/gpu/tessellate/GrPathCurveTessellator.h
@@ -32,12 +32,23 @@
                                         const SkPMColor4f&, DrawInnerFan, int numPathVerbs,
                                         const GrPipeline&, const GrCaps&);
 
+    void prepare(GrMeshDrawTarget* target,
+                 const SkRect& cullBounds,
+                 const PathDrawList& pathDrawList,
+                 int totalCombinedPathVerbCnt) override {
+        this->prepare(target, cullBounds, pathDrawList, totalCombinedPathVerbCnt, nullptr);
+    }
 
+    // Implements GrPathTessellator::prepare(), also sending an additional list of breadcrumb
+    // triangles to the GPU. The breadcrumb triangles are implemented as conics with w=Infinity.
+    //
+    // ALSO NOTE: The breadcrumb triangles do not have a matrix. These need to be pre-transformed by
+    // the caller if a CPU-side transformation is desired.
     void prepare(GrMeshDrawTarget*,
                  const SkRect& cullBounds,
-                 const SkMatrix& pathMatrix,
-                 const SkPath&,
-                 const BreadcrumbTriangleList*) override;
+                 const PathDrawList&,
+                 int totalCombinedPathVerbCnt,
+                 const BreadcrumbTriangleList*);
 
     void draw(GrOpFlushState*) const override;
 
diff --git a/src/gpu/tessellate/GrPathInnerTriangulateOp.cpp b/src/gpu/tessellate/GrPathInnerTriangulateOp.cpp
index 0322191..635e122 100644
--- a/src/gpu/tessellate/GrPathInnerTriangulateOp.cpp
+++ b/src/gpu/tessellate/GrPathInnerTriangulateOp.cpp
@@ -400,7 +400,8 @@
 
     if (fTessellator) {
         // Must be called after polysToTriangles() in order for fFanBreadcrumbs to be complete.
-        fTessellator->prepare(flushState, this->bounds(), SkMatrix::I(), fPath, &fFanBreadcrumbs);
+        fTessellator->prepare(flushState, this->bounds(), {SkMatrix::I(), fPath},
+                              fPath.countVerbs(), &fFanBreadcrumbs);
     }
 
     if (!flushState->caps().shaderCaps()->vertexIDSupport()) {
diff --git a/src/gpu/tessellate/GrPathStencilCoverOp.cpp b/src/gpu/tessellate/GrPathStencilCoverOp.cpp
index e7bf11e..f864bce 100644
--- a/src/gpu/tessellate/GrPathStencilCoverOp.cpp
+++ b/src/gpu/tessellate/GrPathStencilCoverOp.cpp
@@ -239,7 +239,7 @@
         vertexAlloc.unlock(fFanVertexCount);
     }
 
-    fTessellator->prepare(flushState, this->bounds(), pathMatrix, fPath);
+    fTessellator->prepare(flushState, this->bounds(), {pathMatrix, fPath}, fPath.countVerbs());
 
     if (fCoverBBoxProgram) {
         size_t instanceStride = fCoverBBoxProgram->geomProc().instanceStride();
diff --git a/src/gpu/tessellate/GrPathTessellateOp.cpp b/src/gpu/tessellate/GrPathTessellateOp.cpp
index 173e39f..653a779 100644
--- a/src/gpu/tessellate/GrPathTessellateOp.cpp
+++ b/src/gpu/tessellate/GrPathTessellateOp.cpp
@@ -57,7 +57,7 @@
                                   flushState->detachAppliedClip());
         SkASSERT(fTessellator);
     }
-    fTessellator->prepare(flushState, this->bounds(), SkMatrix::I(), fPath);
+    fTessellator->prepare(flushState, this->bounds(), {SkMatrix::I(), fPath}, fPath.countVerbs());
 }
 
 void GrPathTessellateOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
diff --git a/src/gpu/tessellate/GrPathTessellator.h b/src/gpu/tessellate/GrPathTessellator.h
index 2e0a566..6dc72dd 100644
--- a/src/gpu/tessellate/GrPathTessellator.h
+++ b/src/gpu/tessellate/GrPathTessellator.h
@@ -25,34 +25,51 @@
 public:
     using BreadcrumbTriangleList = GrInnerFanTriangulator::BreadcrumbTriangleList;
 
+    struct PathDrawList {
+        PathDrawList(const SkMatrix& pathMatrix, const SkPath& path)
+                : fPathMatrix(pathMatrix), fPath(path) {}
+
+        SkMatrix fPathMatrix;
+        SkPath fPath;
+        PathDrawList* fNext = nullptr;
+
+        struct Iter {
+            void operator++() { fHead = fHead->fNext; }
+            bool operator!=(const Iter& b) const { return fHead != b.fHead; }
+            std::tuple<const SkMatrix&, const SkPath&> operator*() const {
+                return {fHead->fPathMatrix, fHead->fPath};
+            }
+            const PathDrawList* fHead;
+        };
+        Iter begin() const { return {this}; }
+        Iter end() const { return {nullptr}; }
+    };
+
+    virtual ~GrPathTessellator() {}
+
     const GrPathTessellationShader* shader() const { return fShader; }
 
     // Called before draw(). Prepares GPU buffers containing the geometry to tessellate.
     //
-    // 'pathMatrix' is applied on the CPU while the geometry is being written out. This is a tool
-    // for batching, and is applied in addition to the shader's on-GPU matrix.
-    //
-    // If the given BreadcrumbTriangleList is non-null, then we also emit geometry for the
-    // breadcrumb triangles.
+    // Each path's fPathMatrix in the list is applied on the CPU while the geometry is being written
+    // out. This is a tool for batching, and is applied in addition to the shader's on-GPU matrix.
     virtual void prepare(GrMeshDrawTarget*,
                          const SkRect& cullBounds,
-                         const SkMatrix& pathMatrix,
-                         const SkPath&,
-                         const BreadcrumbTriangleList* = nullptr) = 0;
+                         const PathDrawList&,
+                         int totalCombinedPathVerbCnt) = 0;
 
     // Issues draw calls for the tessellated geometry. The caller is responsible for binding its
     // desired pipeline ahead of time.
     virtual void draw(GrOpFlushState*) const = 0;
 
-    virtual ~GrPathTessellator() {}
-
-    // Returns an upper bound on the number of segments (lineTo, quadTo, conicTo, cubicTo) in a
-    // path, also accounting for any implicit lineTos from closing contours.
-    static int MaxSegmentsInPath(const SkPath& path) {
-        // There might be an implicit kClose at the end, but the path always begins with kMove. So
-        // the max number of segments in the path is equal to the number of verbs.
-        SkASSERT(path.countVerbs() == 0 || SkPathPriv::VerbData(path)[0] == SkPath::kMove_Verb);
-        return path.countVerbs();
+    // Returns an upper bound on the number of combined edges there might be from all inner fans in
+    // a PathDrawList.
+    static int MaxCombinedFanEdgesInPathDrawList(int totalCombinedPathVerbCnt) {
+        // Path fans might have an extra edge from an implicit kClose at the end, but they also
+        // always begin with kMove. So the max possible number of edges in a single path is equal to
+        // the number of verbs. Therefore, the max number of combined fan edges in a PathDrawList is
+        // the number of combined path verbs in that PathDrawList.
+        return totalCombinedPathVerbCnt;
     }
 
 protected:
diff --git a/src/gpu/tessellate/GrPathWedgeTessellator.cpp b/src/gpu/tessellate/GrPathWedgeTessellator.cpp
index 869fc33..e215605 100644
--- a/src/gpu/tessellate/GrPathWedgeTessellator.cpp
+++ b/src/gpu/tessellate/GrPathWedgeTessellator.cpp
@@ -111,23 +111,33 @@
 // by the hardware.
 class WedgeWriter {
 public:
-    WedgeWriter(const SkRect& cullBounds,
-                const SkMatrix& totalMatrix,  // shaderMatrix * pathMatrix
-                const SkMatrix& pathMatrix,
+    WedgeWriter(GrMeshDrawTarget* target,
+                GrVertexChunkArray* vertexChunkArray,
+                size_t patchStride,
+                int initialPatchAllocCount,
                 int maxSegments)
-            : fCullTest(cullBounds, totalMatrix)
-            , fTotalVectorXform(totalMatrix)
-            , fPathXform(pathMatrix)
+            : fChunker(target, vertexChunkArray, patchStride, initialPatchAllocCount)
             , fMaxSegments_pow2(maxSegments * maxSegments)
             , fMaxSegments_pow4(fMaxSegments_pow2 * fMaxSegments_pow2) {
     }
 
+    void setMatrices(const SkRect& cullBounds,
+                     const SkMatrix& shaderMatrix,
+                     const SkMatrix& pathMatrix) {
+        SkMatrix totalMatrix;
+        totalMatrix.setConcat(shaderMatrix, pathMatrix);
+        fCullTest.set(cullBounds, totalMatrix);
+        fTotalVectorXform = totalMatrix;
+        fPathXform = pathMatrix;
+    }
+
     const GrPathXform& pathXform() const { return fPathXform; }
 
     SK_ALWAYS_INLINE void writeFlatWedge(const GrShaderCaps& shaderCaps,
-                                         GrVertexChunkBuilder* chunker, SkPoint p0, SkPoint p1,
+                                         SkPoint p0,
+                                         SkPoint p1,
                                          SkPoint midpoint) {
-        if (GrVertexWriter vertexWriter = chunker->appendVertex()) {
+        if (GrVertexWriter vertexWriter = fChunker.appendVertex()) {
             fPathXform.mapLineToCubic(&vertexWriter, p0, p1);
             vertexWriter.write(midpoint);
             vertexWriter.write(GrVertexWriter::If(!shaderCaps.infinitySupport(),
@@ -136,14 +146,14 @@
     }
 
     SK_ALWAYS_INLINE void writeQuadraticWedge(const GrShaderCaps& shaderCaps,
-                                              GrVertexChunkBuilder* chunker, const SkPoint p[3],
+                                              const SkPoint p[3],
                                               SkPoint midpoint) {
         float numSegments_pow4 = GrWangsFormula::quadratic_pow4(kPrecision, p, fTotalVectorXform);
         if (numSegments_pow4 > fMaxSegments_pow4) {
-            this->chopAndWriteQuadraticWedges(shaderCaps, chunker, p, midpoint);
+            this->chopAndWriteQuadraticWedges(shaderCaps, p, midpoint);
             return;
         }
-        if (GrVertexWriter vertexWriter = chunker->appendVertex()) {
+        if (GrVertexWriter vertexWriter = fChunker.appendVertex()) {
             fPathXform.mapQuadToCubic(&vertexWriter, p);
             vertexWriter.write(midpoint);
             vertexWriter.write(GrVertexWriter::If(!shaderCaps.infinitySupport(),
@@ -153,14 +163,15 @@
     }
 
     SK_ALWAYS_INLINE void writeConicWedge(const GrShaderCaps& shaderCaps,
-                                          GrVertexChunkBuilder* chunker, const SkPoint p[3],
-                                          float w, SkPoint midpoint) {
+                                          const SkPoint p[3],
+                                          float w,
+                                          SkPoint midpoint) {
         float numSegments_pow2 = GrWangsFormula::conic_pow2(kPrecision, p, w, fTotalVectorXform);
         if (numSegments_pow2 > fMaxSegments_pow2) {
-            this->chopAndWriteConicWedges(shaderCaps, chunker, {p, w}, midpoint);
+            this->chopAndWriteConicWedges(shaderCaps, {p, w}, midpoint);
             return;
         }
-        if (GrVertexWriter vertexWriter = chunker->appendVertex()) {
+        if (GrVertexWriter vertexWriter = fChunker.appendVertex()) {
             fPathXform.mapConicToPatch(&vertexWriter, p, w);
             vertexWriter.write(midpoint);
             vertexWriter.write(GrVertexWriter::If(!shaderCaps.infinitySupport(),
@@ -171,14 +182,14 @@
     }
 
     SK_ALWAYS_INLINE void writeCubicWedge(const GrShaderCaps& shaderCaps,
-                                          GrVertexChunkBuilder* chunker, const SkPoint p[4],
+                                          const SkPoint p[4],
                                           SkPoint midpoint) {
         float numSegments_pow4 = GrWangsFormula::cubic_pow4(kPrecision, p, fTotalVectorXform);
         if (numSegments_pow4 > fMaxSegments_pow4) {
-            this->chopAndWriteCubicWedges(shaderCaps, chunker, p, midpoint);
+            this->chopAndWriteCubicWedges(shaderCaps, p, midpoint);
             return;
         }
-        if (GrVertexWriter vertexWriter = chunker->appendVertex()) {
+        if (GrVertexWriter vertexWriter = fChunker.appendVertex()) {
             fPathXform.map4Points(&vertexWriter, p);
             vertexWriter.write(midpoint);
             vertexWriter.write(GrVertexWriter::If(!shaderCaps.infinitySupport(),
@@ -190,50 +201,53 @@
     int numFixedSegments_pow4() const { return fNumFixedSegments_pow4; }
 
 private:
-    void chopAndWriteQuadraticWedges(const GrShaderCaps& shaderCaps, GrVertexChunkBuilder* chunker,
-                                     const SkPoint p[3], SkPoint midpoint) {
+    void chopAndWriteQuadraticWedges(const GrShaderCaps& shaderCaps,
+                                     const SkPoint p[3],
+                                     SkPoint midpoint) {
         SkPoint chops[5];
         SkChopQuadAtHalf(p, chops);
         for (int i = 0; i < 2; ++i) {
             const SkPoint* q = chops + i*2;
             if (fCullTest.areVisible3(q)) {
-                this->writeQuadraticWedge(shaderCaps, chunker, q, midpoint);
+                this->writeQuadraticWedge(shaderCaps, q, midpoint);
             } else {
-                this->writeFlatWedge(shaderCaps, chunker, q[0], q[2], midpoint);
+                this->writeFlatWedge(shaderCaps, q[0], q[2], midpoint);
             }
         }
     }
 
-    void chopAndWriteConicWedges(const GrShaderCaps& shaderCaps, GrVertexChunkBuilder* chunker,
-                                 const SkConic& conic, SkPoint midpoint) {
+    void chopAndWriteConicWedges(const GrShaderCaps& shaderCaps,
+                                 const SkConic& conic,
+                                 SkPoint midpoint) {
         SkConic chops[2];
         if (!conic.chopAt(.5, chops)) {
             return;
         }
         for (int i = 0; i < 2; ++i) {
             if (fCullTest.areVisible3(chops[i].fPts)) {
-                this->writeConicWedge(shaderCaps, chunker, chops[i].fPts, chops[i].fW, midpoint);
+                this->writeConicWedge(shaderCaps, chops[i].fPts, chops[i].fW, midpoint);
             } else {
-                this->writeFlatWedge(shaderCaps, chunker, chops[i].fPts[0], chops[i].fPts[2],
-                                     midpoint);
+                this->writeFlatWedge(shaderCaps, chops[i].fPts[0], chops[i].fPts[2], midpoint);
             }
         }
     }
 
-    void chopAndWriteCubicWedges(const GrShaderCaps& shaderCaps, GrVertexChunkBuilder* chunker,
-                                 const SkPoint p[4], SkPoint midpoint) {
+    void chopAndWriteCubicWedges(const GrShaderCaps& shaderCaps,
+                                 const SkPoint p[4],
+                                 SkPoint midpoint) {
         SkPoint chops[7];
         SkChopCubicAtHalf(p, chops);
         for (int i = 0; i < 2; ++i) {
             const SkPoint* c = chops + i*3;
             if (fCullTest.areVisible4(c)) {
-                this->writeCubicWedge(shaderCaps, chunker, c, midpoint);
+                this->writeCubicWedge(shaderCaps, c, midpoint);
             } else {
-                this->writeFlatWedge(shaderCaps, chunker, c[0], c[3], midpoint);
+                this->writeFlatWedge(shaderCaps, c[0], c[3], midpoint);
             }
         }
     }
 
+    GrVertexChunkBuilder fChunker;
     GrCullTest fCullTest;
     GrVectorXform fTotalVectorXform;
     GrPathXform fPathXform;
@@ -273,23 +287,20 @@
 
 void GrPathWedgeTessellator::prepare(GrMeshDrawTarget* target,
                                      const SkRect& cullBounds,
-                                     const SkMatrix& pathMatrix,
-                                     const SkPath& path,
-                                     const BreadcrumbTriangleList* breadcrumbTriangleList) {
-    SkASSERT(!breadcrumbTriangleList);
+                                     const PathDrawList& pathDrawList,
+                                     int totalCombinedPathVerbCnt) {
     SkASSERT(fVertexChunkArray.empty());
 
     const GrShaderCaps& shaderCaps = *target->caps().shaderCaps();
 
     // Over-allocate enough wedges for 1 in 4 to chop.
-    int maxWedges = GrPathTessellator::MaxSegmentsInPath(path);
+    int maxWedges = MaxCombinedFanEdgesInPathDrawList(totalCombinedPathVerbCnt);
     int wedgeAllocCount = (maxWedges * 5 + 3) / 4;  // i.e., ceil(maxWedges * 5/4)
     if (!wedgeAllocCount) {
         return;
     }
     size_t patchStride = fShader->willUseTessellationShaders() ? fShader->vertexStride() * 5
                                                                : fShader->instanceStride();
-    GrVertexChunkBuilder chunker(target, &fVertexChunkArray, patchStride, wedgeAllocCount);
 
     int maxSegments;
     if (fShader->willUseTessellationShaders()) {
@@ -298,43 +309,42 @@
         maxSegments = GrPathTessellationShader::kMaxFixedCountSegments;
     }
 
-    WedgeWriter wedgeWriter(cullBounds,
-                            SkMatrix::Concat(fShader->viewMatrix(), pathMatrix),
-                            pathMatrix,
-                            maxSegments);
-
-    MidpointContourParser parser(path);
-    while (parser.parseNextContour()) {
-        SkPoint midpoint = wedgeWriter.pathXform().mapPoint(parser.currentMidpoint());
-        SkPoint startPoint = {0, 0};
-        SkPoint lastPoint = startPoint;
-        for (auto [verb, pts, w] : parser.currentContour()) {
-            switch (verb) {
-                case SkPathVerb::kMove:
-                    startPoint = lastPoint = pts[0];
-                    break;
-                case SkPathVerb::kClose:
-                    break;  // Ignore. We can assume an implicit close at the end.
-                case SkPathVerb::kLine:
-                    wedgeWriter.writeFlatWedge(shaderCaps, &chunker, pts[0], pts[1], midpoint);
-                    lastPoint = pts[1];
-                    break;
-                case SkPathVerb::kQuad:
-                    wedgeWriter.writeQuadraticWedge(shaderCaps, &chunker, pts, midpoint);
-                    lastPoint = pts[2];
-                    break;
-                case SkPathVerb::kConic:
-                    wedgeWriter.writeConicWedge(shaderCaps, &chunker, pts, *w, midpoint);
-                    lastPoint = pts[2];
-                    break;
-                case SkPathVerb::kCubic:
-                    wedgeWriter.writeCubicWedge(shaderCaps, &chunker, pts, midpoint);
-                    lastPoint = pts[3];
-                    break;
+    WedgeWriter wedgeWriter(target, &fVertexChunkArray, patchStride, wedgeAllocCount, maxSegments);
+    for (auto [pathMatrix, path] : pathDrawList) {
+        wedgeWriter.setMatrices(cullBounds, fShader->viewMatrix(), pathMatrix);
+        MidpointContourParser parser(path);
+        while (parser.parseNextContour()) {
+            SkPoint midpoint = wedgeWriter.pathXform().mapPoint(parser.currentMidpoint());
+            SkPoint startPoint = {0, 0};
+            SkPoint lastPoint = startPoint;
+            for (auto [verb, pts, w] : parser.currentContour()) {
+                switch (verb) {
+                    case SkPathVerb::kMove:
+                        startPoint = lastPoint = pts[0];
+                        break;
+                    case SkPathVerb::kClose:
+                        break;  // Ignore. We can assume an implicit close at the end.
+                    case SkPathVerb::kLine:
+                        wedgeWriter.writeFlatWedge(shaderCaps, pts[0], pts[1], midpoint);
+                        lastPoint = pts[1];
+                        break;
+                    case SkPathVerb::kQuad:
+                        wedgeWriter.writeQuadraticWedge(shaderCaps, pts, midpoint);
+                        lastPoint = pts[2];
+                        break;
+                    case SkPathVerb::kConic:
+                        wedgeWriter.writeConicWedge(shaderCaps, pts, *w, midpoint);
+                        lastPoint = pts[2];
+                        break;
+                    case SkPathVerb::kCubic:
+                        wedgeWriter.writeCubicWedge(shaderCaps, pts, midpoint);
+                        lastPoint = pts[3];
+                        break;
+                }
             }
-        }
-        if (lastPoint != startPoint) {
-            wedgeWriter.writeFlatWedge(shaderCaps, &chunker, lastPoint, startPoint, midpoint);
+            if (lastPoint != startPoint) {
+                wedgeWriter.writeFlatWedge(shaderCaps, lastPoint, startPoint, midpoint);
+            }
         }
     }
 
diff --git a/src/gpu/tessellate/GrPathWedgeTessellator.h b/src/gpu/tessellate/GrPathWedgeTessellator.h
index 50490e4..3ec575a 100644
--- a/src/gpu/tessellate/GrPathWedgeTessellator.h
+++ b/src/gpu/tessellate/GrPathWedgeTessellator.h
@@ -27,9 +27,8 @@
 
     void prepare(GrMeshDrawTarget*,
                  const SkRect& cullBounds,
-                 const SkMatrix& pathMatrix,
-                 const SkPath&,
-                 const BreadcrumbTriangleList*) override;
+                 const PathDrawList&,
+                 int totalCombinedPathVerbCnt) override;
 
     void draw(GrOpFlushState*) const override;
 
diff --git a/src/gpu/tessellate/GrPathXform.h b/src/gpu/tessellate/GrPathXform.h
index 2203df1..c4f3aac 100644
--- a/src/gpu/tessellate/GrPathXform.h
+++ b/src/gpu/tessellate/GrPathXform.h
@@ -23,11 +23,16 @@
     using float4 = grvx::float4;
 
 public:
-    GrPathXform(const SkMatrix& m)
-            : fScale{m.getScaleX(), m.getScaleY(), m.getScaleX(), m.getScaleY()}
-            , fSkew{m.getSkewX(), m.getSkewY(), m.getSkewX(), m.getSkewY()}
-            , fTrans{m.getTranslateX(), m.getTranslateY(), m.getTranslateX(), m.getTranslateY()} {
+    GrPathXform() = default;
+    GrPathXform(const SkMatrix& m) { *this = m; }
+
+    GrPathXform& operator=(const SkMatrix& m) {
         SkASSERT(!m.hasPerspective());
+        // Duplicate the matrix in float4.lo and float4.hi so we can map two points at once.
+        fScale = {m.getScaleX(), m.getScaleY(), m.getScaleX(), m.getScaleY()};
+        fSkew = {m.getSkewX(), m.getSkewY(), m.getSkewX(), m.getSkewY()};
+        fTrans = {m.getTranslateX(), m.getTranslateY(), m.getTranslateX(), m.getTranslateY()};
+        return *this;
     }
 
     SK_ALWAYS_INLINE float2 mapPoint(float2 p) const {
diff --git a/src/gpu/tessellate/GrVectorXform.h b/src/gpu/tessellate/GrVectorXform.h
index 5a47a8b..d80f28e 100644
--- a/src/gpu/tessellate/GrVectorXform.h
+++ b/src/gpu/tessellate/GrVectorXform.h
@@ -20,7 +20,8 @@
     using float2 = skvx::Vec<2, float>;
     using float4 = skvx::Vec<4, float>;
     explicit GrVectorXform() : fType(Type::kIdentity) {}
-    explicit GrVectorXform(const SkMatrix& m) {
+    explicit GrVectorXform(const SkMatrix& m) { *this = m; }
+    GrVectorXform& operator=(const SkMatrix& m) {
         SkASSERT(!m.hasPerspective());
         if (m.getType() & SkMatrix::kAffine_Mask) {
             fType = Type::kAffine;
@@ -36,6 +37,7 @@
             SkASSERT(!(m.getType() & ~SkMatrix::kTranslate_Mask));
             fType = Type::kIdentity;
         }
+        return *this;
     }
     float2 operator()(float2 vector) const {
         switch (fType) {