Fix hairline pathrenderer for Nexus-10. Switches to passing in an offset and using that to compute …

src/gpu/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 11 matching lines @@
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
 
 namespace {
 // quadratics are rendered as 5-sided polys in order to bound the
 // AA stroke around the center-curve. See comments in push_quad_index_buffer and
 // bloat_quad. Quadratics and conics share an index buffer
 static const int kVertsPerQuad = 5;
 static const int kIdxsPerQuad = 9;
 
-static const int kVertsPerLineSeg = 4;
-static const int kIdxsPerLineSeg = 6;
+static const int kVertsPerLineSeg = 6;
+static const int kIdxsPerLineSeg = 12;
 
 static const int kNumQuadsInIdxBuffer = 256;
 static const size_t kQuadIdxSBufize = kIdxsPerQuad *
                                       sizeof(uint16_t) *
                                       kNumQuadsInIdxBuffer;
 
-bool push_quad_index_data(GrIndexBuffer* qIdxBuffer) {
+static const int kNumLineSegsInIdxBuffer = 256;
+static const size_t kLineSegIdxSBufize = kIdxsPerLineSeg *
+                                         sizeof(uint16_t) *
+                                         kNumLineSegsInIdxBuffer;
+
+static bool push_quad_index_data(GrIndexBuffer* qIdxBuffer) {
     uint16_t* data = (uint16_t*) qIdxBuffer->lock();
     bool tempData = NULL == data;
     if (tempData) {
         data = SkNEW_ARRAY(uint16_t, kNumQuadsInIdxBuffer * kIdxsPerQuad);
     }
     for (int i = 0; i < kNumQuadsInIdxBuffer; ++i) {
 
         // Each quadratic is rendered as a five sided polygon. This poly bounds
         // the quadratic's bounding triangle but has been expanded so that the
         // 1-pixel wide area around the curve is inside the poly.
@@ skipping 20 matching lines @@
     }
     if (tempData) {
         bool ret = qIdxBuffer->updateData(data, kQuadIdxSBufize);
         delete[] data;
         return ret;
     } else {
         qIdxBuffer->unlock();
         return true;
     }
 }
+
+static bool push_line_index_data(GrIndexBuffer* lIdxBuffer) {
+    uint16_t* data = (uint16_t*) lIdxBuffer->lock();
+    bool tempData = NULL == data;
+    if (tempData) {
+        data = SkNEW_ARRAY(uint16_t, kNumLineSegsInIdxBuffer * kIdxsPerLineSeg);
+    }
+    for (int i = 0; i < kNumLineSegsInIdxBuffer; ++i) {
+        // Each line segment is rendered as two quads, with alpha = 1 along the
+        // spine of the segment, and alpha = 0 along the outer edges, represented
+        // horizontally (i.e., the line equation is t*(p1-p0) + p0)
+        //
+        // p4                  p5
+        // p0                  p1
+        // p2                  p3
+        //
+        // Each is drawn as four triangles specified by these 12 indices:
+        int baseIdx = i * kIdxsPerLineSeg;
+        uint16_t baseVert = (uint16_t)(i * kVertsPerLineSeg);
+        data[0 + baseIdx] = baseVert + 0; // p0
+        data[1 + baseIdx] = baseVert + 1; // p1
+        data[2 + baseIdx] = baseVert + 2; // p2
+        
+        data[3 + baseIdx] = baseVert + 2; // p2
+        data[4 + baseIdx] = baseVert + 1; // p1
+        data[5 + baseIdx] = baseVert + 3; // p3
+        
+        data[6 + baseIdx] = baseVert + 0; // p0
+        data[7 + baseIdx] = baseVert + 5; // p5
+        data[8 + baseIdx] = baseVert + 1; // p1
+        
+        data[9 + baseIdx] = baseVert + 0; // p0
+        data[10+ baseIdx] = baseVert + 4; // p4
+        data[11+ baseIdx] = baseVert + 5; // p5
+    }
+    if (tempData) {
+        bool ret = lIdxBuffer->updateData(data, kLineSegIdxSBufize);
+        delete[] data;
+        return ret;
+    } else {
+        lIdxBuffer->unlock();
+        return true;
+    }
+}
 }
 
 GrPathRenderer* GrAAHairLinePathRenderer::Create(GrContext* context) {
-    const GrIndexBuffer* lIdxBuffer = context->getQuadIndexBuffer();
-    if (NULL == lIdxBuffer) {
-        return NULL;
-    }
     GrGpu* gpu = context->getGpu();
     GrIndexBuffer* qIdxBuf = gpu->createIndexBuffer(kQuadIdxSBufize, false);
     SkAutoTUnref<GrIndexBuffer> qIdxBuffer(qIdxBuf);
-    if (NULL == qIdxBuf ||
-        !push_quad_index_data(qIdxBuf)) {
+    if (NULL == qIdxBuf || !push_quad_index_data(qIdxBuf)) {
+        return NULL;
+    }
+    GrIndexBuffer* lIdxBuf = gpu->createIndexBuffer(kLineSegIdxSBufize, false);
+    SkAutoTUnref<GrIndexBuffer> lIdxBuffer(lIdxBuf);
+    if (NULL == lIdxBuf || !push_line_index_data(lIdxBuf)) {
         return NULL;
     }
     return SkNEW_ARGS(GrAAHairLinePathRenderer,
-                      (context, lIdxBuffer, qIdxBuf));
+                      (context, lIdxBuf, qIdxBuf));
 }
 
 GrAAHairLinePathRenderer::GrAAHairLinePathRenderer(
                                         const GrContext* context,
                                         const GrIndexBuffer* linesIndexBuffer,
                                         const GrIndexBuffer* quadsIndexBuffer) {
     fLinesIndexBuffer = linesIndexBuffer;
     linesIndexBuffer->ref();
     fQuadsIndexBuffer = quadsIndexBuffer;
     quadsIndexBuffer->ref();
 }
 
 GrAAHairLinePathRenderer::~GrAAHairLinePathRenderer() {
     fLinesIndexBuffer->unref();
     fQuadsIndexBuffer->unref();
 }
 
 namespace {
 
-typedef SkTArray<SkPoint, true> PtArray;
 #define PREALLOC_PTARRAY(N) SkSTArray<(N),SkPoint, true>
-typedef SkTArray<int, true> IntArray;
-typedef SkTArray<float, true> FloatArray;
 
 // Takes 178th time of logf on Z600 / VC2010
 int get_float_exp(float x) {
     GR_STATIC_ASSERT(sizeof(int) == sizeof(float));
 #if GR_DEBUG
     static bool tested;
     if (!tested) {
         tested = true;
         GrAssert(get_float_exp(0.25f) == -2);
         GrAssert(get_float_exp(0.3f) == -2);
@@ skipping 129 matching lines @@
  * device space. We will do a device space bloat to account for the 1pixel
  * thickness.
  * Quads are recorded in device space unless m contains
  * perspective, then in they are in src space. We do this because we will
  * subdivide large quads to reduce over-fill. This subdivision has to be
  * performed before applying the perspective matrix.
  */
 int generate_lines_and_quads(const SkPath& path,
                              const SkMatrix& m,
                              const SkIRect& devClipBounds,
-                             PtArray* lines,
-                             PtArray* quads,
-                             PtArray* conics,
-                             IntArray* quadSubdivCnts,
-                             FloatArray* conicWeights) {
+                             GrAAHairLinePathRenderer::PtArray* lines,
+                             GrAAHairLinePathRenderer::PtArray* quads,
+                             GrAAHairLinePathRenderer::PtArray* conics,
+                             GrAAHairLinePathRenderer::IntArray* quadSubdivCnts,
+                             GrAAHairLinePathRenderer::FloatArray* conicWeights) {
     SkPath::Iter iter(path, false);
 
     int totalQuadCount = 0;
     SkRect bounds;
     SkIRect ibounds;
 
     bool persp = m.hasPerspective();
 
     for (;;) {
         GrPoint pathPts[4];
@@ skipping 141 matching lines @@
                 }
                 break;
             case SkPath::kClose_Verb:
                 break;
             case SkPath::kDone_Verb:
                 return totalQuadCount;
         }
     }
 }
 
-struct Vertex {
+struct LineVertex {
+    GrPoint fPos;
+    GrColor fCoverage;
+};
+        
+struct BezierVertex {
     GrPoint fPos;
     union {
         struct {
-            SkScalar fA;
-            SkScalar fB;
-            SkScalar fC;
-        } fLine;
-        struct {
             SkScalar fK;
             SkScalar fL;
             SkScalar fM;
         } fConic;
         GrVec   fQuadCoord;
         struct {
             SkScalar fBogus[4];
         };
     };
 };
 
-GR_STATIC_ASSERT(sizeof(Vertex) == 3 * sizeof(GrPoint));
+GR_STATIC_ASSERT(sizeof(BezierVertex) == 3 * sizeof(GrPoint));
 
 void intersect_lines(const SkPoint& ptA, const SkVector& normA,
                      const SkPoint& ptB, const SkVector& normB,
                      SkPoint* result) {
 
     SkScalar lineAW = -normA.dot(ptA);
     SkScalar lineBW = -normB.dot(ptB);
 
     SkScalar wInv = SkScalarMul(normA.fX, normB.fY) -
         SkScalarMul(normA.fY, normB.fX);
     wInv = SkScalarInvert(wInv);
 
     result->fX = SkScalarMul(normA.fY, lineBW) - SkScalarMul(lineAW, normB.fY);
     result->fX = SkScalarMul(result->fX, wInv);
 
     result->fY = SkScalarMul(lineAW, normB.fX) - SkScalarMul(normA.fX, lineBW);
     result->fY = SkScalarMul(result->fY, wInv);
 }
 
-void set_uv_quad(const SkPoint qpts[3], Vertex verts[kVertsPerQuad]) {
+void set_uv_quad(const SkPoint qpts[3], BezierVertex verts[kVertsPerQuad]) {
     // this should be in the src space, not dev coords, when we have perspective
     GrPathUtils::QuadUVMatrix DevToUV(qpts);
-    DevToUV.apply<kVertsPerQuad, sizeof(Vertex), sizeof(GrPoint)>(verts);
+    DevToUV.apply<kVertsPerQuad, sizeof(BezierVertex), sizeof(GrPoint)>(verts);
 }
 
 void bloat_quad(const SkPoint qpts[3], const SkMatrix* toDevice,
-                const SkMatrix* toSrc, Vertex verts[kVertsPerQuad],
+                const SkMatrix* toSrc, BezierVertex verts[kVertsPerQuad],
                 SkRect* devBounds) {
     GrAssert(!toDevice == !toSrc);
     // original quad is specified by tri a,b,c
     SkPoint a = qpts[0];
     SkPoint b = qpts[1];
     SkPoint c = qpts[2];
 
     if (toDevice) {
         toDevice->mapPoints(&a, 1);
         toDevice->mapPoints(&b, 1);
         toDevice->mapPoints(&c, 1);
     }
     // make a new poly where we replace a and c by a 1-pixel wide edges orthog
     // to edges ab and bc:
     //
     //   before       |        after
     //                |              b0
     //         b      |
     //                |
     //                |     a0            c0
     // a         c    |        a1       c1
     //
     // edges a0->b0 and b0->c0 are parallel to original edges a->b and b->c,
     // respectively.
-    Vertex& a0 = verts[0];
-    Vertex& a1 = verts[1];
-    Vertex& b0 = verts[2];
-    Vertex& c0 = verts[3];
-    Vertex& c1 = verts[4];
+    BezierVertex& a0 = verts[0];
+    BezierVertex& a1 = verts[1];
+    BezierVertex& b0 = verts[2];
+    BezierVertex& c0 = verts[3];
+    BezierVertex& c1 = verts[4];
 
     SkVector ab = b;
     ab -= a;
     SkVector ac = c;
     ac -= a;
     SkVector cb = b;
     cb -= c;
 
     // We should have already handled degenerates
     GrAssert(ab.length() > 0 && cb.length() > 0);
@@ skipping 21 matching lines @@
     c0.fPos += cbN;
     c1.fPos = c;
     c1.fPos -= cbN;
 
     // This point may not be within 1 pixel of a control point. We update the bounding box to
     // include it.
     intersect_lines(a0.fPos, abN, c0.fPos, cbN, &b0.fPos);
     devBounds->growToInclude(b0.fPos.fX, b0.fPos.fY);
 
     if (toSrc) {
-        toSrc->mapPointsWithStride(&verts[0].fPos, sizeof(Vertex), kVertsPerQuad);
+        toSrc->mapPointsWithStride(&verts[0].fPos, sizeof(BezierVertex), kVertsPerQuad);
     }
 }
 
 // Input:
 // Three control points: p[0], p[1], p[2] and weight: w
 // Output:
 // Let:
 // l = (2*w * (y1 - y0), 2*w * (x0 - x1), 2*w * (x1*y0 - x0*y1))
 // m = (2*w * (y2 - y1), 2*w * (x1 - x2), 2*w * (x2*y1 - x1*y2))
 // k = (y2 - y0, x0 - x2, (x2 - x0)*y0 - (y2 - y0)*x0 )
@@ skipping 32 matching lines @@
     m[2] /= scale;
 }
 
 // Equations based off of Loop-Blinn Quadratic GPU Rendering
 // Input Parametric:
 // P(t) = (P0*(1-t)^2 + 2*w*P1*t*(1-t) + P2*t^2) / (1-t)^2 + 2*w*t*(1-t) + t^2)
 // Output Implicit:
 // f(x, y, w) = f(P) = K^2 - LM
 // K = dot(k, P), L = dot(l, P), M = dot(m, P)
 // k, l, m are calculated in function calc_conic_klm
-void set_conic_coeffs(const SkPoint p[3], Vertex verts[kVertsPerQuad], const float weight) {
+void set_conic_coeffs(const SkPoint p[3], BezierVertex verts[kVertsPerQuad], const float weight) {
     SkScalar k[3];
     SkScalar l[3];
     SkScalar m[3];
 
     calc_conic_klm(p, weight, k, l, m);
 
     for (int i = 0; i < kVertsPerQuad; ++i) {
         const SkPoint pnt = verts[i].fPos;
         verts[i].fConic.fK = pnt.fX * k[0] + pnt.fY * k[1] + k[2];
         verts[i].fConic.fL = pnt.fX * l[0] + pnt.fY * l[1] + l[2];
         verts[i].fConic.fM = pnt.fX * m[0] + pnt.fY * m[1] + m[2];
     }
 }
 
 void add_conics(const SkPoint p[3],
                 float weight,
                 const SkMatrix* toDevice,
                 const SkMatrix* toSrc,
-                Vertex** vert,
+                BezierVertex** vert,
                 SkRect* devBounds) {
     bloat_quad(p, toDevice, toSrc, *vert, devBounds);
     set_conic_coeffs(p, *vert, weight);
     *vert += kVertsPerQuad;
 }
 
 void add_quads(const SkPoint p[3],
                int subdiv,
                const SkMatrix* toDevice,
                const SkMatrix* toSrc,
-               Vertex** vert,
+               BezierVertex** vert,
                SkRect* devBounds) {
     GrAssert(subdiv >= 0);
     if (subdiv) {
         SkPoint newP[5];
         SkChopQuadAtHalf(p, newP);
         add_quads(newP + 0, subdiv-1, toDevice, toSrc, vert, devBounds);
         add_quads(newP + 2, subdiv-1, toDevice, toSrc, vert, devBounds);
     } else {
         bloat_quad(p, toDevice, toSrc, *vert, devBounds);
         set_uv_quad(p, *vert);
         *vert += kVertsPerQuad;
     }
 }
 
 void add_line(const SkPoint p[2],
               int rtHeight,
               const SkMatrix* toSrc,
-              Vertex** vert) {
+              GrColor coverage,
+              LineVertex** vert) {
     const SkPoint& a = p[0];
     const SkPoint& b = p[1];
 
     SkVector orthVec = b;
     orthVec -= a;
 
     if (orthVec.setLength(SK_Scalar1)) {
         orthVec.setOrthog(orthVec);
 
-        SkScalar lineC = -(a.dot(orthVec));
         for (int i = 0; i < kVertsPerLineSeg; ++i) {
-            (*vert)[i].fPos = (i < 2) ? a : b;
-            if (0 == i || 3 == i) {
+            (*vert)[i].fPos = (i & 0x1) ? b : a;
+            if (i & 0x2) {
+                (*vert)[i].fPos += orthVec;
+                (*vert)[i].fCoverage = 0;
+            } else if (i & 0x4) {
                 (*vert)[i].fPos -= orthVec;
+                (*vert)[i].fCoverage = 0;
             } else {
-                (*vert)[i].fPos += orthVec;
+                (*vert)[i].fCoverage = coverage;
             }
-            (*vert)[i].fLine.fA = orthVec.fX;
-            (*vert)[i].fLine.fB = orthVec.fY;
-            (*vert)[i].fLine.fC = lineC;
         }
         if (NULL != toSrc) {
             toSrc->mapPointsWithStride(&(*vert)->fPos,
-                                       sizeof(Vertex),
+                                       sizeof(LineVertex),
                                        kVertsPerLineSeg);
         }
     } else {
         // just make it degenerate and likely offscreen
-        (*vert)[0].fPos.set(SK_ScalarMax, SK_ScalarMax);
-        (*vert)[1].fPos.set(SK_ScalarMax, SK_ScalarMax);
-        (*vert)[2].fPos.set(SK_ScalarMax, SK_ScalarMax);
-        (*vert)[3].fPos.set(SK_ScalarMax, SK_ScalarMax);
+        for (int i = 0; i < kVertsPerLineSeg; ++i) {
+            (*vert)[i].fPos.set(SK_ScalarMax, SK_ScalarMax);
+        }
     }
 
     *vert += kVertsPerLineSeg;
 }
 
 }
 
 /**
  * Shader is based off of Loop-Blinn Quadratic GPU Rendering
  * The output of this effect is a hairline edge for conics.
@@ skipping 230 matching lines @@
 GrEffectRef* HairQuadEdgeEffect::TestCreate(SkMWCRandom* random,
                                             GrContext*,
                                             const GrDrawTargetCaps& caps,
                                             GrTexture*[]) {
     // Doesn't work without derivative instructions.
     return caps.shaderDerivativeSupport() ? HairQuadEdgeEffect::Create() : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-/**
- * The output of this effect is a 1-pixel wide line.
- * Input is 2D implicit device coord line eq (a*x + b*y +c = 0). 4th component unused.
- */
-class HairLineEdgeEffect : public GrEffect {
-public:
-
-    static GrEffectRef* Create() {
-        GR_CREATE_STATIC_EFFECT(gHairLineEdge, HairLineEdgeEffect, ());
-        gHairLineEdge->ref();
-        return gHairLineEdge;
-    }
-
-    virtual ~HairLineEdgeEffect() {}
-
-    static const char* Name() { return "HairLineEdge"; }
-
-    virtual void getConstantColorComponents(GrColor* color,
-                                            uint32_t* validFlags) const SK_OVERRIDE {
-        *validFlags = 0;
-    }
-
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
-        return GrTBackendEffectFactory<HairLineEdgeEffect>::getInstance();
-    }
-
-    class GLEffect : public GrGLEffect {
-    public:
-        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
-            : INHERITED (factory) {}
-
-        virtual void emitCode(GrGLShaderBuilder* builder,
-                              const GrDrawEffect& drawEffect,
-                              EffectKey key,
-                              const char* outputColor,
-                              const char* inputColor,
-                              const TextureSamplerArray& samplers) SK_OVERRIDE {
-            const char *vsName, *fsName;
-            const SkString* attrName =
-                builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-            builder->fsCodeAppendf("\t\tfloat edgeAlpha;\n");
-
-            builder->addVarying(kVec4f_GrSLType, "HairLineEdge", &vsName, &fsName);
-
-            builder->fsCodeAppendf("\t\tedgeAlpha = abs(dot(vec3(%s.xy,1), %s.xyz));\n",
-                                   builder->fragmentPosition(), fsName);
-            builder->fsCodeAppendf("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
-
-            SkString modulate;
-            GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
-            builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
-
-            builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str());
-        }
-
-        static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
-            return 0x0;
-        }
-
-        virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
-
-    private:
-        typedef GrGLEffect INHERITED;
-    };
-
-private:
-    HairLineEdgeEffect() {
-        this->addVertexAttrib(kVec4f_GrSLType);
-        this->setWillReadFragmentPosition();
-    }
-
-    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
-        return true;
-    }
-
-    GR_DECLARE_EFFECT_TEST;
-
-    typedef GrEffect INHERITED;
-};
-
-GR_DEFINE_EFFECT_TEST(HairLineEdgeEffect);
-
-GrEffectRef* HairLineEdgeEffect::TestCreate(SkMWCRandom* random,
-                                            GrContext*,
-                                            const GrDrawTargetCaps& caps,
-                                            GrTexture*[]) {
-    return HairLineEdgeEffect::Create();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 namespace {
 
 // position + edge
-extern const GrVertexAttrib gHairlineAttribs[] = {
+extern const GrVertexAttrib gHairlineBezierAttribs[] = {
     {kVec2f_GrVertexAttribType, 0,                  kPosition_GrVertexAttribBinding},
     {kVec4f_GrVertexAttribType, sizeof(GrPoint),    kEffect_GrVertexAttribBinding}
 };
+
+// position + coverage
+extern const GrVertexAttrib gHairlineLineAttribs[] = {
+    {kVec2f_GrVertexAttribType,  0,               kPosition_GrVertexAttribBinding},
+    {kVec4ub_GrVertexAttribType, sizeof(GrPoint), kCoverage_GrVertexAttribBinding},
 };
 
-bool GrAAHairLinePathRenderer::createGeom(
+};
+
+bool GrAAHairLinePathRenderer::createLineGeom(
             const SkPath& path,
             GrDrawTarget* target,
-            int* lineCnt,
-            int* quadCnt,
-            int* conicCnt,
+            const PtArray& lines,
+            int lineCnt,
             GrDrawTarget::AutoReleaseGeometry* arg,
             SkRect* devBounds) {
     GrDrawState* drawState = target->drawState();
     int rtHeight = drawState->getRenderTarget()->height();
 
-    SkIRect devClipBounds;
-    target->getClip()->getConservativeBounds(drawState->getRenderTarget(), &devClipBounds);
+    const SkMatrix& viewM = drawState->getViewMatrix();
 
-    SkMatrix viewM = drawState->getViewMatrix();
+    *devBounds = path.getBounds();
+    viewM.mapRect(devBounds);
+    devBounds->outset(SK_Scalar1, SK_Scalar1);
 
+    int vertCnt = kVertsPerLineSeg * lineCnt;
+
+    target->drawState()->setVertexAttribs<gHairlineLineAttribs>(SK_ARRAY_COUNT(gHairlineLineAttribs));
+    GrAssert(sizeof(LineVertex) == target->getDrawState().getVertexSize());
+
+    if (!arg->set(target, vertCnt, 0)) {
+        return false;
+    }
+
+    LineVertex* verts = reinterpret_cast<LineVertex*>(arg->vertices());
+
+    const SkMatrix* toSrc = NULL;
+    SkMatrix ivm;
+
+    if (viewM.hasPerspective()) {
+        if (viewM.invert(&ivm)) {
+            toSrc = &ivm;
+        }
+    }
+
+    for (int i = 0; i < lineCnt; ++i) {
+        add_line(&lines[2*i], rtHeight, toSrc, drawState->getCoverage(), &verts);
+    }
+
+    return true;
+}
+
+bool GrAAHairLinePathRenderer::createBezierGeom(
+                                          const SkPath& path,
+                                          GrDrawTarget* target,
+                                          const PtArray& quads,
+                                          int quadCnt,
+                                          const PtArray& conics,
+                                          int conicCnt,
+                                          const IntArray& qSubdivs,
+                                          const FloatArray& cWeights,
+                                          GrDrawTarget::AutoReleaseGeometry* arg,
+                                          SkRect* devBounds) {
+    GrDrawState* drawState = target->drawState();
+    
+    const SkMatrix& viewM = drawState->getViewMatrix();
+    
     // All the vertices that we compute are within 1 of path control points with the exception of
     // one of the bounding vertices for each quad. The add_quads() function will update the bounds
     // for each quad added.
     *devBounds = path.getBounds();
     viewM.mapRect(devBounds);
     devBounds->outset(SK_Scalar1, SK_Scalar1);
-
-    PREALLOC_PTARRAY(128) lines;
-    PREALLOC_PTARRAY(128) quads;
-    PREALLOC_PTARRAY(128) conics;
-    IntArray qSubdivs;
-    FloatArray cWeights;
-    *quadCnt = generate_lines_and_quads(path, viewM, devClipBounds,
-                                        &lines, &quads, &conics, &qSubdivs, &cWeights);
-
-    *lineCnt = lines.count() / 2;
-    *conicCnt = conics.count() / 3;
-    int vertCnt = kVertsPerLineSeg * *lineCnt + kVertsPerQuad * *quadCnt +
-        kVertsPerQuad * *conicCnt;
-
-    target->drawState()->setVertexAttribs<gHairlineAttribs>(SK_ARRAY_COUNT(gHairlineAttribs));
-    GrAssert(sizeof(Vertex) == target->getDrawState().getVertexSize());
-
+    
+    int vertCnt = kVertsPerQuad * quadCnt + kVertsPerQuad * conicCnt;
+    
+    target->drawState()->setVertexAttribs<gHairlineBezierAttribs>(SK_ARRAY_COUNT(gHairlineBezierAttribs));
+    GrAssert(sizeof(BezierVertex) == target->getDrawState().getVertexSize());
+    
     if (!arg->set(target, vertCnt, 0)) {
         return false;
     }
-
-    Vertex* verts = reinterpret_cast<Vertex*>(arg->vertices());
-
+    
+    BezierVertex* verts = reinterpret_cast<BezierVertex*>(arg->vertices());
+    
     const SkMatrix* toDevice = NULL;
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
-
+    
     if (viewM.hasPerspective()) {
         if (viewM.invert(&ivm)) {
             toDevice = &viewM;
             toSrc = &ivm;
         }
     }
-
-    for (int i = 0; i < *lineCnt; ++i) {
-        add_line(&lines[2*i], rtHeight, toSrc, &verts);
-    }
-
+    
     int unsubdivQuadCnt = quads.count() / 3;
     for (int i = 0; i < unsubdivQuadCnt; ++i) {
         GrAssert(qSubdivs[i] >= 0);
         add_quads(&quads[3*i], qSubdivs[i], toDevice, toSrc, &verts, devBounds);
     }
-
+    
     // Start Conics
-    for (int i = 0; i < *conicCnt; ++i) {
+    for (int i = 0; i < conicCnt; ++i) {
         add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &verts, devBounds);
     }
     return true;
 }
 
 bool GrAAHairLinePathRenderer::canDrawPath(const SkPath& path,
                                            const SkStrokeRec& stroke,
                                            const GrDrawTarget* target,
                                            bool antiAlias) const {
     if (!stroke.isHairlineStyle() || !antiAlias) {
         return false;
     }
 
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks() ||
         target->caps()->shaderDerivativeSupport()) {
         return true;
     }
     return false;
 }
 
-bool GrAAHairLinePathRenderer::onDrawPath(const SkPath& path,
-                                          const SkStrokeRec&,
-                                          GrDrawTarget* target,
-                                          bool antiAlias) {
-
-    int lineCnt;
-    int quadCnt;
-    int conicCnt;
-    GrDrawTarget::AutoReleaseGeometry arg;
-    SkRect devBounds;
-
-    if (!this->createGeom(path,
-                          target,
-                          &lineCnt,
-                          &quadCnt,
-                          &conicCnt,
-                          &arg,
-                          &devBounds)) {
-        return false;
-    }
-
-    GrDrawTarget::AutoStateRestore asr;
-
-    // createGeom transforms the geometry to device space when the matrix does not have
-    // perspective.
-    if (target->getDrawState().getViewMatrix().hasPerspective()) {
-        asr.set(target, GrDrawTarget::kPreserve_ASRInit);
-    } else if (!asr.setIdentity(target, GrDrawTarget::kPreserve_ASRInit)) {
-        return false;
-    }
-    GrDrawState* drawState = target->drawState();
-
-    // TODO: See whether rendering lines as degenerate quads improves perf
-    // when we have a mix
-
-    static const int kEdgeAttrIndex = 1;
-
-    GrEffectRef* hairLineEffect = HairLineEdgeEffect::Create();
-    GrEffectRef* hairQuadEffect = HairQuadEdgeEffect::Create();
-    GrEffectRef* hairConicEffect = HairConicEdgeEffect::Create();
-
-    // Check devBounds
-#if GR_DEBUG
+template <class VertexType>
+bool check_bounds(GrDrawState* drawState, const SkRect& devBounds, void* vertices, int vCount)
+{
     SkRect tolDevBounds = devBounds;
     tolDevBounds.outset(SK_Scalar1 / 10000, SK_Scalar1 / 10000);
     SkRect actualBounds;
-    Vertex* verts = reinterpret_cast<Vertex*>(arg.vertices());
-    int vCount = kVertsPerLineSeg * lineCnt + kVertsPerQuad * quadCnt + kVertsPerQuad * conicCnt;
+    
+    VertexType* verts = reinterpret_cast<VertexType*>(vertices);
     bool first = true;
     for (int i = 0; i < vCount; ++i) {
         SkPoint pos = verts[i].fPos;
         // This is a hack to workaround the fact that we move some degenerate segments offscreen.
         if (SK_ScalarMax == pos.fX) {
             continue;
         }
         drawState->getViewMatrix().mapPoints(&pos, 1);
         if (first) {
             actualBounds.set(pos.fX, pos.fY, pos.fX, pos.fY);
             first = false;
         } else {
             actualBounds.growToInclude(pos.fX, pos.fY);
         }
     }
     if (!first) {
-        GrAssert(tolDevBounds.contains(actualBounds));
+        return tolDevBounds.contains(actualBounds);
     }
-#endif
+    
+    return true;
+}
 
+bool GrAAHairLinePathRenderer::onDrawPath(const SkPath& path,
+                                          const SkStrokeRec&,
+                                          GrDrawTarget* target,
+                                          bool antiAlias) {
+    
+    GrDrawState* drawState = target->drawState();
+    
+    SkIRect devClipBounds;
+    target->getClip()->getConservativeBounds(drawState->getRenderTarget(), &devClipBounds);
+    
+    int lineCnt;
+    int quadCnt;
+    int conicCnt;
+    PREALLOC_PTARRAY(128) lines;
+    PREALLOC_PTARRAY(128) quads;
+    PREALLOC_PTARRAY(128) conics;
+    IntArray qSubdivs;
+    FloatArray cWeights;
+    quadCnt = generate_lines_and_quads(path, drawState->getViewMatrix(), devClipBounds,
+                                       &lines, &quads, &conics, &qSubdivs, &cWeights);
+    lineCnt = lines.count() / 2;
+    conicCnt = conics.count() / 3;
+    
+    // do lines first
     {
-        GrDrawState::AutoRestoreEffects are(drawState);
-        target->setIndexSourceToBuffer(fLinesIndexBuffer);
-        int lines = 0;
-        int nBufLines = fLinesIndexBuffer->maxQuads();
-        drawState->addCoverageEffect(hairLineEffect, kEdgeAttrIndex)->unref();
-        while (lines < lineCnt) {
-            int n = GrMin(lineCnt - lines, nBufLines);
-            target->drawIndexed(kTriangles_GrPrimitiveType,
-                                kVertsPerLineSeg*lines,     // startV
-                                0,                          // startI
-                                kVertsPerLineSeg*n,         // vCount
-                                kIdxsPerLineSeg*n,
-                                &devBounds);                // iCount
-            lines += n;
+        GrDrawTarget::AutoReleaseGeometry arg;
+        SkRect devBounds;
+
+        if (!this->createLineGeom(path,
+                                  target,
+                                  lines,
+                                  lineCnt,
+                                  &arg,
+                                  &devBounds)) {
+            return false;
+        }
+
+        GrDrawTarget::AutoStateRestore asr;
+
+        // createGeom transforms the geometry to device space when the matrix does not have
+        // perspective.
+        if (target->getDrawState().getViewMatrix().hasPerspective()) {
+            asr.set(target, GrDrawTarget::kPreserve_ASRInit);
+        } else if (!asr.setIdentity(target, GrDrawTarget::kPreserve_ASRInit)) {
+            return false;
+        }
+        GrDrawState* drawState = target->drawState();
+
+        // Check devBounds
+        SkASSERT(check_bounds<LineVertex>(drawState, devBounds, arg.vertices(),
+                                          kVertsPerLineSeg * lineCnt));
+
+        {
+            GrDrawState::AutoRestoreEffects are(drawState);
+            target->setIndexSourceToBuffer(fLinesIndexBuffer);
+            int lines = 0;
+            while (lines < lineCnt) {
+                int n = GrMin(lineCnt - lines, kNumLineSegsInIdxBuffer);
+                target->drawIndexed(kTriangles_GrPrimitiveType,
+                                    kVertsPerLineSeg*lines,     // startV
+                                    0,                          // startI
+                                    kVertsPerLineSeg*n,         // vCount
+                                    kIdxsPerLineSeg*n,
+                                    &devBounds);                // iCount
+                lines += n;
+            }
         }
     }
+    
+    // then quadratics/conics
+    {
+        GrDrawTarget::AutoReleaseGeometry arg;
+        SkRect devBounds;
+        
+        if (!this->createBezierGeom(path,
+                                    target,
+                                    quads,
+                                    quadCnt,
+                                    conics,
+                                    conicCnt,
+                                    qSubdivs,
+                                    cWeights,
+                                    &arg,
+                                    &devBounds)) {
+            return false;
+        }
+        
+        GrDrawTarget::AutoStateRestore asr;
+        
+        // createGeom transforms the geometry to device space when the matrix does not have
+        // perspective.
+        if (target->getDrawState().getViewMatrix().hasPerspective()) {
+            asr.set(target, GrDrawTarget::kPreserve_ASRInit);
+        } else if (!asr.setIdentity(target, GrDrawTarget::kPreserve_ASRInit)) {
+            return false;
+        }
+        GrDrawState* drawState = target->drawState();
 
-    {
-        GrDrawState::AutoRestoreEffects are(drawState);
-        target->setIndexSourceToBuffer(fQuadsIndexBuffer);
-        int quads = 0;
-        drawState->addCoverageEffect(hairQuadEffect, kEdgeAttrIndex)->unref();
-        while (quads < quadCnt) {
-            int n = GrMin(quadCnt - quads, kNumQuadsInIdxBuffer);
-            target->drawIndexed(kTriangles_GrPrimitiveType,
-                                kVertsPerLineSeg * lineCnt + kVertsPerQuad*quads,  // startV
-                                0,                                                 // startI
-                                kVertsPerQuad*n,                                   // vCount
-                                kIdxsPerQuad*n,                                    // iCount
-                                &devBounds);
-            quads += n;
+        static const int kEdgeAttrIndex = 1;
+        
+        GrEffectRef* hairQuadEffect = HairQuadEdgeEffect::Create();
+        GrEffectRef* hairConicEffect = HairConicEdgeEffect::Create();
+        
+        // Check devBounds
+        SkASSERT(check_bounds<BezierVertex>(drawState, devBounds, arg.vertices(),
+                                            kVertsPerQuad * quadCnt + kVertsPerQuad * conicCnt));
+        
+        {
+            GrDrawState::AutoRestoreEffects are(drawState);
+            target->setIndexSourceToBuffer(fQuadsIndexBuffer);
+            int quads = 0;
+            drawState->addCoverageEffect(hairQuadEffect, kEdgeAttrIndex)->unref();
+            while (quads < quadCnt) {
+                int n = GrMin(quadCnt - quads, kNumQuadsInIdxBuffer);
+                target->drawIndexed(kTriangles_GrPrimitiveType,
+                                    kVertsPerQuad*quads,               // startV
+                                    0,                                 // startI
+                                    kVertsPerQuad*n,                   // vCount
+                                    kIdxsPerQuad*n,                    // iCount
+                                    &devBounds);
+                quads += n;
+            }
+        }
+        
+        {
+            GrDrawState::AutoRestoreEffects are(drawState);
+            int conics = 0;
+            drawState->addCoverageEffect(hairConicEffect, 1, 2)->unref();
+            while (conics < conicCnt) {
+                int n = GrMin(conicCnt - conics, kNumQuadsInIdxBuffer);
+                target->drawIndexed(kTriangles_GrPrimitiveType,
+                                    kVertsPerQuad*(quadCnt + conics),  // startV
+                                    0,                                 // startI
+                                    kVertsPerQuad*n,                   // vCount
+                                    kIdxsPerQuad*n,                    // iCount
+                                    &devBounds);
+                conics += n;
+            }
         }
     }
-
-    {
-        GrDrawState::AutoRestoreEffects are(drawState);
-        int conics = 0;
-        drawState->addCoverageEffect(hairConicEffect, 1, 2)->unref();
-        while (conics < conicCnt) {
-            int n = GrMin(conicCnt - conics, kNumQuadsInIdxBuffer);
-            target->drawIndexed(kTriangles_GrPrimitiveType,
-                                kVertsPerLineSeg*lineCnt +
-                                kVertsPerQuad*(quadCnt + conics),  // startV
-                                0,                                 // startI
-                                kVertsPerQuad*n,                   // vCount
-                                kIdxsPerQuad*n,                    // iCount
-                                &devBounds);
-            conics += n;
-        }
-    }
+    
     target->resetIndexSource();
 
     return true;
 }