diff --git a/src/gpu/tessellate/GrFillPathShader.cpp b/src/gpu/tessellate/GrFillPathShader.cpp
index 6274845..71fd72d 100644
--- a/src/gpu/tessellate/GrFillPathShader.cpp
+++ b/src/gpu/tessellate/GrFillPathShader.cpp
@@ -72,16 +72,20 @@
                                            GrGLSLUniformHandler* uniformHandler) const {
     v->codeAppend(R"(
     float4x2 P = float4x2(input_points_0_1, input_points_2_3);
-    if (isinf(P[3].y)) {
-        // This curve is actually a conic. Convert the control points to a trapeziodal hull
-        // that circumcscribes the conic.
+    if (isinf(P[3].y)) {  // Is the curve a conic?
         float w = P[3].x;
-        float2 p1w = P[1] * w;
-        float T = .51;  // Bias outward a bit to ensure we cover the outermost samples.
-        float2 c1 = mix(P[0], p1w, T);
-        float2 c2 = mix(P[2], p1w, T);
-        float iw = 1 / mix(1, w, T);
-        P = float4x2(P[0], c1 * iw, c2 * iw, P[2]);
+        if (isinf(w)) {
+            // A conic with w=Inf is an exact triangle.
+            P = float4x2(P[0], P[1], P[2], P[2]);
+        } else {
+            // Convert the control points to a trapeziodal hull that circumcscribes the conic.
+            float2 p1w = P[1] * w;
+            float T = .51;  // Bias outward a bit to ensure we cover the outermost samples.
+            float2 c1 = mix(P[0], p1w, T);
+            float2 c2 = mix(P[2], p1w, T);
+            float iw = 1 / mix(1, w, T);
+            P = float4x2(P[0], c1 * iw, c2 * iw, P[2]);
+        }
     }
 
     // Translate the points to v0..3 where v0=0.
diff --git a/src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h b/src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h
index b960ab5..fb17db1 100644
--- a/src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h
+++ b/src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h
@@ -13,6 +13,7 @@
 #include "include/private/SkTemplates.h"
 #include "src/core/SkMathPriv.h"
 #include "src/core/SkPathPriv.h"
+#include <limits>
 
 // This class emits a polygon triangulation with a "middle-out" topology. Conceptually, middle-out
 // emits one large triangle with vertices on both endpoints and a middle point, then recurses on
@@ -40,6 +41,12 @@
 // This class is designed to not know or store all the vertices in the polygon at once. The caller
 // pushes each vertex in linear order (perhaps while parsing a path), then rather than relying on
 // recursion, we manipulate an O(log N) stack to determine the correct middle-out triangulation.
+//
+// perTriangleVertexAdvance controls how much padding to put after triangles (namely, we append
+// "perTriangleVertexAdvance - 3" vertices of padding after each triangle, including the final one).
+// Padding vertices are filled with infinity. This has the effect, when perTriangleVertexAdvance is
+// 4, of defining a conic with w=Inf for tessellation shaders, which comes out to be an exact
+// triangle.
 class GrMiddleOutPolygonTriangulator {
 public:
     GrMiddleOutPolygonTriangulator(SkPoint* vertexData, int perTriangleVertexAdvance,
@@ -166,6 +173,10 @@
         fVertexData[0] = fTop[0].fPoint;
         fVertexData[1] = fTop[1].fPoint;
         fVertexData[2] = lastPt;
+        for (int i = 3; i < fPerTriangleVertexAdvance; ++i) {
+            fVertexData[i].set(std::numeric_limits<float>::infinity(),
+                               std::numeric_limits<float>::infinity());
+        }
         fVertexData += fPerTriangleVertexAdvance;
     }
 
diff --git a/src/gpu/tessellate/GrPathTessellator.cpp b/src/gpu/tessellate/GrPathTessellator.cpp
index 24db640..7fe80ae 100644
--- a/src/gpu/tessellate/GrPathTessellator.cpp
+++ b/src/gpu/tessellate/GrPathTessellator.cpp
@@ -14,6 +14,7 @@
 #include "src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h"
 #include "src/gpu/tessellate/GrMidpointContourParser.h"
 #include "src/gpu/tessellate/GrStencilPathShader.h"
+#include <limits>
 
 GrPathIndirectTessellator::GrPathIndirectTessellator(const SkMatrix& viewMatrix, const SkPath& path,
                                                      DrawInnerFan drawInnerFan)
@@ -92,8 +93,9 @@
             }
             SkPoint* breadcrumbData = instanceData + numTrianglesAtBeginningOfData * 4;
             memcpy(breadcrumbData, p, sizeof(SkPoint) * 3);
-            // Duplicate the final point since it will also be used by the convex hull shader.
-            breadcrumbData[3] = p[2];
+            // Mark this instance as a triangle by setting it to a conic with w=Inf.
+            breadcrumbData[3].set(std::numeric_limits<float>::infinity(),
+                                  std::numeric_limits<float>::infinity());
             ++numTrianglesAtBeginningOfData;
         }
         SkASSERT(count == breadcrumbTriangleList->count());
@@ -122,29 +124,24 @@
     // location at each resolve level.
     SkPoint* instanceLocations[kMaxResolveLevel + 1];
     int runningInstanceCount = 0;
-    if (numTrianglesAtBeginningOfData) {
-        // The caller has already packed "triangleInstanceCount" triangles into 4-point instances
-        // at the beginning of the instance buffer. Add a special-case indirect draw here that will
-        // emit the triangles [P0, P1, P2] from these 4-point instances.
-        SkASSERT(fIndirectDrawCount < indirectLockCnt);
-        GrMiddleOutCubicShader::WriteDrawTrianglesIndirectCmd(&indirectWriter,
-                                                              numTrianglesAtBeginningOfData,
-                                                              fBaseInstance);
-        ++fIndirectDrawCount;
-        runningInstanceCount = numTrianglesAtBeginningOfData;
-    }
     SkASSERT(fResolveLevelCounts[0] == 0);
     for (int resolveLevel = 1; resolveLevel <= kMaxResolveLevel; ++resolveLevel) {
         int instanceCountAtCurrLevel = fResolveLevelCounts[resolveLevel];
+        if (resolveLevel == 1) {
+            instanceCountAtCurrLevel += numTrianglesAtBeginningOfData;
+        }
         if (!instanceCountAtCurrLevel) {
             SkDEBUGCODE(instanceLocations[resolveLevel] = nullptr;)
             continue;
         }
         instanceLocations[resolveLevel] = instanceData + runningInstanceCount * 4;
+        if (resolveLevel == 1) {
+            instanceLocations[resolveLevel] += numTrianglesAtBeginningOfData * 4;
+        }
         SkASSERT(fIndirectDrawCount < indirectLockCnt);
-        GrMiddleOutCubicShader::WriteDrawCubicsIndirectCmd(&indirectWriter, resolveLevel,
-                                                           instanceCountAtCurrLevel,
-                                                           fBaseInstance + runningInstanceCount);
+        GrMiddleOutCubicShader::WriteDrawIndirectCmd(&indirectWriter, resolveLevel,
+                                                     instanceCountAtCurrLevel,
+                                                     fBaseInstance + runningInstanceCount);
         ++fIndirectDrawCount;
         runningInstanceCount += instanceCountAtCurrLevel;
     }
diff --git a/src/gpu/tessellate/GrStencilPathShader.cpp b/src/gpu/tessellate/GrStencilPathShader.cpp
index 85b1f42..fb4aee8 100644
--- a/src/gpu/tessellate/GrStencilPathShader.cpp
+++ b/src/gpu/tessellate/GrStencilPathShader.cpp
@@ -374,10 +374,10 @@
         args.fVertBuilder->insertFunction(kEvalRationalCubicFn);
         args.fVertBuilder->codeAppend(R"(
         float2 pos;
-        if (sk_VertexID > kMaxVertexID) {
-            // This is a special index value that instructs us to emit a specific point.
-            pos = ((sk_VertexID & 3) == 0) ? inputPoints_0_1.xy :
-                  ((sk_VertexID & 2) == 0) ? inputPoints_0_1.zw : inputPoints_2_3.xy;
+        if (isinf(inputPoints_2_3.z)) {
+            // A conic with w=Inf is an exact triangle.
+            pos = (sk_VertexID == 0) ? inputPoints_0_1.xy :
+                  (sk_VertexID != kMaxVertexID) ? inputPoints_0_1.zw : inputPoints_2_3.xy;
         } else {
             // Evaluate the cubic at T = (sk_VertexID / 2^kMaxResolveLevel).
             float T = float(sk_VertexID) * kInverseMaxVertexID;
diff --git a/src/gpu/tessellate/GrStencilPathShader.h b/src/gpu/tessellate/GrStencilPathShader.h
index 7236dea..203a184 100644
--- a/src/gpu/tessellate/GrStencilPathShader.h
+++ b/src/gpu/tessellate/GrStencilPathShader.h
@@ -152,9 +152,8 @@
 
     // Configures an indirect draw to render cubic instances with 2^resolveLevel evenly-spaced (in
     // the parametric sense) line segments.
-    static void WriteDrawCubicsIndirectCmd(GrDrawIndexedIndirectWriter* indirectWriter,
-                                           int resolveLevel, uint32_t instanceCount,
-                                           uint32_t baseInstance) {
+    static void WriteDrawIndirectCmd(GrDrawIndexedIndirectWriter* indirectWriter, int resolveLevel,
+                                     uint32_t instanceCount, uint32_t baseInstance) {
         SkASSERT(resolveLevel > 0 && resolveLevel <= GrTessellationPathRenderer::kMaxResolveLevel);
         // Starting at baseIndex=3, the index buffer triangulates a cubic with 2^kMaxResolveLevel
         // line segments. Each index value corresponds to a parametric T value on the curve. Since
@@ -164,15 +163,6 @@
         indirectWriter->writeIndexed(indexCount, 3, instanceCount, baseInstance, 0);
     }
 
-    // For performance reasons we can often express triangles as an indirect cubic draw and sneak
-    // them in alongside the other indirect draws. This method configures an indirect draw to emit
-    // the triangle [P0, P1, P2] from a 4-point instance.
-    static void WriteDrawTrianglesIndirectCmd(GrDrawIndexedIndirectWriter* indirectWriter,
-                                              uint32_t instanceCount, uint32_t baseInstance) {
-        // Indices 0,1,2 have special index values that emit points P0, P1, and P2 respectively.
-        indirectWriter->writeIndexed(3, 0, instanceCount, baseInstance, 0);
-    }
-
     // Returns the index buffer that should be bound when drawing with this shader.
     // (Our vertex shader uses raw index values directly, so there is no vertex buffer.)
     static sk_sp<const GrGpuBuffer> FindOrMakeMiddleOutIndexBuffer(GrResourceProvider*);