diff --git a/src/gpu/GrDrawOpTest.cpp b/src/gpu/GrDrawOpTest.cpp
index fcf70e0..c2bf2c6 100644
--- a/src/gpu/GrDrawOpTest.cpp
+++ b/src/gpu/GrDrawOpTest.cpp
@@ -6,14 +6,14 @@
  */
 
 #include "GrDrawOpTest.h"
-#include "ops/GrDrawOp.h"
 #include "SkRandom.h"
 #include "SkTypes.h"
+#include "ops/GrMeshDrawOp.h"
 
 #if GR_TEST_UTILS
 
 #define DRAW_OP_TEST_EXTERN(Op) \
-    extern std::unique_ptr<GrDrawOp> Op##__Test(SkRandom*, GrContext* context);
+    extern std::unique_ptr<GrMeshDrawOp> Op##__Test(SkRandom*, GrContext* context);
 
 #define DRAW_OP_TEST_ENTRY(Op) Op##__Test
 
@@ -37,8 +37,8 @@
 DRAW_OP_TEST_EXTERN(TextBlobOp);
 DRAW_OP_TEST_EXTERN(VerticesOp);
 
-std::unique_ptr<GrDrawOp> GrRandomDrawOp(SkRandom* random, GrContext* context) {
-    using MakeTestDrawOpFn = std::unique_ptr<GrDrawOp>(SkRandom* random, GrContext* context);
+std::unique_ptr<GrMeshDrawOp> GrRandomDrawOp(SkRandom* random, GrContext* context) {
+    using MakeTestDrawOpFn = std::unique_ptr<GrMeshDrawOp>(SkRandom* random, GrContext* context);
     static constexpr MakeTestDrawOpFn* gFactories[] = {
         DRAW_OP_TEST_ENTRY(AAConvexPathOp),
         DRAW_OP_TEST_ENTRY(AADistanceFieldPathOp),
diff --git a/src/gpu/GrDrawOpTest.h b/src/gpu/GrDrawOpTest.h
index 8c98597..43bd21a 100644
--- a/src/gpu/GrDrawOpTest.h
+++ b/src/gpu/GrDrawOpTest.h
@@ -13,20 +13,20 @@
 
 #if GR_TEST_UTILS
 
-class GrDrawOp;
 class GrContext;
+class GrMeshDrawOp;
 class SkRandom;
 
 /**  This function returns a randomly configured GrDrawOp for testing purposes. */
-std::unique_ptr<GrDrawOp> GrRandomDrawOp(SkRandom*, GrContext*);
+std::unique_ptr<GrMeshDrawOp> GrRandomDrawOp(SkRandom*, GrContext*);
 
 /** GrDrawOp subclasses should define test factory functions using this macro. */
 #define DRAW_OP_TEST_DEFINE(Op) \
-    std::unique_ptr<GrDrawOp> Op##__Test(SkRandom* random, GrContext* context)
+    std::unique_ptr<GrMeshDrawOp> Op##__Test(SkRandom* random, GrContext* context)
 
 /** This macro may be used if the test factory function must be made a friend of a class. */
 #define DRAW_OP_TEST_FRIEND(Op) \
-    friend std::unique_ptr<GrDrawOp> Op##__Test(SkRandom* random, GrContext* context);
+    friend std::unique_ptr<GrMeshDrawOp> Op##__Test(SkRandom* random, GrContext* context);
 
 #endif
 #endif
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 1d891df..5937054 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -507,13 +507,12 @@
         return true;
     }
 
-    std::unique_ptr<GrDrawOp> op;
     GrAAType aaType;
 
     if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) {
         InstancedRendering* ir = this->getOpList()->instancedRendering();
-        op = ir->recordRect(croppedRect, viewMatrix, paint.getColor(), aa, fInstancedPipelineInfo,
-                            &aaType);
+        std::unique_ptr<GrDrawOp> op = ir->recordRect(croppedRect, viewMatrix, paint.getColor(), aa,
+                                                      fInstancedPipelineInfo, &aaType);
         if (op) {
             GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
             if (ss) {
@@ -529,14 +528,14 @@
         if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
             SkRect devBoundRect;
             viewMatrix.mapRect(&devBoundRect, croppedRect);
-
-            op = GrRectOpFactory::MakeAAFill(paint, viewMatrix, rect, croppedRect, devBoundRect);
+            std::unique_ptr<GrMeshDrawOp> op =
+                    GrRectOpFactory::MakeAAFill(paint, viewMatrix, rect, croppedRect, devBoundRect);
             if (op) {
                 GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
                 if (ss) {
                     pipelineBuilder.setUserStencil(ss);
                 }
-                this->addDrawOp(pipelineBuilder, clip, std::move(op));
+                this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
                 return true;
             }
         }
@@ -637,7 +636,7 @@
         }
 
         bool snapToPixelCenters = false;
-        std::unique_ptr<GrDrawOp> op;
+        std::unique_ptr<GrMeshDrawOp> op;
 
         GrColor color = paint.getColor();
         GrAAType aaType = this->decideAAType(aa);
@@ -659,7 +658,7 @@
         if (op) {
             GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
             pipelineBuilder.setSnapVerticesToPixelCenters(snapToPixelCenters);
-            this->addDrawOp(pipelineBuilder, clip, std::move(op));
+            this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
             return;
         }
     }
@@ -893,10 +892,10 @@
     }
 
     if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
-        std::unique_ptr<GrDrawOp> op =
+        std::unique_ptr<GrMeshDrawOp> op =
                 GrAAFillRectOp::Make(paint.getColor(), viewMatrix, localMatrix, croppedRect);
         GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
-        this->addDrawOp(pipelineBuilder, clip, std::move(op));
+        this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
         return;
     }
 
@@ -939,14 +938,14 @@
         return;
     }
 
-    std::unique_ptr<GrDrawOp> op = GrDrawVerticesOp::Make(
+    std::unique_ptr<GrMeshDrawOp> op = GrDrawVerticesOp::Make(
             paint.getColor(), primitiveType, viewMatrix, positions, vertexCount, indices,
             indexCount, colors, texCoords, bounds, colorArrayType);
     if (!op) {
         return;
     }
     GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
-    this->addDrawOp(pipelineBuilder, clip, std::move(op));
+    this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
 }
 
 void GrRenderTargetContext::drawVertices(const GrClip& clip,
@@ -962,13 +961,13 @@
     AutoCheckFlush acf(this->drawingManager());
 
     SkASSERT(vertices);
-    std::unique_ptr<GrDrawOp> op =
+    std::unique_ptr<GrMeshDrawOp> op =
             GrDrawVerticesOp::Make(paint.getColor(), std::move(vertices), viewMatrix, flags);
     if (!op) {
         return;
     }
     GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
-    this->addDrawOp(pipelineBuilder, clip, std::move(op));
+    this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -987,10 +986,10 @@
 
     AutoCheckFlush acf(this->drawingManager());
 
-    std::unique_ptr<GrDrawOp> op =
+    std::unique_ptr<GrMeshDrawOp> op =
             GrDrawAtlasOp::Make(paint.getColor(), viewMatrix, spriteCount, xform, texRect, colors);
     GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
-    this->addDrawOp(pipelineBuilder, clip, std::move(op));
+    this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1043,15 +1042,16 @@
     aaType = this->decideAAType(aa);
     if (GrAAType::kCoverage == aaType) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-        std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeRRectOp(paint.getColor(),
-                                                                    paint.usesDistanceVectorField(),
-                                                                    viewMatrix,
-                                                                    rrect,
-                                                                    stroke,
-                                                                    shaderCaps);
+        std::unique_ptr<GrMeshDrawOp> op =
+                GrOvalOpFactory::MakeRRectOp(paint.getColor(),
+                                             paint.usesDistanceVectorField(),
+                                             viewMatrix,
+                                             rrect,
+                                             stroke,
+                                             shaderCaps);
         if (op) {
             GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
-            this->addDrawOp(pipelineBuilder, *clip, std::move(op));
+            this->addMeshDrawOp(pipelineBuilder, *clip, std::move(op));
             return;
         }
     }
@@ -1085,11 +1085,11 @@
     // TODO: add instancing support?
 
     const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-    std::unique_ptr<GrDrawOp> op = GrShadowRRectOp::Make(paint.getColor(), viewMatrix, rrect,
-                                                         blurRadius, stroke, shaderCaps);
+    std::unique_ptr<GrMeshDrawOp> op = GrShadowRRectOp::Make(paint.getColor(), viewMatrix, rrect,
+                                                             blurRadius, stroke, shaderCaps);
     if (op) {
         GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
-        this->addDrawOp(pipelineBuilder, clip, std::move(op));
+        this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
         return;
     }
 }
@@ -1231,9 +1231,9 @@
         return this->drawPath(clip, std::move(paint), aa, viewMatrix, path, style);
     }
 
-    std::unique_ptr<GrDrawOp> op = GrRegionOp::Make(paint.getColor(), viewMatrix, region);
+    std::unique_ptr<GrMeshDrawOp> op = GrRegionOp::Make(paint.getColor(), viewMatrix, region);
     GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
-    this->addDrawOp(pipelineBuilder, clip, std::move(op));
+    this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
 }
 
 void GrRenderTargetContext::drawOval(const GrClip& clip,
@@ -1272,11 +1272,11 @@
     aaType = this->decideAAType(aa);
     if (GrAAType::kCoverage == aaType) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-        std::unique_ptr<GrDrawOp> op =
+        std::unique_ptr<GrMeshDrawOp> op =
                 GrOvalOpFactory::MakeOvalOp(paint.getColor(), viewMatrix, oval, stroke, shaderCaps);
         if (op) {
             GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
-            this->addDrawOp(pipelineBuilder, clip, std::move(op));
+            this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
             return;
         }
     }
@@ -1306,17 +1306,17 @@
     GrAAType aaType = this->decideAAType(aa);
     if (GrAAType::kCoverage == aaType) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-        std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeArcOp(paint.getColor(),
-                                                                  viewMatrix,
-                                                                  oval,
-                                                                  startAngle,
-                                                                  sweepAngle,
-                                                                  useCenter,
-                                                                  style,
-                                                                  shaderCaps);
+        std::unique_ptr<GrMeshDrawOp> op = GrOvalOpFactory::MakeArcOp(paint.getColor(),
+                                                                      viewMatrix,
+                                                                      oval,
+                                                                      startAngle,
+                                                                      sweepAngle,
+                                                                      useCenter,
+                                                                      style,
+                                                                      shaderCaps);
         if (op) {
             GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
-            this->addDrawOp(pipelineBuilder, clip, std::move(op));
+            this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
             return;
         }
     }
@@ -1340,11 +1340,11 @@
 
     AutoCheckFlush acf(this->drawingManager());
 
-    std::unique_ptr<GrDrawOp> op = GrLatticeOp::MakeNonAA(paint.getColor(), viewMatrix, imageWidth,
-                                                          imageHeight, std::move(iter), dst);
+    std::unique_ptr<GrMeshDrawOp> op = GrLatticeOp::MakeNonAA(
+            paint.getColor(), viewMatrix, imageWidth, imageHeight, std::move(iter), dst);
 
     GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
-    this->addDrawOp(pipelineBuilder, clip, std::move(op));
+    this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
 }
 
 void GrRenderTargetContext::prepareForExternalIO() {
@@ -1375,13 +1375,13 @@
                                                 GrAAType hwOrNoneAAType) {
     SkASSERT(GrAAType::kCoverage != hwOrNoneAAType);
     SkASSERT(hwOrNoneAAType == GrAAType::kNone || this->isStencilBufferMultisampled());
-    std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewMatrix,
-                                                                  rect, localRect, localMatrix);
+    std::unique_ptr<GrMeshDrawOp> op = GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewMatrix,
+                                                                      rect, localRect, localMatrix);
     GrPipelineBuilder pipelineBuilder(std::move(paint), hwOrNoneAAType);
     if (ss) {
         pipelineBuilder.setUserStencil(ss);
     }
-    this->addDrawOp(pipelineBuilder, clip, std::move(op));
+    this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
@@ -1457,11 +1457,11 @@
             SkRect rects[2];
 
             if (fills_as_nested_rects(viewMatrix, path, rects)) {
-                std::unique_ptr<GrDrawOp> op =
+                std::unique_ptr<GrMeshDrawOp> op =
                         GrRectOpFactory::MakeAAFillNestedRects(paint.getColor(), viewMatrix, rects);
                 if (op) {
                     GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
-                    this->addDrawOp(pipelineBuilder, clip, std::move(op));
+                    this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
                 }
                 return;
             }
@@ -1471,11 +1471,11 @@
 
         if (isOval && !path.isInverseFillType()) {
             const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-            std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeOvalOp(
+            std::unique_ptr<GrMeshDrawOp> op = GrOvalOpFactory::MakeOvalOp(
                     paint.getColor(), viewMatrix, ovalRect, style.strokeRec(), shaderCaps);
             if (op) {
                 GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
-                this->addDrawOp(pipelineBuilder, clip, std::move(op));
+                this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
                 return;
             }
         }
@@ -1673,6 +1673,12 @@
     }
 }
 
+uint32_t GrRenderTargetContext::addMeshDrawOp(const GrPipelineBuilder& pipelineBuilder,
+                                              const GrClip& clip,
+                                              std::unique_ptr<GrMeshDrawOp> op) {
+    return this->addDrawOp(pipelineBuilder, clip, std::move(op));
+}
+
 uint32_t GrRenderTargetContext::addDrawOp(const GrPipelineBuilder& pipelineBuilder,
                                           const GrClip& clip,
                                           std::unique_ptr<GrDrawOp> op) {
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index 1126c76..479fc93 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -23,6 +23,7 @@
 class GrDrawOp;
 class GrFixedClip;
 class GrPipelineBuilder;
+class GrMeshDrawOp;
 class GrRenderTarget;
 class GrRenderTargetContextPriv;
 class GrRenderTargetOpList;
@@ -414,24 +415,24 @@
         return GrAAType::kCoverage;
     }
 
-    friend class GrAtlasTextBlob; // for access to addDrawOp
-    friend class GrStencilAndCoverTextContext; // for access to addDrawOp
+    friend class GrAtlasTextBlob;               // for access to add[Mesh]DrawOp
+    friend class GrStencilAndCoverTextContext;  // for access to add[Mesh]DrawOp
 
     friend class GrDrawingManager; // for ctor
     friend class GrRenderTargetContextPriv;
-    friend class GrSWMaskHelper;                 // for access to addDrawOp
+    friend class GrSWMaskHelper;  // for access to add[Mesh]DrawOp
 
     // All the path renderers currently make their own ops
-    friend class GrSoftwarePathRenderer;         // for access to addDrawOp
-    friend class GrAAConvexPathRenderer;         // for access to addDrawOp
-    friend class GrDashLinePathRenderer;         // for access to addDrawOp
-    friend class GrAAHairLinePathRenderer;       // for access to addDrawOp
-    friend class GrAALinearizingConvexPathRenderer;  // for access to addDrawOp
-    friend class GrAADistanceFieldPathRenderer;  // for access to addDrawOp
-    friend class GrDefaultPathRenderer;          // for access to addDrawOp
-    friend class GrMSAAPathRenderer;             // for access to addDrawOp
-    friend class GrStencilAndCoverPathRenderer;  // for access to addDrawOp
-    friend class GrTessellatingPathRenderer;     // for access to addDrawOp
+    friend class GrSoftwarePathRenderer;             // for access to add[Mesh]DrawOp
+    friend class GrAAConvexPathRenderer;             // for access to add[Mesh]DrawOp
+    friend class GrDashLinePathRenderer;             // for access to add[Mesh]DrawOp
+    friend class GrAAHairLinePathRenderer;           // for access to add[Mesh]DrawOp
+    friend class GrAALinearizingConvexPathRenderer;  // for access to add[Mesh]DrawOp
+    friend class GrAADistanceFieldPathRenderer;      // for access to add[Mesh]DrawOp
+    friend class GrDefaultPathRenderer;              // for access to add[Mesh]DrawOp
+    friend class GrMSAAPathRenderer;                 // for access to add[Mesh]DrawOp
+    friend class GrStencilAndCoverPathRenderer;      // for access to add[Mesh]DrawOp
+    friend class GrTessellatingPathRenderer;         // for access to add[Mesh]DrawOp
     // for a unit test
     friend void test_draw_op(GrContext*, GrRenderTargetContext*,
                              sk_sp<GrFragmentProcessor>, sk_sp<GrTextureProxy>);
@@ -472,10 +473,12 @@
     bool onWritePixels(const SkImageInfo& srcInfo, const void* srcBuffer,
                        size_t srcRowBytes, int x, int y, uint32_t flags) override;
 
-    // This performs processing specific to GrDrawOp-derived ops before recording them into the
-    // op list. It returns the id of the opList to which the op was added, or 0, if it was
+    // These perform processing specific to Gr[Mesh]DrawOp-derived ops before recording them into
+    // the op list. They return the id of the opList to which the op was added, or 0, if it was
     // dropped (e.g., due to clipping).
     uint32_t addDrawOp(const GrPipelineBuilder&, const GrClip&, std::unique_ptr<GrDrawOp>);
+    uint32_t addMeshDrawOp(const GrPipelineBuilder&, const GrClip&,
+                           std::unique_ptr<GrMeshDrawOp> op);
 
     // Makes a copy of the dst if it is necessary for the draw and returns the texture that should
     // be used by GrXferProcessor to access the destination color. If the texture is nullptr then
diff --git a/src/gpu/GrRenderTargetContextPriv.h b/src/gpu/GrRenderTargetContextPriv.h
index 842e23c..430abd0 100644
--- a/src/gpu/GrRenderTargetContextPriv.h
+++ b/src/gpu/GrRenderTargetContextPriv.h
@@ -108,11 +108,9 @@
         return fRenderTargetContext->fRenderTargetProxy->uniqueID();
     }
 
-    uint32_t testingOnly_addDrawOp(GrPaint&&,
-                                   GrAAType,
-                                   std::unique_ptr<GrDrawOp>,
-                                   const GrUserStencilSettings* = nullptr,
-                                   bool snapToCenters = false);
+    uint32_t testingOnly_addMeshDrawOp(GrPaint&&, GrAAType, std::unique_ptr<GrMeshDrawOp>,
+                                       const GrUserStencilSettings* = nullptr,
+                                       bool snapToCenters = false);
 
     bool refsWrappedObjects() const {
         return fRenderTargetContext->fRenderTargetProxy->refsWrappedObjects();
diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp
index f7e518b..6b6f1e6 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -175,11 +175,11 @@
     SkMatrix maskMatrix = SkMatrix::MakeTrans(SkIntToScalar(-textureOriginInDeviceSpace.fX),
                                               SkIntToScalar(-textureOriginInDeviceSpace.fY));
     maskMatrix.preConcat(viewMatrix);
-    std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFill(paint.getColor(), SkMatrix::I(),
-                                                                  dstRect, nullptr, &invert);
+    std::unique_ptr<GrMeshDrawOp> op = GrRectOpFactory::MakeNonAAFill(
+            paint.getColor(), SkMatrix::I(), dstRect, nullptr, &invert);
     paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(
             texture, nullptr, maskMatrix, GrSamplerParams::kNone_FilterMode));
     GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
     pipelineBuilder.setUserStencil(&userStencilSettings);
-    renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+    renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
 }
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index eb5495c..31ed746 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -77,12 +77,12 @@
                                            const SkMatrix& viewMatrix,
                                            const SkRect& rect,
                                            const SkMatrix& localMatrix) {
-    std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewMatrix, rect,
-                                                                nullptr, &localMatrix));
+    std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewMatrix,
+                                                                    rect, nullptr, &localMatrix));
 
     GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
     pipelineBuilder.setUserStencil(&userStencilSettings);
-    renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+    renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
 }
 
 void GrSoftwarePathRenderer::DrawAroundInvPath(GrRenderTargetContext* renderTargetContext,
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 4a2c6e2..68f4357 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -725,9 +725,9 @@
 class AAConvexPathOp final : public GrMeshDrawOp {
 public:
     DEFINE_OP_CLASS_ID
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
-                                          const SkPath& path) {
-        return std::unique_ptr<GrDrawOp>(new AAConvexPathOp(color, viewMatrix, path));
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                              const SkPath& path) {
+        return std::unique_ptr<GrMeshDrawOp>(new AAConvexPathOp(color, viewMatrix, path));
     }
 
     const char* name() const override { return "AAConvexPathOp"; }
@@ -972,13 +972,13 @@
     SkPath path;
     args.fShape->asPath(&path);
 
-    std::unique_ptr<GrDrawOp> op =
+    std::unique_ptr<GrMeshDrawOp> op =
             AAConvexPathOp::Make(args.fPaint.getColor(), *args.fViewMatrix, path);
 
     GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
-    args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+    args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
 
     return true;
 
diff --git a/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp b/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
index a856ba6..e77dfa9 100644
--- a/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
+++ b/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
@@ -141,11 +141,11 @@
     using ShapeCache = SkTDynamicHash<ShapeData, ShapeData::Key>;
     using ShapeDataList = GrAADistanceFieldPathRenderer::ShapeDataList;
 
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const GrShape& shape,
-                                          const SkMatrix& viewMatrix, GrDrawOpAtlas* atlas,
-                                          ShapeCache* shapeCache, ShapeDataList* shapeList,
-                                          bool gammaCorrect) {
-        return std::unique_ptr<GrDrawOp>(new AADistanceFieldPathOp(
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const GrShape& shape,
+                                              const SkMatrix& viewMatrix, GrDrawOpAtlas* atlas,
+                                              ShapeCache* shapeCache, ShapeDataList* shapeList,
+                                              bool gammaCorrect) {
+        return std::unique_ptr<GrMeshDrawOp>(new AADistanceFieldPathOp(
                 color, shape, viewMatrix, atlas, shapeCache, shapeList, gammaCorrect));
     }
 
@@ -757,13 +757,13 @@
         }
     }
 
-    std::unique_ptr<GrDrawOp> op = AADistanceFieldPathOp::Make(
+    std::unique_ptr<GrMeshDrawOp> op = AADistanceFieldPathOp::Make(
             args.fPaint.getColor(), *args.fShape, *args.fViewMatrix, fAtlas.get(), &fShapeCache,
             &fShapeList, args.fGammaCorrect);
     GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
-    args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+    args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
 
     return true;
 }
diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp
index c66e7ee..850a3c9 100644
--- a/src/gpu/ops/GrAAFillRectOp.cpp
+++ b/src/gpu/ops/GrAAFillRectOp.cpp
@@ -342,35 +342,36 @@
 
 namespace GrAAFillRectOp {
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRect& rect,
-                               const SkRect& devRect) {
-    return std::unique_ptr<GrDrawOp>(new AAFillRectOp(color, viewMatrix, rect, devRect, nullptr));
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const SkRect& devRect) {
+    return std::unique_ptr<GrMeshDrawOp>(
+            new AAFillRectOp(color, viewMatrix, rect, devRect, nullptr));
 }
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkMatrix& localMatrix,
-                               const SkRect& rect,
-                               const SkRect& devRect) {
-    return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkMatrix& localMatrix,
+                                   const SkRect& rect,
+                                   const SkRect& devRect) {
+    return std::unique_ptr<GrMeshDrawOp>(
             new AAFillRectOp(color, viewMatrix, rect, devRect, &localMatrix));
 }
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkMatrix& localMatrix,
-                               const SkRect& rect) {
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkMatrix& localMatrix,
+                                   const SkRect& rect) {
     SkRect devRect;
     viewMatrix.mapRect(&devRect, rect);
     return Make(color, viewMatrix, localMatrix, rect, devRect);
 }
 
-std::unique_ptr<GrDrawOp> MakeWithLocalRect(GrColor color,
-                                            const SkMatrix& viewMatrix,
-                                            const SkRect& rect,
-                                            const SkRect& localRect) {
+std::unique_ptr<GrMeshDrawOp> MakeWithLocalRect(GrColor color,
+                                                const SkMatrix& viewMatrix,
+                                                const SkRect& rect,
+                                                const SkRect& localRect) {
     SkRect devRect;
     viewMatrix.mapRect(&devRect, rect);
     SkMatrix localMatrix;
diff --git a/src/gpu/ops/GrAAFillRectOp.h b/src/gpu/ops/GrAAFillRectOp.h
index ff9844e..c047eed 100644
--- a/src/gpu/ops/GrAAFillRectOp.h
+++ b/src/gpu/ops/GrAAFillRectOp.h
@@ -11,31 +11,31 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class SkMatrix;
 struct SkRect;
 
 namespace GrAAFillRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRect& rect,
-                               const SkRect& devRect);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const SkRect& devRect);
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkMatrix& localMatrix,
-                               const SkRect& rect);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkMatrix& localMatrix,
+                                   const SkRect& rect);
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkMatrix& localMatrix,
-                               const SkRect& rect,
-                               const SkRect& devRect);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkMatrix& localMatrix,
+                                   const SkRect& rect,
+                                   const SkRect& devRect);
 
-std::unique_ptr<GrDrawOp> MakeWithLocalRect(GrColor color,
-                                            const SkMatrix& viewMatrix,
-                                            const SkRect& rect,
-                                            const SkRect& localRect);
+std::unique_ptr<GrMeshDrawOp> MakeWithLocalRect(GrColor color,
+                                                const SkMatrix& viewMatrix,
+                                                const SkRect& rect,
+                                                const SkRect& localRect);
 };
 
 #endif
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index 408740d..e373b97 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -676,18 +676,18 @@
 public:
     DEFINE_OP_CLASS_ID
 
-    static std::unique_ptr<GrDrawOp> Make(GrColor color,
-                                          const SkMatrix& viewMatrix,
-                                          const SkPath& path,
-                                          const GrStyle& style,
-                                          const SkIRect& devClipBounds) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                              const SkMatrix& viewMatrix,
+                                              const SkPath& path,
+                                              const GrStyle& style,
+                                              const SkIRect& devClipBounds) {
         SkScalar hairlineCoverage;
         uint8_t newCoverage = 0xff;
         if (GrPathRenderer::IsStrokeHairlineOrEquivalent(style, viewMatrix, &hairlineCoverage)) {
             newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
         }
 
-        return std::unique_ptr<GrDrawOp>(
+        return std::unique_ptr<GrMeshDrawOp>(
                 new AAHairlineOp(color, newCoverage, viewMatrix, path, devClipBounds));
     }
 
@@ -949,11 +949,11 @@
                                       &devClipBounds);
     SkPath path;
     args.fShape->asPath(&path);
-    std::unique_ptr<GrDrawOp> op = AAHairlineOp::Make(args.fPaint.getColor(), *args.fViewMatrix,
-                                                      path, args.fShape->style(), devClipBounds);
+    std::unique_ptr<GrMeshDrawOp> op = AAHairlineOp::Make(
+            args.fPaint.getColor(), *args.fViewMatrix, path, args.fShape->style(), devClipBounds);
     GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
-    args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+    args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
     return true;
 }
 
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index f0ff12b..bdec758 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -120,14 +120,14 @@
 class AAFlatteningConvexPathOp final : public GrMeshDrawOp {
 public:
     DEFINE_OP_CLASS_ID
-    static std::unique_ptr<GrDrawOp> Make(GrColor color,
-                                          const SkMatrix& viewMatrix,
-                                          const SkPath& path,
-                                          SkScalar strokeWidth,
-                                          SkStrokeRec::Style style,
-                                          SkPaint::Join join,
-                                          SkScalar miterLimit) {
-        return std::unique_ptr<GrDrawOp>(new AAFlatteningConvexPathOp(
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                              const SkMatrix& viewMatrix,
+                                              const SkPath& path,
+                                              SkScalar strokeWidth,
+                                              SkStrokeRec::Style style,
+                                              SkPaint::Join join,
+                                              SkScalar miterLimit) {
+        return std::unique_ptr<GrMeshDrawOp>(new AAFlatteningConvexPathOp(
                 color, viewMatrix, path, strokeWidth, style, join, miterLimit));
     }
 
@@ -335,14 +335,14 @@
     SkPaint::Join join = fill ? SkPaint::Join::kMiter_Join : stroke.getJoin();
     SkScalar miterLimit = stroke.getMiter();
 
-    std::unique_ptr<GrDrawOp> op =
+    std::unique_ptr<GrMeshDrawOp> op =
             AAFlatteningConvexPathOp::Make(args.fPaint.getColor(), *args.fViewMatrix, path,
                                            strokeWidth, stroke.getStyle(), join, miterLimit);
 
     GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
-    args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+    args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
 
     return true;
 }
diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp
index 207b95f..3780752 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrAAStrokeRectOp.cpp
@@ -125,8 +125,8 @@
         fMiterStroke = true;
     }
 
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
-                                          const SkRect& rect, const SkStrokeRec& stroke) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                              const SkRect& rect, const SkStrokeRec& stroke) {
         bool isMiter;
         if (!allowed_stroke(stroke, &isMiter)) {
             return nullptr;
@@ -140,7 +140,7 @@
         info.fColor = color;
         op->setBounds(info.fDevOutside, HasAABloat::kYes, IsZeroArea::kNo);
         op->fViewMatrix = viewMatrix;
-        return std::unique_ptr<GrDrawOp>(op);
+        return std::unique_ptr<GrMeshDrawOp>(op);
     }
 
     const char* name() const override { return "AAStrokeRect"; }
@@ -562,17 +562,18 @@
 
 namespace GrAAStrokeRectOp {
 
-std::unique_ptr<GrDrawOp> MakeFillBetweenRects(GrColor color,
-                                               const SkMatrix& viewMatrix,
-                                               const SkRect& devOutside,
-                                               const SkRect& devInside) {
-    return std::unique_ptr<GrDrawOp>(new AAStrokeRectOp(color, viewMatrix, devOutside, devInside));
+std::unique_ptr<GrMeshDrawOp> MakeFillBetweenRects(GrColor color,
+                                                   const SkMatrix& viewMatrix,
+                                                   const SkRect& devOutside,
+                                                   const SkRect& devInside) {
+    return std::unique_ptr<GrMeshDrawOp>(
+            new AAStrokeRectOp(color, viewMatrix, devOutside, devInside));
 }
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRect& rect,
-                               const SkStrokeRec& stroke) {
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const SkStrokeRec& stroke) {
     return AAStrokeRectOp::Make(color, viewMatrix, rect, stroke);
 }
 }
diff --git a/src/gpu/ops/GrAAStrokeRectOp.h b/src/gpu/ops/GrAAStrokeRectOp.h
index d9f830e..4dfbe64 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.h
+++ b/src/gpu/ops/GrAAStrokeRectOp.h
@@ -11,22 +11,22 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class SkMatrix;
 struct SkRect;
 class SkStrokeRec;
 
 namespace GrAAStrokeRectOp {
 
-std::unique_ptr<GrDrawOp> MakeFillBetweenRects(GrColor color,
-                                               const SkMatrix& viewMatrix,
-                                               const SkRect& devOutside,
-                                               const SkRect& devInside);
+std::unique_ptr<GrMeshDrawOp> MakeFillBetweenRects(GrColor color,
+                                                   const SkMatrix& viewMatrix,
+                                                   const SkRect& devOutside,
+                                                   const SkRect& devInside);
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRect& rect,
-                               const SkStrokeRec& stroke);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const SkStrokeRec& stroke);
 }
 
 #endif
diff --git a/src/gpu/ops/GrAnalyticRectOp.cpp b/src/gpu/ops/GrAnalyticRectOp.cpp
index 711ce33..5dbfd5e 100644
--- a/src/gpu/ops/GrAnalyticRectOp.cpp
+++ b/src/gpu/ops/GrAnalyticRectOp.cpp
@@ -377,12 +377,12 @@
     typedef GrMeshDrawOp INHERITED;
 };
 
-std::unique_ptr<GrDrawOp> GrAnalyticRectOp::Make(GrColor color,
-                                                 const SkMatrix& viewMatrix,
-                                                 const SkRect& rect,
-                                                 const SkRect& croppedRect,
-                                                 const SkRect& bounds) {
-    return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> GrAnalyticRectOp::Make(GrColor color,
+                                                     const SkMatrix& viewMatrix,
+                                                     const SkRect& rect,
+                                                     const SkRect& croppedRect,
+                                                     const SkRect& bounds) {
+    return std::unique_ptr<GrMeshDrawOp>(
             new AnalyticRectOp(color, viewMatrix, rect, croppedRect, bounds));
 }
 
@@ -394,7 +394,7 @@
     SkRect rect = GrTest::TestSquare(random);
     SkRect croppedRect = GrTest::TestSquare(random);
     SkRect bounds = GrTest::TestSquare(random);
-    return std::unique_ptr<GrDrawOp>(
+    return std::unique_ptr<GrMeshDrawOp>(
             new AnalyticRectOp(color, viewMatrix, rect, croppedRect, bounds));
 }
 
diff --git a/src/gpu/ops/GrAnalyticRectOp.h b/src/gpu/ops/GrAnalyticRectOp.h
index 1266879..4331794 100644
--- a/src/gpu/ops/GrAnalyticRectOp.h
+++ b/src/gpu/ops/GrAnalyticRectOp.h
@@ -11,7 +11,7 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class SkMatrix;
 struct SkRect;
 
@@ -27,11 +27,11 @@
  */
 class GrAnalyticRectOp {
 public:
-    static std::unique_ptr<GrDrawOp> Make(GrColor color,
-                                          const SkMatrix& viewMatrix,
-                                          const SkRect& rect,
-                                          const SkRect& croppedRect,
-                                          const SkRect& bounds);
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                              const SkMatrix& viewMatrix,
+                                              const SkRect& rect,
+                                              const SkRect& croppedRect,
+                                              const SkRect& bounds);
 };
 
 #endif  // GrAnalyticRectOp_DEFINED
diff --git a/src/gpu/ops/GrDashLinePathRenderer.cpp b/src/gpu/ops/GrDashLinePathRenderer.cpp
index 1c43cb5..9f170ff 100644
--- a/src/gpu/ops/GrDashLinePathRenderer.cpp
+++ b/src/gpu/ops/GrDashLinePathRenderer.cpp
@@ -11,6 +11,7 @@
 #include "GrGpu.h"
 #include "GrPipelineBuilder.h"
 #include "ops/GrDashOp.h"
+#include "ops/GrMeshDrawOp.h"
 
 bool GrDashLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     SkPoint pts[2];
@@ -45,7 +46,7 @@
     }
     SkPoint pts[2];
     SkAssertResult(args.fShape->asLine(pts, nullptr));
-    std::unique_ptr<GrDrawOp> op = GrDashOp::MakeDashLineOp(
+    std::unique_ptr<GrMeshDrawOp> op = GrDashOp::MakeDashLineOp(
             args.fPaint.getColor(), *args.fViewMatrix, pts, aaMode, args.fShape->style());
     if (!op) {
         return false;
@@ -54,6 +55,6 @@
     GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
-    args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+    args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
     return true;
 }
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index d91e86b..1372a8b 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -251,9 +251,9 @@
         SkScalar fPerpendicularScale;
     };
 
-    static std::unique_ptr<GrDrawOp> Make(const LineData& geometry, GrColor color, SkPaint::Cap cap,
-                                          AAMode aaMode, bool fullDash) {
-        return std::unique_ptr<GrDrawOp>(new DashOp(geometry, color, cap, aaMode, fullDash));
+    static std::unique_ptr<GrMeshDrawOp> Make(const LineData& geometry, GrColor color,
+                                              SkPaint::Cap cap, AAMode aaMode, bool fullDash) {
+        return std::unique_ptr<GrMeshDrawOp>(new DashOp(geometry, color, cap, aaMode, fullDash));
     }
 
     const char* name() const override { return "DashOp"; }
@@ -681,11 +681,11 @@
     typedef GrMeshDrawOp INHERITED;
 };
 
-std::unique_ptr<GrDrawOp> GrDashOp::MakeDashLineOp(GrColor color,
-                                                   const SkMatrix& viewMatrix,
-                                                   const SkPoint pts[2],
-                                                   AAMode aaMode,
-                                                   const GrStyle& style) {
+std::unique_ptr<GrMeshDrawOp> GrDashOp::MakeDashLineOp(GrColor color,
+                                                       const SkMatrix& viewMatrix,
+                                                       const SkPoint pts[2],
+                                                       AAMode aaMode,
+                                                       const GrStyle& style) {
     SkASSERT(GrDashOp::CanDrawDashLine(pts, style, viewMatrix));
     const SkScalar* intervals = style.dashIntervals();
     SkScalar phase = style.dashPhase();
diff --git a/src/gpu/ops/GrDashOp.h b/src/gpu/ops/GrDashOp.h
index 2f4a30f..6ffd326 100644
--- a/src/gpu/ops/GrDashOp.h
+++ b/src/gpu/ops/GrDashOp.h
@@ -12,7 +12,7 @@
 #include "GrTypesPriv.h"
 #include "SkPathEffect.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class GrStyle;
 
 namespace GrDashOp {
@@ -23,8 +23,8 @@
 };
 static const int kAAModeCnt = static_cast<int>(AAMode::kCoverageWithMSAA) + 1;
 
-std::unique_ptr<GrDrawOp> MakeDashLineOp(GrColor, const SkMatrix& viewMatrix, const SkPoint pts[2],
-                                         AAMode, const GrStyle& style);
+std::unique_ptr<GrMeshDrawOp> MakeDashLineOp(GrColor, const SkMatrix& viewMatrix,
+                                             const SkPoint pts[2], AAMode, const GrStyle& style);
 bool CanDrawDashLine(const SkPoint pts[2], const GrStyle& style, const SkMatrix& viewMatrix);
 }
 
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index f2be968..300090d 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -98,11 +98,11 @@
 public:
     DEFINE_OP_CLASS_ID
 
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkPath& path, SkScalar tolerance,
-                                          uint8_t coverage, const SkMatrix& viewMatrix,
-                                          bool isHairline, const SkRect& devBounds) {
-        return std::unique_ptr<GrDrawOp>(new DefaultPathOp(color, path, tolerance, coverage,
-                                                           viewMatrix, isHairline, devBounds));
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkPath& path, SkScalar tolerance,
+                                              uint8_t coverage, const SkMatrix& viewMatrix,
+                                              bool isHairline, const SkRect& devBounds) {
+        return std::unique_ptr<GrMeshDrawOp>(new DefaultPathOp(color, path, tolerance, coverage,
+                                                               viewMatrix, isHairline, devBounds));
     }
 
     const char* name() const override { return "DefaultPathOp"; }
@@ -546,16 +546,16 @@
             }
             const SkMatrix& viewM = (reverse && viewMatrix.hasPerspective()) ? SkMatrix::I() :
                                                                                viewMatrix;
-            std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+            std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
                     paint.getColor(), viewM, bounds, nullptr, &localMatrix));
 
             SkASSERT(GrDrawFace::kBoth == drawFace[p]);
             GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
             pipelineBuilder.setDrawFace(drawFace[p]);
             pipelineBuilder.setUserStencil(passes[p]);
-            renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+            renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
         } else {
-            std::unique_ptr<GrDrawOp> op =
+            std::unique_ptr<GrMeshDrawOp> op =
                     DefaultPathOp::Make(paint.getColor(), path, srcSpaceTol, newCoverage,
                                         viewMatrix, isHairline, devBounds);
             bool stencilPass = stencilOnly || passCount > 1;
@@ -566,7 +566,7 @@
             GrPipelineBuilder pipelineBuilder(std::move(passPaint), aaType);
             pipelineBuilder.setDrawFace(drawFace[p]);
             pipelineBuilder.setUserStencil(passes[p]);
-            renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+            renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
         }
     }
     return true;
diff --git a/src/gpu/ops/GrDrawAtlasOp.h b/src/gpu/ops/GrDrawAtlasOp.h
index d6a211d..cde345e 100644
--- a/src/gpu/ops/GrDrawAtlasOp.h
+++ b/src/gpu/ops/GrDrawAtlasOp.h
@@ -16,10 +16,10 @@
 public:
     DEFINE_OP_CLASS_ID
 
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
-                                          int spriteCount, const SkRSXform* xforms,
-                                          const SkRect* rects, const SkColor* colors) {
-        return std::unique_ptr<GrDrawOp>(
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                              int spriteCount, const SkRSXform* xforms,
+                                              const SkRect* rects, const SkColor* colors) {
+        return std::unique_ptr<GrMeshDrawOp>(
                 new GrDrawAtlasOp(color, viewMatrix, spriteCount, xforms, rects, colors));
     }
 
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index 5b59b13..c79d9ac 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -10,7 +10,7 @@
 #include "GrOpFlushState.h"
 #include "SkGr.h"
 
-std::unique_ptr<GrDrawOp> GrDrawVerticesOp::Make(
+std::unique_ptr<GrMeshDrawOp> GrDrawVerticesOp::Make(
         GrColor color, GrPrimitiveType primitiveType, const SkMatrix& viewMatrix,
         const SkPoint* positions, int vertexCount, const uint16_t* indices, int indexCount,
         const uint32_t* colors, const SkPoint* localCoords, const SkRect& bounds,
@@ -58,15 +58,15 @@
     if (!vertices) {
         return nullptr;
     }
-    return std::unique_ptr<GrDrawOp>(new GrDrawVerticesOp(std::move(vertices), primitiveType, color,
-                                                          colorArrayType, viewMatrix));
+    return std::unique_ptr<GrMeshDrawOp>(new GrDrawVerticesOp(std::move(vertices), primitiveType,
+                                                              color, colorArrayType, viewMatrix));
 }
 
-std::unique_ptr<GrDrawOp> GrDrawVerticesOp::Make(GrColor color, sk_sp<SkVertices> vertices,
-                                                 const SkMatrix& viewMatrix, uint32_t flags) {
+std::unique_ptr<GrMeshDrawOp> GrDrawVerticesOp::Make(GrColor color, sk_sp<SkVertices> vertices,
+                                                     const SkMatrix& viewMatrix, uint32_t flags) {
     SkASSERT(vertices);
     GrPrimitiveType primType = SkVertexModeToGrPrimitiveType(vertices->mode());
-    return std::unique_ptr<GrDrawOp>(new GrDrawVerticesOp(
+    return std::unique_ptr<GrMeshDrawOp>(new GrDrawVerticesOp(
             std::move(vertices), primType, color, GrRenderTargetContext::ColorArrayType::kSkColor,
             viewMatrix, flags));
 }
diff --git a/src/gpu/ops/GrDrawVerticesOp.h b/src/gpu/ops/GrDrawVerticesOp.h
index 2ce9bdc..c837734 100644
--- a/src/gpu/ops/GrDrawVerticesOp.h
+++ b/src/gpu/ops/GrDrawVerticesOp.h
@@ -33,12 +33,12 @@
      * as local coords. 'colorArrayType' specifies whether the colors are premul GrColors or
      * unpremul SkColors.
      */
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, GrPrimitiveType primitiveType,
-                                          const SkMatrix& viewMatrix, const SkPoint* positions,
-                                          int vertexCount, const uint16_t* indices, int indexCount,
-                                          const uint32_t* colors, const SkPoint* localCoords,
-                                          const SkRect& bounds,
-                                          GrRenderTargetContext::ColorArrayType colorArrayType);
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, GrPrimitiveType primitiveType,
+                                              const SkMatrix& viewMatrix, const SkPoint* positions,
+                                              int vertexCount, const uint16_t* indices,
+                                              int indexCount, const uint32_t* colors,
+                                              const SkPoint* localCoords, const SkRect& bounds,
+                                              GrRenderTargetContext::ColorArrayType colorArrayType);
 
     /**
      * Draw a SkVertices. The GrColor param is used if the vertices lack per-vertex color or 'flags'
@@ -46,8 +46,8 @@
      * specified by SkCanvas::VerticesFlags. If the vertices lack local coords or 'flags' indicates
      * that they should be ignored then the vertex positions are used as local coords.
      */
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, sk_sp<SkVertices>,
-                                          const SkMatrix& viewMatrix, uint32_t flags);
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, sk_sp<SkVertices>,
+                                              const SkMatrix& viewMatrix, uint32_t flags);
 
     const char* name() const override { return "DrawVerticesOp"; }
 
diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp
index 531a646..a1b7584 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -165,10 +165,10 @@
 };
 
 namespace GrLatticeOp {
-std::unique_ptr<GrDrawOp> MakeNonAA(GrColor color, const SkMatrix& viewMatrix, int imageWidth,
-                                    int imageHeight, std::unique_ptr<SkLatticeIter> iter,
-                                    const SkRect& dst) {
-    return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> MakeNonAA(GrColor color, const SkMatrix& viewMatrix, int imageWidth,
+                                        int imageHeight, std::unique_ptr<SkLatticeIter> iter,
+                                        const SkRect& dst) {
+    return std::unique_ptr<GrMeshDrawOp>(
             new NonAALatticeOp(color, viewMatrix, imageWidth, imageHeight, std::move(iter), dst));
 }
 };
diff --git a/src/gpu/ops/GrLatticeOp.h b/src/gpu/ops/GrLatticeOp.h
index 2ed3b9c..ef0f58a 100644
--- a/src/gpu/ops/GrLatticeOp.h
+++ b/src/gpu/ops/GrLatticeOp.h
@@ -11,15 +11,15 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class SkLatticeIter;
 class SkMatrix;
 struct SkRect;
 
 namespace GrLatticeOp {
-std::unique_ptr<GrDrawOp> MakeNonAA(GrColor color, const SkMatrix& viewMatrix, int imageWidth,
-                                    int imageHeight, std::unique_ptr<SkLatticeIter> iter,
-                                    const SkRect& dst);
+std::unique_ptr<GrMeshDrawOp> MakeNonAA(GrColor color, const SkMatrix& viewMatrix, int imageWidth,
+                                        int imageHeight, std::unique_ptr<SkLatticeIter> iter,
+                                        const SkRect& dst);
 };
 
 #endif
diff --git a/src/gpu/ops/GrMSAAPathRenderer.cpp b/src/gpu/ops/GrMSAAPathRenderer.cpp
index b149b4c..04b0b14 100644
--- a/src/gpu/ops/GrMSAAPathRenderer.cpp
+++ b/src/gpu/ops/GrMSAAPathRenderer.cpp
@@ -218,8 +218,8 @@
 class MSAAPathOp final : public GrMeshDrawOp {
 public:
     DEFINE_OP_CLASS_ID
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkPath& path,
-                                          const SkMatrix& viewMatrix, const SkRect& devBounds) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkPath& path,
+                                              const SkMatrix& viewMatrix, const SkRect& devBounds) {
         int contourCount;
         int maxLineVertices;
         int maxQuadVertices;
@@ -230,7 +230,7 @@
             return nullptr;
         }
 
-        return std::unique_ptr<GrDrawOp>(new MSAAPathOp(
+        return std::unique_ptr<GrMeshDrawOp>(new MSAAPathOp(
                 color, path, viewMatrix, devBounds, maxLineVertices, maxQuadVertices, isIndexed));
     }
 
@@ -620,7 +620,7 @@
 
     SkASSERT(passes[0]);
     {  // First pass
-        std::unique_ptr<GrDrawOp> op =
+        std::unique_ptr<GrMeshDrawOp> op =
                 MSAAPathOp::Make(paint.getColor(), path, viewMatrix, devBounds);
         if (!op) {
             return false;
@@ -634,7 +634,7 @@
         }
         GrPipelineBuilder pipelineBuilder(std::move(firstPassPaint), aaType);
         pipelineBuilder.setUserStencil(passes[0]);
-        renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+        renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
     }
 
     if (passes[1]) {
@@ -657,13 +657,13 @@
         }
         const SkMatrix& viewM =
                 (reverse && viewMatrix.hasPerspective()) ? SkMatrix::I() : viewMatrix;
-        std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewM, bounds,
-                                                                    nullptr, &localMatrix));
+        std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+                paint.getColor(), viewM, bounds, nullptr, &localMatrix));
 
         GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
         pipelineBuilder.setUserStencil(passes[1]);
 
-        renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+        renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
     }
     return true;
 }
diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp
index 871eece..a83da15 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectOp.cpp
@@ -176,12 +176,12 @@
 
 namespace GrNonAAFillRectOp {
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRect& rect,
-                               const SkRect* localRect,
-                               const SkMatrix* localMatrix) {
-    return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const SkRect* localRect,
+                                   const SkMatrix* localMatrix) {
+    return std::unique_ptr<GrMeshDrawOp>(
             new NonAAFillRectOp(color, viewMatrix, rect, localRect, localMatrix));
 }
 };
diff --git a/src/gpu/ops/GrNonAAFillRectOp.h b/src/gpu/ops/GrNonAAFillRectOp.h
index e699221..046a955 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.h
+++ b/src/gpu/ops/GrNonAAFillRectOp.h
@@ -11,23 +11,23 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class SkMatrix;
 struct SkRect;
 
 namespace GrNonAAFillRectOp {
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRect& rect,
-                               const SkRect* localRect,
-                               const SkMatrix* localMatrix);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const SkRect* localRect,
+                                   const SkMatrix* localMatrix);
 
-std::unique_ptr<GrDrawOp> MakeWithPerspective(GrColor color,
-                                              const SkMatrix& viewMatrix,
-                                              const SkRect& rect,
-                                              const SkRect* localRect,
-                                              const SkMatrix* localMatrix);
+std::unique_ptr<GrMeshDrawOp> MakeWithPerspective(GrColor color,
+                                                  const SkMatrix& viewMatrix,
+                                                  const SkRect& rect,
+                                                  const SkRect* localRect,
+                                                  const SkMatrix* localMatrix);
 };
 
 #endif
diff --git a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
index 5a0f81f..26a6469 100644
--- a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
@@ -220,12 +220,12 @@
 
 namespace GrNonAAFillRectOp {
 
-std::unique_ptr<GrDrawOp> MakeWithPerspective(GrColor color,
-                                              const SkMatrix& viewMatrix,
-                                              const SkRect& rect,
-                                              const SkRect* localRect,
-                                              const SkMatrix* localMatrix) {
-    return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> MakeWithPerspective(GrColor color,
+                                                  const SkMatrix& viewMatrix,
+                                                  const SkRect& rect,
+                                                  const SkRect* localRect,
+                                                  const SkMatrix* localMatrix) {
+    return std::unique_ptr<GrMeshDrawOp>(
             new NonAAFillRectPerspectiveOp(color, viewMatrix, rect, localRect, localMatrix));
 }
 };
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
index bcab4e0..a4de594 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
@@ -63,9 +63,9 @@
         return string;
     }
 
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
-                                          const SkRect& rect, const SkStrokeRec& stroke,
-                                          bool snapToPixelCenters) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                              const SkRect& rect, const SkStrokeRec& stroke,
+                                              bool snapToPixelCenters) {
         if (!allowed_stroke(stroke)) {
             return nullptr;
         }
@@ -96,7 +96,7 @@
         } else {
             op->setTransformedBounds(bounds, op->fViewMatrix, HasAABloat::kNo, IsZeroArea::kNo);
         }
-        return std::unique_ptr<GrDrawOp>(op);
+        return std::unique_ptr<GrMeshDrawOp>(op);
     }
 
 private:
@@ -185,11 +185,11 @@
 
 namespace GrNonAAStrokeRectOp {
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRect& rect,
-                               const SkStrokeRec& stroke,
-                               bool snapToPixelCenters) {
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const SkStrokeRec& stroke,
+                                   bool snapToPixelCenters) {
     return NonAAStrokeRectOp::Make(color, viewMatrix, rect, stroke, snapToPixelCenters);
 }
 }
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.h b/src/gpu/ops/GrNonAAStrokeRectOp.h
index 9c46f40..5c9c98e 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.h
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.h
@@ -11,18 +11,18 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 struct SkRect;
 class SkStrokeRec;
 class SkMatrix;
 
 namespace GrNonAAStrokeRectOp {
 
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRect& rect,
-                               const SkStrokeRec&,
-                               bool snapToPixelCenters);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const SkStrokeRec&,
+                                   bool snapToPixelCenters);
 }
 
 #endif
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index bf27f5a..8ab33f5 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -618,9 +618,9 @@
         SkScalar fSweepAngleRadians;
         bool fUseCenter;
     };
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, SkPoint center,
-                                          SkScalar radius, const GrStyle& style,
-                                          const ArcParams* arcParams = nullptr) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                              SkPoint center, SkScalar radius, const GrStyle& style,
+                                              const ArcParams* arcParams = nullptr) {
         SkASSERT(circle_stays_circle(viewMatrix));
         const SkStrokeRec& stroke = style.strokeRec();
         if (style.hasPathEffect()) {
@@ -1159,8 +1159,8 @@
 class EllipseOp : public GrMeshDrawOp {
 public:
     DEFINE_OP_CLASS_ID
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
-                                          const SkRect& ellipse, const SkStrokeRec& stroke) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                              const SkRect& ellipse, const SkStrokeRec& stroke) {
         SkASSERT(viewMatrix.rectStaysRect());
 
         // do any matrix crunching before we reset the draw state for device coords
@@ -1378,10 +1378,10 @@
 public:
     DEFINE_OP_CLASS_ID
 
-    static std::unique_ptr<GrDrawOp> Make(GrColor color,
-                                          const SkMatrix& viewMatrix,
-                                          const SkRect& ellipse,
-                                          const SkStrokeRec& stroke) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                              const SkMatrix& viewMatrix,
+                                              const SkRect& ellipse,
+                                              const SkStrokeRec& stroke) {
         SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
         SkScalar xRadius = SkScalarHalf(ellipse.width());
         SkScalar yRadius = SkScalarHalf(ellipse.height());
@@ -2068,9 +2068,10 @@
 
     // If devStrokeWidths values are <= 0 indicates then fill only. Otherwise, strokeOnly indicates
     // whether the rrect is only stroked or stroked and filled.
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
-                                          const SkRect& devRect, float devXRadius, float devYRadius,
-                                          SkVector devStrokeWidths, bool strokeOnly) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                              const SkRect& devRect, float devXRadius,
+                                              float devYRadius, SkVector devStrokeWidths,
+                                              bool strokeOnly) {
         SkASSERT(devXRadius > 0.5);
         SkASSERT(devYRadius > 0.5);
         SkASSERT((devStrokeWidths.fX > 0) == (devStrokeWidths.fY > 0));
@@ -2280,11 +2281,11 @@
     typedef GrMeshDrawOp INHERITED;
 };
 
-static std::unique_ptr<GrDrawOp> make_rrect_op(GrColor color,
-                                               bool needsDistance,
-                                               const SkMatrix& viewMatrix,
-                                               const SkRRect& rrect,
-                                               const SkStrokeRec& stroke) {
+static std::unique_ptr<GrMeshDrawOp> make_rrect_op(GrColor color,
+                                                   bool needsDistance,
+                                                   const SkMatrix& viewMatrix,
+                                                   const SkRRect& rrect,
+                                                   const SkStrokeRec& stroke) {
     SkASSERT(viewMatrix.rectStaysRect());
     SkASSERT(rrect.isSimple());
     SkASSERT(!rrect.isOval());
@@ -2342,7 +2343,7 @@
 
     // if the corners are circles, use the circle renderer
     if (isCircular) {
-        return std::unique_ptr<GrDrawOp>(new CircularRRectOp(
+        return std::unique_ptr<GrMeshDrawOp>(new CircularRRectOp(
                 color, needsDistance, viewMatrix, bounds, xRadius, scaledStroke.fX, isStrokeOnly));
         // otherwise we use the ellipse renderer
     } else {
@@ -2351,12 +2352,12 @@
     }
 }
 
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeRRectOp(GrColor color,
-                                                       bool needsDistance,
-                                                       const SkMatrix& viewMatrix,
-                                                       const SkRRect& rrect,
-                                                       const SkStrokeRec& stroke,
-                                                       const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> GrOvalOpFactory::MakeRRectOp(GrColor color,
+                                                           bool needsDistance,
+                                                           const SkMatrix& viewMatrix,
+                                                           const SkRRect& rrect,
+                                                           const SkStrokeRec& stroke,
+                                                           const GrShaderCaps* shaderCaps) {
     if (rrect.isOval()) {
         return MakeOvalOp(color, viewMatrix, rrect.getBounds(), stroke, shaderCaps);
     }
@@ -2370,11 +2371,11 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeOvalOp(GrColor color,
-                                                      const SkMatrix& viewMatrix,
-                                                      const SkRect& oval,
-                                                      const SkStrokeRec& stroke,
-                                                      const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> GrOvalOpFactory::MakeOvalOp(GrColor color,
+                                                          const SkMatrix& viewMatrix,
+                                                          const SkRect& oval,
+                                                          const SkStrokeRec& stroke,
+                                                          const GrShaderCaps* shaderCaps) {
     // we can draw circles
     SkScalar width = oval.width();
     if (SkScalarNearlyEqual(width, oval.height()) && circle_stays_circle(viewMatrix)) {
@@ -2397,11 +2398,11 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeArcOp(GrColor color, const SkMatrix& viewMatrix,
-                                                     const SkRect& oval, SkScalar startAngle,
-                                                     SkScalar sweepAngle, bool useCenter,
-                                                     const GrStyle& style,
-                                                     const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> GrOvalOpFactory::MakeArcOp(GrColor color, const SkMatrix& viewMatrix,
+                                                         const SkRect& oval, SkScalar startAngle,
+                                                         SkScalar sweepAngle, bool useCenter,
+                                                         const GrStyle& style,
+                                                         const GrShaderCaps* shaderCaps) {
     SkASSERT(!oval.isEmpty());
     SkASSERT(sweepAngle);
     SkScalar width = oval.width();
@@ -2444,8 +2445,8 @@
             arcParamsTmp.fUseCenter = random->nextBool();
             arcParams = &arcParamsTmp;
         }
-        std::unique_ptr<GrDrawOp> op = CircleOp::Make(color, viewMatrix, center, radius,
-                                                      GrStyle(stroke, nullptr), arcParams);
+        std::unique_ptr<GrMeshDrawOp> op = CircleOp::Make(color, viewMatrix, center, radius,
+                                                          GrStyle(stroke, nullptr), arcParams);
         if (op) {
             return op;
         }
diff --git a/src/gpu/ops/GrOvalOpFactory.h b/src/gpu/ops/GrOvalOpFactory.h
index 0ddcc9b..e6a160d 100644
--- a/src/gpu/ops/GrOvalOpFactory.h
+++ b/src/gpu/ops/GrOvalOpFactory.h
@@ -11,7 +11,7 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class GrShaderCaps;
 class GrStyle;
 class SkMatrix;
@@ -24,26 +24,26 @@
  */
 class GrOvalOpFactory {
 public:
-    static std::unique_ptr<GrDrawOp> MakeOvalOp(GrColor,
-                                                const SkMatrix& viewMatrix,
-                                                const SkRect& oval,
-                                                const SkStrokeRec& stroke,
-                                                const GrShaderCaps* shaderCaps);
-    static std::unique_ptr<GrDrawOp> MakeRRectOp(GrColor,
-                                                 bool needsDistance,
-                                                 const SkMatrix& viewMatrix,
-                                                 const SkRRect& rrect,
-                                                 const SkStrokeRec& stroke,
-                                                 const GrShaderCaps* shaderCaps);
+    static std::unique_ptr<GrMeshDrawOp> MakeOvalOp(GrColor,
+                                                    const SkMatrix& viewMatrix,
+                                                    const SkRect& oval,
+                                                    const SkStrokeRec& stroke,
+                                                    const GrShaderCaps* shaderCaps);
+    static std::unique_ptr<GrMeshDrawOp> MakeRRectOp(GrColor,
+                                                     bool needsDistance,
+                                                     const SkMatrix& viewMatrix,
+                                                     const SkRRect& rrect,
+                                                     const SkStrokeRec& stroke,
+                                                     const GrShaderCaps* shaderCaps);
 
-    static std::unique_ptr<GrDrawOp> MakeArcOp(GrColor,
-                                               const SkMatrix& viewMatrix,
-                                               const SkRect& oval,
-                                               SkScalar startAngle,
-                                               SkScalar sweepAngle,
-                                               bool useCenter,
-                                               const GrStyle&,
-                                               const GrShaderCaps* shaderCaps);
+    static std::unique_ptr<GrMeshDrawOp> MakeArcOp(GrColor,
+                                                   const SkMatrix& viewMatrix,
+                                                   const SkRect& oval,
+                                                   SkScalar startAngle,
+                                                   SkScalar sweepAngle,
+                                                   bool useCenter,
+                                                   const GrStyle&,
+                                                   const GrShaderCaps* shaderCaps);
 };
 
 #endif  // GrOvalOpFactory_DEFINED
diff --git a/src/gpu/ops/GrRectOpFactory.cpp b/src/gpu/ops/GrRectOpFactory.cpp
index 5c8d344..e6d0c1f 100644
--- a/src/gpu/ops/GrRectOpFactory.cpp
+++ b/src/gpu/ops/GrRectOpFactory.cpp
@@ -8,14 +8,14 @@
 #include "GrRectOpFactory.h"
 
 #include "GrAAStrokeRectOp.h"
-
+#include "GrMeshDrawOp.h"
 #include "SkStrokeRec.h"
 
 namespace GrRectOpFactory {
 
-std::unique_ptr<GrDrawOp> MakeAAFillNestedRects(GrColor color,
-                                                const SkMatrix& viewMatrix,
-                                                const SkRect rects[2]) {
+std::unique_ptr<GrMeshDrawOp> MakeAAFillNestedRects(GrColor color,
+                                                    const SkMatrix& viewMatrix,
+                                                    const SkRect rects[2]) {
     SkASSERT(viewMatrix.rectStaysRect());
     SkASSERT(!rects[0].isEmpty() && !rects[1].isEmpty());
 
diff --git a/src/gpu/ops/GrRectOpFactory.h b/src/gpu/ops/GrRectOpFactory.h
index 3f42008..19bce7f 100644
--- a/src/gpu/ops/GrRectOpFactory.h
+++ b/src/gpu/ops/GrRectOpFactory.h
@@ -12,12 +12,12 @@
 #include "GrAAStrokeRectOp.h"
 #include "GrAnalyticRectOp.h"
 #include "GrColor.h"
+#include "GrMeshDrawOp.h"
 #include "GrNonAAFillRectOp.h"
 #include "GrNonAAStrokeRectOp.h"
 #include "GrPaint.h"
 #include "SkMatrix.h"
 #include "SkRefCnt.h"
-#include "ops/GrDrawOp.h"
 
 struct SkRect;
 class SkStrokeRec;
@@ -27,11 +27,11 @@
  */
 namespace GrRectOpFactory {
 
-inline std::unique_ptr<GrDrawOp> MakeNonAAFill(GrColor color,
-                                               const SkMatrix& viewMatrix,
-                                               const SkRect& rect,
-                                               const SkRect* localRect,
-                                               const SkMatrix* localMatrix) {
+inline std::unique_ptr<GrMeshDrawOp> MakeNonAAFill(GrColor color,
+                                                   const SkMatrix& viewMatrix,
+                                                   const SkRect& rect,
+                                                   const SkRect* localRect,
+                                                   const SkMatrix* localMatrix) {
     if (viewMatrix.hasPerspective() || (localMatrix && localMatrix->hasPerspective())) {
         return GrNonAAFillRectOp::MakeWithPerspective(color, viewMatrix, rect, localRect,
                                                       localMatrix);
@@ -40,11 +40,11 @@
     }
 }
 
-inline std::unique_ptr<GrDrawOp> MakeAAFill(const GrPaint& paint,
-                                            const SkMatrix& viewMatrix,
-                                            const SkRect& rect,
-                                            const SkRect& croppedRect,
-                                            const SkRect& devRect) {
+inline std::unique_ptr<GrMeshDrawOp> MakeAAFill(const GrPaint& paint,
+                                                const SkMatrix& viewMatrix,
+                                                const SkRect& rect,
+                                                const SkRect& croppedRect,
+                                                const SkRect& devRect) {
     if (!paint.usesDistanceVectorField()) {
         return GrAAFillRectOp::Make(paint.getColor(), viewMatrix, croppedRect, devRect);
     } else {
@@ -52,32 +52,32 @@
     }
 }
 
-inline std::unique_ptr<GrDrawOp> MakeAAFill(GrColor color,
-                                            const SkMatrix& viewMatrix,
-                                            const SkMatrix& localMatrix,
-                                            const SkRect& rect,
-                                            const SkRect& devRect) {
+inline std::unique_ptr<GrMeshDrawOp> MakeAAFill(GrColor color,
+                                                const SkMatrix& viewMatrix,
+                                                const SkMatrix& localMatrix,
+                                                const SkRect& rect,
+                                                const SkRect& devRect) {
     return GrAAFillRectOp::Make(color, viewMatrix, localMatrix, rect, devRect);
 }
 
-inline std::unique_ptr<GrDrawOp> MakeNonAAStroke(GrColor color,
-                                                 const SkMatrix& viewMatrix,
-                                                 const SkRect& rect,
-                                                 const SkStrokeRec& strokeRec,
-                                                 bool snapToPixelCenters) {
+inline std::unique_ptr<GrMeshDrawOp> MakeNonAAStroke(GrColor color,
+                                                     const SkMatrix& viewMatrix,
+                                                     const SkRect& rect,
+                                                     const SkStrokeRec& strokeRec,
+                                                     bool snapToPixelCenters) {
     return GrNonAAStrokeRectOp::Make(color, viewMatrix, rect, strokeRec, snapToPixelCenters);
 }
 
-inline std::unique_ptr<GrDrawOp> MakeAAStroke(GrColor color,
-                                              const SkMatrix& viewMatrix,
-                                              const SkRect& rect,
-                                              const SkStrokeRec& stroke) {
+inline std::unique_ptr<GrMeshDrawOp> MakeAAStroke(GrColor color,
+                                                  const SkMatrix& viewMatrix,
+                                                  const SkRect& rect,
+                                                  const SkStrokeRec& stroke) {
     return GrAAStrokeRectOp::Make(color, viewMatrix, rect, stroke);
 }
 
 // First rect is outer; second rect is inner
-std::unique_ptr<GrDrawOp> MakeAAFillNestedRects(GrColor, const SkMatrix& viewMatrix,
-                                                const SkRect rects[2]);
+std::unique_ptr<GrMeshDrawOp> MakeAAFillNestedRects(GrColor, const SkMatrix& viewMatrix,
+                                                    const SkRect rects[2]);
 };
 
 #endif
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index e80a687..32cb8e4 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -149,7 +149,8 @@
 
 namespace GrRegionOp {
 
-std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, const SkRegion& region) {
-    return std::unique_ptr<GrDrawOp>(new RegionOp(color, viewMatrix, region));
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                   const SkRegion& region) {
+    return std::unique_ptr<GrMeshDrawOp>(new RegionOp(color, viewMatrix, region));
 }
 }
diff --git a/src/gpu/ops/GrRegionOp.h b/src/gpu/ops/GrRegionOp.h
index e4b8f3e..5ee6f35 100644
--- a/src/gpu/ops/GrRegionOp.h
+++ b/src/gpu/ops/GrRegionOp.h
@@ -11,12 +11,13 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class SkMatrix;
 class SkRegion;
 
 namespace GrRegionOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, const SkRegion& region);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                   const SkRegion& region);
 }
 
 #endif
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index 637c38a..1381bc9 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -67,9 +67,9 @@
 public:
     DEFINE_OP_CLASS_ID
 
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, SkPoint center,
-                                          SkScalar radius, SkScalar blurRadius,
-                                          const GrStyle& style) {
+    static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+                                              SkPoint center, SkScalar radius, SkScalar blurRadius,
+                                              const GrStyle& style) {
         SkASSERT(viewMatrix.isSimilarity());
         const SkStrokeRec& stroke = style.strokeRec();
         if (style.hasPathEffect()) {
@@ -806,12 +806,12 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-std::unique_ptr<GrDrawOp> make_shadow_circle_op(GrColor color,
-                                                const SkMatrix& viewMatrix,
-                                                const SkRect& oval,
-                                                SkScalar blurRadius,
-                                                const SkStrokeRec& stroke,
-                                                const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> make_shadow_circle_op(GrColor color,
+                                                    const SkMatrix& viewMatrix,
+                                                    const SkRect& oval,
+                                                    SkScalar blurRadius,
+                                                    const SkStrokeRec& stroke,
+                                                    const GrShaderCaps* shaderCaps) {
     // we can only draw circles
     SkScalar width = oval.width();
     SkASSERT(SkScalarNearlyEqual(width, oval.height()) && viewMatrix.isSimilarity());
@@ -820,11 +820,11 @@
                                 GrStyle(stroke, nullptr));
 }
 
-static std::unique_ptr<GrDrawOp> make_shadow_rrect_op(GrColor color,
-                                                      const SkMatrix& viewMatrix,
-                                                      const SkRRect& rrect,
-                                                      SkScalar blurRadius,
-                                                      const SkStrokeRec& stroke) {
+static std::unique_ptr<GrMeshDrawOp> make_shadow_rrect_op(GrColor color,
+                                                          const SkMatrix& viewMatrix,
+                                                          const SkRRect& rrect,
+                                                          SkScalar blurRadius,
+                                                          const SkStrokeRec& stroke) {
     SkASSERT(viewMatrix.rectStaysRect());
     SkASSERT(rrect.isSimple());
     SkASSERT(!rrect.isOval());
@@ -877,17 +877,17 @@
         return nullptr;
     }
 
-    return std::unique_ptr<GrDrawOp>(new ShadowCircularRRectOp(
+    return std::unique_ptr<GrMeshDrawOp>(new ShadowCircularRRectOp(
             color, viewMatrix, bounds, xRadius, blurRadius, scaledStroke.fX, isStrokeOnly));
 }
 
 namespace GrShadowRRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
-                               const SkMatrix& viewMatrix,
-                               const SkRRect& rrect,
-                               const SkScalar blurRadius,
-                               const SkStrokeRec& stroke,
-                               const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRRect& rrect,
+                                   const SkScalar blurRadius,
+                                   const SkStrokeRec& stroke,
+                                   const GrShaderCaps* shaderCaps) {
     if (rrect.isOval()) {
         return make_shadow_circle_op(color, viewMatrix, rrect.getBounds(), blurRadius, stroke,
                                      shaderCaps);
@@ -920,8 +920,8 @@
         SkScalar radius = circle.width() / 2.f;
         SkStrokeRec stroke = GrTest::TestStrokeRec(random);
         SkScalar blurRadius = random->nextSScalar1() * 72.f;
-        std::unique_ptr<GrDrawOp> op = ShadowCircleOp::Make(color, viewMatrix, center, radius,
-                                                            blurRadius, GrStyle(stroke, nullptr));
+        std::unique_ptr<GrMeshDrawOp> op = ShadowCircleOp::Make(
+                color, viewMatrix, center, radius, blurRadius, GrStyle(stroke, nullptr));
         if (op) {
             return op;
         }
diff --git a/src/gpu/ops/GrShadowRRectOp.h b/src/gpu/ops/GrShadowRRectOp.h
index 50e0102..081b217 100644
--- a/src/gpu/ops/GrShadowRRectOp.h
+++ b/src/gpu/ops/GrShadowRRectOp.h
@@ -11,7 +11,7 @@
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
-class GrDrawOp;
+class GrMeshDrawOp;
 class GrShaderCaps;
 class SkMatrix;
 class SkRRect;
@@ -19,9 +19,9 @@
 
 namespace GrShadowRRectOp {
 
-std::unique_ptr<GrDrawOp> Make(GrColor, const SkMatrix& viewMatrix, const SkRRect& rrect,
-                               const SkScalar blurRadius, const SkStrokeRec& stroke,
-                               const GrShaderCaps* shaderCaps);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor, const SkMatrix& viewMatrix, const SkRRect& rrect,
+                                   const SkScalar blurRadius, const SkStrokeRec& stroke,
+                                   const GrShaderCaps* shaderCaps);
 }
 
 #endif
diff --git a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
index 77d8d23..3b38163 100644
--- a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
@@ -112,7 +112,7 @@
         }
         const SkMatrix& viewM = viewMatrix.hasPerspective() ? SkMatrix::I() : viewMatrix;
 
-        std::unique_ptr<GrDrawOp> coverOp(GrRectOpFactory::MakeNonAAFill(
+        std::unique_ptr<GrMeshDrawOp> coverOp(GrRectOpFactory::MakeNonAAFill(
                 args.fPaint.getColor(), viewM, bounds, nullptr, &invert));
 
         // fake inverse with a stencil and cover
@@ -141,7 +141,8 @@
             GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), coverAAType);
             pipelineBuilder.setUserStencil(&kInvertedCoverPass);
 
-            args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(coverOp));
+            args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip,
+                                                     std::move(coverOp));
         }
     } else {
         static constexpr GrUserStencilSettings kCoverPass(
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index 7ecaf28..d1fd28a 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -160,12 +160,12 @@
 public:
     DEFINE_OP_CLASS_ID
 
-    static std::unique_ptr<GrDrawOp> Make(const GrColor& color,
-                                          const GrShape& shape,
-                                          const SkMatrix& viewMatrix,
-                                          SkIRect devClipBounds,
-                                          bool antiAlias) {
-        return std::unique_ptr<GrDrawOp>(
+    static std::unique_ptr<GrMeshDrawOp> Make(const GrColor& color,
+                                              const GrShape& shape,
+                                              const SkMatrix& viewMatrix,
+                                              SkIRect devClipBounds,
+                                              bool antiAlias) {
+        return std::unique_ptr<GrMeshDrawOp>(
                 new TessellatingPathOp(color, shape, viewMatrix, devClipBounds, antiAlias));
     }
 
@@ -357,14 +357,15 @@
     args.fClip->getConservativeBounds(args.fRenderTargetContext->width(),
                                       args.fRenderTargetContext->height(),
                                       &clipBoundsI);
-    std::unique_ptr<GrDrawOp> op = TessellatingPathOp::Make(args.fPaint.getColor(),
-                                                            *args.fShape,
-                                                            *args.fViewMatrix,
-                                                            clipBoundsI,
-                                                            GrAAType::kCoverage == args.fAAType);
+    std::unique_ptr<GrMeshDrawOp> op =
+            TessellatingPathOp::Make(args.fPaint.getColor(),
+                                     *args.fShape,
+                                     *args.fViewMatrix,
+                                     clipBoundsI,
+                                     GrAAType::kCoverage == args.fAAType);
     GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
-    args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+    args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
     return true;
 }
 
diff --git a/src/gpu/text/GrAtlasTextBlob.cpp b/src/gpu/text/GrAtlasTextBlob.cpp
index 601eb37..accdf6b 100644
--- a/src/gpu/text/GrAtlasTextBlob.cpp
+++ b/src/gpu/text/GrAtlasTextBlob.cpp
@@ -256,7 +256,7 @@
     return false;
 }
 
-inline std::unique_ptr<GrDrawOp> GrAtlasTextBlob::makeOp(
+inline std::unique_ptr<GrMeshDrawOp> GrAtlasTextBlob::makeOp(
         const Run::SubRunInfo& info, int glyphCount, int run, int subRun,
         const SkMatrix& viewMatrix, SkScalar x, SkScalar y, const GrTextUtils::Paint& paint,
         const SkSurfaceProps& props, const GrDistanceFieldAdjustTable* distanceAdjustTable,
@@ -304,12 +304,12 @@
             continue;
         }
 
-        std::unique_ptr<GrDrawOp> op(this->makeOp(info, glyphCount, run, subRun, viewMatrix, x, y,
-                                                  paint, props, distanceAdjustTable,
-                                                  rtc->isGammaCorrect(), cache));
+        std::unique_ptr<GrMeshDrawOp> op(this->makeOp(info, glyphCount, run, subRun, viewMatrix, x,
+                                                      y, paint, props, distanceAdjustTable,
+                                                      rtc->isGammaCorrect(), cache));
         GrPipelineBuilder pipelineBuilder(std::move(grPaint), GrAAType::kNone);
 
-        rtc->addDrawOp(pipelineBuilder, clip, std::move(op));
+        rtc->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
     }
 }
 
@@ -424,7 +424,7 @@
     this->flushBigGlyphs(context, rtc, clip, paint, viewMatrix, x, y, clipBounds);
 }
 
-std::unique_ptr<GrDrawOp> GrAtlasTextBlob::test_makeOp(
+std::unique_ptr<GrMeshDrawOp> GrAtlasTextBlob::test_makeOp(
         int glyphCount, int run, int subRun, const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
         const GrTextUtils::Paint& paint, const SkSurfaceProps& props,
         const GrDistanceFieldAdjustTable* distanceAdjustTable, GrAtlasGlyphCache* cache) {
diff --git a/src/gpu/text/GrAtlasTextBlob.h b/src/gpu/text/GrAtlasTextBlob.h
index 787518d..7d686a9 100644
--- a/src/gpu/text/GrAtlasTextBlob.h
+++ b/src/gpu/text/GrAtlasTextBlob.h
@@ -24,6 +24,7 @@
 class GrBlobRegenHelper;
 struct GrDistanceFieldAdjustTable;
 class GrMemoryPool;
+class GrMeshDrawOp;
 class SkDrawFilter;
 class SkTextBlob;
 class SkTextBlobRunIterator;
@@ -269,12 +270,12 @@
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Internal test methods
-    std::unique_ptr<GrDrawOp> test_makeOp(int glyphCount, int run, int subRun,
-                                          const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
-                                          const GrTextUtils::Paint& paint,
-                                          const SkSurfaceProps& props,
-                                          const GrDistanceFieldAdjustTable* distanceAdjustTable,
-                                          GrAtlasGlyphCache* cache);
+    std::unique_ptr<GrMeshDrawOp> test_makeOp(int glyphCount, int run, int subRun,
+                                              const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
+                                              const GrTextUtils::Paint& paint,
+                                              const SkSurfaceProps& props,
+                                              const GrDistanceFieldAdjustTable* distanceAdjustTable,
+                                              GrAtlasGlyphCache* cache);
 
 private:
     GrAtlasTextBlob()
@@ -488,13 +489,11 @@
                    Run* run, Run::SubRunInfo* info, SkAutoGlyphCache*, int glyphCount,
                    size_t vertexStride, GrColor color, SkScalar transX, SkScalar transY) const;
 
-    inline std::unique_ptr<GrDrawOp> makeOp(const Run::SubRunInfo& info, int glyphCount, int run,
-                                            int subRun, const SkMatrix& viewMatrix, SkScalar x,
-                                            SkScalar y, const GrTextUtils::Paint& paint,
-                                            const SkSurfaceProps& props,
-                                            const GrDistanceFieldAdjustTable* distanceAdjustTable,
-                                            bool useGammaCorrectDistanceTable,
-                                            GrAtlasGlyphCache* cache);
+    inline std::unique_ptr<GrMeshDrawOp> makeOp(
+            const Run::SubRunInfo& info, int glyphCount, int run, int subRun,
+            const SkMatrix& viewMatrix, SkScalar x, SkScalar y, const GrTextUtils::Paint& paint,
+            const SkSurfaceProps& props, const GrDistanceFieldAdjustTable* distanceAdjustTable,
+            bool useGammaCorrectDistanceTable, GrAtlasGlyphCache* cache);
 
     struct BigGlyph {
         BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy, SkScalar scale, bool treatAsBMP)
diff --git a/src/gpu/text/GrAtlasTextContext.cpp b/src/gpu/text/GrAtlasTextContext.cpp
index 512df0a..e15281e 100644
--- a/src/gpu/text/GrAtlasTextContext.cpp
+++ b/src/gpu/text/GrAtlasTextContext.cpp
@@ -5,13 +5,13 @@
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
-
 #include "GrContext.h"
 #include "GrRenderTargetContext.h"
 #include "GrTextBlobCache.h"
 #include "SkDraw.h"
 #include "SkDrawFilter.h"
 #include "SkGr.h"
+#include "ops/GrMeshDrawOp.h"
 
 GrAtlasTextContext::GrAtlasTextContext()
     : fDistanceAdjustTable(new GrDistanceFieldAdjustTable) {