diff --git a/gpu/include/GrDrawTarget.h b/gpu/include/GrDrawTarget.h
index d8d0498..d576d80 100644
--- a/gpu/include/GrDrawTarget.h
+++ b/gpu/include/GrDrawTarget.h
@@ -89,6 +89,10 @@
         kNoColorWrites_StateBit = 0x08, //<! If set it disables writing colors.
                                         //   Useful while performing stencil
                                         //   ops.
+        kEdgeAAConcave_StateBit =  0x10,//<! If set, edge AA will test edge
+                                        //   pairs for convexity while 
+                                        //   rasterizing.  Set this if the
+                                        //   source polygon is non-convex.
 
         // subclass may use additional bits internally
         kDummyStateBit,
diff --git a/gpu/src/GrGLProgram.cpp b/gpu/src/GrGLProgram.cpp
index ecb4753..b0d41aa 100644
--- a/gpu/src/GrGLProgram.cpp
+++ b/gpu/src/GrGLProgram.cpp
@@ -510,21 +510,39 @@
                 segments.fFSCode.appendS32(i);
                 segments.fFSCode.append("], pos), 0.0, 1.0);\n");
             }
-            segments.fFSCode.append("\tfloat edgeAlpha = ");
-            for (int i = 0; i < count - 1; i++) {
-                segments.fFSCode.append("min(a");
-                segments.fFSCode.appendS32(i);
-                segments.fFSCode.append(" * a");
-                segments.fFSCode.appendS32(i + 1);
-                segments.fFSCode.append(", ");
+            if (fProgramDesc.fEdgeAAConcave && (count & 0x01) == 0) {
+                // For concave polys, we consider the edges in pairs.
+                segments.fFSFunctions.append("float cross2(vec2 a, vec2 b) {\n");
+                segments.fFSFunctions.append("\treturn dot(a, vec2(b.y, -b.x));\n");
+                segments.fFSFunctions.append("}\n");
+                for (int i = 0; i < count; i += 2) {
+                    segments.fFSCode.appendf("\tfloat eb%d;\n", i / 2);
+                    segments.fFSCode.appendf("\tif (cross2(" EDGES_UNI_NAME "[%d].xy, " EDGES_UNI_NAME "[%d].xy) < 0.0) {\n", i, i + 1);
+                    segments.fFSCode.appendf("\t\teb%d = a%d * a%d;\n", i / 2, i, i + 1);
+                    segments.fFSCode.append("\t} else {\n");
+                    segments.fFSCode.appendf("\t\teb%d = a%d + a%d - a%d * a%d;\n", i / 2, i, i + 1, i, i + 1);
+                    segments.fFSCode.append("\t}\n");
+                }
+                segments.fFSCode.append("\tfloat edgeAlpha = ");
+                for (int i = 0; i < count / 2 - 1; i++) {
+                    segments.fFSCode.appendf("min(eb%d, ", i);
+                }
+                segments.fFSCode.appendf("eb%d", count / 2 - 1);
+                for (int i = 0; i < count / 2 - 1; i++) {
+                    segments.fFSCode.append(")");
+                }
+                segments.fFSCode.append(";\n");
+            } else {
+                segments.fFSCode.append("\tfloat edgeAlpha = ");
+                for (int i = 0; i < count - 1; i++) {
+                    segments.fFSCode.appendf("min(a%d * a%d, ", i, i + 1);
+                }
+                segments.fFSCode.appendf("a%d * a0", count - 1);
+                for (int i = 0; i < count - 1; i++) {
+                    segments.fFSCode.append(")");
+                }
+                segments.fFSCode.append(";\n");
             }
-            segments.fFSCode.append("a");
-            segments.fFSCode.appendS32(count - 1);
-            segments.fFSCode.append(" * a0");
-            for (int i = 0; i < count - 1; i++) {
-                segments.fFSCode.append(")");
-            }
-            segments.fFSCode.append(";\n");
             inCoverage = "edgeAlpha";
         }
 
@@ -702,6 +720,11 @@
         lengths[stringCnt] = segments.fFSOutputs.size();
         ++stringCnt;
     }
+    if (segments.fFSFunctions.size()) {
+        strings[stringCnt] = segments.fFSFunctions.c_str();
+        lengths[stringCnt] = segments.fFSFunctions.size();
+        ++stringCnt;
+    }
 
     GrAssert(segments.fFSCode.size());
     strings[stringCnt] = segments.fFSCode.c_str();
@@ -714,6 +737,7 @@
     GrPrintf(segments.fFSUnis.c_str());
     GrPrintf(segments.fVaryings.c_str());
     GrPrintf(segments.fFSOutputs.c_str());
+    GrPrintf(segments.fFSFunctions.c_str());
     GrPrintf(segments.fFSCode.c_str());
     GrPrintf("\n");
 #endif
diff --git a/gpu/src/GrGLProgram.h b/gpu/src/GrGLProgram.h
index 473bcb6..5c4727b 100644
--- a/gpu/src/GrGLProgram.h
+++ b/gpu/src/GrGLProgram.h
@@ -32,6 +32,7 @@
     GrStringBuilder fVaryings;
     GrStringBuilder fFSUnis;
     GrStringBuilder fFSOutputs;
+    GrStringBuilder fFSFunctions;
     GrStringBuilder fVSCode;
     GrStringBuilder fFSCode;
 };
@@ -161,11 +162,12 @@
         uint8_t fDualSrcOutput;  // casts to enum DualSrcOutput
         int8_t fFirstCoverageStage;
         SkBool8 fEmitsPointSize;
+        SkBool8 fEdgeAAConcave;
 
         int8_t fEdgeAANumEdges;
         uint8_t fColorFilterXfermode;  // casts to enum SkXfermode::Mode
 
-        uint8_t fPadTo32bLengthMultiple [2];
+        uint8_t fPadTo32bLengthMultiple [1];
 
     } fProgramDesc;
 
diff --git a/gpu/src/GrGpuGLShaders.cpp b/gpu/src/GrGpuGLShaders.cpp
index 0a933b5..689c1fc 100644
--- a/gpu/src/GrGpuGLShaders.cpp
+++ b/gpu/src/GrGpuGLShaders.cpp
@@ -199,6 +199,7 @@
         pdesc.fFirstCoverageStage = idx;
 
         pdesc.fEdgeAANumEdges = (random.nextF() * (getMaxEdges() + 1));
+        pdesc.fEdgeAAConcave = random.nextF() > .5f;
 
         if (fDualSourceBlendingSupport) {
             pdesc.fDualSrcOutput =
@@ -731,6 +732,7 @@
     }
 
     desc.fEdgeAANumEdges = fCurrDrawState.fEdgeAANumEdges;
+    desc.fEdgeAAConcave = desc.fEdgeAANumEdges > 0 && SkToBool(fCurrDrawState.fFlagBits & kEdgeAAConcave_StateBit);
 
     int lastEnabledStage = -1;
 
diff --git a/gpu/src/GrPathUtils.cpp b/gpu/src/GrPathUtils.cpp
index 8a72ba8..1fb043c 100644
--- a/gpu/src/GrPathUtils.cpp
+++ b/gpu/src/GrPathUtils.cpp
@@ -111,7 +111,7 @@
 
     bool first = true;
 
-    SkPath::Iter iter(path, true);
+    SkPath::Iter iter(path, false);
     GrPathCmd cmd;
 
     GrPoint pts[4];
diff --git a/gpu/src/GrTesselatedPathRenderer.cpp b/gpu/src/GrTesselatedPathRenderer.cpp
index 0e3389c..2783a9b 100644
--- a/gpu/src/GrTesselatedPathRenderer.cpp
+++ b/gpu/src/GrTesselatedPathRenderer.cpp
@@ -21,49 +21,256 @@
 #include "GrPoint.h"
 #include "GrTDArray.h"
 
+#include <limits.h>
 #include <sk_glu.h>
 
-struct PolygonData {
-    PolygonData(GrTDArray<GrPoint>* vertices, GrTDArray<short>* indices)
-      : fVertices(vertices)
-      , fIndices(indices)
-    {
+typedef GrTDArray<GrDrawTarget::Edge> GrEdgeArray;
+typedef GrTDArray<GrPoint> GrPointArray;
+typedef GrTDArray<uint16_t> GrIndexArray;
+typedef void (*TESSCB)();
+
+// limit the allowable vertex range to approximately half of the representable
+// IEEE exponent in order to avoid overflow when doing multiplies between
+// vertex components,
+const float kMaxVertexValue = 1e18;
+
+static inline GrDrawTarget::Edge computeEdge(const GrPoint& p,
+                                             const GrPoint& q,
+                                             float sign) {
+    GrVec tangent = GrVec::Make(p.fY - q.fY, q.fX - p.fX);
+    float scale = sign / tangent.length();
+    float cross2 = p.fX * q.fY - q.fX * p.fY;
+    return GrDrawTarget::Edge(tangent.fX * scale,
+                              tangent.fY * scale,
+                              cross2 * scale);
+}
+
+static inline GrPoint sanitizePoint(const GrPoint& pt) {
+    GrPoint r;
+    r.fX = SkScalarPin(pt.fX, -kMaxVertexValue, kMaxVertexValue);
+    r.fY = SkScalarPin(pt.fY, -kMaxVertexValue, kMaxVertexValue);
+    return r;
+}
+
+class GrTess {
+public:
+    GrTess(int count, unsigned winding_rule) {
+        fTess = Sk_gluNewTess();
+        Sk_gluTessProperty(fTess, GLU_TESS_WINDING_RULE, winding_rule);
+        Sk_gluTessNormal(fTess, 0.0f, 0.0f, 1.0f);
+        Sk_gluTessCallback(fTess, GLU_TESS_BEGIN_DATA, (TESSCB) &beginCB);
+        Sk_gluTessCallback(fTess, GLU_TESS_VERTEX_DATA, (TESSCB) &vertexCB);
+        Sk_gluTessCallback(fTess, GLU_TESS_END_DATA, (TESSCB) &endCB);
+        Sk_gluTessCallback(fTess, GLU_TESS_EDGE_FLAG_DATA, (TESSCB) &edgeFlagCB);
+        Sk_gluTessCallback(fTess, GLU_TESS_COMBINE_DATA, (TESSCB) &combineCB);
+        fInVertices = new double[count * 3];
     }
-    GrTDArray<GrPoint>* fVertices;
-    GrTDArray<short>* fIndices;
+    ~GrTess() {
+        Sk_gluDeleteTess(fTess);
+        delete[] fInVertices;
+    }
+    void addVertex(const GrPoint& pt, int index) {
+        if (index > USHRT_MAX) return;
+        double* inVertex = &fInVertices[index * 3];
+        inVertex[0] = pt.fX;
+        inVertex[1] = pt.fY;
+        inVertex[2] = 0.0;
+        *fVertices.append() = pt;
+        Sk_gluTessVertex(fTess, inVertex, reinterpret_cast<void*>(index));
+    }
+    void addVertices(const GrPoint* points, const uint16_t* contours, int numContours) {
+        Sk_gluTessBeginPolygon(fTess, this);
+        size_t i = 0;
+        for (int j = 0; j < numContours; ++j) {
+            Sk_gluTessBeginContour(fTess);
+            size_t end = i + contours[j];
+            for (; i < end; ++i) {
+                addVertex(points[i], i);
+            }
+            Sk_gluTessEndContour(fTess);
+        }
+        Sk_gluTessEndPolygon(fTess);
+    }
+    GLUtesselator* tess() { return fTess; }
+    const GrPointArray& vertices() const { return fVertices; }
+protected:
+    virtual void begin(GLenum type) = 0;
+    virtual void vertex(int index) = 0;
+    virtual void edgeFlag(bool flag) = 0;
+    virtual void end() = 0;
+    virtual int combine(GLdouble coords[3], int vertexIndices[4], 
+                         GLfloat weight[4]) = 0;
+    static void beginCB(GLenum type, void* data) {
+        static_cast<GrTess*>(data)->begin(type);
+    }
+    static void vertexCB(void* vertexData, void* data) {
+        static_cast<GrTess*>(data)->vertex(reinterpret_cast<long>(vertexData));
+    }
+    static void edgeFlagCB(GLboolean flag, void* data) {
+        static_cast<GrTess*>(data)->edgeFlag(flag != 0);
+    }
+    static void endCB(void* data) {
+        static_cast<GrTess*>(data)->end();
+    }
+    static void combineCB(GLdouble coords[3], void* vertexData[4],
+                          GLfloat weight[4], void **outData, void* data) {
+        int vertexIndex[4];
+        vertexIndex[0] = reinterpret_cast<long>(vertexData[0]);
+        vertexIndex[1] = reinterpret_cast<long>(vertexData[1]);
+        vertexIndex[2] = reinterpret_cast<long>(vertexData[2]);
+        vertexIndex[3] = reinterpret_cast<long>(vertexData[3]);
+        GrTess* tess = static_cast<GrTess*>(data);
+        int outIndex = tess->combine(coords, vertexIndex, weight);
+        *reinterpret_cast<long*>(outData) = outIndex;
+    }
+protected:
+    GLUtesselator* fTess;
+    GrPointArray fVertices;
+    double* fInVertices;
 };
 
-static void beginData(GLenum type, void* data)
-{
-    GR_DEBUGASSERT(type == GL_TRIANGLES);
+class GrPolygonTess : public GrTess {
+public:
+    GrPolygonTess(int count, unsigned winding_rule)
+      : GrTess(count, winding_rule) {
+    }
+    ~GrPolygonTess() {
+    }
+    const GrIndexArray& indices() const { return fIndices; }
+protected:
+    virtual void begin(GLenum type) {
+        GR_DEBUGASSERT(type == GL_TRIANGLES);
+    }
+    virtual void vertex(int index) {
+        *fIndices.append() = index;
+    }
+    virtual void edgeFlag(bool flag) {}
+    virtual void end() {}
+    virtual int combine(GLdouble coords[3], int vertexIndices[4],
+                         GLfloat weight[4]) {
+        int index = fVertices.count();
+        GrPoint p = GrPoint::Make(static_cast<float>(coords[0]),
+                                  static_cast<float>(coords[1]));
+        *fVertices.append() = p;
+        return index;
+    }
+protected:
+    GrIndexArray fIndices;
+};
+
+class GrEdgePolygonTess : public GrPolygonTess {
+public:
+    GrEdgePolygonTess(int count, unsigned winding_rule, const SkMatrix& matrix)
+      : GrPolygonTess(count, winding_rule),
+        fMatrix(matrix),
+        fEdgeFlag(false),
+        fEdgeVertex(-1),
+        fTriStartVertex(-1),
+        fEdges(NULL) {
+    }
+    ~GrEdgePolygonTess() {
+        delete[] fEdges;
+    }
+    const GrDrawTarget::Edge* edges() const { return fEdges; }
+private:
+    void addEdge(int index0, int index1) {
+        GrPoint p = fVertices[index0];
+        GrPoint q = fVertices[index1];
+        fMatrix.mapPoints(&p, 1);
+        fMatrix.mapPoints(&q, 1);
+        p = sanitizePoint(p);
+        q = sanitizePoint(q);
+        if (p == q) return;
+        GrDrawTarget::Edge edge = computeEdge(p, q, 1.0f);
+        fEdges[index0 * 2 + 1] = edge;
+        fEdges[index1 * 2] = edge;
+    }
+    virtual void begin(GLenum type) {
+        GR_DEBUGASSERT(type == GL_TRIANGLES);
+        int count = fVertices.count() * 2;
+        fEdges = new GrDrawTarget::Edge[count];
+        memset(fEdges, 0, count * sizeof(GrDrawTarget::Edge));
+    }
+    virtual void edgeFlag(bool flag) {
+        fEdgeFlag = flag;
+    }
+    virtual void vertex(int index) {
+        bool triStart = fIndices.count() % 3 == 0;
+        GrPolygonTess::vertex(index);
+        if (fEdgeVertex != -1) {
+            if (triStart) {
+                addEdge(fEdgeVertex, fTriStartVertex);
+            } else {
+                addEdge(fEdgeVertex, index);
+            }
+        }
+        if (triStart) {
+            fTriStartVertex = index;
+        }
+        if (fEdgeFlag) {
+            fEdgeVertex = index;
+        } else {
+            fEdgeVertex = -1;
+        }
+    }
+    virtual void end() {
+        if (fEdgeVertex != -1) {
+            addEdge(fEdgeVertex, fTriStartVertex);
+        }
+    }
+    GrMatrix fMatrix;
+    bool fEdgeFlag;
+    int fEdgeVertex, fTriStartVertex;
+    GrDrawTarget::Edge* fEdges;
+};
+
+class GrBoundaryTess : public GrTess {
+public:
+    GrBoundaryTess(int count, unsigned winding_rule)
+      : GrTess(count, winding_rule),
+        fContourStart(0) {
+        Sk_gluTessProperty(fTess, GLU_TESS_BOUNDARY_ONLY, 1);
+    }
+    ~GrBoundaryTess() {
+    }
+    GrPointArray& contourPoints() { return fContourPoints; }
+    const GrIndexArray& contours() const { return fContours; }
+private:
+    virtual void begin(GLenum type) {
+        fContourStart = fContourPoints.count();
+    }
+    virtual void vertex(int index) {
+        *fContourPoints.append() = fVertices.at(index);
+    }
+    virtual void edgeFlag(bool flag) {}
+    virtual void end() {
+        *fContours.append() = fContourPoints.count() - fContourStart;
+    }
+    virtual int combine(GLdouble coords[3], int vertexIndices[4],
+                        GLfloat weight[4]) {
+        int index = fVertices.count();
+        *fVertices.append() = GrPoint::Make(static_cast<float>(coords[0]),
+                                            static_cast<float>(coords[1]));
+        return index;
+    }
+    GrPointArray fContourPoints;
+    GrIndexArray fContours;
+    size_t fContourStart;
+};
+
+static bool nearlyEqual(float a, float b) {
+    return fabsf(a - b) < 0.0001f;
 }
 
-static void edgeFlagData(GLboolean flag, void* data)
-{
+static bool nearlyEqual(const GrPoint& a, const GrPoint& b) {
+    return nearlyEqual(a.fX, b.fX) && nearlyEqual(a.fY, b.fY);
 }
 
-static void vertexData(void* vertexData, void* data)
-{
-    short* end = static_cast<PolygonData*>(data)->fIndices->append();
-    *end = reinterpret_cast<long>(vertexData);
+static bool parallel(const GrDrawTarget::Edge& a, const GrDrawTarget::Edge& b) {
+    return (nearlyEqual(a.fX, b.fX) && nearlyEqual(a.fY, b.fY)) ||
+           (nearlyEqual(a.fX, -b.fX) && nearlyEqual(a.fY, -b.fY));
 }
 
-static void endData(void* data)
-{
-}
-
-static void combineData(GLdouble coords[3], void* vertexData[4],
-                                 GLfloat weight[4], void **outData, void* data)
-{
-    PolygonData* polygonData = static_cast<PolygonData*>(data);
-    int index = polygonData->fVertices->count();
-    *polygonData->fVertices->append() = GrPoint::Make(static_cast<float>(coords[0]),
-                                                      static_cast<float>(coords[1]));
-    *outData = reinterpret_cast<void*>(index);
-}
-
-typedef void (*TESSCB)();
-
 static unsigned fill_type_to_glu_winding_rule(GrPathFill fill) {
     switch (fill) {
         case kWinding_PathFill:
@@ -85,40 +292,59 @@
 GrTesselatedPathRenderer::GrTesselatedPathRenderer() {
 }
 
-typedef GrTDArray<GrDrawTarget::Edge> EdgeArray;
-
-bool isCCW(const GrPoint* pts)
-{
-    GrVec v1 = pts[1] - pts[0];
-    GrVec v2 = pts[2] - pts[1];
+static bool isCCW(const GrPoint* pts, int count) {
+    GrVec v1, v2;
+    do {
+        v1 = pts[1] - pts[0];
+        v2 = pts[2] - pts[1];
+        pts++;
+        count--;
+    } while (nearlyEqual(v1, v2) && count > 3);
     return v1.cross(v2) < 0;
 }
 
-static size_t computeEdgesAndOffsetVertices(const GrMatrix& matrix,
-                                            const GrMatrix& inverse,
-                                            GrPoint* vertices,
-                                            size_t numVertices,
-                                            EdgeArray* edges)
-{
+static bool validEdge(const GrDrawTarget::Edge& edge) {
+    return !(edge.fX == 0.0f && edge.fY == 0.0f && edge.fZ == 0.0f);
+}
+
+static size_t computeEdgesAndIntersect(const GrMatrix& matrix,
+                                       const GrMatrix& inverse,
+                                       GrPoint* vertices,
+                                       size_t numVertices,
+                                       GrEdgeArray* edges,
+                                       float sign) {
+    if (numVertices < 3) {
+        return 0;
+    }
     matrix.mapPoints(vertices, numVertices);
-    GrPoint p = vertices[numVertices - 1];
-    float sign = isCCW(vertices) ? -1.0f : 1.0f;
+    if (sign == 0.0f) {
+        sign = isCCW(vertices, numVertices) ? -1.0f : 1.0f;
+    }
+    GrPoint p = sanitizePoint(vertices[numVertices - 1]);
     for (size_t i = 0; i < numVertices; ++i) {
-        GrPoint q = vertices[i];
-        if (p == q) continue;
-        GrVec tangent = GrVec::Make(p.fY - q.fY, q.fX - p.fX);
-        float scale = sign / tangent.length();
-        float cross2 = p.fX * q.fY - q.fX * p.fY;
-        GrDrawTarget::Edge edge(tangent.fX * scale,
-                  tangent.fY * scale,
-                  cross2 * scale + 0.5f);
+        GrPoint q = sanitizePoint(vertices[i]);
+        if (p == q) {
+            continue;
+        }
+        GrDrawTarget::Edge edge = computeEdge(p, q, sign);
+        edge.fZ += 0.5f;    // Offset by half a pixel along the tangent.
         *edges->append() = edge;
         p = q;
     }
-    GrDrawTarget::Edge prev_edge = *edges->back();
-    for (int i = 0; i < edges->count(); ++i) {
-        GrDrawTarget::Edge edge = edges->at(i);
-        vertices[i] = prev_edge.intersect(edge);
+    int count = edges->count();
+    if (count == 0) {
+        return 0;
+    }
+    GrDrawTarget::Edge prev_edge = edges->at(0);
+    for (int i = 0; i < count; ++i) {
+        GrDrawTarget::Edge edge = edges->at(i < count - 1 ? i + 1 : 0);
+        if (parallel(edge, prev_edge)) {
+            // 3 points are collinear; offset by half the tangent instead
+            vertices[i].fX -= edge.fX * 0.5f;
+            vertices[i].fY -= edge.fY * 0.5f;
+        } else {
+            vertices[i] = prev_edge.intersect(edge);
+        }
         inverse.mapPoints(&vertices[i], 1);
         prev_edge = edge;
     }
@@ -164,14 +390,18 @@
         maxPts += 4;
         subpathCnt++;
     }
-    GrPoint* base = new GrPoint[maxPts];
+    if (maxPts > USHRT_MAX) {
+        return;
+    }
+    GrAutoSTMalloc<8, GrPoint> baseMem(maxPts);
+    GrPoint* base = (GrPoint*) baseMem;
     GrPoint* vert = base;
     GrPoint* subpathBase = base;
 
     GrAutoSTMalloc<8, uint16_t> subpathVertCount(subpathCnt);
 
     GrPoint pts[4];
-    SkPath::Iter iter(path, true);
+    SkPath::Iter iter(path, false);
 
     bool first = true;
     int subpath = 0;
@@ -242,18 +472,20 @@
     size_t count = vert - base;
 
     if (count < 3) {
-      delete[] base;
-      return;
+        return;
     }
 
     if (subpathCnt == 1 && !inverted && path.isConvex()) {
         if (target->isAntialiasState()) {
-            EdgeArray edges;
+            GrEdgeArray edges;
             GrMatrix inverse, matrix = target->getViewMatrix();
             target->getViewInverse(&inverse);
 
-            count = computeEdgesAndOffsetVertices(matrix, inverse, base, count, &edges);
+            count = computeEdgesAndIntersect(matrix, inverse, base, count, &edges, 0.0f);
             size_t maxEdges = target->getMaxEdges();
+            if (count == 0) {
+                return;
+            }
             if (count <= maxEdges) {
                 // All edges fit; upload all edges and draw all verts as a fan
                 target->setVertexSourceToArray(layout, base, count);
@@ -276,48 +508,96 @@
             target->setVertexSourceToArray(layout, base, count);
             target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, count);
         }
-        delete[] base;
         return;
     }
 
-    // FIXME:  This copy could be removed if we had (templated?) versions of
-    // generate_*_point above that wrote directly into doubles.
-    double* inVertices = new double[count * 3];
-    for (size_t i = 0; i < count; ++i) {
-        inVertices[i * 3]     = base[i].fX;
-        inVertices[i * 3 + 1] = base[i].fY;
-        inVertices[i * 3 + 2] = 1.0;
-    }
+    if (target->isAntialiasState()) {
+        // Run the tesselator once to get the boundaries.
+        GrBoundaryTess btess(count, fill_type_to_glu_winding_rule(fill));
+        btess.addVertices(base, subpathVertCount, subpathCnt);
 
-    GLUtesselator* tess = Sk_gluNewTess();
-    unsigned windingRule = fill_type_to_glu_winding_rule(fill);
-    Sk_gluTessProperty(tess, GLU_TESS_WINDING_RULE, windingRule);
-    Sk_gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (TESSCB) &beginData);
-    Sk_gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (TESSCB) &vertexData);
-    Sk_gluTessCallback(tess, GLU_TESS_END_DATA, (TESSCB) &endData);
-    Sk_gluTessCallback(tess, GLU_TESS_EDGE_FLAG_DATA, (TESSCB) &edgeFlagData);
-    Sk_gluTessCallback(tess, GLU_TESS_COMBINE_DATA, (TESSCB) &combineData);
-    GrTDArray<short> indices;
-    GrTDArray<GrPoint> vertices;
-    PolygonData data(&vertices, &indices);
-
-    Sk_gluTessBeginPolygon(tess, &data);
-    size_t i = 0;
-    for (int sp = 0; sp < subpathCnt; ++sp) {
-        Sk_gluTessBeginContour(tess);
-        int start = i;
-        size_t end = start + subpathVertCount[sp];
-        for (; i < end; ++i) {
-            double* inVertex = &inVertices[i * 3];
-            *vertices.append() = GrPoint::Make(inVertex[0], inVertex[1]);
-            Sk_gluTessVertex(tess, inVertex, reinterpret_cast<void*>(i));
+        GrMatrix inverse, matrix = target->getViewMatrix();
+        if (!target->getViewInverse(&inverse)) {
+            return;
         }
-        Sk_gluTessEndContour(tess);
+
+        if (btess.vertices().count() > USHRT_MAX) {
+            return;
+        }
+
+        // Inflate the boundary, and run the tesselator again to generate
+        // interior polys.
+        const GrPointArray& contourPoints = btess.contourPoints();
+        const GrIndexArray& contours = btess.contours();
+        GrEdgePolygonTess ptess(contourPoints.count(), GLU_TESS_WINDING_NONZERO, matrix);
+
+        size_t i = 0;
+        Sk_gluTessBeginPolygon(ptess.tess(), &ptess);
+        for (int contour = 0; contour < contours.count(); ++contour) {
+            int count = contours[contour];
+            GrEdgeArray edges;
+            int newCount = computeEdgesAndIntersect(matrix, inverse, &btess.contourPoints()[i], count, &edges, 1.0f);
+            Sk_gluTessBeginContour(ptess.tess());
+            for (int j = 0; j < newCount; j++) {
+                ptess.addVertex(contourPoints[i + j], ptess.vertices().count());
+            }
+            i += count;
+            Sk_gluTessEndContour(ptess.tess());
+        }
+
+        Sk_gluTessEndPolygon(ptess.tess());
+
+        if (ptess.vertices().count() > USHRT_MAX) {
+            return;
+        }
+
+        // Draw the resulting polys and upload their edge data.
+        target->enableState(GrDrawTarget::kEdgeAAConcave_StateBit);
+        const GrPointArray& vertices = ptess.vertices();
+        const GrIndexArray& indices = ptess.indices();
+        const GrDrawTarget::Edge* edges = ptess.edges();
+        GR_DEBUGASSERT(indices.count() % 3 == 0);
+        for (int i = 0; i < indices.count(); i += 3) {
+            GrPoint tri_verts[3];
+            int index0 = indices[i];
+            int index1 = indices[i + 1];
+            int index2 = indices[i + 2];
+            tri_verts[0] = vertices[index0];
+            tri_verts[1] = vertices[index1];
+            tri_verts[2] = vertices[index2];
+            GrDrawTarget::Edge tri_edges[6];
+            int t = 0;
+            const GrDrawTarget::Edge& edge0 = edges[index0 * 2];
+            const GrDrawTarget::Edge& edge1 = edges[index0 * 2 + 1];
+            const GrDrawTarget::Edge& edge2 = edges[index1 * 2];
+            const GrDrawTarget::Edge& edge3 = edges[index1 * 2 + 1];
+            const GrDrawTarget::Edge& edge4 = edges[index2 * 2];
+            const GrDrawTarget::Edge& edge5 = edges[index2 * 2 + 1];
+            if (validEdge(edge0) && validEdge(edge1)) {
+                tri_edges[t++] = edge0;
+                tri_edges[t++] = edge1;
+            }
+            if (validEdge(edge2) && validEdge(edge3)) {
+                tri_edges[t++] = edge2;
+                tri_edges[t++] = edge3;
+            }
+            if (validEdge(edge4) && validEdge(edge5)) {
+                tri_edges[t++] = edge4;
+                tri_edges[t++] = edge5;
+            }
+            target->setEdgeAAData(&tri_edges[0], t);
+            target->setVertexSourceToArray(layout, &tri_verts[0], 3);
+            target->drawNonIndexed(kTriangles_PrimitiveType, 0, 3);
+        }
+        target->setEdgeAAData(NULL, 0);
+        target->disableState(GrDrawTarget::kEdgeAAConcave_StateBit);
+        return;
     }
 
-    Sk_gluTessEndPolygon(tess);
-    Sk_gluDeleteTess(tess);
-
+    GrPolygonTess ptess(count, fill_type_to_glu_winding_rule(fill));
+    ptess.addVertices(base, subpathVertCount, subpathCnt);
+    const GrPointArray& vertices = ptess.vertices();
+    const GrIndexArray& indices = ptess.indices();
     if (indices.count() > 0) {
         target->setVertexSourceToArray(layout, vertices.begin(), vertices.count());
         target->setIndexSourceToArray(indices.begin(), indices.count());
@@ -327,8 +607,6 @@
                             vertices.count(),
                             indices.count());
     }
-    delete[] inVertices;
-    delete[] base;
 }
 
 bool GrTesselatedPathRenderer::canDrawPath(const GrDrawTarget* target,
@@ -347,10 +625,5 @@
 bool GrTesselatedPathRenderer::supportsAA(GrDrawTarget* target,
                                                   const SkPath& path,
                                                   GrPathFill fill) {
-    int subpathCnt = 0;
-    int tol = GrPathUtils::gTolerance;
-    GrPathUtils::worstCasePointCount(path, &subpathCnt, tol);
-    return (subpathCnt == 1 &&
-            !IsFillInverted(fill) &&
-            path.isConvex());
+    return true;
 }
diff --git a/gyp/SampleApp.gyp b/gyp/SampleApp.gyp
index f0446d9..04e07d6 100644
--- a/gyp/SampleApp.gyp
+++ b/gyp/SampleApp.gyp
@@ -43,6 +43,7 @@
         '../samplecode/SampleCode.h',
         '../samplecode/SampleColorFilter.cpp',
         '../samplecode/SampleComplexClip.cpp',
+        '../samplecode/SampleConcavePaths.cpp',
         '../samplecode/SampleCull.cpp',
         '../samplecode/SampleDecode.cpp',
         '../samplecode/SampleDither.cpp',
diff --git a/samplecode/SampleConcavePaths.cpp b/samplecode/SampleConcavePaths.cpp
new file mode 100644
index 0000000..e084af2
--- /dev/null
+++ b/samplecode/SampleConcavePaths.cpp
@@ -0,0 +1,146 @@
+
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkParsePath.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkGeometry.h"
+
+class ConcavePathView : public SampleView {
+public:
+	ConcavePathView() {}
+    
+protected:
+    // overrides from SkEventSink
+    virtual bool onQuery(SkEvent* evt) {
+        if (SampleCode::TitleQ(*evt)) {
+            SampleCode::TitleR(evt, "ConcavePaths");
+            return true;
+        }
+        return this->INHERITED::onQuery(evt);
+    }
+    
+    virtual void onDrawContent(SkCanvas* canvas) {        
+        SkPaint paint;
+        
+        paint.setAntiAlias(true);
+        paint.setStyle(SkPaint::kFill_Style);
+
+        // Concave test
+        if (1) {
+            SkPath path;
+            canvas->translate(0, 0);
+            path.moveTo(SkIntToScalar(20), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(30), SkIntToScalar(30));
+            path.lineTo(SkIntToScalar(20), SkIntToScalar(80));
+            canvas->drawPath(path, paint);
+        }
+        // Reverse concave test
+        if (1) {
+            SkPath path;
+            canvas->save();
+            canvas->translate(100, 0);
+            path.moveTo(SkIntToScalar(20), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(20), SkIntToScalar(80));
+            path.lineTo(SkIntToScalar(30), SkIntToScalar(30));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(20));
+            canvas->drawPath(path, paint);
+            canvas->restore();
+        }
+        // Bowtie (intersection)
+        if (1) {
+            SkPath path;
+            canvas->save();
+            canvas->translate(200, 0);
+            path.moveTo(SkIntToScalar(20), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(80));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(20), SkIntToScalar(80));
+            canvas->drawPath(path, paint);
+            canvas->restore();
+        }
+        // "fake" bowtie (concave, but no intersection)
+        if (1) {
+            SkPath path;
+            canvas->save();
+            canvas->translate(300, 0);
+            path.moveTo(SkIntToScalar(20), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(50), SkIntToScalar(40));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(80));
+            path.lineTo(SkIntToScalar(50), SkIntToScalar(60));
+            path.lineTo(SkIntToScalar(20), SkIntToScalar(80));
+            canvas->drawPath(path, paint);
+            canvas->restore();
+        }
+        // Fish test (intersection/concave)
+        if (1) {
+            SkPath path;
+            canvas->save();
+            canvas->translate(0, 100);
+            path.moveTo(SkIntToScalar(20), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(80));
+            path.lineTo(SkIntToScalar(70), SkIntToScalar(50));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(20), SkIntToScalar(80));
+            path.lineTo(SkIntToScalar(0), SkIntToScalar(50));
+            canvas->drawPath(path, paint);
+            canvas->restore();
+        }
+        // Collinear test
+        if (1) {
+            SkPath path;
+            canvas->save();
+            canvas->translate(100, 100);
+            path.moveTo(SkIntToScalar(20), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(50), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(50), SkIntToScalar(80));
+            canvas->drawPath(path, paint);
+            canvas->restore();
+        }
+        // Hole test
+        if (1) {
+            SkPath path;
+            canvas->save();
+            canvas->translate(200, 100);
+            path.moveTo(SkIntToScalar(20), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(20));
+            path.lineTo(SkIntToScalar(80), SkIntToScalar(80));
+            path.lineTo(SkIntToScalar(20), SkIntToScalar(80));
+            path.moveTo(SkIntToScalar(30), SkIntToScalar(30));
+            path.lineTo(SkIntToScalar(30), SkIntToScalar(70));
+            path.lineTo(SkIntToScalar(70), SkIntToScalar(70));
+            path.lineTo(SkIntToScalar(70), SkIntToScalar(30));
+            canvas->drawPath(path, paint);
+            canvas->restore();
+        }
+    }
+    
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+        this->inval(NULL);
+        return this->INHERITED::onFindClickHandler(x, y);
+    }
+    
+private:
+    typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ConcavePathView; }
+static SkViewRegister reg(MyFactory);
+