Include non-legacy GrMeshDrawOps in GLPrograms test.

Bug: skia:
Change-Id: Ifa0c3ffb5643c84ccdcb339fae75ea5d03a8451c
Reviewed-on: https://skia-review.googlesource.com/16580
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

22 files changed, 196 insertions, 141 deletions

diff --git a/src/gpu/GrDrawOpTest.cpp b/src/gpu/GrDrawOpTest.cpp
index 1e88c219f5..7aba424b3d 100644
--- a/src/gpu/GrDrawOpTest.cpp
+++ b/src/gpu/GrDrawOpTest.cpp
@@ -6,63 +6,53 @@
  */
 
 #include "GrDrawOpTest.h"
+#include "GrCaps.h"
+#include "GrContext.h"
+#include "GrUserStencilSettings.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<GrLegacyMeshDrawOp> Op##__Test(SkRandom*, GrContext* context);
+const GrUserStencilSettings* GrGetRandomStencil(SkRandom* random, GrContext* context) {
+    if (context->caps()->avoidStencilBuffers()) {
+        return &GrUserStencilSettings::kUnused;
+    }
+    static constexpr GrUserStencilSettings kReads(
+        GrUserStencilSettings::StaticInit<
+            0x8080,
+            GrUserStencilTest::kLess,
+            0xffff,
+            GrUserStencilOp::kKeep,
+            GrUserStencilOp::kKeep,
+            0xffff>()
+    );
+    static constexpr GrUserStencilSettings kWrites(
+        GrUserStencilSettings::StaticInit<
+            0xffff,
+            GrUserStencilTest::kAlways,
+            0xffff,
+            GrUserStencilOp::kReplace,
+            GrUserStencilOp::kReplace,
+            0xffff>()
+    );
+    static constexpr GrUserStencilSettings kReadsAndWrites(
+        GrUserStencilSettings::StaticInit<
+            0x8000,
+            GrUserStencilTest::kEqual,
+            0x6000,
+            GrUserStencilOp::kIncWrap,
+            GrUserStencilOp::kInvert,
+            0x77ff>()
+    );
 
-#define DRAW_OP_TEST_ENTRY(Op) Op##__Test
-
-DRAW_OP_TEST_EXTERN(AAConvexPathOp);
-DRAW_OP_TEST_EXTERN(AAFillRectOp);
-DRAW_OP_TEST_EXTERN(AAFillRectOpLocalMatrix);
-DRAW_OP_TEST_EXTERN(AAFlatteningConvexPathOp)
-DRAW_OP_TEST_EXTERN(AAHairlineOp);
-DRAW_OP_TEST_EXTERN(AAStrokeRectOp);
-DRAW_OP_TEST_EXTERN(AnalyticRectOp);
-DRAW_OP_TEST_EXTERN(DashOp);
-DRAW_OP_TEST_EXTERN(DefaultPathOp);
-DRAW_OP_TEST_EXTERN(CircleOp);
-DRAW_OP_TEST_EXTERN(DIEllipseOp);
-DRAW_OP_TEST_EXTERN(EllipseOp);
-DRAW_OP_TEST_EXTERN(GrDrawAtlasOp);
-DRAW_OP_TEST_EXTERN(NonAAStrokeRectOp);
-DRAW_OP_TEST_EXTERN(RRectOp);
-DRAW_OP_TEST_EXTERN(SmallPathOp);
-DRAW_OP_TEST_EXTERN(TesselatingPathOp);
-DRAW_OP_TEST_EXTERN(TextBlobOp);
-DRAW_OP_TEST_EXTERN(VerticesOp);
-
-std::unique_ptr<GrLegacyMeshDrawOp> GrRandomDrawOp(SkRandom* random, GrContext* context) {
-    using MakeTestDrawOpFn =
-            std::unique_ptr<GrLegacyMeshDrawOp>(SkRandom * random, GrContext * context);
-    static constexpr MakeTestDrawOpFn* gFactories[] = {
-        DRAW_OP_TEST_ENTRY(AAConvexPathOp),
-        DRAW_OP_TEST_ENTRY(AAFillRectOp),
-        DRAW_OP_TEST_ENTRY(AAFillRectOpLocalMatrix),
-        DRAW_OP_TEST_ENTRY(AAFlatteningConvexPathOp),
-        DRAW_OP_TEST_ENTRY(AAHairlineOp),
-        DRAW_OP_TEST_ENTRY(AAStrokeRectOp),
-        DRAW_OP_TEST_ENTRY(AnalyticRectOp),
-        DRAW_OP_TEST_ENTRY(DashOp),
-        DRAW_OP_TEST_ENTRY(DefaultPathOp),
-        DRAW_OP_TEST_ENTRY(CircleOp),
-        DRAW_OP_TEST_ENTRY(DIEllipseOp),
-        DRAW_OP_TEST_ENTRY(EllipseOp),
-        DRAW_OP_TEST_ENTRY(GrDrawAtlasOp),
-        DRAW_OP_TEST_ENTRY(NonAAStrokeRectOp),
-        DRAW_OP_TEST_ENTRY(RRectOp),
-        DRAW_OP_TEST_ENTRY(SmallPathOp),
-        DRAW_OP_TEST_ENTRY(TesselatingPathOp),
-        DRAW_OP_TEST_ENTRY(TextBlobOp),
-        DRAW_OP_TEST_ENTRY(VerticesOp)
+    static const GrUserStencilSettings* kStencilSettings[] = {
+            &GrUserStencilSettings::kUnused,
+            &kReads,
+            &kWrites,
+            &kReadsAndWrites,
     };
-
-    uint32_t index = random->nextULessThan(static_cast<uint32_t>(SK_ARRAY_COUNT(gFactories)));
-    return gFactories[index](random, context);
+    return kStencilSettings[random->nextULessThan(SK_ARRAY_COUNT(kStencilSettings))];
 }
+
 #endif
diff --git a/src/gpu/GrDrawOpTest.h b/src/gpu/GrDrawOpTest.h
index 376022999b..a30ca2801f 100644
--- a/src/gpu/GrDrawOpTest.h
+++ b/src/gpu/GrDrawOpTest.h
@@ -13,20 +13,29 @@
 
 #if GR_TEST_UTILS
 
-class GrContext;
+class GrDrawOp;
 class GrLegacyMeshDrawOp;
+class GrPaint;
+class GrRenderTargetContext;
+struct GrUserStencilSettings;
 class SkRandom;
 
-/**  This function returns a randomly configured GrDrawOp for testing purposes. */
-std::unique_ptr<GrLegacyMeshDrawOp> GrRandomDrawOp(SkRandom*, GrContext*);
+/**  This function draws a randomly configured GrDrawOp for testing purposes. */
+void GrDrawRandomOp(SkRandom*, GrRenderTargetContext*, GrPaint&&);
 
 /** GrDrawOp subclasses should define test factory functions using this macro. */
-#define DRAW_OP_TEST_DEFINE(Op) \
-    std::unique_ptr<GrLegacyMeshDrawOp> Op##__Test(SkRandom* random, GrContext* context)
+#define GR_DRAW_OP_TEST_DEFINE(Op)                                                              \
+    std::unique_ptr<GrDrawOp> Op##__Test(GrPaint&& paint, SkRandom* random, GrContext* context, \
+                                         GrFSAAType fsaaType)
 
-/** This macro may be used if the test factory function must be made a friend of a class. */
-#define DRAW_OP_TEST_FRIEND(Op) \
+/** Variations for GrLegacyMeshDrawOps. To be deleted. */
+#define GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(Op) \
+    std::unique_ptr<GrLegacyMeshDrawOp> Op##__Test(SkRandom* random, GrContext* context)
+#define GR_LEGACY_MESH_DRAW_OP_TEST_FRIEND(Op) \
     friend std::unique_ptr<GrLegacyMeshDrawOp> Op##__Test(SkRandom* random, GrContext* context);
 
+/** Helper for op test factories to pick a random stencil state. */
+const GrUserStencilSettings* GrGetRandomStencil(SkRandom* random, GrContext*);
+
 #endif
 #endif
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 47132595e9..a06de2789a 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -992,7 +992,7 @@ bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(AAConvexPathOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAConvexPathOp) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkPath path = GrTest::TestPathConvex(random);
diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp
index ca91e94cd5..ea85b4eb01 100644
--- a/src/gpu/ops/GrAAFillRectOp.cpp
+++ b/src/gpu/ops/GrAAFillRectOp.cpp
@@ -389,7 +389,7 @@ std::unique_ptr<GrLegacyMeshDrawOp> MakeWithLocalRect(GrColor color,
 
 #include "GrDrawOpTest.h"
 
-DRAW_OP_TEST_DEFINE(AAFillRectOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAFillRectOp) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkRect rect = GrTest::TestRect(random);
@@ -397,7 +397,7 @@ DRAW_OP_TEST_DEFINE(AAFillRectOp) {
     return GrAAFillRectOp::Make(color, viewMatrix, rect, devRect);
 }
 
-DRAW_OP_TEST_DEFINE(AAFillRectOpLocalMatrix) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAFillRectOpLocalMatrix) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkMatrix localMatrix = GrTest::TestMatrix(random);
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index 91e8c368a6..755a9f6ff6 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -974,7 +974,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(AAHairlineOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAHairlineOp) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     SkPath path = GrTest::TestPath(random);
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index ad18518656..af632f76ab 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -356,7 +356,7 @@ bool GrAALinearizingConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(AAFlatteningConvexPathOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAFlatteningConvexPathOp) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixPreservesRightAngles(random);
     SkPath path = GrTest::TestPathConvex(random);
diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp
index cf16d1bea4..dc13ba14dc 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrAAStrokeRectOp.cpp
@@ -593,7 +593,7 @@ std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
 
 #include "GrDrawOpTest.h"
 
-DRAW_OP_TEST_DEFINE(AAStrokeRectOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAStrokeRectOp) {
     bool miterStroke = random->nextBool();
 
     // Create either a empty rect or a non-empty rect.
diff --git a/src/gpu/ops/GrAnalyticRectOp.cpp b/src/gpu/ops/GrAnalyticRectOp.cpp
index 6a9daf305a..358b5622e3 100644
--- a/src/gpu/ops/GrAnalyticRectOp.cpp
+++ b/src/gpu/ops/GrAnalyticRectOp.cpp
@@ -389,7 +389,7 @@ std::unique_ptr<GrLegacyMeshDrawOp> GrAnalyticRectOp::Make(GrColor color,
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(AnalyticRectOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AnalyticRectOp) {
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
     SkRect rect = GrTest::TestSquare(random);
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 01ae34b98c..dda9fa21c0 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -1195,7 +1195,7 @@ static sk_sp<GrGeometryProcessor> make_dash_gp(GrColor color,
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(DashOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(DashOp) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixPreservesRightAngles(random);
     AAMode aaMode = static_cast<AAMode>(random->nextULessThan(GrDashOp::kAAModeCnt));
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index c683c33cf4..4193a39291 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -586,7 +586,7 @@ void GrDefaultPathRenderer::onStencilPath(const StencilPathArgs& args) {
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(DefaultPathOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(DefaultPathOp) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
 
diff --git a/src/gpu/ops/GrDrawAtlasOp.cpp b/src/gpu/ops/GrDrawAtlasOp.cpp
index 4b3d0d3e48..1c7251a0bb 100644
--- a/src/gpu/ops/GrDrawAtlasOp.cpp
+++ b/src/gpu/ops/GrDrawAtlasOp.cpp
@@ -222,7 +222,7 @@ static void randomize_params(uint32_t count, SkRandom* random, SkTArray<SkRSXfor
     }
 }
 
-DRAW_OP_TEST_DEFINE(GrDrawAtlasOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(GrDrawAtlasOp) {
     uint32_t spriteCount = random->nextRangeU(1, 100);
 
     SkTArray<SkRSXform> xforms(spriteCount);
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index aa90db9afd..4921b42c78 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -358,7 +358,7 @@ static void randomize_params(size_t count, size_t maxVertex, SkScalar min, SkSca
     }
 }
 
-DRAW_OP_TEST_DEFINE(VerticesOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(VerticesOp) {
     GrPrimitiveType type = GrPrimitiveType(random->nextULessThan(kLast_GrPrimitiveType + 1));
     uint32_t primitiveCount = random->nextRangeU(1, 100);
 
diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp
index 384856aec7..2962e93cd4 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectOp.cpp
@@ -9,6 +9,7 @@
 #include "GrAppliedClip.h"
 #include "GrColor.h"
 #include "GrDefaultGeoProcFactory.h"
+#include "GrDrawOpTest.h"
 #include "GrMeshDrawOp.h"
 #include "GrOpFlushState.h"
 #include "GrPrimitiveProcessor.h"
@@ -377,3 +378,20 @@ std::unique_ptr<GrDrawOp> Make(GrPaint&& paint,
 };  // namespace GrNonAAFillRectOp
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+
+GR_DRAW_OP_TEST_DEFINE(NonAAFillRectOp) {
+    SkRect rect = GrTest::TestRect(random);
+    SkRect localRect = GrTest::TestRect(random);
+    SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
+    SkMatrix localMatrix = GrTest::TestMatrix(random);
+    bool hasLocalRect = random->nextBool();
+    bool hasLocalMatrix = random->nextBool();
+    const GrUserStencilSettings* stencil = GrGetRandomStencil(random, context);
+    GrAAType aaType = GrAAType::kNone;
+    if (fsaaType == GrFSAAType::kUnifiedMSAA) {
+        aaType = random->nextBool() ? GrAAType::kMSAA : GrAAType::kNone;
+    }
+    return GrNonAAFillRectOp::Make(std::move(paint), viewMatrix, rect,
+                                   hasLocalRect ? &localRect : nullptr,
+                                   hasLocalMatrix ? &localMatrix : nullptr, aaType, stencil);
+}
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
index c40364dcb1..09eaa97e25 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
@@ -200,7 +200,7 @@ std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(NonAAStrokeRectOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(NonAAStrokeRectOp) {
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
     SkRect rect = GrTest::TestRect(random);
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index 4d44b13949..f5cc2ec7f2 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -2438,7 +2438,7 @@ std::unique_ptr<GrLegacyMeshDrawOp> GrOvalOpFactory::MakeArcOp(
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(CircleOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(CircleOp) {
     do {
         SkScalar rotate = random->nextSScalar1() * 360.f;
         SkScalar translateX = random->nextSScalar1() * 1000.f;
@@ -2469,21 +2469,21 @@ DRAW_OP_TEST_DEFINE(CircleOp) {
     } while (true);
 }
 
-DRAW_OP_TEST_DEFINE(EllipseOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(EllipseOp) {
     SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
     GrColor color = GrRandomColor(random);
     SkRect ellipse = GrTest::TestSquare(random);
     return EllipseOp::Make(color, viewMatrix, ellipse, GrTest::TestStrokeRec(random));
 }
 
-DRAW_OP_TEST_DEFINE(DIEllipseOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(DIEllipseOp) {
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
     SkRect ellipse = GrTest::TestSquare(random);
     return DIEllipseOp::Make(color, viewMatrix, ellipse, GrTest::TestStrokeRec(random));
 }
 
-DRAW_OP_TEST_DEFINE(RRectOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(RRectOp) {
     SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
     GrColor color = GrRandomColor(random);
     const SkRRect& rrect = GrTest::TestRRectSimple(random);
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index 43c8839c5a..69e33c7905 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -702,7 +702,7 @@ std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(ShadowRRectOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(ShadowRRectOp) {
     // create a similarity matrix
     SkScalar rotate = random->nextSScalar1() * 360.f;
     SkScalar translateX = random->nextSScalar1() * 1000.f;
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 7b937e58c6..212605c93e 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -823,7 +823,7 @@ struct PathTestStruct {
     ShapeDataList fShapeList;
 };
 
-DRAW_OP_TEST_DEFINE(SmallPathOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(SmallPathOp) {
     static PathTestStruct gTestStruct;
 
     if (context->uniqueID() != gTestStruct.fContextID) {
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index 96c91247d5..2a8714f3bb 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -381,7 +381,7 @@ bool GrTessellatingPathRenderer::onDrawPath(const DrawPathArgs& args) {
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(TesselatingPathOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(TesselatingPathOp) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkPath path = GrTest::TestPath(random);
diff --git a/src/gpu/text/GrAtlasTextContext.cpp b/src/gpu/text/GrAtlasTextContext.cpp
index abe8d24d07..9efe4665c5 100644
--- a/src/gpu/text/GrAtlasTextContext.cpp
+++ b/src/gpu/text/GrAtlasTextContext.cpp
@@ -339,7 +339,7 @@ void GrAtlasTextContext::drawPosText(GrContext* context, GrRenderTargetContext*
 
 #if GR_TEST_UTILS
 
-DRAW_OP_TEST_DEFINE(TextBlobOp) {
+GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(TextBlobOp) {
     static uint32_t gContextID = SK_InvalidGenID;
     static GrAtlasTextContext* gTextContext = nullptr;
     static SkSurfaceProps gSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
diff --git a/src/gpu/text/GrAtlasTextContext.h b/src/gpu/text/GrAtlasTextContext.h
index 7438b647b2..e375195cde 100644
--- a/src/gpu/text/GrAtlasTextContext.h
+++ b/src/gpu/text/GrAtlasTextContext.h
@@ -89,7 +89,7 @@ private:
 #if GR_TEST_UTILS
     static const uint32_t kTextBlobOpScalerContextFlags =
             SkPaint::kFakeGammaAndBoostContrast_ScalerContextFlags;
-    DRAW_OP_TEST_FRIEND(TextBlobOp);
+    GR_LEGACY_MESH_DRAW_OP_TEST_FRIEND(TextBlobOp);
 #endif
 };
 
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 3cf28daad2..86b7469179 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -240,47 +240,15 @@ static void set_random_color_coverage_stages(GrPaint* paint,
     }
 }
 
-static bool set_random_state(GrPaint* paint, SkRandom* random) {
+static void set_random_state(GrPaint* paint, SkRandom* random) {
     if (random->nextBool()) {
         paint->setDisableOutputConversionToSRGB(true);
     }
     if (random->nextBool()) {
         paint->setAllowSRGBInputs(true);
     }
-    return random->nextBool();
 }
 
-// right now, the only thing we seem to care about in drawState's stencil is 'doesWrite()'
-static const GrUserStencilSettings* get_random_stencil(SkRandom* random, GrContext* context) {
-    if (context->caps()->avoidStencilBuffers()) {
-        return &GrUserStencilSettings::kUnused;
-    }
-
-    static constexpr GrUserStencilSettings kDoesWriteStencil(
-        GrUserStencilSettings::StaticInit<
-            0xffff,
-            GrUserStencilTest::kAlways,
-            0xffff,
-            GrUserStencilOp::kReplace,
-            GrUserStencilOp::kReplace,
-            0xffff>()
-    );
-    static constexpr GrUserStencilSettings kDoesNotWriteStencil(
-        GrUserStencilSettings::StaticInit<
-            0xffff,
-            GrUserStencilTest::kNever,
-            0xffff,
-            GrUserStencilOp::kKeep,
-            GrUserStencilOp::kKeep,
-            0xffff>()
-    );
-
-    if (random->nextBool()) {
-        return &kDoesWriteStencil;
-    } else {
-        return &kDoesNotWriteStencil;
-    }
-}
 #endif
 
 #if !GR_TEST_UTILS
@@ -327,23 +295,12 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
             return false;
         }
 
-        GrPaint grPaint;
-
-        std::unique_ptr<GrLegacyMeshDrawOp> op(GrRandomDrawOp(&random, context));
-        SkASSERT(op);
-
+        GrPaint paint;
         GrProcessorTestData ptd(&random, context, renderTargetContext.get(), proxies);
-        set_random_color_coverage_stages(&grPaint, &ptd, maxStages);
-        set_random_xpf(&grPaint, &ptd);
-        bool snapToCenters = set_random_state(&grPaint, &random);
-        const GrUserStencilSettings* uss = get_random_stencil(&random, context);
-        // We don't use kHW because we will hit an assertion if the render target is not
-        // multisampled
-        static constexpr GrAAType kAATypes[] = {GrAAType::kNone, GrAAType::kCoverage};
-        GrAAType aaType = kAATypes[random.nextULessThan(SK_ARRAY_COUNT(kAATypes))];
-
-        renderTargetContext->priv().testingOnly_addLegacyMeshDrawOp(
-                std::move(grPaint), aaType, std::move(op), uss, snapToCenters);
+        set_random_color_coverage_stages(&paint, &ptd, maxStages);
+        set_random_xpf(&paint, &ptd);
+        set_random_state(&paint, &random);
+        GrDrawRandomOp(&random, renderTargetContext.get(), std::move(paint));
     }
     // Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes)
     drawingManager->flush(nullptr);
@@ -364,20 +321,16 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
     for (int i = 0; i < fpFactoryCnt; ++i) {
         // Since FP factories internally randomize, call each 10 times.
         for (int j = 0; j < 10; ++j) {
-            std::unique_ptr<GrLegacyMeshDrawOp> op(GrRandomDrawOp(&random, context));
-            SkASSERT(op);
             GrProcessorTestData ptd(&random, context, renderTargetContext.get(), proxies);
-            GrPaint grPaint;
-            grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
 
+            GrPaint paint;
+            paint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
             sk_sp<GrFragmentProcessor> fp(
                 GrProcessorTestFactory<GrFragmentProcessor>::MakeIdx(i, &ptd));
             sk_sp<GrFragmentProcessor> blockFP(
                 BlockInputFragmentProcessor::Make(std::move(fp)));
-            grPaint.addColorFragmentProcessor(std::move(blockFP));
-
-            renderTargetContext->priv().testingOnly_addLegacyMeshDrawOp(
-                    std::move(grPaint), GrAAType::kNone, std::move(op));
+            paint.addColorFragmentProcessor(std::move(blockFP));
+            GrDrawRandomOp(&random, renderTargetContext.get(), std::move(paint));
             drawingManager->flush(nullptr);
         }
     }
diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp
index 73ceab435c..78b0d2078d 100644
--- a/tools/gpu/GrTest.cpp
+++ b/tools/gpu/GrTest.cpp
@@ -6,7 +6,7 @@
  */
 
 #include "GrTest.h"
-
+#include <algorithm>
 #include "GrBackendSurface.h"
 #include "GrContextOptions.h"
 #include "GrContextPriv.h"
@@ -14,21 +14,20 @@
 #include "GrDrawingManager.h"
 #include "GrGpuResourceCacheAccess.h"
 #include "GrPipelineBuilder.h"
+#include "GrRenderTargetContext.h"
 #include "GrRenderTargetContextPriv.h"
 #include "GrRenderTargetProxy.h"
 #include "GrResourceCache.h"
 #include "GrSemaphore.h"
-
+#include "GrSurfaceContextPriv.h"
 #include "SkGr.h"
 #include "SkImage_Gpu.h"
 #include "SkMathPriv.h"
 #include "SkString.h"
-
+#include "ops/GrMeshDrawOp.h"
 #include "text/GrAtlasGlyphCache.h"
 #include "text/GrTextBlobCache.h"
 
-#include <algorithm>
-
 namespace GrTest {
 void SetupAlwaysEvictAtlas(GrContext* context) {
     // These sizes were selected because they allow each atlas to hold a single plot and will thus
@@ -453,6 +452,8 @@ void GrContext::initMockContext() {
     fDrawingManager->abandon();
 }
 
+//////////////////////////////////////////////////////////////////////////////
+
 void GrContextPriv::testingOnly_flushAndRemoveOnFlushCallbackObject(GrOnFlushCallbackObject* cb) {
     fContext->flush();
     fContext->fDrawingManager->testingOnly_removeOnFlushCallbackObject(cb);
@@ -464,3 +465,87 @@ void GrDrawingManager::testingOnly_removeOnFlushCallbackObject(GrOnFlushCallback
     SkASSERT(n < fOnFlushCBObjects.count());
     fOnFlushCBObjects.removeShuffle(n);
 }
+
+//////////////////////////////////////////////////////////////////////////////
+
+#define DRAW_OP_TEST_EXTERN(Op) \
+    extern std::unique_ptr<GrDrawOp> Op##__Test(GrPaint&&, SkRandom*, GrContext*, GrFSAAType);
+
+#define LEGACY_MESH_DRAW_OP_TEST_EXTERN(Op) \
+    extern std::unique_ptr<GrLegacyMeshDrawOp> Op##__Test(SkRandom*, GrContext*);
+
+#define DRAW_OP_TEST_ENTRY(Op) Op##__Test
+
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAConvexPathOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAFillRectOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAFillRectOpLocalMatrix);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAFlatteningConvexPathOp)
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAHairlineOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAStrokeRectOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(AnalyticRectOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(CircleOp)
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(DashOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(DefaultPathOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(DIEllipseOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(EllipseOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(GrDrawAtlasOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(NonAAStrokeRectOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(RRectOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(SmallPathOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(TesselatingPathOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(TextBlobOp);
+LEGACY_MESH_DRAW_OP_TEST_EXTERN(VerticesOp);
+
+DRAW_OP_TEST_EXTERN(NonAAFillRectOp)
+
+void GrDrawRandomOp(SkRandom* random, GrRenderTargetContext* renderTargetContext, GrPaint&& paint) {
+    GrContext* context = renderTargetContext->surfPriv().getContext();
+    using MakeTestLegacyMeshDrawOpFn = std::unique_ptr<GrLegacyMeshDrawOp>(SkRandom*, GrContext*);
+    static constexpr MakeTestLegacyMeshDrawOpFn* gLegacyFactories[] = {
+        DRAW_OP_TEST_ENTRY(AAConvexPathOp),
+        DRAW_OP_TEST_ENTRY(AAFillRectOp),
+        DRAW_OP_TEST_ENTRY(AAFillRectOpLocalMatrix),
+        DRAW_OP_TEST_ENTRY(AAFlatteningConvexPathOp),
+        DRAW_OP_TEST_ENTRY(AAHairlineOp),
+        DRAW_OP_TEST_ENTRY(AAStrokeRectOp),
+        DRAW_OP_TEST_ENTRY(AnalyticRectOp),
+        DRAW_OP_TEST_ENTRY(CircleOp),
+        DRAW_OP_TEST_ENTRY(DashOp),
+        DRAW_OP_TEST_ENTRY(DefaultPathOp),
+        DRAW_OP_TEST_ENTRY(DIEllipseOp),
+        DRAW_OP_TEST_ENTRY(EllipseOp),
+        DRAW_OP_TEST_ENTRY(GrDrawAtlasOp),
+        DRAW_OP_TEST_ENTRY(NonAAStrokeRectOp),
+        DRAW_OP_TEST_ENTRY(RRectOp),
+        DRAW_OP_TEST_ENTRY(SmallPathOp),
+        DRAW_OP_TEST_ENTRY(TesselatingPathOp),
+        DRAW_OP_TEST_ENTRY(TextBlobOp),
+        DRAW_OP_TEST_ENTRY(VerticesOp)
+    };
+
+    using MakeDrawOpFn = std::unique_ptr<GrDrawOp>(GrPaint&&, SkRandom*, GrContext*, GrFSAAType);
+    static constexpr MakeDrawOpFn* gFactories[] = {
+        DRAW_OP_TEST_ENTRY(NonAAFillRectOp),
+    };
+
+    static constexpr size_t kTotal = SK_ARRAY_COUNT(gLegacyFactories) + SK_ARRAY_COUNT(gFactories);
+
+    uint32_t index = random->nextULessThan(static_cast<uint32_t>(kTotal));
+    if (index < SK_ARRAY_COUNT(gLegacyFactories)) {
+        const GrUserStencilSettings* uss = GrGetRandomStencil(random, context);
+        // We don't use kHW because we will hit an assertion if the render target is not
+        // multisampled
+        static constexpr GrAAType kAATypes[] = {GrAAType::kNone, GrAAType::kCoverage};
+        GrAAType aaType = kAATypes[random->nextULessThan(SK_ARRAY_COUNT(kAATypes))];
+        bool snapToCenters = random->nextBool();
+        auto op = gLegacyFactories[index](random, context);
+        SkASSERT(op);
+        renderTargetContext->priv().testingOnly_addLegacyMeshDrawOp(
+                std::move(paint), aaType, std::move(op), uss, snapToCenters);
+    } else {
+        auto op = gFactories[index - SK_ARRAY_COUNT(gLegacyFactories)](
+                std::move(paint), random, context, renderTargetContext->fsaaType());
+        SkASSERT(op);
+        renderTargetContext->priv().testingOnly_addDrawOp(std::move(op));
+    }
+}