diff --git a/bench/TessellateBench.cpp b/bench/TessellateBench.cpp
index bbeefd6..38f0d40 100644
--- a/bench/TessellateBench.cpp
+++ b/bench/TessellateBench.cpp
@@ -153,7 +153,7 @@
 }
 
 static void benchmark_wangs_formula_conic(const SkMatrix& matrix, const SkPath& path) {
-    // Conic version expects tolerance, not intolerance
+    // Conic version expects tolerance, not "precision"
     constexpr float kTolerance = 4;
     int sum = 0;
     GrVectorXform xform(matrix);
@@ -169,7 +169,7 @@
 }
 
 static void benchmark_wangs_formula_conic_log2(const SkMatrix& matrix, const SkPath& path) {
-    // Conic version expects tolerance, not intolerance
+    // Conic version expects tolerance, not "precision"
     constexpr float kTolerance = 4;
     int sum = 0;
     GrVectorXform xform(matrix);
diff --git a/src/gpu/tessellate/GrPathTessellator.cpp b/src/gpu/tessellate/GrPathTessellator.cpp
index 756e65f..573a0c1 100644
--- a/src/gpu/tessellate/GrPathTessellator.cpp
+++ b/src/gpu/tessellate/GrPathTessellator.cpp
@@ -24,13 +24,13 @@
         int level;
         switch (verb) {
             case SkPathVerb::kConic:
-                level = GrWangsFormula::conic_log2(1.f / kLinearizationIntolerance, pts, *w, xform);
+                level = GrWangsFormula::conic_log2(1.f / kLinearizationPrecision, pts, *w, xform);
                 break;
             case SkPathVerb::kQuad:
-                level = GrWangsFormula::quadratic_log2(kLinearizationIntolerance, pts, xform);
+                level = GrWangsFormula::quadratic_log2(kLinearizationPrecision, pts, xform);
                 break;
             case SkPathVerb::kCubic:
-                level = GrWangsFormula::cubic_log2(kLinearizationIntolerance, pts, xform);
+                level = GrWangsFormula::cubic_log2(kLinearizationPrecision, pts, xform);
                 break;
             default:
                 continue;
@@ -179,14 +179,14 @@
                 default:
                     continue;
                 case SkPathVerb::kConic:
-                    level = GrWangsFormula::conic_log2(1.f / kLinearizationIntolerance, pts, *w,
+                    level = GrWangsFormula::conic_log2(1.f / kLinearizationPrecision, pts, *w,
                                                        xform);
                     break;
                 case SkPathVerb::kQuad:
-                    level = GrWangsFormula::quadratic_log2(kLinearizationIntolerance, pts, xform);
+                    level = GrWangsFormula::quadratic_log2(kLinearizationPrecision, pts, xform);
                     break;
                 case SkPathVerb::kCubic:
-                    level = GrWangsFormula::cubic_log2(kLinearizationIntolerance, pts, xform);
+                    level = GrWangsFormula::cubic_log2(kLinearizationPrecision, pts, xform);
                     break;
             }
             if (level == 0) {
diff --git a/src/gpu/tessellate/GrPathTessellator.h b/src/gpu/tessellate/GrPathTessellator.h
index 2545e60..393ac26 100644
--- a/src/gpu/tessellate/GrPathTessellator.h
+++ b/src/gpu/tessellate/GrPathTessellator.h
@@ -56,8 +56,8 @@
     void drawHullInstances(GrOpFlushState*) const override;
 
 private:
-    constexpr static float kLinearizationIntolerance =
-            GrTessellationPathRenderer::kLinearizationIntolerance;
+    constexpr static float kLinearizationPrecision =
+            GrTessellationPathRenderer::kLinearizationPrecision;
     constexpr static int kMaxResolveLevel = GrTessellationPathRenderer::kMaxResolveLevel;
 
     const bool fDrawInnerFan;
diff --git a/src/gpu/tessellate/GrStrokeHardwareTessellator.cpp b/src/gpu/tessellate/GrStrokeHardwareTessellator.cpp
index 2aea611..aee3ab3 100644
--- a/src/gpu/tessellate/GrStrokeHardwareTessellator.cpp
+++ b/src/gpu/tessellate/GrStrokeHardwareTessellator.cpp
@@ -58,14 +58,13 @@
             // 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)
-            , fParametricIntolerance(GrStrokeTolerances::CalcParametricIntolerance(
-                    matrixMaxScale)) {
+            , fParametricPrecision(GrStrokeTolerances::CalcParametricPrecision(matrixMaxScale)) {
     }
 
-    // This is the intolerance value, adjusted for the view matrix, to use with Wang's formulas when
+    // This is the precision value, adjusted for the view matrix, to use with Wang's formulas when
     // determining how many parametric segments a curve will require.
-    float parametricIntolerance() const {
-        return fParametricIntolerance;
+    float parametricPrecision() const {
+        return fParametricPrecision;
     }
     // Will a line and worst-case previous join both fit in a single patch together?
     bool lineFitsInPatch_withJoin() {
@@ -366,8 +365,7 @@
             GrPathShader::WriteConicPatch(p, w, asPatch);
         }
 
-        float numParametricSegments_pow4 =
-                GrWangsFormula::quadratic_pow4(fParametricIntolerance, p);
+        float numParametricSegments_pow4 = GrWangsFormula::quadratic_pow4(fParametricPrecision, p);
         if (this->stroke180FitsInPatch(numParametricSegments_pow4) || maxDepth == 0) {
             this->internalPatchTo(prevJoinType,
                                   this->stroke180FitsInPatch_withJoin(numParametricSegments_pow4),
@@ -431,7 +429,7 @@
             return;
         }
 
-        float numParametricSegments_pow4 = GrWangsFormula::cubic_pow4(fParametricIntolerance, p);
+        float numParametricSegments_pow4 = GrWangsFormula::cubic_pow4(fParametricPrecision, p);
         if (this->stroke180FitsInPatch(numParametricSegments_pow4) || maxDepth == 0) {
             this->internalPatchTo(prevJoinType,
                                   this->stroke180FitsInPatch_withJoin(numParametricSegments_pow4),
@@ -600,9 +598,9 @@
     // The maximum number of tessellation segments the hardware can emit for a single patch.
     const int fMaxTessellationSegments;
 
-    // This is the intolerance value, adjusted for the view matrix, to use with Wang's formulas when
+    // This is the precision value, adjusted for the view matrix, to use with Wang's formulas when
     // determining how many parametric segments a curve will require.
-    const float fParametricIntolerance;
+    const float fParametricPrecision;
 
     // Number of radial segments required for each radian of rotation in order to look smooth with
     // the current stroke radius.
@@ -703,13 +701,13 @@
         float localStrokeWidth = GrStrokeTolerances::GetLocalStrokeWidth(matrixMinMaxScales.data(),
                                                                          stroke.getWidth());
         float numRadialSegmentsPerRadian = GrStrokeTolerances::CalcNumRadialSegmentsPerRadian(
-                patchWriter.parametricIntolerance(), localStrokeWidth);
+                patchWriter.parametricPrecision(), localStrokeWidth);
         patchWriter.updateTolerances(numRadialSegmentsPerRadian, stroke.getJoin());
     }
 
     // Fast SIMD queue that buffers up values for "numRadialSegmentsPerRadian". Only used when we
     // have dynamic strokes.
-    GrStrokeToleranceBuffer toleranceBuffer(patchWriter.parametricIntolerance());
+    GrStrokeToleranceBuffer toleranceBuffer(patchWriter.parametricPrecision());
 
     for (PathStrokeList* pathStroke = fPathStrokeList; pathStroke; pathStroke = pathStroke->fNext) {
         const SkStrokeRec& stroke = pathStroke->fStroke;
@@ -775,7 +773,7 @@
                         continue;
                     }
                     float numParametricSegments_pow4 =
-                            GrWangsFormula::quadratic_pow4(patchWriter.parametricIntolerance(), p);
+                            GrWangsFormula::quadratic_pow4(patchWriter.parametricPrecision(), p);
                     if (!patchWriter.stroke180FitsInPatch(numParametricSegments_pow4)) {
                         // The curve requires more tessellation segments than the hardware can
                         // support. This is rare. Recursively chop until each sub-curve fits.
@@ -814,7 +812,7 @@
                     // draws conics.
                     // TODO: Update here when the shader starts using the real conic formula.
                     float numParametricSegments_pow4 =
-                            GrWangsFormula::quadratic_pow4(patchWriter.parametricIntolerance(), p);
+                            GrWangsFormula::quadratic_pow4(patchWriter.parametricPrecision(), p);
                     if (!patchWriter.stroke180FitsInPatch(numParametricSegments_pow4)) {
                         // The curve requires more tessellation segments than the hardware can
                         // support. This is rare. Recursively chop until each sub-curve fits.
@@ -839,7 +837,7 @@
                         continue;
                     }
                     float numParametricSegments_pow4 =
-                            GrWangsFormula::cubic_pow4(patchWriter.parametricIntolerance(), p);
+                            GrWangsFormula::cubic_pow4(patchWriter.parametricPrecision(), p);
                     if (!patchWriter.stroke360FitsInPatch(numParametricSegments_pow4) ||
                         cubic_has_cusp(p)) {
                         // Either the curve requires more tessellation segments than the hardware
diff --git a/src/gpu/tessellate/GrStrokeIndirectTessellator.cpp b/src/gpu/tessellate/GrStrokeIndirectTessellator.cpp
index f306ad3..93a2ede 100644
--- a/src/gpu/tessellate/GrStrokeIndirectTessellator.cpp
+++ b/src/gpu/tessellate/GrStrokeIndirectTessellator.cpp
@@ -81,8 +81,8 @@
                 1, kMaxResolveLevel);
         fIsRoundJoin = isRoundJoin;
 #if USE_SIMD
-        fWangsTermQuadratic = GrWangsFormula::length_term<2>(fTolerances.fParametricIntolerance);
-        fWangsTermCubic = GrWangsFormula::length_term<3>(fTolerances.fParametricIntolerance);
+        fWangsTermQuadratic = GrWangsFormula::length_term<2>(fTolerances.fParametricPrecision);
+        fWangsTermCubic = GrWangsFormula::length_term<3>(fTolerances.fParametricPrecision);
 #endif
     }
 
@@ -112,7 +112,7 @@
 
     void countQuad(const SkPoint pts[3], SkPoint lastControlPoint, int8_t* resolveLevelPtr) {
         float numParametricSegments =
-                GrWangsFormula::quadratic(fTolerances.fParametricIntolerance, pts);
+                GrWangsFormula::quadratic(fTolerances.fParametricPrecision, pts);
         float rotation = SkMeasureQuadRotation(pts);
         if (fIsRoundJoin) {
             SkVector nextTan = ((pts[0] == pts[1]) ? pts[2] : pts[1]) - pts[0];
@@ -122,8 +122,7 @@
     }
 
     void countCubic(const SkPoint pts[4], SkPoint lastControlPoint, int8_t* resolveLevelPtr) {
-        float numParametricSegments =
-                GrWangsFormula::cubic(fTolerances.fParametricIntolerance, pts);
+        float numParametricSegments = GrWangsFormula::cubic(fTolerances.fParametricPrecision, pts);
         SkVector tan0 = ((pts[0] == pts[1]) ? pts[2] : pts[1]) - pts[0];
         SkVector tan1 = pts[3] - ((pts[3] == pts[2]) ? pts[1] : pts[2]);
         float rotation = SkMeasureAngleBetweenVectors(tan0, tan1);
diff --git a/src/gpu/tessellate/GrStrokeTessellateShader.cpp b/src/gpu/tessellate/GrStrokeTessellateShader.cpp
index 52c4b56..29d2e9d 100644
--- a/src/gpu/tessellate/GrStrokeTessellateShader.cpp
+++ b/src/gpu/tessellate/GrStrokeTessellateShader.cpp
@@ -47,8 +47,8 @@
 })";
 
 static const char* kNumRadialSegmentsPerRadian = R"(
-float num_radial_segments_per_radian(float parametricIntolerance, float strokeRadius) {
-    return .5 / acos(max(1.0 - 1.0/(parametricIntolerance * strokeRadius), -1.0));
+float num_radial_segments_per_radian(float parametricPrecision, float strokeRadius) {
+    return .5 / acos(max(1.0 - 1.0/(parametricPrecision * strokeRadius), -1.0));
 })";
 
 // Unlike mix(), this does not return b when t==1. But it otherwise seems to get better
@@ -70,7 +70,7 @@
 // will be a composition of these parametric segments as well as radial segments.
 static void append_wangs_formula_fn(SkString* code, bool hasConics) {
     code->appendf(R"(
-    float wangs_formula(in float4x2 P, in float w, in float parametricIntolerance) {
+    float wangs_formula(in float4x2 P, in float w, in float parametricPrecision) {
         const float CUBIC_TERM_POW2 = %f;
         float l0 = length_pow2(fma(float2(-2), P[1], P[2]) + P[0]);
         float l1 = length_pow2(fma(float2(-2), P[2], P[3]) + P[1]);
@@ -81,7 +81,7 @@
         m = (w > 0.0) ? QUAD_TERM_POW2 * l0 : m;)", GrWangsFormula::length_term_pow2<2>(1));
     }
     code->append(R"(
-        return max(ceil(sqrt(parametricIntolerance * sqrt(m))), 1.0);
+        return max(ceil(sqrt(parametricPrecision * sqrt(m))), 1.0);
     })");
 }
 
@@ -150,7 +150,7 @@
         }
 
         if (!shader.hasDynamicStroke()) {
-            // [PARAMETRIC_INTOLERANCE, NUM_RADIAL_SEGMENTS_PER_RADIAN, JOIN_TYPE, STROKE_RADIUS]
+            // [PARAMETRIC_PRECISION, NUM_RADIAL_SEGMENTS_PER_RADIAN, JOIN_TYPE, STROKE_RADIUS]
             const char* tessArgsName;
             fTessArgsUniform = uniHandler->addUniform(nullptr,
                                                       kVertex_GrShaderFlag |
@@ -161,17 +161,17 @@
             float NUM_RADIAL_SEGMENTS_PER_RADIAN = %s.y;
             float JOIN_TYPE = %s.z;)", tessArgsName, tessArgsName);
         } else {
-            const char* parametricIntoleranceName;
+            const char* parametricPrecisionName;
             fTessArgsUniform = uniHandler->addUniform(nullptr,
                                                       kVertex_GrShaderFlag |
                                                       kTessControl_GrShaderFlag |
                                                       kTessEvaluation_GrShaderFlag,
-                                                      kFloat_GrSLType, "parametricIntolerance",
-                                                      &parametricIntoleranceName);
+                                                      kFloat_GrSLType, "parametricPrecision",
+                                                      &parametricPrecisionName);
             v->codeAppendf(R"(
             float STROKE_RADIUS = dynamicStrokeAttr.x;
             float NUM_RADIAL_SEGMENTS_PER_RADIAN = num_radial_segments_per_radian(%s,STROKE_RADIUS);
-            float JOIN_TYPE = dynamicStrokeAttr.y;)", parametricIntoleranceName);
+            float JOIN_TYPE = dynamicStrokeAttr.y;)", parametricPrecisionName);
         }
 
         if (!shader.viewMatrix().isIdentity()) {
@@ -432,14 +432,14 @@
             }
             float strokeRadius = (stroke.isHairlineStyle()) ? .5f : stroke.getWidth() * .5;
             pdman.set4f(fTessArgsUniform,
-                        tolerances.fParametricIntolerance,  // PARAMETRIC_INTOLERANCE
+                        tolerances.fParametricPrecision,  // PARAMETRIC_PRECISION
                         tolerances.fNumRadialSegmentsPerRadian,  // NUM_RADIAL_SEGMENTS_PER_RADIAN
                         GetJoinType(shader.fStroke),  // JOIN_TYPE
                         strokeRadius);  // STROKE_RADIUS
         } else {
             SkASSERT(!stroke.isHairlineStyle());
             float maxScale = shader.viewMatrix().getMaxScale();
-            pdman.set1f(fTessArgsUniform, GrStrokeTolerances::CalcParametricIntolerance(maxScale));
+            pdman.set1f(fTessArgsUniform, GrStrokeTolerances::CalcParametricPrecision(maxScale));
         }
 
         // Set up the view matrix, if any.
@@ -486,11 +486,11 @@
     const char* tessArgsName = impl->getTessArgsUniformName(uniformHandler);
     if (!this->hasDynamicStroke()) {
         code.appendf("uniform vec4 %s;\n", tessArgsName);
-        code.appendf("#define PARAMETRIC_INTOLERANCE %s.x\n", tessArgsName);
+        code.appendf("#define PARAMETRIC_PRECISION %s.x\n", tessArgsName);
         code.appendf("#define NUM_RADIAL_SEGMENTS_PER_RADIAN %s.y\n", tessArgsName);
     } else {
         code.appendf("uniform float %s;\n", tessArgsName);
-        code.appendf("#define PARAMETRIC_INTOLERANCE %s\n", tessArgsName);
+        code.appendf("#define PARAMETRIC_PRECISION %s\n", tessArgsName);
         code.appendf("#define NUM_RADIAL_SEGMENTS_PER_RADIAN vsStrokeArgs[0].x\n");
     }
 
@@ -575,7 +575,7 @@
         // Calculate the number of parametric segments. The final tessellated strip will be a
         // composition of these parametric segments as well as radial segments.
         float w = isinf(P[3].y) ? P[3].x : -1.0; // w<0 means the curve is an integral cubic.
-        float numParametricSegments = wangs_formula(P, w, PARAMETRIC_INTOLERANCE);
+        float numParametricSegments = wangs_formula(P, w, PARAMETRIC_PRECISION);
         if (P[0] == P[1] && P[2] == P[3]) {
             // This is how the patch builder articulates lineTos but Wang's formula returns
             // >>1 segment in this scenario. Assign 1 parametric segment.
@@ -1020,27 +1020,27 @@
 
         // Tessellation control uniforms and/or dynamic attributes.
         if (!shader.hasDynamicStroke()) {
-            // [PARAMETRIC_INTOLERANCE, NUM_RADIAL_SEGMENTS_PER_RADIAN, JOIN_TYPE, STROKE_RADIUS]
+            // [PARAMETRIC_PRECISION, NUM_RADIAL_SEGMENTS_PER_RADIAN, JOIN_TYPE, STROKE_RADIUS]
             const char* tessArgsName;
             fTessControlArgsUniform = args.fUniformHandler->addUniform(
                     nullptr, kVertex_GrShaderFlag, kFloat4_GrSLType, "tessControlArgs",
                     &tessArgsName);
             args.fVertBuilder->codeAppendf(R"(
-            float PARAMETRIC_INTOLERANCE = %s.x;
+            float PARAMETRIC_PRECISION = %s.x;
             float NUM_RADIAL_SEGMENTS_PER_RADIAN = %s.y;
             float JOIN_TYPE = %s.z;
             float STROKE_RADIUS = %s.w;)", tessArgsName, tessArgsName, tessArgsName, tessArgsName);
         } else {
-            const char* parametricIntoleranceName;
+            const char* parametricPrecisionName;
             fTessControlArgsUniform = args.fUniformHandler->addUniform(
-                    nullptr, kVertex_GrShaderFlag, kFloat_GrSLType, "parametricIntolerance",
-                    &parametricIntoleranceName);
+                    nullptr, kVertex_GrShaderFlag, kFloat_GrSLType, "parametricPrecision",
+                    &parametricPrecisionName);
             args.fVertBuilder->codeAppendf(R"(
-            float PARAMETRIC_INTOLERANCE = %s;
+            float PARAMETRIC_PRECISION = %s;
             float STROKE_RADIUS = dynamicStrokeAttr.x;
             float NUM_RADIAL_SEGMENTS_PER_RADIAN = num_radial_segments_per_radian(
-                    PARAMETRIC_INTOLERANCE, STROKE_RADIUS);
-            float JOIN_TYPE = dynamicStrokeAttr.y;)", parametricIntoleranceName);
+                    PARAMETRIC_PRECISION, STROKE_RADIUS);
+            float JOIN_TYPE = dynamicStrokeAttr.y;)", parametricPrecisionName);
         }
 
         // View matrix uniforms.
@@ -1079,7 +1079,7 @@
         float numTotalEdges = abs(argsAttr.z);
 
         // Find how many parametric segments this stroke requires.
-        float numParametricSegments = min(wangs_formula(P, w, PARAMETRIC_INTOLERANCE),
+        float numParametricSegments = min(wangs_formula(P, w, PARAMETRIC_PRECISION),
                                           float(1 << MAX_PARAMETRIC_SEGMENTS_LOG2));
         if (P[0] == P[1] && P[2] == P[3]) {
             // This is how we describe lines, but Wang's formula does not return 1 in this case.
@@ -1273,7 +1273,7 @@
             }
             float strokeRadius = (stroke.isHairlineStyle()) ? .5f : stroke.getWidth() * .5;
             pdman.set4f(fTessControlArgsUniform,
-                        tolerances.fParametricIntolerance,  // PARAMETRIC_INTOLERANCE
+                        tolerances.fParametricPrecision,  // PARAMETRIC_PRECISION
                         tolerances.fNumRadialSegmentsPerRadian,  // NUM_RADIAL_SEGMENTS_PER_RADIAN
                         GetJoinType(shader.fStroke),  // JOIN_TYPE
                         strokeRadius);  // STROKE_RADIUS
@@ -1281,7 +1281,7 @@
             SkASSERT(!stroke.isHairlineStyle());
             float maxScale = shader.viewMatrix().getMaxScale();
             pdman.set1f(fTessControlArgsUniform,
-                        GrStrokeTolerances::CalcParametricIntolerance(maxScale));
+                        GrStrokeTolerances::CalcParametricPrecision(maxScale));
         }
 
         // Set up the view matrix, if any.
diff --git a/src/gpu/tessellate/GrStrokeTessellator.h b/src/gpu/tessellate/GrStrokeTessellator.h
index 8d0ec4e..bbc1a7e 100644
--- a/src/gpu/tessellate/GrStrokeTessellator.h
+++ b/src/gpu/tessellate/GrStrokeTessellator.h
@@ -49,20 +49,20 @@
     // Decides the number of parametric segments the tessellator adds for each curve. (Uniform
     // steps in parametric space.) The tessellator will add enough parametric segments so that,
     // once transformed into device space, they never deviate by more than
-    // 1/GrTessellationPathRenderer::kLinearizationIntolerance pixels from the true curve.
-    constexpr static float CalcParametricIntolerance(float matrixMaxScale) {
-        return matrixMaxScale * GrTessellationPathRenderer::kLinearizationIntolerance;
+    // 1/GrTessellationPathRenderer::kLinearizationPrecision pixels from the true curve.
+    constexpr static float CalcParametricPrecision(float matrixMaxScale) {
+        return matrixMaxScale * GrTessellationPathRenderer::kLinearizationPrecision;
     }
     // Decides the number of radial segments the tessellator adds for each curve. (Uniform steps
     // in tangent angle.) The tessellator will add this number of radial segments for each
     // radian of rotation in local path space.
-    static float CalcNumRadialSegmentsPerRadian(float parametricIntolerance,
+    static float CalcNumRadialSegmentsPerRadian(float parametricPrecision,
                                                 float strokeWidth) {
-        return .5f / acosf(std::max(1 - 2 / (parametricIntolerance * strokeWidth), -1.f));
+        return .5f / acosf(std::max(1 - 2 / (parametricPrecision * strokeWidth), -1.f));
     }
     template<int N> static grvx::vec<N> ApproxNumRadialSegmentsPerRadian(
-            float parametricIntolerance, grvx::vec<N> strokeWidths) {
-        grvx::vec<N> cosTheta = skvx::max(1 - 2 / (parametricIntolerance * strokeWidths), -1);
+            float parametricPrecision, grvx::vec<N> strokeWidths) {
+        grvx::vec<N> cosTheta = skvx::max(1 - 2 / (parametricPrecision * strokeWidths), -1);
         // Subtract GRVX_APPROX_ACOS_MAX_ERROR so we never account for too few segments.
         return .5f / (grvx::approx_acos(cosTheta) - GRVX_APPROX_ACOS_MAX_ERROR);
     }
@@ -99,11 +99,11 @@
     }
     static GrStrokeTolerances MakeNonHairline(float matrixMaxScale, float strokeWidth) {
         SkASSERT(strokeWidth > 0);
-        float parametricIntolerance = CalcParametricIntolerance(matrixMaxScale);
-        return {parametricIntolerance,
-                CalcNumRadialSegmentsPerRadian(parametricIntolerance, strokeWidth)};
+        float parametricPrecision = CalcParametricPrecision(matrixMaxScale);
+        return {parametricPrecision,
+                CalcNumRadialSegmentsPerRadian(parametricPrecision, strokeWidth)};
     }
-    float fParametricIntolerance;
+    float fParametricPrecision;
     float fNumRadialSegmentsPerRadian;
 };
 
@@ -112,8 +112,8 @@
 public:
     using PathStrokeList = GrStrokeTessellator::PathStrokeList;
 
-    GrStrokeToleranceBuffer(float parametricIntolerance)
-            : fParametricIntolerance(parametricIntolerance) {
+    GrStrokeToleranceBuffer(float parametricPrecision)
+            : fParametricPrecision(parametricPrecision) {
     }
 
     float fetchRadialSegmentsPerRadian(PathStrokeList* head) {
@@ -128,7 +128,7 @@
             do {
                 fStrokeWidths[i++] = peekAhead->fStroke.getWidth();
             } while ((peekAhead = peekAhead->fNext) && i < 4);
-            auto tol = GrStrokeTolerances::ApproxNumRadialSegmentsPerRadian(fParametricIntolerance,
+            auto tol = GrStrokeTolerances::ApproxNumRadialSegmentsPerRadian(fParametricPrecision,
                                                                             fStrokeWidths);
             tol.store(fNumRadialSegmentsPerRadian);
             fBufferIdx = 0;
@@ -141,7 +141,7 @@
 private:
     grvx::float4 fStrokeWidths{};  // Must be first for alignment purposes.
     float fNumRadialSegmentsPerRadian[4];
-    const float fParametricIntolerance;
+    const float fParametricPrecision;
     int fBufferIdx = 4;  // Initialize the buffer as "empty";
 };
 
diff --git a/src/gpu/tessellate/GrTessellationPathRenderer.cpp b/src/gpu/tessellate/GrTessellationPathRenderer.cpp
index 154ebc0..7437de1 100644
--- a/src/gpu/tessellate/GrTessellationPathRenderer.cpp
+++ b/src/gpu/tessellate/GrTessellationPathRenderer.cpp
@@ -81,10 +81,10 @@
     //
     // Solve the following equation for w:
     //
-    //     GrWangsFormula::worst_case_cubic(kLinearizationIntolerance, w, kMaxAtlasPathHeight^2 / w)
+    //     GrWangsFormula::worst_case_cubic(kLinearizationPrecision, w, kMaxAtlasPathHeight^2 / w)
     //              == maxTessellationSegments
     //
-    float k = GrWangsFormula::length_term<3>(kLinearizationIntolerance);
+    float k = GrWangsFormula::length_term<3>(kLinearizationPrecision);
     float h = kMaxAtlasPathHeight;
     float s = caps.shaderCaps()->maxTessellationSegments();
     // Quadratic formula from Numerical Recipes in C:
@@ -119,7 +119,7 @@
     // Verify GrWangsFormula::worst_case_cubic() still works as we expect. The worst case number of
     // segments for this bounding box should be maxTessellationSegments.
     SkASSERT(SkScalarNearlyEqual(GrWangsFormula::worst_case_cubic(
-            kLinearizationIntolerance, worstCaseWidth, worstCaseHeight), s, 1));
+            kLinearizationPrecision, worstCaseWidth, worstCaseHeight), s, 1));
 #endif
     fStencilAtlasFlags &= ~OpFlags::kDisableHWTessellation;
     fMaxAtlasPathWidth = std::min(fMaxAtlasPathWidth, (int)worstCaseWidth);
@@ -157,8 +157,8 @@
                            GrTessellationPathRenderer::OpFlags opFlags, GrAAType aaType,
                            const SkRect& shapeDevBounds, const SkMatrix& viewMatrix,
                            const GrStyledShape& shape, GrPaint&& paint) {
-    constexpr static auto kLinearizationIntolerance =
-            GrTessellationPathRenderer::kLinearizationIntolerance;
+    constexpr static auto kLinearizationPrecision =
+            GrTessellationPathRenderer::kLinearizationPrecision;
     constexpr static auto kMaxResolveLevel = GrTessellationPathRenderer::kMaxResolveLevel;
     using OpFlags = GrTessellationPathRenderer::OpFlags;
 
@@ -169,7 +169,7 @@
 
     // Find the worst-case log2 number of line segments that a curve in this path might need to be
     // divided into.
-    int worstCaseResolveLevel = GrWangsFormula::worst_case_cubic_log2(kLinearizationIntolerance,
+    int worstCaseResolveLevel = GrWangsFormula::worst_case_cubic_log2(kLinearizationPrecision,
                                                                       shapeDevBounds.width(),
                                                                       shapeDevBounds.height());
     if (worstCaseResolveLevel > kMaxResolveLevel) {
@@ -205,7 +205,7 @@
 
         SkRect newDevBounds;
         viewMatrix.mapRect(&newDevBounds, path.getBounds());
-        worstCaseResolveLevel = GrWangsFormula::worst_case_cubic_log2(kLinearizationIntolerance,
+        worstCaseResolveLevel = GrWangsFormula::worst_case_cubic_log2(kLinearizationPrecision,
                                                                       newDevBounds.width(),
                                                                       newDevBounds.height());
         // kMaxResolveLevel should be large enough to tessellate paths the size of any screen we
@@ -272,7 +272,7 @@
         // sufficient for this path. fMaxAtlasPathWidth should have been tuned for this to always be
         // the case.
         if (!(fStencilAtlasFlags & OpFlags::kDisableHWTessellation)) {
-            int worstCaseNumSegments = GrWangsFormula::worst_case_cubic(kLinearizationIntolerance,
+            int worstCaseNumSegments = GrWangsFormula::worst_case_cubic(kLinearizationPrecision,
                                                                         devIBounds.width(),
                                                                         devIBounds.height());
             const GrShaderCaps& shaderCaps = *args.fContext->priv().caps()->shaderCaps();
diff --git a/src/gpu/tessellate/GrTessellationPathRenderer.h b/src/gpu/tessellate/GrTessellationPathRenderer.h
index 020ae0d..fd4fe0e 100644
--- a/src/gpu/tessellate/GrTessellationPathRenderer.h
+++ b/src/gpu/tessellate/GrTessellationPathRenderer.h
@@ -20,7 +20,7 @@
 class GrTessellationPathRenderer : public GrPathRenderer, public GrOnFlushCallbackObject {
 public:
     // Don't allow linearized segments to be off by more than 1/4th of a pixel from the true curve.
-    constexpr static float kLinearizationIntolerance = 4;
+    constexpr static float kLinearizationPrecision = 4;
 
     // This is the maximum resolve level supported by our internal indirect draw shaders. (Indirect
     // draws are an alternative to hardware tessellation, and we can use them when hardware support
@@ -29,7 +29,7 @@
     // At a given resolveLevel, a curve gets linearized into 2^resolveLevel line segments. So the
     // finest resolveLevel supported by our indirect draw shaders is 2^10 == 1024 line segments.
     //
-    // 1024 line segments is enough resolution (with intolerance == 4) to guarantee we can render a
+    // 1024 line segments is enough resolution (with precision == 4) to guarantee we can render a
     // 123575px x 123575px path. (See GrWangsFormula::worst_case_cubic.)
     constexpr static int kMaxResolveLevel = 10;
 
diff --git a/src/gpu/tessellate/GrWangsFormula.h b/src/gpu/tessellate/GrWangsFormula.h
index a6118da..fa160af 100644
--- a/src/gpu/tessellate/GrWangsFormula.h
+++ b/src/gpu/tessellate/GrWangsFormula.h
@@ -15,22 +15,22 @@
 
 // Wang's formula gives the minimum number of evenly spaced (in the parametric sense) line segments
 // that a bezier curve must be chopped into in order to guarantee all lines stay within a distance
-// of "1/intolerance" pixels from the true curve. Its definition for a bezier curve of degree "n" is
+// of "1/precision" pixels from the true curve. Its definition for a bezier curve of degree "n" is
 // as follows:
 //
 //     maxLength = max([length(p[i+2] - 2p[i+1] + p[i]) for (0 <= i <= n-2)])
-//     numParametricSegments = sqrt(maxLength * intolerance * n*(n - 1)/8)
+//     numParametricSegments = sqrt(maxLength * precision * n*(n - 1)/8)
 //
 // (Goldman, Ron. (2003). 5.6.3 Wang's Formula. "Pyramid Algorithms: A Dynamic Programming Approach
 // to Curves and Surfaces for Geometric Modeling". Morgan Kaufmann Publishers.)
 namespace GrWangsFormula {
 
 // Returns the value by which to multiply length in Wang's formula. (See above.)
-template<int Degree> constexpr float length_term(float intolerance) {
-    return (Degree * (Degree - 1) / 8.f) * intolerance;
+template<int Degree> constexpr float length_term(float precision) {
+    return (Degree * (Degree - 1) / 8.f) * precision;
 }
-template<int Degree> constexpr float length_term_pow2(float intolerance) {
-    return ((Degree * Degree) * ((Degree - 1) * (Degree - 1)) / 64.f) * (intolerance * intolerance);
+template<int Degree> constexpr float length_term_pow2(float precision) {
+    return ((Degree * Degree) * ((Degree - 1) * (Degree - 1)) / 64.f) * (precision * precision);
 }
 
 SK_ALWAYS_INLINE static float root4(float x) {
@@ -54,7 +54,7 @@
 }
 
 // Returns Wang's formula, raised to the 4th power, specialized for a quadratic curve.
-SK_ALWAYS_INLINE static float quadratic_pow4(float intolerance, const SkPoint pts[],
+SK_ALWAYS_INLINE static float quadratic_pow4(float precision, const SkPoint pts[],
                                              const GrVectorXform& vectorXform = GrVectorXform()) {
     using grvx::float2, skvx::bit_pun;
     float2 p0 = bit_pun<float2>(pts[0]);
@@ -63,25 +63,25 @@
     float2 v = grvx::fast_madd<2>(-2, p1, p0) + p2;
     v = vectorXform(v);
     float2 vv = v*v;
-    return (vv[0] + vv[1]) * length_term_pow2<2>(intolerance);
+    return (vv[0] + vv[1]) * length_term_pow2<2>(precision);
 }
 
 // Returns Wang's formula specialized for a quadratic curve.
-SK_ALWAYS_INLINE static float quadratic(float intolerance, const SkPoint pts[],
+SK_ALWAYS_INLINE static float quadratic(float precision, const SkPoint pts[],
                                         const GrVectorXform& vectorXform = GrVectorXform()) {
-    return root4(quadratic_pow4(intolerance, pts, vectorXform));
+    return root4(quadratic_pow4(precision, pts, vectorXform));
 }
 
 // Returns the log2 value of Wang's formula specialized for a quadratic curve, rounded up to the
 // next int.
-SK_ALWAYS_INLINE static int quadratic_log2(float intolerance, const SkPoint pts[],
+SK_ALWAYS_INLINE static int quadratic_log2(float precision, const SkPoint pts[],
                                            const GrVectorXform& vectorXform = GrVectorXform()) {
     // nextlog16(x) == ceil(log2(sqrt(sqrt(x))))
-    return nextlog16(quadratic_pow4(intolerance, pts, vectorXform));
+    return nextlog16(quadratic_pow4(precision, pts, vectorXform));
 }
 
 // Returns Wang's formula, raised to the 4th power, specialized for a cubic curve.
-SK_ALWAYS_INLINE static float cubic_pow4(float intolerance, const SkPoint pts[],
+SK_ALWAYS_INLINE static float cubic_pow4(float precision, const SkPoint pts[],
                                          const GrVectorXform& vectorXform = GrVectorXform()) {
     using grvx::float4;
     float4 p01 = float4::Load(pts);
@@ -90,42 +90,42 @@
     float4 v = grvx::fast_madd<4>(-2, p12, p01) + p23;
     v = vectorXform(v);
     float4 vv = v*v;
-    return std::max(vv[0] + vv[1], vv[2] + vv[3]) * length_term_pow2<3>(intolerance);
+    return std::max(vv[0] + vv[1], vv[2] + vv[3]) * length_term_pow2<3>(precision);
 }
 
 // Returns Wang's formula specialized for a cubic curve.
-SK_ALWAYS_INLINE static float cubic(float intolerance, const SkPoint pts[],
+SK_ALWAYS_INLINE static float cubic(float precision, const SkPoint pts[],
                                     const GrVectorXform& vectorXform = GrVectorXform()) {
-    return root4(cubic_pow4(intolerance, pts, vectorXform));
+    return root4(cubic_pow4(precision, pts, vectorXform));
 }
 
 // Returns the log2 value of Wang's formula specialized for a cubic curve, rounded up to the next
 // int.
-SK_ALWAYS_INLINE static int cubic_log2(float intolerance, const SkPoint pts[],
+SK_ALWAYS_INLINE static int cubic_log2(float precision, const SkPoint pts[],
                                        const GrVectorXform& vectorXform = GrVectorXform()) {
     // nextlog16(x) == ceil(log2(sqrt(sqrt(x))))
-    return nextlog16(cubic_pow4(intolerance, pts, vectorXform));
+    return nextlog16(cubic_pow4(precision, pts, vectorXform));
 }
 
 // Returns the maximum number of line segments a cubic with the given device-space bounding box size
 // would ever need to be divided into. This is simply a special case of the cubic formula where we
 // maximize its value by placing control points on specific corners of the bounding box.
-SK_ALWAYS_INLINE static float worst_case_cubic(float intolerance, float devWidth, float devHeight) {
-    float k = length_term<3>(intolerance);
+SK_ALWAYS_INLINE static float worst_case_cubic(float precision, float devWidth, float devHeight) {
+    float k = length_term<3>(precision);
     return sqrtf(2*k * SkVector::Length(devWidth, devHeight));
 }
 
 // Returns the maximum log2 number of line segments a cubic with the given device-space bounding box
 // size would ever need to be divided into.
-SK_ALWAYS_INLINE static int worst_case_cubic_log2(float intolerance, float devWidth,
+SK_ALWAYS_INLINE static int worst_case_cubic_log2(float precision, float devWidth,
                                                   float devHeight) {
-    float kk = length_term_pow2<3>(intolerance);
+    float kk = length_term_pow2<3>(precision);
     // nextlog16(x) == ceil(log2(sqrt(sqrt(x))))
     return nextlog16(4*kk * (devWidth * devWidth + devHeight * devHeight));
 }
 
 // Returns Wang's formula specialized for a conic curve, raised to the second power.
-// Input points should be in projected space, and note tolerance parameter is not intolerance.
+// Input points should be in projected space, and note tolerance parameter is not "precision".
 //
 // This is not actually due to Wang, but is an analogue from (Theorem 3, corollary 1):
 //   J. Zheng, T. Sederberg. "Estimating Tessellation Parameter Intervals for
diff --git a/tests/StrokeIndirectTest.cpp b/tests/StrokeIndirectTest.cpp
index 0451e47..e2c0297 100644
--- a/tests/StrokeIndirectTest.cpp
+++ b/tests/StrokeIndirectTest.cpp
@@ -331,7 +331,7 @@
                     }
                 }
                 float numParametricSegments = (hasCusp) ? 0 : GrWangsFormula::quadratic(
-                        tolerances.fParametricIntolerance, pts);
+                        tolerances.fParametricPrecision, pts);
                 float rotation = (hasCusp) ? 0 : SkMeasureQuadRotation(pts);
                 if (stroke.getJoin() == SkPaint::kRound_Join) {
                     SkVector controlPoint = (pts[0] == pts[1]) ? pts[2] : pts[1];
@@ -374,7 +374,7 @@
                     // it matches the answer we got already.
                     SkPoint* p = chops + i*3;
                     float numParametricSegments =
-                            GrWangsFormula::cubic(tolerances.fParametricIntolerance, p);
+                            GrWangsFormula::cubic(tolerances.fParametricPrecision, p);
                     SkVector tan0 =
                             ((p[0] == p[1]) ? (p[1] == p[2]) ? p[3] : p[2] : p[1]) - p[0];
                     SkVector tan1 =
@@ -454,8 +454,7 @@
         for (unsigned j = 0; j < indirect->fInstanceCount; ++j) {
             SkASSERT(fabsf(instance->fNumTotalEdges) == indirect->fVertexCount/2);
             const SkPoint* p = instance->fPts;
-            float numParametricSegments = GrWangsFormula::cubic(
-                    tolerances.fParametricIntolerance, p);
+            float numParametricSegments = GrWangsFormula::cubic(tolerances.fParametricPrecision, p);
             float alternateNumParametricSegments = numParametricSegments;
             if (p[0] == p[1] && p[2] == p[3]) {
                 // We articulate lines as "p0,p0,p1,p1". This one might actually expect 0 parametric
diff --git a/tests/WangsFormulaTest.cpp b/tests/WangsFormulaTest.cpp
index eee1db9..6d3bdff 100644
--- a/tests/WangsFormulaTest.cpp
+++ b/tests/WangsFormulaTest.cpp
@@ -10,7 +10,7 @@
 #include "src/gpu/tessellate/GrWangsFormula.h"
 #include "tests/Test.h"
 
-constexpr static int kIntolerance = 4;  // 1/4 pixel max error.
+constexpr static int kPrecision = 4;  // 1/4 pixel max error.
 
 const SkPoint kSerp[4] = {
         {285.625f, 499.687f}, {411.625f, 808.188f}, {1064.62f, 135.688f}, {1042.63f, 585.187f}};
@@ -21,13 +21,13 @@
 const SkPoint kQuad[4] = {
         {460.625f, 557.187f}, {707.121f, 209.688f}, {779.628f, 577.687f}};
 
-static float wangs_formula_quadratic_reference_impl(float intolerance, const SkPoint p[3]) {
-    float k = (2 * 1) / 8.f * intolerance;
+static float wangs_formula_quadratic_reference_impl(float precision, const SkPoint p[3]) {
+    float k = (2 * 1) / 8.f * precision;
     return sqrtf(k * (p[0] - p[1]*2 + p[2]).length());
 }
 
-static float wangs_formula_cubic_reference_impl(float intolerance, const SkPoint p[4]) {
-    float k = (3 * 2) / 8.f * intolerance;
+static float wangs_formula_cubic_reference_impl(float precision, const SkPoint p[4]) {
+    float k = (3 * 2) / 8.f * precision;
     return sqrtf(k * std::max((p[0] - p[1]*2 + p[2]).length(),
                               (p[1] - p[2]*2 + p[3]).length()));
 }
@@ -40,7 +40,7 @@
 // See Thm 3, Corollary 1.
 //
 // Input points should be in projected space.
-static float wangs_formula_conic_reference_impl(float intolerance,
+static float wangs_formula_conic_reference_impl(float precision,
                                                 const SkPoint P[3],
                                                 const float w) {
     // Compute center of bounding box in projected space
@@ -63,7 +63,7 @@
     SkASSERT(max_len > 0);
 
     // Compute delta = parametric step size of linearization
-    const float eps = 1 / intolerance;
+    const float eps = 1 / precision;
     const float r_minus_eps = std::max(0.f, max_len - eps);
     const float min_w = std::min(w, 1.f);
     const float numer = 4 * min_w * eps;
@@ -199,55 +199,55 @@
             // Test cubic boundaries.
             //     f = sqrt(k * length(max(abs(p0 - p1*2 + p2),
             //                             abs(p1 - p2*2 + p3))));
-            constexpr static float k = (3 * 2) / (8 * (1.f/kIntolerance));
+            constexpr static float k = (3 * 2) / (8 * (1.f/kPrecision));
             float x = std::ldexp(1, level * 2) / k;
             setupCubicLengthTerm(level << 1, pts, x - epsilon);
-            float referenceValue = wangs_formula_cubic_reference_impl(kIntolerance, pts);
+            float referenceValue = wangs_formula_cubic_reference_impl(kPrecision, pts);
             REPORTER_ASSERT(r, std::ceil(std::log2(referenceValue)) == level);
-            float c = GrWangsFormula::cubic(kIntolerance, pts);
+            float c = GrWangsFormula::cubic(kPrecision, pts);
             REPORTER_ASSERT(r, SkScalarNearlyEqual(c/referenceValue, 1, kTessellationTolerance));
-            REPORTER_ASSERT(r, GrWangsFormula::cubic_log2(kIntolerance, pts) == level);
+            REPORTER_ASSERT(r, GrWangsFormula::cubic_log2(kPrecision, pts) == level);
             setupCubicLengthTerm(level << 1, pts, x + epsilon);
-            referenceValue = wangs_formula_cubic_reference_impl(kIntolerance, pts);
+            referenceValue = wangs_formula_cubic_reference_impl(kPrecision, pts);
             REPORTER_ASSERT(r, std::ceil(std::log2(referenceValue)) == level + 1);
-            c = GrWangsFormula::cubic(kIntolerance, pts);
+            c = GrWangsFormula::cubic(kPrecision, pts);
             REPORTER_ASSERT(r, SkScalarNearlyEqual(c/referenceValue, 1, kTessellationTolerance));
-            REPORTER_ASSERT(r, GrWangsFormula::cubic_log2(kIntolerance, pts) == level + 1);
+            REPORTER_ASSERT(r, GrWangsFormula::cubic_log2(kPrecision, pts) == level + 1);
         }
 
         {
             // Test quadratic boundaries.
             //     f = std::sqrt(k * Length(p0 - p1*2 + p2));
-            constexpr static float k = 2 / (8 * (1.f/kIntolerance));
+            constexpr static float k = 2 / (8 * (1.f/kPrecision));
             float x = std::ldexp(1, level * 2) / k;
             setupQuadraticLengthTerm(level << 1, pts, x - epsilon);
-            float referenceValue = wangs_formula_quadratic_reference_impl(kIntolerance, pts);
+            float referenceValue = wangs_formula_quadratic_reference_impl(kPrecision, pts);
             REPORTER_ASSERT(r, std::ceil(std::log2(referenceValue)) == level);
-            float q = GrWangsFormula::quadratic(kIntolerance, pts);
+            float q = GrWangsFormula::quadratic(kPrecision, pts);
             REPORTER_ASSERT(r, SkScalarNearlyEqual(q/referenceValue, 1, kTessellationTolerance));
-            REPORTER_ASSERT(r, GrWangsFormula::quadratic_log2(kIntolerance, pts) == level);
+            REPORTER_ASSERT(r, GrWangsFormula::quadratic_log2(kPrecision, pts) == level);
             setupQuadraticLengthTerm(level << 1, pts, x + epsilon);
-            referenceValue = wangs_formula_quadratic_reference_impl(kIntolerance, pts);
+            referenceValue = wangs_formula_quadratic_reference_impl(kPrecision, pts);
             REPORTER_ASSERT(r, std::ceil(std::log2(referenceValue)) == level+1);
-            q = GrWangsFormula::quadratic(kIntolerance, pts);
+            q = GrWangsFormula::quadratic(kPrecision, pts);
             REPORTER_ASSERT(r, SkScalarNearlyEqual(q/referenceValue, 1, kTessellationTolerance));
-            REPORTER_ASSERT(r, GrWangsFormula::quadratic_log2(kIntolerance, pts) == level + 1);
+            REPORTER_ASSERT(r, GrWangsFormula::quadratic_log2(kPrecision, pts) == level + 1);
         }
     }
 
     auto check_cubic_log2 = [&](const SkPoint* pts) {
-        float f = std::max(1.f, wangs_formula_cubic_reference_impl(kIntolerance, pts));
-        int f_log2 = GrWangsFormula::cubic_log2(kIntolerance, pts);
+        float f = std::max(1.f, wangs_formula_cubic_reference_impl(kPrecision, pts));
+        int f_log2 = GrWangsFormula::cubic_log2(kPrecision, pts);
         REPORTER_ASSERT(r, SkScalarCeilToInt(std::log2(f)) == f_log2);
-        float c = std::max(1.f, GrWangsFormula::cubic(kIntolerance, pts));
+        float c = std::max(1.f, GrWangsFormula::cubic(kPrecision, pts));
         REPORTER_ASSERT(r, SkScalarNearlyEqual(c/f, 1, kTessellationTolerance));
     };
 
     auto check_quadratic_log2 = [&](const SkPoint* pts) {
-        float f = std::max(1.f, wangs_formula_quadratic_reference_impl(kIntolerance, pts));
-        int f_log2 = GrWangsFormula::quadratic_log2(kIntolerance, pts);
+        float f = std::max(1.f, wangs_formula_quadratic_reference_impl(kPrecision, pts));
+        int f_log2 = GrWangsFormula::quadratic_log2(kPrecision, pts);
         REPORTER_ASSERT(r, SkScalarCeilToInt(std::log2(f)) == f_log2);
-        float q = std::max(1.f, GrWangsFormula::quadratic(kIntolerance, pts));
+        float q = std::max(1.f, GrWangsFormula::quadratic(kPrecision, pts));
         REPORTER_ASSERT(r, SkScalarNearlyEqual(q/f, 1, kTessellationTolerance));
     };
 
@@ -279,16 +279,16 @@
     auto check_cubic_log2_with_transform = [&](const SkPoint* pts, const SkMatrix& m){
         SkPoint ptsXformed[4];
         m.mapPoints(ptsXformed, pts, 4);
-        int expected = GrWangsFormula::cubic_log2(kIntolerance, ptsXformed);
-        int actual = GrWangsFormula::cubic_log2(kIntolerance, pts, GrVectorXform(m));
+        int expected = GrWangsFormula::cubic_log2(kPrecision, ptsXformed);
+        int actual = GrWangsFormula::cubic_log2(kPrecision, pts, GrVectorXform(m));
         REPORTER_ASSERT(r, actual == expected);
     };
 
     auto check_quadratic_log2_with_transform = [&](const SkPoint* pts, const SkMatrix& m) {
         SkPoint ptsXformed[3];
         m.mapPoints(ptsXformed, pts, 3);
-        int expected = GrWangsFormula::quadratic_log2(kIntolerance, ptsXformed);
-        int actual = GrWangsFormula::quadratic_log2(kIntolerance, pts, GrVectorXform(m));
+        int expected = GrWangsFormula::quadratic_log2(kPrecision, ptsXformed);
+        int actual = GrWangsFormula::quadratic_log2(kPrecision, pts, GrVectorXform(m));
         REPORTER_ASSERT(r, actual == expected);
     };
 
@@ -312,25 +312,25 @@
 DEF_TEST(WangsFormula_worst_case_cubic, r) {
     {
         SkPoint worstP[] = {{0,0}, {100,100}, {0,0}, {0,0}};
-        REPORTER_ASSERT(r, GrWangsFormula::worst_case_cubic(kIntolerance, 100, 100) ==
-                           wangs_formula_cubic_reference_impl(kIntolerance, worstP));
-        REPORTER_ASSERT(r, GrWangsFormula::worst_case_cubic_log2(kIntolerance, 100, 100) ==
-                           GrWangsFormula::cubic_log2(kIntolerance, worstP));
+        REPORTER_ASSERT(r, GrWangsFormula::worst_case_cubic(kPrecision, 100, 100) ==
+                           wangs_formula_cubic_reference_impl(kPrecision, worstP));
+        REPORTER_ASSERT(r, GrWangsFormula::worst_case_cubic_log2(kPrecision, 100, 100) ==
+                           GrWangsFormula::cubic_log2(kPrecision, worstP));
     }
     {
         SkPoint worstP[] = {{100,100}, {100,100}, {200,200}, {100,100}};
-        REPORTER_ASSERT(r, GrWangsFormula::worst_case_cubic(kIntolerance, 100, 100) ==
-                           wangs_formula_cubic_reference_impl(kIntolerance, worstP));
-        REPORTER_ASSERT(r, GrWangsFormula::worst_case_cubic_log2(kIntolerance, 100, 100) ==
-                           GrWangsFormula::cubic_log2(kIntolerance, worstP));
+        REPORTER_ASSERT(r, GrWangsFormula::worst_case_cubic(kPrecision, 100, 100) ==
+                           wangs_formula_cubic_reference_impl(kPrecision, worstP));
+        REPORTER_ASSERT(r, GrWangsFormula::worst_case_cubic_log2(kPrecision, 100, 100) ==
+                           GrWangsFormula::cubic_log2(kPrecision, worstP));
     }
     auto check_worst_case_cubic = [&](const SkPoint* pts) {
         SkRect bbox;
         bbox.setBoundsNoCheck(pts, 4);
-        float worst = GrWangsFormula::worst_case_cubic(kIntolerance, bbox.width(), bbox.height());
-        int worst_log2 = GrWangsFormula::worst_case_cubic_log2(kIntolerance, bbox.width(),
+        float worst = GrWangsFormula::worst_case_cubic(kPrecision, bbox.width(), bbox.height());
+        int worst_log2 = GrWangsFormula::worst_case_cubic_log2(kPrecision, bbox.width(),
                                                                bbox.height());
-        float actual = wangs_formula_cubic_reference_impl(kIntolerance, pts);
+        float actual = wangs_formula_cubic_reference_impl(kPrecision, pts);
         REPORTER_ASSERT(r, worst >= actual);
         REPORTER_ASSERT(r, std::ceil(std::log2(std::max(1.f, worst))) == worst_log2);
     };
@@ -351,7 +351,7 @@
     SkRandom rand;
     for_random_beziers(3, &rand, [&r](const SkPoint pts[]) {
         const int nsegs = static_cast<int>(
-                std::ceil(wangs_formula_quadratic_reference_impl(kIntolerance, pts)));
+                std::ceil(wangs_formula_quadratic_reference_impl(kPrecision, pts)));
 
         const float tdelta = 1.f / nsegs;
         for (int j = 0; j < nsegs; ++j) {
@@ -388,7 +388,7 @@
             const float d = std::abs((p - sectionPts[0]).dot(n)) / n.length();
 
             // Check distance is within specified tolerance
-            REPORTER_ASSERT(r, d <= (1.f / kIntolerance) + SK_ScalarNearlyZero);
+            REPORTER_ASSERT(r, d <= (1.f / kPrecision) + SK_ScalarNearlyZero);
         }
     }, maxExponent);
 }
@@ -401,8 +401,8 @@
     SkRandom rand;
     for (int i = 0; i < 100; ++i) {
         for_random_beziers(3, &rand, [&r](const SkPoint pts[]) {
-            const float rational_nsegs = wangs_formula_conic_reference_impl(kIntolerance, pts, 1.f);
-            const float integral_nsegs = wangs_formula_quadratic_reference_impl(kIntolerance, pts);
+            const float rational_nsegs = wangs_formula_conic_reference_impl(kPrecision, pts, 1.f);
+            const float integral_nsegs = wangs_formula_quadratic_reference_impl(kPrecision, pts);
             REPORTER_ASSERT(
                     r, SkScalarNearlyEqual(rational_nsegs, integral_nsegs, kTessellationTolerance));
         });
@@ -447,7 +447,7 @@
                 3, &rand,
                 [&](const SkPoint pts[]) {
                     const int nsegs = static_cast<int>(
-                            std::ceil(wangs_formula_conic_reference_impl(kIntolerance, pts, w)));
+                            std::ceil(wangs_formula_conic_reference_impl(kPrecision, pts, w)));
 
                     const float tdelta = 1.f / nsegs;
                     for (int j = 0; j < nsegs; ++j) {
@@ -465,7 +465,7 @@
                         const double d = std::abs(dot(p1 - p0, n)) / length(n);
 
                         // Check distance is within tolerance
-                        REPORTER_ASSERT(r, d <= (1.0 / kIntolerance) + SK_ScalarNearlyZero);
+                        REPORTER_ASSERT(r, d <= (1.0 / kPrecision) + SK_ScalarNearlyZero);
                     }
                 },
                 maxExponent);
@@ -474,13 +474,13 @@
 
 // Ensure the vectorized conic version equals the reference implementation
 DEF_TEST(WangsFormula_conic_matches_reference, r) {
-    constexpr static float kTolerance = 1.f / kIntolerance;
+    constexpr static float kTolerance = 1.f / kPrecision;
 
     SkRandom rand;
     for (int i = -10; i <= 10; ++i) {
         const float w = std::ldexp(1 + rand.nextF(), i);
         for_random_beziers(3, &rand, [&r, w](const SkPoint pts[]) {
-            const float ref_nsegs = wangs_formula_conic_reference_impl(kIntolerance, pts, w);
+            const float ref_nsegs = wangs_formula_conic_reference_impl(kPrecision, pts, w);
             const float nsegs = GrWangsFormula::conic(kTolerance, pts, w);
 
             // Because the Gr version may implement the math differently for performance,
@@ -493,7 +493,7 @@
 
 // Ensure using transformations gives the same result as pre-transforming all points.
 DEF_TEST(WangsFormula_conic_vectorXforms, r) {
-    constexpr static float kTolerance = 1.f / kIntolerance;
+    constexpr static float kTolerance = 1.f / kPrecision;
 
     auto check_conic_with_transform = [&](const SkPoint* pts, float w, const SkMatrix& m) {
         SkPoint ptsXformed[3];