diff --git a/bench/TessellateBench.cpp b/bench/TessellateBench.cpp
index 01ed8f7..2594030 100644
--- a/bench/TessellateBench.cpp
+++ b/bench/TessellateBench.cpp
@@ -283,8 +283,12 @@
         }
         for (int i = 0; i < loops; ++i) {
             fPatchChunks.reset();
-            GrStrokePatchBuilder builder(&fTarget, &fPatchChunks, 1, fStrokeRec,
-                                         fPath.countVerbs());
+            // TODO: Combine GrStrokePatchBuilder with GrStrokeTessellateOp.
+            float parametricIntolerance = GrTessellationPathRenderer::kLinearizationIntolerance;
+            float numRadialSegmentsPerRadian = .5f /
+                    acosf(1 - 2/(parametricIntolerance * fStrokeRec.getWidth()));
+            GrStrokePatchBuilder builder(&fTarget, &fPatchChunks, fStrokeRec, parametricIntolerance,
+                                         numRadialSegmentsPerRadian, fPath.countVerbs());
             builder.addPath(fPath);
         }
     }
diff --git a/src/gpu/tessellate/GrStrokePatchBuilder.cpp b/src/gpu/tessellate/GrStrokePatchBuilder.cpp
index f23a55a..9cc09e5 100644
--- a/src/gpu/tessellate/GrStrokePatchBuilder.cpp
+++ b/src/gpu/tessellate/GrStrokePatchBuilder.cpp
@@ -55,24 +55,23 @@
 }
 
 GrStrokePatchBuilder::GrStrokePatchBuilder(GrMeshDrawOp::Target* target,
-                                           SkTArray<PatchChunk>* patchChunkArray, float matrixScale,
-                                           const SkStrokeRec& stroke, int totalCombinedVerbCnt)
+                                           SkTArray<PatchChunk>* patchChunkArray,
+                                           const SkStrokeRec& stroke,
+                                           float parametricIntolerance,
+                                           float numRadialSegmentsPerRadian,
+                                           int totalCombinedVerbCnt)
         : fTarget(target)
         , fPatchChunkArray(patchChunkArray)
-        , fMaxTessellationSegments(target->caps().shaderCaps()->maxTessellationSegments())
-        , fLinearizationIntolerance(matrixScale *
-                                    GrTessellationPathRenderer::kLinearizationIntolerance)
-        , fStroke(stroke) {
+        // Subtract 2 because the tessellation shader chops every cubic at two locations, and each
+        // chop has the potential to introduce an extra segment.
+        , fMaxTessellationSegments(target->caps().shaderCaps()->maxTessellationSegments() - 2)
+        , fStroke(stroke)
+        , fParametricIntolerance(parametricIntolerance)
+        , fNumRadialSegmentsPerRadian(numRadialSegmentsPerRadian) {
     // We don't support hairline strokes. For now, the client can transform the path into device
     // space and then use a stroke width of 1.
     SkASSERT(fStroke.getWidth() > 0);
 
-    // This is the number of radial segments we need to add to a triangle strip for each radian
-    // of rotation, given the current stroke radius. Any fewer radial segments and our error
-    // would fall outside the linearization tolerance.
-    fNumRadialSegmentsPerRadian = 1 / std::acos(
-            std::max(1 - 1 / (fLinearizationIntolerance * fStroke.getWidth() * .5f), -1.f));
-
     // Calculate the worst-case numbers of parametric segments our hardware can support for the
     // current stroke radius, in the event that there are also enough radial segments to rotate
     // 180 and 360 degrees respectively. These are used for "quick accepts" that allow us to
@@ -225,7 +224,7 @@
     //
     // An informal survey of skottie animations and gms revealed that even with a bare minimum of 64
     // tessellation segments, 99.9%+ of quadratics take this early out.
-    float numParametricSegments_pow4 = GrWangsFormula::quadratic_pow4(fLinearizationIntolerance, p);
+    float numParametricSegments_pow4 = GrWangsFormula::quadratic_pow4(fParametricIntolerance, p);
     if (numParametricSegments_pow4 <= fMaxParametricSegments180_pow4_withJoin &&
         prevJoinType != JoinType::kCusp) {
         this->cubicToRaw(prevJoinType, asCubic);
@@ -311,7 +310,7 @@
     //
     // An informal survey of skottie animations revealed that with a bare minimum of 64 tessellation
     // segments, 95% of cubics take this early out.
-    float numParametricSegments_pow4 = GrWangsFormula::cubic_pow4(fLinearizationIntolerance, p);
+    float numParametricSegments_pow4 = GrWangsFormula::cubic_pow4(fParametricIntolerance, p);
     if (numParametricSegments_pow4 <= fMaxParametricSegments360_pow4_withJoin &&
         prevJoinType != JoinType::kCusp) {
         this->cubicToRaw(prevJoinType, p);
diff --git a/src/gpu/tessellate/GrStrokePatchBuilder.h b/src/gpu/tessellate/GrStrokePatchBuilder.h
index a67e3a8..8794bcc 100644
--- a/src/gpu/tessellate/GrStrokePatchBuilder.h
+++ b/src/gpu/tessellate/GrStrokePatchBuilder.h
@@ -43,9 +43,16 @@
     // push to as addPath is called. The caller is responsible to bind and draw each chunk that gets
     // pushed to the array. (See GrStrokeTessellateShader.)
     //
-    // All points are multiplied by 'matrixScale' before being written to the GPU buffer.
-    GrStrokePatchBuilder(GrMeshDrawOp::Target*, SkTArray<PatchChunk>*, float matrixScale,
-                         const SkStrokeRec&, int totalCombinedVerbCnt);
+    // 'parametricIntolerance' controls the number of parametric segments we need to account for on
+    // each curve. The tessellator will add enough parametric segments so that the center of each
+    // one falls within 1/parametricIntolerance local path units from the true curve.
+    //
+    // 'numRadialSegmentsPerRadian' controls the number of radial segments we need to account for on
+    // each curve. The tessellator will add this number of radial segments for each radian of
+    // rotation, in order to guarantee smoothness.
+    GrStrokePatchBuilder(GrMeshDrawOp::Target*, SkTArray<PatchChunk>*, const SkStrokeRec&,
+                         float parametricIntolerance, float numRadialSegmentsPerRadian,
+                         int totalCombinedVerbCnt);
 
     // "Releases" the target to be used externally again by putting back any unused pre-allocated
     // vertices.
@@ -97,12 +104,10 @@
     SkTArray<PatchChunk>* const fPatchChunkArray;
 
     const int fMaxTessellationSegments;
-    // GrTessellationPathRenderer::kIntolerance adjusted for the matrix scale.
-    const float fLinearizationIntolerance;
-
-    // Variables related to the stroke parameters.
     const SkStrokeRec fStroke;
-    float fNumRadialSegmentsPerRadian;
+    const float fParametricIntolerance;
+    const float fNumRadialSegmentsPerRadian;
+
     // These values contain worst-case numbers of parametric segments, raised to the 4th power, that
     // our hardware can support for the current stroke radius. They assume curve rotations of 180
     // and 360 degrees respectively. These are used for "quick accepts" that allow us to send almost
diff --git a/src/gpu/tessellate/GrStrokeTessellateOp.cpp b/src/gpu/tessellate/GrStrokeTessellateOp.cpp
index ecacda0..ec4853c 100644
--- a/src/gpu/tessellate/GrStrokeTessellateOp.cpp
+++ b/src/gpu/tessellate/GrStrokeTessellateOp.cpp
@@ -26,14 +26,17 @@
         : GrDrawOp(ClassID())
         , fAAType(aaType)
         , fViewMatrix(viewMatrix)
-        , fMatrixScale(fViewMatrix.getMaxScale())
         , fStroke(stroke)
+        , fParametricIntolerance(fViewMatrix.getMaxScale() *
+                                 GrTessellationPathRenderer::kLinearizationIntolerance)
+        , fNumRadialSegmentsPerRadian(.5f / acosf(
+                std::max(1 - 2/(fParametricIntolerance * fStroke.getWidth()), -1.f)))
         , fColor(get_paint_constant_blended_color(paint))
         , fProcessors(std::move(paint))
         , fPaths(path)
         , fTotalCombinedVerbCnt(path.countVerbs()) {
     SkASSERT(fAAType != GrAAType::kCoverage);  // No mixed samples support yet.
-    SkASSERT(fMatrixScale >= 0);
+    SkASSERT(fParametricIntolerance >= 0);
     SkRect devBounds = path.getBounds();
     float inflationRadius = fStroke.getInflationRadius();
     devBounds.outset(inflationRadius, inflationRadius);
@@ -91,8 +94,9 @@
                                                   const GrXferProcessor::DstProxyView& dstProxyView,
                                                   GrXferBarrierFlags renderPassXferBarriers,
                                                   const GrCaps& caps) {
-    auto* strokeShader = arena->make<GrStrokeTessellateShader>(fStroke, fMatrixScale, fViewMatrix,
-                                                               fColor);
+    auto* strokeShader = arena->make<GrStrokeTessellateShader>(fStroke, fParametricIntolerance,
+                                                               fNumRadialSegmentsPerRadian,
+                                                               fViewMatrix, fColor);
     auto pipelineFlags = GrPipeline::InputFlags::kNone;
     if (GrAAType::kNone != fAAType) {
         pipelineFlags |= GrPipeline::InputFlags::kHWAntialias;
@@ -111,8 +115,8 @@
                                      flushState->detachAppliedClip(), flushState->dstProxyView(),
                                      flushState->renderPassBarriers(), flushState->caps());
     }
-    GrStrokePatchBuilder builder(flushState, &fPatchChunks, fMatrixScale, fStroke,
-                                 fTotalCombinedVerbCnt);
+    GrStrokePatchBuilder builder(flushState, &fPatchChunks, fStroke, fParametricIntolerance,
+                                 fNumRadialSegmentsPerRadian, fTotalCombinedVerbCnt);
     for (const SkPath& path : fPaths) {
         builder.addPath(path);
     }
diff --git a/src/gpu/tessellate/GrStrokeTessellateOp.h b/src/gpu/tessellate/GrStrokeTessellateOp.h
index 80ec4de..757edbe 100644
--- a/src/gpu/tessellate/GrStrokeTessellateOp.h
+++ b/src/gpu/tessellate/GrStrokeTessellateOp.h
@@ -45,8 +45,15 @@
 
     const GrAAType fAAType;
     const SkMatrix fViewMatrix;
-    const float fMatrixScale;
     const SkStrokeRec fStroke;
+    // Controls the number of parametric segments the tessellator adds for each curve. The
+    // tessellator will add enough parametric segments so that the center of each one falls within
+    // 1/parametricIntolerance local path units from the true curve.
+    const float fParametricIntolerance;
+    // Controls the number of radial segments the tessellator adds for each curve. The tessellator
+    // will add this number of radial segments for each radian of rotation, in order to guarantee
+    // smoothness.
+    const float fNumRadialSegmentsPerRadian;
     SkPMColor4f fColor;
     GrProcessorSet fProcessors;
 
diff --git a/src/gpu/tessellate/GrStrokeTessellateShader.cpp b/src/gpu/tessellate/GrStrokeTessellateShader.cpp
index a012a7a..5ea67d6 100644
--- a/src/gpu/tessellate/GrStrokeTessellateShader.cpp
+++ b/src/gpu/tessellate/GrStrokeTessellateShader.cpp
@@ -13,9 +13,6 @@
 #include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
 #include "src/gpu/tessellate/GrWangsFormula.h"
 
-constexpr static float kLinearizationIntolerance =
-        GrTessellationPathRenderer::kLinearizationIntolerance;
-
 class GrStrokeTessellateShader::Impl : public GrGLSLGeometryProcessor {
 public:
     const char* getTessArgs1UniformName(const GrGLSLUniformHandler& uniformHandler) const {
@@ -41,7 +38,7 @@
         // uNumSegmentsInJoin, uCubicConstantPow2, uNumRadialSegmentsPerRadian, uMiterLimitInvPow2.
         fTessArgs1Uniform = uniHandler->addUniform(nullptr, kTessControl_GrShaderFlag,
                                                    kFloat4_GrSLType, "tessArgs1", nullptr);
-        // uRadialTolerancePow2, uStrokeRadius.
+        // uJoinTolerancePow2, uStrokeRadius.
         fTessArgs2Uniform = uniHandler->addUniform(nullptr, kTessControl_GrShaderFlag |
                                                             kTessEvaluation_GrShaderFlag,
                                                    kFloat2_GrSLType,
@@ -262,18 +259,17 @@
                 numSegmentsInJoin = 0;  // Use the rotation to calculate the number of segments.
                 break;
         }
-        float intolerance = kLinearizationIntolerance * shader.fMatrixScale;
-        float cubicConstant = GrWangsFormula::cubic_constant(intolerance);
-        float strokeRadius = shader.fStroke.getWidth() * .5;
-        float radialIntolerance = 1 / (strokeRadius * intolerance);
+        float cubicConstant = GrWangsFormula::cubic_constant(shader.fParametricIntolerance);
         float miterLimit = shader.fStroke.getMiter();
         pdman.set4f(fTessArgs1Uniform,
             numSegmentsInJoin,  // uNumSegmentsInJoin
             cubicConstant * cubicConstant,  // uCubicConstantPow2 in path space.
-            .5f / acosf(std::max(1 - radialIntolerance, -1.f)),  // uNumRadialSegmentsPerRadian
+            shader.fNumRadialSegmentsPerRadian,  // uNumRadialSegmentsPerRadian
             1 / (miterLimit * miterLimit));  // uMiterLimitInvPow2.
+        float strokeRadius = shader.fStroke.getWidth() * .5;
+        float joinTolerance = 1 / (strokeRadius * shader.fParametricIntolerance);
         pdman.set2f(fTessArgs2Uniform,
-                    radialIntolerance * radialIntolerance,  // uRadialTolerancePow2.
+                    joinTolerance * joinTolerance,  // uJoinTolerancePow2.
                     strokeRadius);  // uStrokeRadius.
         const SkMatrix& m = shader.viewMatrix();
         if (!m.isIdentity()) {
@@ -314,7 +310,7 @@
 
     const char* tessArgs2Name = impl->getTessArgs2UniformName(uniformHandler);
     code.appendf("uniform vec2 %s;\n", tessArgs2Name);
-    code.appendf("#define uRadialTolerancePow2 %s.x\n", tessArgs2Name);
+    code.appendf("#define uJoinTolerancePow2 %s.x\n", tessArgs2Name);
 
     code.append(R"(
     in vec4 vsPts01[];
@@ -424,7 +420,7 @@
                 innerStrokeRadiusMultiplier = (x >= uMiterLimitInvPow2) ? inversesqrt(x) : sqrt(x);
             }
             vec2 strokeOutsetClamp = vec2(-1, 1);
-            if (length_pow2(tan1norm - tan0norm) > uRadialTolerancePow2) {
+            if (length_pow2(tan1norm - tan0norm) > uJoinTolerancePow2) {
                 // Clamp the join to the exterior side of its junction. We only do this if the join
                 // angle is large enough to guarantee there won't be cracks on the interior side of
                 // the junction.
diff --git a/src/gpu/tessellate/GrStrokeTessellateShader.h b/src/gpu/tessellate/GrStrokeTessellateShader.h
index 2dd2a5d..7bed8a8 100644
--- a/src/gpu/tessellate/GrStrokeTessellateShader.h
+++ b/src/gpu/tessellate/GrStrokeTessellateShader.h
@@ -16,27 +16,13 @@
 
 class GrGLSLUniformHandler;
 
-// Tessellates a batch of stroke patches directly to the canvas.
-//
-// Current limitations: (These restrictions will hopefully all be lifted in the future.)
-//
-//     * A given curve must not have inflection points. Chop curves at inflection points on CPU
-//       before sending them down.
-//
-//     * A given curve must not rotate more than 180 degrees. Chop curves that rotate more than 180
-//       degrees at midtangent before sending them down.
-//
-//     * It is illegal for P1 and P2 to both be coincident with P0 or P3. If this is the case, send
-//       the curve [P0, P0, P3, P3] instead.
-//
-//     * Perspective is not supported.
-//
-// Tessellated stroking works by creating stroke-width, orthogonal edges at set locations along the
-// curve and then connecting them with a quad strip. These orthogonal edges come from two different
-// sets: "parametric edges" and "radial edges". Parametric edges are spaced evenly in the parametric
-// sense, and radial edges divide the curve's _rotation_ into even steps. The tessellation shader
-// evaluates both sets of edges and sorts them into a single quad strip. With this combined set of
-// edges we can stroke any curve, regardless of curvature.
+// Tessellates a batch of stroke patches directly to the canvas. Tessellated stroking works by
+// creating stroke-width, orthogonal edges at set locations along the curve and then connecting them
+// with a quad strip. These orthogonal edges come from two different sets: "parametric edges" and
+// "radial edges". Parametric edges are spaced evenly in the parametric sense, and radial edges
+// divide the curve's _rotation_ into even steps. The tessellation shader evaluates both sets of
+// edges and sorts them into a single quad strip. With this combined set of edges we can stroke any
+// curve, regardless of curvature.
 class GrStrokeTessellateShader : public GrPathShader {
 public:
     // The vertex array bound for this shader should contain a vector of Patch structs. A Patch is
@@ -56,19 +42,23 @@
         std::array<SkPoint, 4> fPts;
     };
 
-    // 'matrixScale' is used to set up an appropriate number of tessellation triangles. It should be
-    // equal to viewMatrix.getMaxScale(). (This works because perspective isn't supported.)
+    // 'parametricIntolerance' controls the number of parametric segments we add for each curve.
+    // We add enough parametric segments so that the center of each one falls within
+    // 1/parametricIntolerance local path units from the true curve.
     //
-    // 'miterLimit' contains the stroke's miter limit, or may be zero if no patches being drawn will
-    // be miter joins.
+    // 'numRadialSegmentsPerRadian' controls the number of radial segments we add for each curve.
+    // We add this number of radial segments for each radian of rotation, in order to guarantee
+    // smoothness.
     //
     // 'viewMatrix' is applied to the geometry post tessellation. It cannot have perspective.
-    GrStrokeTessellateShader(const SkStrokeRec& stroke, float matrixScale,
-                             const SkMatrix& viewMatrix, SkPMColor4f color)
+    GrStrokeTessellateShader(const SkStrokeRec& stroke, float parametricIntolerance,
+                             float numRadialSegmentsPerRadian, const SkMatrix& viewMatrix,
+                             SkPMColor4f color)
             : GrPathShader(kTessellate_GrStrokeTessellateShader_ClassID, viewMatrix,
                            GrPrimitiveType::kPatches, 1)
             , fStroke(stroke)
-            , fMatrixScale(matrixScale)
+            , fParametricIntolerance(parametricIntolerance)
+            , fNumRadialSegmentsPerRadian(numRadialSegmentsPerRadian)
             , fColor(color) {
         SkASSERT(!fStroke.isHairlineStyle());  // No hairline support yet.
         constexpr static Attribute kInputPointAttribs[] = {
@@ -96,7 +86,8 @@
                                          const GrShaderCaps&) const override;
 
     const SkStrokeRec fStroke;
-    const float fMatrixScale;
+    const float fParametricIntolerance;
+    const float fNumRadialSegmentsPerRadian;
     const SkPMColor4f fColor;
 
     class Impl;