diff --git a/src/gpu/ccpr/GrCCPathProcessor.cpp b/src/gpu/ccpr/GrCCPathProcessor.cpp
index feefd4f..852875e 100644
--- a/src/gpu/ccpr/GrCCPathProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPathProcessor.cpp
@@ -17,19 +17,20 @@
 #include "glsl/GrGLSLVarying.h"
 
 // Paths are drawn as octagons. Each point on the octagon is the intersection of two lines: one edge
-// from the path's bounding box and one edge from its 45-degree bounding box. The below inputs
-// define a vertex by the two edges that need to be intersected. Normals point out of the octagon,
-// and the bounding boxes are sent in as instance attribs.
-static constexpr float kOctoEdgeNorms[8 * 4] = {
+// from the path's bounding box and one edge from its 45-degree bounding box. The selectors
+// below indicate one corner from the bounding box, paired with a corner from the 45-degree bounding
+// box. The octagon vertex is the point that lies between these two corners, found by intersecting
+// their edges.
+static constexpr float kOctoEdgeNorms[8*4] = {
     // bbox   // bbox45
-    -1, 0,    -1,+1,
-    -1, 0,    -1,-1,
-     0,-1,    -1,-1,
-     0,-1,    +1,-1,
-    +1, 0,    +1,-1,
-    +1, 0,    +1,+1,
-     0,+1,    +1,+1,
-     0,+1,    -1,+1,
+    0,0,      0,0,
+    0,0,      1,0,
+    1,0,      1,0,
+    1,0,      1,1,
+    1,1,      1,1,
+    1,1,      0,1,
+    0,1,      0,1,
+    0,1,      0,0,
 };
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gVertexBufferKey);
@@ -43,26 +44,26 @@
 static constexpr uint16_t kRestartStrip = 0xffff;
 
 static constexpr uint16_t kOctoIndicesAsStrips[] = {
-    1, 0, 2, 4, 3, kRestartStrip, // First half.
-    5, 4, 6, 0, 7 // Second half.
+    3, 4, 2, 0, 1, kRestartStrip,  // First half.
+    7, 0, 6, 4, 5  // Second half.
 };
 
 static constexpr uint16_t kOctoIndicesAsTris[] = {
     // First half.
-    1, 0, 2,
-    0, 4, 2,
-    2, 4, 3,
+    3, 4, 2,
+    4, 0, 2,
+    2, 0, 1,
 
     // Second half.
-    5, 4, 6,
-    4, 0, 6,
-    6, 0, 7,
+    7, 0, 6,
+    0, 4, 6,
+    6, 4, 5,
 };
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gIndexBufferKey);
 
 constexpr GrPrimitiveProcessor::Attribute GrCCPathProcessor::kInstanceAttribs[];
-constexpr GrPrimitiveProcessor::Attribute GrCCPathProcessor::kEdgeNormsAttrib;
+constexpr GrPrimitiveProcessor::Attribute GrCCPathProcessor::kCornersAttrib;
 
 sk_sp<const GrGpuBuffer> GrCCPathProcessor::FindIndexBuffer(GrOnFlushResourceProvider* onFlushRP) {
     GR_DEFINE_STATIC_UNIQUE_KEY(gIndexBufferKey);
@@ -85,10 +86,10 @@
         , fAtlasSize(atlas->isize())
         , fAtlasOrigin(atlas->origin()) {
     // TODO: Can we just assert that atlas has GrCCAtlas::kTextureOrigin and remove fAtlasOrigin?
-    this->setInstanceAttributes(kInstanceAttribs, kNumInstanceAttribs);
+    this->setInstanceAttributes(kInstanceAttribs, SK_ARRAY_COUNT(kInstanceAttribs));
     SkASSERT(this->instanceStride() == sizeof(Instance));
 
-    this->setVertexAttributes(&kEdgeNormsAttrib, 1);
+    this->setVertexAttributes(&kCornersAttrib, 1);
     this->setTextureSamplerCnt(1);
 
     if (!viewMatrixIfUsingLocalCoords.invert(&fLocalMatrix)) {
@@ -96,7 +97,7 @@
     }
 }
 
-class GLSLPathProcessor : public GrGLSLGeometryProcessor {
+class GrCCPathProcessor::Impl : public GrGLSLGeometryProcessor {
 public:
     void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override;
 
@@ -115,7 +116,7 @@
 };
 
 GrGLSLPrimitiveProcessor* GrCCPathProcessor::createGLSLInstance(const GrShaderCaps&) const {
-    return new GLSLPathProcessor();
+    return new Impl();
 }
 
 void GrCCPathProcessor::drawPaths(GrOpFlushState* flushState, const GrPipeline& pipeline,
@@ -141,8 +142,7 @@
                                         bounds);
 }
 
-void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
-    using InstanceAttribs = GrCCPathProcessor::InstanceAttribs;
+void GrCCPathProcessor::Impl::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     using Interpolation = GrGLSLVaryingHandler::Interpolation;
 
     const GrCCPathProcessor& proc = args.fGP.cast<GrCCPathProcessor>();
@@ -151,45 +151,38 @@
 
     const char* atlasAdjust;
     fAtlasAdjustUniform = uniHandler->addUniform(
-            kVertex_GrShaderFlag,
-            kFloat2_GrSLType, "atlas_adjust", &atlasAdjust);
+            kVertex_GrShaderFlag, kFloat2_GrSLType, "atlas_adjust", &atlasAdjust);
 
     varyingHandler->emitAttributes(proc);
 
     GrGLSLVarying texcoord(kFloat3_GrSLType);
     GrGLSLVarying color(kHalf4_GrSLType);
     varyingHandler->addVarying("texcoord", &texcoord);
-    varyingHandler->addPassThroughAttribute(proc.getInstanceAttrib(InstanceAttribs::kColor),
-                                            args.fOutputColor, Interpolation::kCanBeFlat);
+    varyingHandler->addPassThroughAttribute(
+            kInstanceAttribs[kColorAttribIdx], args.fOutputColor, Interpolation::kCanBeFlat);
 
     // The vertex shader bloats and intersects the devBounds and devBounds45 rectangles, in order to
     // find an octagon that circumscribes the (bloated) path.
     GrGLSLVertexBuilder* v = args.fVertBuilder;
 
-    // Each vertex is the intersection of one edge from devBounds and one from devBounds45.
-    // 'N' holds the normals to these edges as column vectors.
-    //
-    // NOTE: "float2x2(float4)" is valid and equivalent to "float2x2(float4.xy, float4.zw)",
-    // however Intel compilers crash when we use the former syntax in this shader.
-    v->codeAppendf("float2x2 N = float2x2(%s.xy, %s.zw);", proc.getEdgeNormsAttrib().name(),
-                   proc.getEdgeNormsAttrib().name());
+    // Are we clockwise (positive wind, nonzero fill), or counter-clockwise (negative wind,
+    // even/odd fill)?
+    v->codeAppendf("float wind = sign(devbounds.z - devbounds.x);");
 
-    // N[0] is the normal for the edge we are intersecting from the regular bounding box, pointing
-    // out of the octagon.
-    v->codeAppendf("float4 devbounds = %s;",
-                   proc.getInstanceAttrib(InstanceAttribs::kDevBounds).name());
-    v->codeAppend ("float2 refpt = (0 == sk_VertexID >> 2)"
-                           "? float2(min(devbounds.x, devbounds.z), devbounds.y)"
-                           ": float2(max(devbounds.x, devbounds.z), devbounds.w);");
+    // Find our reference corner from the device-space bounding box.
+    v->codeAppendf("float2 refpt = mix(devbounds.xy, devbounds.zw, corners.xy);");
 
-    // N[1] is the normal for the edge we are intersecting from the 45-degree bounding box, pointing
-    // out of the octagon.
-    v->codeAppendf("float2 refpt45 = (0 == ((sk_VertexID + 1) & (1 << 2))) ? %s.xy : %s.zw;",
-                   proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).name(),
-                   proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).name());
-    v->codeAppendf("refpt45 *= float2x2(.5,.5,-.5,.5);"); // transform back to device space.
+    // Find our reference corner from the 45-degree bounding box.
+    v->codeAppendf("float2 refpt45 = mix(devbounds45.xy, devbounds45.zw, corners.zw);");
+    // Transform back to device space.
+    v->codeAppendf("refpt45 *= float2x2(+1, +1, -wind, +wind) * .5;");
 
-    v->codeAppend ("float2 K = float2(dot(N[0], refpt), dot(N[1], refpt45));");
+    // Find the normals to each edge, then intersect them to find our octagon vertex.
+    v->codeAppendf("float2x2 N = float2x2("
+                           "corners.z + corners.w - 1, corners.w - corners.z, "
+                           "corners.xy*2 - 1);");
+    v->codeAppendf("N = float2x2(wind, 0, 0, 1) * N;");
+    v->codeAppendf("float2 K = float2(dot(N[0], refpt), dot(N[1], refpt45));");
     v->codeAppendf("float2 octocoord = K * inverse(N);");
 
     // Round the octagon out to ensure we rasterize every pixel the path might touch. (Positive
@@ -198,16 +191,13 @@
     // NOTE: If we were just drawing a rect, ceil/floor would be enough. But since there are also
     // diagonals in the octagon that cross through pixel centers, we need to outset by another
     // quarter px to ensure those pixels get rasterized.
-    v->codeAppend ("half2 bloatdir = (0 != N[0].x) "
-                           "? half2(half(N[0].x), half(N[1].y))"
-                           ": half2(half(N[1].x), half(N[0].y));");
-    v->codeAppend ("octocoord = (ceil(octocoord * bloatdir - 1e-4) + 0.25) * bloatdir;");
-
-    gpArgs->fPositionVar.set(kFloat2_GrSLType, "octocoord");
+    v->codeAppendf("float2 bloatdir = (0 != N[0].x) "
+                           "? float2(N[0].x, N[1].y)"
+                           ": float2(N[1].x, N[0].y);");
+    v->codeAppendf("octocoord = (ceil(octocoord * bloatdir - 1e-4) + 0.25) * bloatdir;");
 
     // Convert to atlas coordinates in order to do our texture lookup.
-    v->codeAppendf("float2 atlascoord = octocoord + float2(%s);",
-                   proc.getInstanceAttrib(InstanceAttribs::kDevToAtlasOffset).name());
+    v->codeAppendf("float2 atlascoord = octocoord + float2(dev_to_atlas_offset);");
     if (kTopLeft_GrSurfaceOrigin == proc.atlasOrigin()) {
         v->codeAppendf("%s.xy = atlascoord * %s;", texcoord.vsOut(), atlasAdjust);
     } else {
@@ -215,12 +205,11 @@
         v->codeAppendf("%s.xy = float2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);",
                        texcoord.vsOut(), atlasAdjust, atlasAdjust);
     }
-    // The third texture coordinate is -.5 for even-odd paths and +.5 for winding ones.
-    // ("right < left" indicates even-odd fill type.)
-    v->codeAppendf("%s.z = sign(devbounds.z - devbounds.x) * .5;", texcoord.vsOut());
+    v->codeAppendf("%s.z = wind * .5;", texcoord.vsOut());
 
-    this->emitTransforms(v, varyingHandler, uniHandler, GrShaderVar("octocoord", kFloat2_GrSLType),
-                         proc.localMatrix(), args.fFPCoordTransformHandler);
+    gpArgs->fPositionVar.set(kFloat2_GrSLType, "octocoord");
+    this->emitTransforms(v, varyingHandler, uniHandler, gpArgs->fPositionVar, proc.localMatrix(),
+                         args.fFPCoordTransformHandler);
 
     // Fragment shader.
     GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
diff --git a/src/gpu/ccpr/GrCCPathProcessor.h b/src/gpu/ccpr/GrCCPathProcessor.h
index 534f08d..3143819 100644
--- a/src/gpu/ccpr/GrCCPathProcessor.h
+++ b/src/gpu/ccpr/GrCCPathProcessor.h
@@ -31,14 +31,6 @@
  */
 class GrCCPathProcessor : public GrGeometryProcessor {
 public:
-    enum class InstanceAttribs {
-        kDevBounds,
-        kDevBounds45,
-        kDevToAtlasOffset,
-        kColor
-    };
-    static constexpr int kNumInstanceAttribs = 1 + (int)InstanceAttribs::kColor;
-
     // Helper to offset the 45-degree bounding box returned by GrCCPathParser::parsePath().
     static SkRect MakeOffset45(const SkRect& devBounds45, float dx, float dy) {
         // devBounds45 is in "| 1  -1 | * devCoords" space.
@@ -76,12 +68,6 @@
     const SkISize& atlasSize() const { return fAtlasSize; }
     GrSurfaceOrigin atlasOrigin() const { return fAtlasOrigin; }
     const SkMatrix& localMatrix() const { return fLocalMatrix; }
-    const Attribute& getInstanceAttrib(InstanceAttribs attribID) const {
-        int idx = static_cast<int>(attribID);
-        SkASSERT(idx >= 0 && idx < static_cast<int>(SK_ARRAY_COUNT(kInstanceAttribs)));
-        return kInstanceAttribs[idx];
-    }
-    const Attribute& getEdgeNormsAttrib() const { return kEdgeNormsAttrib; }
 
     void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
     GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override;
@@ -98,28 +84,36 @@
     GrSurfaceOrigin fAtlasOrigin;
 
     SkMatrix fLocalMatrix;
-    static constexpr Attribute kInstanceAttribs[kNumInstanceAttribs] = {
+    static constexpr Attribute kInstanceAttribs[] = {
             {"devbounds", kFloat4_GrVertexAttribType, kFloat4_GrSLType},
             {"devbounds45", kFloat4_GrVertexAttribType, kFloat4_GrSLType},
             {"dev_to_atlas_offset", kInt2_GrVertexAttribType, kInt2_GrSLType},
             {"color", kHalf4_GrVertexAttribType, kHalf4_GrSLType}
     };
-    static constexpr Attribute kEdgeNormsAttrib = {"edge_norms", kFloat4_GrVertexAttribType,
-                                                                 kFloat4_GrSLType};
+    static constexpr int kColorAttribIdx = 3;
+    static constexpr Attribute kCornersAttrib =
+            {"corners", kFloat4_GrVertexAttribType, kFloat4_GrSLType};
+
+    class Impl;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
-inline void GrCCPathProcessor::Instance::set(const SkRect& devBounds, const SkRect& devBounds45,
-                                             const SkIVector& devToAtlasOffset, uint64_t color,
-                                             DoEvenOddFill doEvenOddFill) {
-    if (DoEvenOddFill::kYes == doEvenOddFill) {
-        // "right < left" indicates even-odd fill type.
-        fDevBounds.setLTRB(devBounds.fRight, devBounds.fTop, devBounds.fLeft, devBounds.fBottom);
-    } else {
+inline void GrCCPathProcessor::Instance::set(
+        const SkRect& devBounds, const SkRect& devBounds45, const SkIVector& devToAtlasOffset,
+        uint64_t color, DoEvenOddFill doEvenOddFill) {
+    if (DoEvenOddFill::kNo == doEvenOddFill) {
+        // We cover "nonzero" paths with clockwise triangles, which is the default result from
+        // normal bounding boxes.
         fDevBounds = devBounds;
+        fDevBounds45 = devBounds45;
+    } else {
+        // We cover "even/odd" paths with counterclockwise triangles. Reorder the bounding box
+        // vertices so the output is flipped horizontally.
+        fDevBounds.setLTRB(devBounds.fRight, devBounds.fTop, devBounds.fLeft, devBounds.fBottom);
+        fDevBounds45.setLTRB(
+                devBounds45.fBottom, devBounds45.fRight, devBounds45.fTop, devBounds45.fLeft);
     }
-    fDevBounds45 = devBounds45;
     fDevToAtlasOffset = devToAtlasOffset;
     fColor = color;
 }