diff --git a/gn/gpu.gni b/gn/gpu.gni
index f3a0123..ba69292 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -461,6 +461,8 @@
   "$_src/gpu/tessellate/GrPathInnerTriangulateOp.cpp",
   "$_src/gpu/tessellate/GrPathInnerTriangulateOp.h",
   "$_src/gpu/tessellate/GrPathShader.h",
+  "$_src/gpu/tessellate/GrPathStencilFillOp.cpp",
+  "$_src/gpu/tessellate/GrPathStencilFillOp.h",
   "$_src/gpu/tessellate/GrPathTessellator.cpp",
   "$_src/gpu/tessellate/GrPathTessellator.h",
   "$_src/gpu/tessellate/GrStencilPathShader.cpp",
@@ -477,8 +479,6 @@
   "$_src/gpu/tessellate/GrStrokeTessellateShader.cpp",
   "$_src/gpu/tessellate/GrStrokeTessellateShader.h",
   "$_src/gpu/tessellate/GrStrokeTessellator.h",
-  "$_src/gpu/tessellate/GrTessellatingStencilFillOp.cpp",
-  "$_src/gpu/tessellate/GrTessellatingStencilFillOp.h",
   "$_src/gpu/tessellate/GrTessellationPathRenderer.cpp",
   "$_src/gpu/tessellate/GrTessellationPathRenderer.h",
   "$_src/gpu/tessellate/GrVectorXform.h",
diff --git a/samplecode/SampleTessellatedWedge.cpp b/samplecode/SampleTessellatedWedge.cpp
index b46d8f8..cbd874d 100644
--- a/samplecode/SampleTessellatedWedge.cpp
+++ b/samplecode/SampleTessellatedWedge.cpp
@@ -19,7 +19,7 @@
 #include "src/gpu/GrMemoryPool.h"
 #include "src/gpu/GrRecordingContextPriv.h"
 #include "src/gpu/GrSurfaceDrawContext.h"
-#include "src/gpu/tessellate/GrTessellatingStencilFillOp.h"
+#include "src/gpu/tessellate/GrPathStencilFillOp.h"
 #include "src/gpu/tessellate/GrWangsFormula.h"
 
 static float kConicWeight = .5;
@@ -90,8 +90,8 @@
         aa = GrAAType::kNone;
     }
 
-    sdc->addDrawOp(GrOp::Make<GrTessellatingStencilFillOp>(ctx, canvas->getTotalMatrix(), fPath,
-                                                           std::move(paint), aa, fOpFlags));
+    sdc->addDrawOp(GrOp::Make<GrPathStencilFillOp>(ctx, canvas->getTotalMatrix(), fPath,
+                                                   std::move(paint), aa, fOpFlags));
 
     // Draw the path points.
     SkPaint pointsPaint;
diff --git a/src/gpu/tessellate/GrTessellatingStencilFillOp.cpp b/src/gpu/tessellate/GrPathStencilFillOp.cpp
similarity index 85%
rename from src/gpu/tessellate/GrTessellatingStencilFillOp.cpp
rename to src/gpu/tessellate/GrPathStencilFillOp.cpp
index 6a23adb..fec05f0 100644
--- a/src/gpu/tessellate/GrTessellatingStencilFillOp.cpp
+++ b/src/gpu/tessellate/GrPathStencilFillOp.cpp
@@ -5,7 +5,7 @@
  * found in the LICENSE file.
  */
 
-#include "src/gpu/tessellate/GrTessellatingStencilFillOp.h"
+#include "src/gpu/tessellate/GrPathStencilFillOp.h"
 
 #include "src/gpu/GrEagerVertexAllocator.h"
 #include "src/gpu/GrOpFlushState.h"
@@ -18,7 +18,7 @@
 
 using OpFlags = GrTessellationPathRenderer::OpFlags;
 
-void GrTessellatingStencilFillOp::visitProxies(const VisitProxyFunc& fn) const {
+void GrPathStencilFillOp::visitProxies(const VisitProxyFunc& fn) const {
     if (fFillBBoxProgram) {
         fFillBBoxProgram->pipeline().visitProxies(fn);
     } else {
@@ -26,7 +26,7 @@
     }
 }
 
-GrDrawOp::FixedFunctionFlags GrTessellatingStencilFillOp::fixedFunctionFlags() const {
+GrDrawOp::FixedFunctionFlags GrPathStencilFillOp::fixedFunctionFlags() const {
     auto flags = FixedFunctionFlags::kUsesStencil;
     if (fAAType != GrAAType::kNone) {
         flags |= FixedFunctionFlags::kUsesHWAA;
@@ -34,15 +34,15 @@
     return flags;
 }
 
-GrProcessorSet::Analysis GrTessellatingStencilFillOp::finalize(const GrCaps& caps,
-                                                               const GrAppliedClip* clip,
-                                                               GrClampType clampType) {
+GrProcessorSet::Analysis GrPathStencilFillOp::finalize(const GrCaps& caps,
+                                                       const GrAppliedClip* clip,
+                                                       GrClampType clampType) {
     return fProcessors.finalize(fColor, GrProcessorAnalysisCoverage::kNone, clip, nullptr, caps,
                                 clampType, &fColor);
 }
 
-void GrTessellatingStencilFillOp::prePreparePrograms(const GrPathShader::ProgramArgs& args,
-                                                     GrAppliedClip&& appliedClip) {
+void GrPathStencilFillOp::prePreparePrograms(const GrPathShader::ProgramArgs& args,
+                                             GrAppliedClip&& appliedClip) {
     using DrawInnerFan = GrPathIndirectTessellator::DrawInnerFan;
     SkASSERT(!fStencilFanProgram);
     SkASSERT(!fStencilPathProgram);
@@ -108,12 +108,11 @@
     }
 }
 
-void GrTessellatingStencilFillOp::onPrePrepare(GrRecordingContext* context,
-                                               const GrSurfaceProxyView& writeView,
-                                               GrAppliedClip* clip,
-                                               const GrXferProcessor::DstProxyView& dstProxyView,
-                                               GrXferBarrierFlags renderPassXferBarriers,
-                                               GrLoadOp colorLoadOp) {
+void GrPathStencilFillOp::onPrePrepare(GrRecordingContext* context,
+                                       const GrSurfaceProxyView& writeView, GrAppliedClip* clip,
+                                       const GrXferProcessor::DstProxyView& dstProxyView,
+                                       GrXferBarrierFlags renderPassXferBarriers,
+                                       GrLoadOp colorLoadOp) {
     this->prePreparePrograms({context->priv().recordTimeAllocator(), writeView, &dstProxyView,
                              renderPassXferBarriers, colorLoadOp, context->priv().caps()},
                              (clip) ? std::move(*clip) : GrAppliedClip::Disabled());
@@ -128,7 +127,7 @@
     }
 }
 
-void GrTessellatingStencilFillOp::onPrepare(GrOpFlushState* flushState) {
+void GrPathStencilFillOp::onPrepare(GrOpFlushState* flushState) {
     if (!fTessellator) {
         this->prePreparePrograms({flushState->allocator(), flushState->writeView(),
                                   &flushState->dstProxyView(), flushState->renderPassBarriers(),
@@ -154,7 +153,7 @@
     fTessellator->prepare(flushState, fViewMatrix, fPath);
 }
 
-void GrTessellatingStencilFillOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
+void GrPathStencilFillOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
     if (!fTessellator) {
         return;
     }
diff --git a/src/gpu/tessellate/GrTessellatingStencilFillOp.h b/src/gpu/tessellate/GrPathStencilFillOp.h
similarity index 85%
rename from src/gpu/tessellate/GrTessellatingStencilFillOp.h
rename to src/gpu/tessellate/GrPathStencilFillOp.h
index ec2e83d..cfecd47 100644
--- a/src/gpu/tessellate/GrTessellatingStencilFillOp.h
+++ b/src/gpu/tessellate/GrPathStencilFillOp.h
@@ -5,8 +5,8 @@
  * found in the LICENSE file.
  */
 
-#ifndef GrTessellatingStencilFillOp_DEFINED
-#define GrTessellatingStencilFillOp_DEFINED
+#ifndef GrPathStencilFillOp_DEFINED
+#define GrPathStencilFillOp_DEFINED
 
 #include "src/gpu/ops/GrDrawOp.h"
 #include "src/gpu/tessellate/GrPathShader.h"
@@ -17,12 +17,12 @@
 // Draws paths using a standard Redbook "stencil then fill" method. Curves get linearized by either
 // GPU tessellation shaders or indirect draws. This Op doesn't apply analytic AA, so it requires
 // MSAA if AA is desired.
-class GrTessellatingStencilFillOp : public GrDrawOp {
+class GrPathStencilFillOp : public GrDrawOp {
 private:
     DEFINE_OP_CLASS_ID
 
-    GrTessellatingStencilFillOp(const SkMatrix& viewMatrix, const SkPath& path, GrPaint&& paint,
-                                GrAAType aaType, GrTessellationPathRenderer::OpFlags opFlags)
+    GrPathStencilFillOp(const SkMatrix& viewMatrix, const SkPath& path, GrPaint&& paint,
+                        GrAAType aaType, GrTessellationPathRenderer::OpFlags opFlags)
             : GrDrawOp(ClassID())
             , fOpFlags(opFlags)
             , fViewMatrix(viewMatrix)
@@ -35,7 +35,7 @@
         this->setBounds(devBounds, HasAABloat::kNo, IsHairline::kNo);
     }
 
-    const char* name() const override { return "GrTessellatingStencilFillOp"; }
+    const char* name() const override { return "GrPathStencilFillOp"; }
     void visitProxies(const VisitProxyFunc& fn) const override;
     FixedFunctionFlags fixedFunctionFlags() const override;
     GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*, GrClampType) override;
diff --git a/src/gpu/tessellate/GrTessellationPathRenderer.cpp b/src/gpu/tessellate/GrTessellationPathRenderer.cpp
index 8804a4a..106efd2 100644
--- a/src/gpu/tessellate/GrTessellationPathRenderer.cpp
+++ b/src/gpu/tessellate/GrTessellationPathRenderer.cpp
@@ -18,8 +18,8 @@
 #include "src/gpu/ops/GrFillRectOp.h"
 #include "src/gpu/tessellate/GrDrawAtlasPathOp.h"
 #include "src/gpu/tessellate/GrPathInnerTriangulateOp.h"
+#include "src/gpu/tessellate/GrPathStencilFillOp.h"
 #include "src/gpu/tessellate/GrStrokeTessellateOp.h"
-#include "src/gpu/tessellate/GrTessellatingStencilFillOp.h"
 #include "src/gpu/tessellate/GrWangsFormula.h"
 
 constexpr static SkISize kAtlasInitialSize{512, 512};
@@ -239,8 +239,8 @@
                                                             std::move(paint), aaType, opFlags);
             }
         }
-        return GrOp::Make<GrTessellatingStencilFillOp>(rContext, viewMatrix, path, std::move(paint),
-                                                       aaType, opFlags);
+        return GrOp::Make<GrPathStencilFillOp>(rContext, viewMatrix, path, std::move(paint), aaType,
+                                               opFlags);
     }
 }
 
@@ -410,8 +410,9 @@
             }
             uberPath->setFillType(fillType);
             GrAAType aaType = (antialias) ? GrAAType::kMSAA : GrAAType::kNone;
-            auto op = GrOp::Make<GrTessellatingStencilFillOp>(onFlushRP->recordingContext(),
-                    SkMatrix::I(), *uberPath, GrPaint(), aaType, fStencilAtlasFlags);
+            auto op = GrOp::Make<GrPathStencilFillOp>(onFlushRP->recordingContext(), SkMatrix::I(),
+                                                      *uberPath, GrPaint(), aaType,
+                                                      fStencilAtlasFlags);
             rtc->addDrawOp(nullptr, std::move(op));
         }
     }