Begin implementing onPrePrepare for tessellation ops

Records programInfos for the stroke ops and for the stencil portions
of the path ops.

We can't prePrepare programInfos for the fill portions yet because it
would require multiple GrPipelines that all reference the same
GrProcessorSet. And GrProcessorSet is currently designed to be
std::moved into one single GrPipeline.

Bug: skia:10419
Change-Id: I3b8c061da181e20d3ff68746cf4b9c61f6d73a88
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/319256
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>

Author: csmartdalton86

bench/TessellateBench.cpp

@@ -147,10 +147,14 @@ class GrPathTessellateOp::TestingOnly_Benchmark : public Benchmark {
         }
         for (int i = 0; i < loops; ++i) {
             fOp.fTriangleBuffer.reset();
-            fOp.fDoStencilTriangleBuffer = false;
+            fOp.fTriangleVertexCount = 0;
+            fOp.fSharedStencilPipeline = nullptr;
+            fOp.fStencilTrianglesProgram = nullptr;
             fOp.fDoFillTriangleBuffer = false;
             fOp.fCubicBuffer.reset();
-            fOp.fStencilCubicsShader = nullptr;
+            fOp.fCubicVertexCount = 0;
+            // Make fStencilTrianglesProgram non-null to keep assertions happy.
+            fOp.fStencilCubicsProgram = (GrProgramInfo*)-1;
             this->runBench(&fTarget, &fOp);
             fTarget.resetAllocator();
         }
@@ -175,13 +179,16 @@ class GrPathTessellateOp::TestingOnly_Benchmark : public Benchmark {
             GrMeshDrawOp::Target* TARGET, GrPathTessellateOp* op)
 
 DEF_PATH_TESS_BENCH(prepareMiddleOutStencilGeometry, make_cubic_path(), SkMatrix::I(), target, op) {
+    // Make fStencilTrianglesProgram non-null so we benchmark the tessellation path with separate
+    // triangles.
+    op->fStencilTrianglesProgram = (GrProgramInfo*)-1;
     op->prepareMiddleOutTrianglesAndCubics(target);
 }
 
 DEF_PATH_TESS_BENCH(prepareMiddleOutStencilGeometry_indirect, make_cubic_path(), SkMatrix::I(),
                     target, op) {
     GrResolveLevelCounter resolveLevelCounter;
-    op->prepareMiddleOutTrianglesAndCubics(target, &resolveLevelCounter, true);
+    op->prepareMiddleOutTrianglesAndCubics(target, &resolveLevelCounter);
 }
 
 DEF_PATH_TESS_BENCH(prepareIndirectOuterCubics, make_cubic_path(), SkMatrix::I(), target, op) {

src/gpu/tessellate/GrPathShader.h

@@ -8,6 +8,7 @@
 #ifndef GrPathShader_DEFINED
 #define GrPathShader_DEFINED
 
+#include "src/core/SkArenaAlloc.h"
 #include "src/gpu/GrGeometryProcessor.h"
 #include "src/gpu/GrOpFlushState.h"
 #include "src/gpu/GrOpsRenderPass.h"
@@ -27,30 +28,41 @@ class GrPathShader : public GrGeometryProcessor {
         }
     }
 
+    GrPrimitiveType primitiveType() const { return fPrimitiveType; }
+    int tessellationPatchVertexCount() const { return fTessellationPatchVertexCount; }
     const SkMatrix& viewMatrix() const { return fViewMatrix; }
 
-    // This subclass is used to simplify the argument list for constructing GrProgramInfo from a
-    // GrPathShader.
-    class ProgramInfo : public GrProgramInfo {
-    public:
-        ProgramInfo(const GrSurfaceProxyView* view,
-                    const GrPipeline* pipeline,
-                    const GrPathShader* shader,
-                    GrXferBarrierFlags renderPassXferBarriers)
-                : ProgramInfo(view->asRenderTargetProxy(), view->origin(), pipeline, shader,
-                              renderPassXferBarriers) {
-        }
-        ProgramInfo(const GrRenderTargetProxy* proxy,
-                    GrSurfaceOrigin origin,
-                    const GrPipeline* pipeline,
-                    const GrPathShader* shader,
-                    GrXferBarrierFlags renderPassXferBarriers)
-                : GrProgramInfo(proxy->numSamples(), proxy->numStencilSamples(),
-                                proxy->backendFormat(), origin, pipeline, shader,
-                                shader->fPrimitiveType, shader->fTessellationPatchVertexCount,
-                                renderPassXferBarriers) {
-        }
-    };
+    static GrProgramInfo* MakeProgramInfo(const GrPathShader* shader, SkArenaAlloc* arena,
+                                          const GrSurfaceProxyView* writeView,
+                                          GrPipeline::InputFlags pipelineFlags,
+                                          GrProcessorSet&& processors, GrAppliedClip&& appliedClip,
+                                          const GrXferProcessor::DstProxyView& dstProxyView,
+                                          GrXferBarrierFlags renderPassXferBarriers,
+                                          const GrCaps& caps) {
+        GrPipeline::InitArgs pipelineArgs;
+        pipelineArgs.fInputFlags = pipelineFlags;
+        pipelineArgs.fCaps = ∩︀
+        pipelineArgs.fDstProxyView = dstProxyView;
+        pipelineArgs.fWriteSwizzle = writeView->swizzle();
+        auto* pipeline = arena->make<GrPipeline>(pipelineArgs, std::move(processors),
+                                                 std::move(appliedClip));
+        return MakeProgramInfo(shader, arena, writeView, pipeline, dstProxyView,
+                               renderPassXferBarriers, caps);
+    }
+
+    static GrProgramInfo* MakeProgramInfo(const GrPathShader* shader, SkArenaAlloc* arena,
+                                          const GrSurfaceProxyView* writeView,
+                                          const GrPipeline* pipeline,
+                                          const GrXferProcessor::DstProxyView& dstProxyView,
+                                          GrXferBarrierFlags renderPassXferBarriers,
+                                          const GrCaps& caps) {
+        GrRenderTargetProxy* proxy = writeView->asRenderTargetProxy();
+        return arena->make<GrProgramInfo>(proxy->numSamples(), proxy->numStencilSamples(),
+                                          proxy->backendFormat(), writeView->origin(), pipeline,
+                                          shader, shader->fPrimitiveType,
+                                          shader->fTessellationPatchVertexCount,
+                                          renderPassXferBarriers);
+    }
 
 private:
     const SkMatrix fViewMatrix;