Revert "Add a tessellation mode that uses indirect draws"

This reverts commit 02d7cf7.

Reason for revert:

  Perf-Debian10-Clang-GCE-CPU-AVX2-x86_64-Debug-All-ASAN
  Perf-Win2019-Clang-GCE-CPU-AVX2-x86_64-Debug-All-ASAN

Running tessellate_prepareTessellatedCubicWedges	nonrendering
../../../../../../skia/bench/TessellatePathBench.cpp:79: fatal error: "unimplemented."

Signal 5 [Trace/breakpoint trap]:
    /mnt/pd0/s/w/ir/build/nanobench(backtrace+0x3d) [0x34851fd]
    /mnt/pd0/s/w/ir/build/nanobench() [0x3db3d49]
    /lib/x86_64-linux-gnu/libc.so.6(+0x37840) [0x7fdb4722d840]
    sk_abort_no_print()
    BenchmarkTarget::caps() const
    GrTessellatePathOp::prepareTessellatedCubicWedges(GrMeshDrawOp::Target*)
    GrTessellatePathOp::TestingOnly_Benchmark::prepareTessellatedCubicWedges::runBench(GrMeshDrawOp::Target*, GrTessellatePathOp*)
    GrTessellatePathOp::TestingOnly_Benchmark::onDraw(int, SkCanvas*)
    Benchmark::draw(int, SkCanvas*)
    /mnt/pd0/s/w/ir/build/nanobench() [0x3543b81]
    /mnt/pd0/s/w/ir/build/nanobench(main+0x1347) [0x3540a17]
    /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xeb) [0x7fdb4721a09b]
    /mnt/pd0/s/w/ir/build/nanobench(_start+0x2a) [0x346429a]
Command exited with code 5


Original change's description:
> Add a tessellation mode that uses indirect draws
> 
> This mode is oftentimes faster than tessellation, and other times it
> serves as a polyfill when tessellation just isn't supported.
> 
> Change-Id: I7b3d57fd0194c6869bfe28ee53ff0ff2e43df479
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/291036
> Commit-Queue: Chris Dalton <csmartdalton@google.com>
> Reviewed-by: Brian Osman <brianosman@google.com>

TBR=egdaniel@google.com,brianosman@google.com,csmartdalton@google.com

Change-Id: I4257d5ae5c0aafeebd61d8f1b78eca755ad977ff
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/291642
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: Mike Klein <mtklein@google.com>

Author: Mike Klein

bench/TessellatePathBench.cpp

@@ -10,8 +10,6 @@
 #include "src/core/SkPathPriv.h"
 #include "src/gpu/GrContextPriv.h"
 #include "src/gpu/GrOpFlushState.h"
-#include "src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h"
-#include "src/gpu/tessellate/GrResolveLevelCounter.h"
 #include "src/gpu/tessellate/GrTessellatePathOp.h"
 #include "src/gpu/tessellate/GrWangsFormula.h"
 #include "tools/ToolUtils.h"
@@ -81,7 +79,7 @@ class BenchmarkTarget : public GrMeshDrawOp::Target {
 #undef UNIMPL
 
 private:
-    SkPoint fStaticVertexData[(kNumCubicsInChalkboard + 2) * 8];
+    SkPoint fStaticVertexData[(kNumCubicsInChalkboard + 2) * 5];
     GrDrawIndexedIndirectCommand fStaticDrawIndexedIndirectData[32];
     SkSTArenaAlloc<1024 * 1024> fAllocator;
 };
@@ -97,15 +95,10 @@ class GrTessellatePathOp::TestingOnly_Benchmark : public Benchmark {
     const char* onGetName() override { return fName.c_str(); }
     bool isSuitableFor(Backend backend) final { return backend == kNonRendering_Backend; }
 
-    class prepareMiddleOutStencilGeometry;
-    class prepareMiddleOutStencilGeometry_indirect;
-    class prepareIndirectOuterCubics;
-    class prepareTessellatedOuterCubics;
-    class prepareTessellatedCubicWedges;
-    class wangs_formula_cubic_log2;
-    class wangs_formula_cubic_log2_scale;
-    class wangs_formula_cubic_log2_affine;
-    class middle_out_triangulation;
+    class MiddleOutInnerTrianglesBench;
+    class OuterCubicsBench;
+    class CubicWedgesBench;
+    class WangsFormulaBench;
 
 private:
     void onDraw(int loops, SkCanvas*) final {
@@ -127,91 +120,83 @@ class GrTessellatePathOp::TestingOnly_Benchmark : public Benchmark {
     SkString fName;
 };
 
-#define DEF_TESS_BENCH(NAME, PATH, MATRIX, TARGET, OP) \
-    class GrTessellatePathOp::TestingOnly_Benchmark::NAME \
-            : public GrTessellatePathOp::TestingOnly_Benchmark { \
-    public: \
-        NAME() : TestingOnly_Benchmark(#NAME, (PATH), (MATRIX)) {} \
-        void runBench(GrMeshDrawOp::Target* target, GrTessellatePathOp* op) override; \
-    }; \
-    DEF_BENCH( return new GrTessellatePathOp::TestingOnly_Benchmark::NAME(); ); \
-    void GrTessellatePathOp::TestingOnly_Benchmark::NAME::runBench( \
-            GrMeshDrawOp::Target* TARGET, GrTessellatePathOp* op)
-
-DEF_TESS_BENCH(prepareMiddleOutStencilGeometry, make_cubic_path(), SkMatrix::I(), target, op) {
-    op->prepareMiddleOutTrianglesAndCubics(target);
-}
-
-DEF_TESS_BENCH(prepareMiddleOutStencilGeometry_indirect, make_cubic_path(), SkMatrix::I(), target,
-               op) {
-    GrResolveLevelCounter resolveLevelCounter;
-    op->prepareMiddleOutTrianglesAndCubics(target, &resolveLevelCounter, true);
-}
-
-DEF_TESS_BENCH(prepareIndirectOuterCubics, make_cubic_path(), SkMatrix::I(), target, op) {
-    GrResolveLevelCounter resolveLevelCounter;
-    resolveLevelCounter.reset(op->fPath, SkMatrix::I(), 4);
-    op->prepareIndirectOuterCubics(target, resolveLevelCounter);
-}
-
-DEF_TESS_BENCH(prepareTessellatedOuterCubics, make_cubic_path(), SkMatrix::I(), target, op) {
-    op->prepareTessellatedOuterCubics(target, kNumCubicsInChalkboard);
-}
+class GrTessellatePathOp::TestingOnly_Benchmark::MiddleOutInnerTrianglesBench
+        : public GrTessellatePathOp::TestingOnly_Benchmark {
+public:
+    MiddleOutInnerTrianglesBench()
+            : TestingOnly_Benchmark("prepareMiddleOutInnerTriangles",
+                                    ToolUtils::make_star(SkRect::MakeWH(100, 100),
+                                                         kNumCubicsInChalkboard),
+                                    SkMatrix::I()) {
+    }
+    void runBench(GrMeshDrawOp::Target* target, GrTessellatePathOp* op) override {
+        int numBeziers;
+        op->prepareMiddleOutInnerTriangles(target, &numBeziers);
+    }
+};
 
-DEF_TESS_BENCH(prepareTessellatedCubicWedges, make_cubic_path(), SkMatrix::I(), target, op) {
-    op->prepareTessellatedCubicWedges(target);
-}
+DEF_BENCH( return new GrTessellatePathOp::TestingOnly_Benchmark::MiddleOutInnerTrianglesBench(); );
 
-static void benchmark_wangs_formula_cubic_log2(const SkMatrix& matrix, const SkPath& path) {
-    int sum = 0;
-    GrVectorXform xform(matrix);
-    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
-        if (verb == SkPathVerb::kCubic) {
-            sum += GrWangsFormula::cubic_log2(4, pts, xform);
-        }
+class GrTessellatePathOp::TestingOnly_Benchmark::OuterCubicsBench
+        : public GrTessellatePathOp::TestingOnly_Benchmark {
+public:
+    OuterCubicsBench()
+            : TestingOnly_Benchmark("prepareOuterCubics", make_cubic_path(), SkMatrix::I()) {
     }
-    // Don't let the compiler optimize away GrWangsFormula::cubic_log2.
-    if (sum <= 0) {
-        SK_ABORT("sum should be > 0.");
+    void runBench(GrMeshDrawOp::Target* target, GrTessellatePathOp* op) override {
+        op->prepareOuterCubics(target, kNumCubicsInChalkboard,
+                               CubicDataAlignment::kVertexBoundary);
     }
-}
+};
 
-DEF_TESS_BENCH(wangs_formula_cubic_log2, make_cubic_path(), SkMatrix::I(), target, op) {
-    benchmark_wangs_formula_cubic_log2(op->fViewMatrix, op->fPath);
-}
+DEF_BENCH( return new GrTessellatePathOp::TestingOnly_Benchmark::OuterCubicsBench(); );
 
-DEF_TESS_BENCH(wangs_formula_cubic_log2_scale, make_cubic_path(), SkMatrix::Scale(1.1f, 0.9f),
-               target, op) {
-    benchmark_wangs_formula_cubic_log2(op->fViewMatrix, op->fPath);
-}
+class GrTessellatePathOp::TestingOnly_Benchmark::CubicWedgesBench
+        : public GrTessellatePathOp::TestingOnly_Benchmark {
+public:
+    CubicWedgesBench()
+            : TestingOnly_Benchmark("prepareCubicWedges", make_cubic_path(), SkMatrix::I()) {
+    }
+    void runBench(GrMeshDrawOp::Target* target, GrTessellatePathOp* op) override {
+        op->prepareCubicWedges(target);
+    }
+};
 
-DEF_TESS_BENCH(wangs_formula_cubic_log2_affine, make_cubic_path(),
-               SkMatrix::MakeAll(.9f,0.9f,0,  1.1f,1.1f,0, 0,0,1), target, op) {
-    benchmark_wangs_formula_cubic_log2(op->fViewMatrix, op->fPath);
-}
+DEF_BENCH( return new GrTessellatePathOp::TestingOnly_Benchmark::CubicWedgesBench(););
 
-DEF_TESS_BENCH(middle_out_triangulation,
-               ToolUtils::make_star(SkRect::MakeWH(500, 500), kNumCubicsInChalkboard),
-               SkMatrix::I(), target, op) {
-    auto vertexData = static_cast<SkPoint*>(target->makeVertexSpace(
-            sizeof(SkPoint), kNumCubicsInChalkboard, nullptr, nullptr));
-    GrMiddleOutPolygonTriangulator middleOut(vertexData, 3, kNumCubicsInChalkboard + 2);
-    for (auto [verb, pts, w] : SkPathPriv::Iterate(op->fPath)) {
-        switch (verb) {
-            case SkPathVerb::kMove:
-                middleOut.closeAndMove(pts[0]);
-                break;
-            case SkPathVerb::kLine:
-                middleOut.pushVertex(pts[1]);
-                break;
-            case SkPathVerb::kClose:
-                middleOut.close();
-                break;
-            case SkPathVerb::kQuad:
-            case SkPathVerb::kConic:
-            case SkPathVerb::kCubic:
-                SkUNREACHABLE;
+class GrTessellatePathOp::TestingOnly_Benchmark::WangsFormulaBench
+        : public GrTessellatePathOp::TestingOnly_Benchmark {
+public:
+    WangsFormulaBench(const char* suffix, const SkMatrix& matrix)
+            : TestingOnly_Benchmark(SkStringPrintf("wangs_formula_cubic_log2%s", suffix).c_str(),
+                                    make_cubic_path(), SkMatrix::I())
+            , fMatrix(matrix) {
+    }
+    void runBench(GrMeshDrawOp::Target*, GrTessellatePathOp* op) override {
+        int sum = 0;
+        GrVectorXform xform(fMatrix);
+        for (auto [verb, pts, w] : SkPathPriv::Iterate(op->fPath)) {
+            if (verb == SkPathVerb::kCubic) {
+                sum += GrWangsFormula::cubic_log2(4, pts, xform);
+            }
+        }
+        // Don't let the compiler optimize away GrWangsFormula::cubic_log2.
+        if (sum <= 0) {
+            SK_ABORT("sum should be > 0.");
         }
-        middleOut.closeAndMove(pts[0]);
     }
-}
+private:
+    SkMatrix fMatrix;
+};
+
+DEF_BENCH(
+    return new GrTessellatePathOp::TestingOnly_Benchmark::WangsFormulaBench("", SkMatrix::I());
+);
+DEF_BENCH(
+    return new GrTessellatePathOp::TestingOnly_Benchmark::WangsFormulaBench(
+            "_scale", SkMatrix::Scale(1.1f, 0.9f));
+);
+DEF_BENCH(
+    return new GrTessellatePathOp::TestingOnly_Benchmark::WangsFormulaBench(
+            "_affine", SkMatrix::MakeAll(.9f,0.9f,0,  1.1f,1.1f,0, 0,0,1));
+);

gn/gpu.gni

@@ -444,7 +444,6 @@ skia_gpu_sources = [
   "$_src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h",
   "$_src/gpu/tessellate/GrMidpointContourParser.h",
   "$_src/gpu/tessellate/GrPathShader.h",
-  "$_src/gpu/tessellate/GrResolveLevelCounter.h",
   "$_src/gpu/tessellate/GrStencilPathShader.cpp",
   "$_src/gpu/tessellate/GrStencilPathShader.h",
   "$_src/gpu/tessellate/GrTessellatePathOp.cpp",

src/gpu/GrPathRendererChain.cpp

@@ -32,7 +32,7 @@ GrPathRendererChain::GrPathRendererChain(GrRecordingContext* context, const Opti
         fChain.push_back(sk_make_sp<GrDashLinePathRenderer>());
     }
     if (options.fGpuPathRenderers & GpuPathRenderers::kTessellation) {
-        if (caps.drawInstancedSupport()) {
+        if (caps.shaderCaps()->tessellationSupport() && caps.drawInstancedSupport()) {
             auto tess = sk_make_sp<GrTessellationPathRenderer>(caps);
             context->priv().addOnFlushCallbackObject(tess.get());
             fChain.push_back(std::move(tess));

src/gpu/GrProcessor.h

@@ -162,10 +162,9 @@ class GrProcessor {
         kTessellate_GrFillBoundingBoxShader_ClassID,
         kTessellate_GrFillCubicHullShader_ClassID,
         kTessellate_GrFillTriangleShader_ClassID,
-        kTessellate_GrMiddleOutCubicShader_ClassID,
+        kTessellate_GrStencilCubicShader_ClassID,
         kTessellate_GrStencilTriangleShader_ClassID,
-        kTessellate_GrTessellateCubicShader_ClassID,
-        kTessellate_GrTessellateWedgeShader_ClassID,
+        kTessellate_GrStencilWedgeShader_ClassID,
         kTestFP_ClassID,
         kTestRectOp_ClassID,
         kFlatNormalsFP_ClassID,