diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
index 93c012c..9df7105 100644
--- a/gpu/include/GrContext.h
+++ b/gpu/include/GrContext.h
@@ -27,6 +27,7 @@
 class GrVertexBufferAllocPool;
 class GrIndexBufferAllocPool;
 class GrInOrderDrawBuffer;
+class GrPathRenderer;
 
 class GrContext : public GrRefCnt {
 public:
@@ -277,19 +278,6 @@
                         const GrMatrix* srcMatrix = NULL);
 
     /**
-     * Path filling rules
-     */
-    enum PathFills {
-        kWinding_PathFill,
-        kEvenOdd_PathFill,
-        kInverseWinding_PathFill,
-        kInverseEvenOdd_PathFill,
-        kHairLine_PathFill,
-
-        kPathFillCount
-    };
-
-    /**
      * Tessellates and draws a path.
      *
      * @param paint         describes how to color pixels.
@@ -300,7 +288,7 @@
      */
     void drawPath(const GrPaint& paint,
                   GrPathIter* path,
-                  PathFills fill,
+                  GrPathFill fill,
                   const GrPoint* translate = NULL);
     /**
      * Draws vertices with a paint.
@@ -319,7 +307,7 @@
      *                          number of indices.
      */
     void drawVertices(const GrPaint& paint,
-                      GrDrawTarget::PrimitiveType primitiveType,
+                      GrPrimitiveType primitiveType,
                       int vertexCount,
                       const GrPoint positions[],
                       const GrPoint texs[],
@@ -358,7 +346,7 @@
               typename COL_SRC,
               typename IDX_SRC>
     void drawCustomVertices(const GrPaint& paint,
-                            GrDrawTarget::PrimitiveType primitiveType,
+                            GrPrimitiveType primitiveType,
                             const POS_SRC& posSrc,
                             const TEX_SRC* texCoordSrc,
                             const COL_SRC* colorSrc,
@@ -369,16 +357,16 @@
      */
     template <typename POS_SRC>
     void drawCustomVertices(const GrPaint& paint,
-                            GrDrawTarget::PrimitiveType primitiveType,
+                            GrPrimitiveType primitiveType,
                             const POS_SRC& posSrc);
     template <typename POS_SRC, typename TEX_SRC>
     void drawCustomVertices(const GrPaint& paint,
-                            GrDrawTarget::PrimitiveType primitiveType,
+                            GrPrimitiveType primitiveType,
                             const POS_SRC& posSrc,
                             const TEX_SRC* texCoordSrc);
     template <typename POS_SRC, typename TEX_SRC, typename COL_SRC>
     void drawCustomVertices(const GrPaint& paint,
-                            GrDrawTarget::PrimitiveType primitiveType,
+                            GrPrimitiveType primitiveType,
                             const POS_SRC& posSrc,
                             const TEX_SRC* texCoordSrc,
                             const COL_SRC* colorSrc);
@@ -466,6 +454,7 @@
     GrGpu*          fGpu;
     GrTextureCache* fTextureCache;
     GrFontCache*    fFontCache;
+    GrPathRenderer* fPathRenderer;
 
     GrVertexBufferAllocPool*    fDrawBufferVBAllocPool;
     GrIndexBufferAllocPool*     fDrawBufferIBAllocPool;
diff --git a/gpu/include/GrContext_impl.h b/gpu/include/GrContext_impl.h
index 8af38e6..c0a2107 100644
--- a/gpu/include/GrContext_impl.h
+++ b/gpu/include/GrContext_impl.h
@@ -20,7 +20,7 @@
 template <typename POS_SRC, typename TEX_SRC,
           typename COL_SRC, typename IDX_SRC>
 inline void GrContext::drawCustomVertices(const GrPaint& paint,
-                                          GrDrawTarget::PrimitiveType primitiveType,
+                                          GrPrimitiveType primitiveType,
                                           const POS_SRC& posSrc,
                                           const TEX_SRC* texCoordSrc,
                                           const COL_SRC* colorSrc,
@@ -101,7 +101,7 @@
 
 template <typename POS_SRC>
 inline void GrContext::drawCustomVertices(const GrPaint& paint,
-                                          GrDrawTarget::PrimitiveType primitiveType,
+                                          GrPrimitiveType primitiveType,
                                           const POS_SRC& posSrc) {
     this->drawCustomVertices<POS_SRC,
                              GrNullTexCoordSource,
@@ -112,7 +112,7 @@
 
 template <typename POS_SRC, typename TEX_SRC>
 inline void GrContext::drawCustomVertices(const GrPaint& paint,
-                                          GrDrawTarget::PrimitiveType primitiveType,
+                                          GrPrimitiveType primitiveType,
                                           const POS_SRC& posSrc,
                                           const TEX_SRC* texCoordSrc) {
     this->drawCustomVertices<POS_SRC, TEX_SRC,
@@ -123,7 +123,7 @@
 
 template <typename POS_SRC, typename TEX_SRC, typename COL_SRC>
 inline void GrContext::drawCustomVertices(const GrPaint& paint,
-                                          GrDrawTarget::PrimitiveType primitiveType,
+                                          GrPrimitiveType primitiveType,
                                           const POS_SRC& posSrc,
                                           const TEX_SRC* texCoordSrc,
                                           const COL_SRC* colorSrc) {
diff --git a/gpu/include/GrDrawTarget.h b/gpu/include/GrDrawTarget.h
index 9c78902..929b9ff 100644
--- a/gpu/include/GrDrawTarget.h
+++ b/gpu/include/GrDrawTarget.h
@@ -52,16 +52,10 @@
     };
 
     /**
-     * Geometric primitives used for drawing.
+     *  Bitfield used to indicate which stages are in use.
      */
-    enum PrimitiveType {
-        kTriangles_PrimitiveType,
-        kTriangleStrip_PrimitiveType,
-        kTriangleFan_PrimitiveType,
-        kPoints_PrimitiveType,
-        kLines_PrimitiveType,
-        kLineStrip_PrimitiveType
-    };
+    typedef int StageBitfield;
+    GR_STATIC_ASSERT(sizeof(StageBitfield)*8 >= kNumStages);
 
     /**
      *  Flags that affect rendering. Controlled using enable/disableState(). All
@@ -81,22 +75,6 @@
     };
 
     /**
-     * Coeffecients for alpha-blending.
-     */
-    enum BlendCoeff {
-        kZero_BlendCoeff,    //<! 0
-        kOne_BlendCoeff,     //<! 1
-        kSC_BlendCoeff,      //<! src color
-        kISC_BlendCoeff,     //<! one minus src color
-        kDC_BlendCoeff,      //<! dst color
-        kIDC_BlendCoeff,     //<! one minus dst color
-        kSA_BlendCoeff,      //<! src alpha
-        kISA_BlendCoeff,     //<! one minus src alpha
-        kDA_BlendCoeff,      //<! dst alpha
-        kIDA_BlendCoeff,     //<! one minus dst alpha
-    };
-
-    /**
      * StencilPass
      *
      * Sets the stencil state for subsequent draw calls. Used to fill paths.
@@ -145,8 +123,8 @@
 
     struct DrState {
         uint32_t                fFlagBits;
-        BlendCoeff              fSrcBlend;
-        BlendCoeff              fDstBlend;
+        GrBlendCoeff            fSrcBlend;
+        GrBlendCoeff            fDstBlend;
         GrTexture*              fTextures[kNumStages];
         GrSamplerState          fSamplerStates[kNumStages];
         GrRenderTarget*         fRenderTarget;
@@ -362,7 +340,7 @@
      * @param srcCoef coeffecient applied to the src color.
      * @param dstCoef coeffecient applied to the dst color.
      */
-    void setBlendFunc(BlendCoeff srcCoef, BlendCoeff dstCoef);
+    void setBlendFunc(GrBlendCoeff srcCoef, GrBlendCoeff dstCoef);
 
     /**
      * Used to save and restore the GrGpu's drawing state
@@ -645,7 +623,7 @@
      *                     is effectively trimmed to the last completely
      *                     specified primitive.
      */
-    virtual void drawIndexed(PrimitiveType type,
+    virtual void drawIndexed(GrPrimitiveType type,
                              int startVertex,
                              int startIndex,
                              int vertexCount,
@@ -660,7 +638,7 @@
      *                     to index 0
      * @param vertexCount  one greater than the max index.
      */
-    virtual void drawNonIndexed(PrimitiveType type,
+    virtual void drawNonIndexed(GrPrimitiveType type,
                                 int startVertex,
                                 int vertexCount)  = 0;
 
@@ -674,8 +652,8 @@
      * drawNonIndexed.
      * @param rect      the rect to draw
      * @param matrix    optional matrix applied to rect (before viewMatrix)
-     * @param stageEnableMask   bitmask indicating which stages are enabled.
-     *                          Bit i indicates whether stage i is enabled.
+     * @param stageEnableBitfield bitmask indicating which stages are enabled.
+     *                            Bit i indicates whether stage i is enabled.
      * @param srcRects  specifies rects for stages enabled by stageEnableMask.
      *                  if stageEnableMask bit i is 1, srcRects is not NULL,
      *                  and srcRects[i] is not NULL, then srcRects[i] will be
@@ -689,7 +667,7 @@
      */
     virtual void drawRect(const GrRect& rect, 
                           const GrMatrix* matrix,
-                          int stageEnableMask,
+                          StageBitfield stageEnableBitfield,
                           const GrRect* srcRects[],
                           const GrMatrix* srcMatrices[]);
 
@@ -699,8 +677,8 @@
      */
     void drawSimpleRect(const GrRect& rect, 
                         const GrMatrix* matrix, 
-                        int stageEnableMask) {
-         drawRect(rect, matrix, stageEnableMask, NULL, NULL);
+                        StageBitfield stageEnableBitfield) {
+         drawRect(rect, matrix, stageEnableBitfield, NULL, NULL);
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -1003,7 +981,7 @@
 
     // Helpers for drawRect, protected so subclasses that override drawRect
     // can use them.
-    static GrVertexLayout GetRectVertexLayout(int stageEnableMask, 
+    static GrVertexLayout GetRectVertexLayout(StageBitfield stageEnableBitfield,
                                               const GrRect* srcRects[]);
 
     static void SetRectVertices(const GrRect& rect,
diff --git a/gpu/include/GrGpu.h b/gpu/include/GrGpu.h
index cfa1509..661708b 100644
--- a/gpu/include/GrGpu.h
+++ b/gpu/include/GrGpu.h
@@ -284,13 +284,13 @@
     int maxTextureDimension() const { return fMaxTextureDimension; }
 
     // GrDrawTarget overrides
-    virtual void drawIndexed(PrimitiveType type,
+    virtual void drawIndexed(GrPrimitiveType type,
                              int startVertex,
                              int startIndex,
                              int vertexCount,
                              int indexCount);
 
-    virtual void drawNonIndexed(PrimitiveType type,
+    virtual void drawNonIndexed(GrPrimitiveType type,
                                 int startVertex,
                                 int vertexCount);
 
@@ -351,7 +351,7 @@
     virtual void clipWillBeSet(const GrClip& newClip);
 
     // prepares clip flushes gpu state before a draw
-    bool setupClipAndFlushState(PrimitiveType type);
+    bool setupClipAndFlushState(GrPrimitiveType type);
 
     // defaults to false, subclass can set true to support palleted textures
     bool f8bitPaletteSupport;
@@ -398,13 +398,13 @@
     void finalizeReservedIndices();
 
     // overridden by API specific GrGpu-derived class to perform the draw call.
-    virtual void drawIndexedHelper(PrimitiveType type,
+    virtual void drawIndexedHelper(GrPrimitiveType type,
                                    uint32_t startVertex,
                                    uint32_t startIndex,
                                    uint32_t vertexCount,
                                    uint32_t indexCount) = 0;
 
-    virtual void drawNonIndexedHelper(PrimitiveType type,
+    virtual void drawNonIndexedHelper(GrPrimitiveType type,
                                       uint32_t vertexCount,
                                       uint32_t numVertices) = 0;
 
@@ -421,7 +421,7 @@
     // deltas from previous state at draw time. This function does the
     // API-specific flush of the state
     // returns false if current state is unsupported.
-    virtual bool flushGraphicsState(PrimitiveType type) = 0;
+    virtual bool flushGraphicsState(GrPrimitiveType type) = 0;
 
     // Sets the scissor rect, or disables if rect is NULL.
     virtual void flushScissor(const GrIRect* rect) = 0;
diff --git a/gpu/include/GrInOrderDrawBuffer.h b/gpu/include/GrInOrderDrawBuffer.h
index 0dba8e3..d59eb96 100644
--- a/gpu/include/GrInOrderDrawBuffer.h
+++ b/gpu/include/GrInOrderDrawBuffer.h
@@ -81,12 +81,12 @@
     void playback(GrDrawTarget* target);
     
     // overrides from GrDrawTarget
-    virtual void drawIndexed(PrimitiveType primitiveType,
+    virtual void drawIndexed(GrPrimitiveType primitiveType,
                              int startVertex,
                              int startIndex,
                              int vertexCount,
                              int indexCount);
-    virtual void drawNonIndexed(PrimitiveType primitiveType,
+    virtual void drawNonIndexed(GrPrimitiveType primitiveType,
                                 int startVertex,
                                 int vertexCount);
 
@@ -103,7 +103,7 @@
 private:
 
     struct Draw {
-        PrimitiveType           fPrimitiveType;
+        GrPrimitiveType         fPrimitiveType;
         int                     fStartVertex;
         int                     fStartIndex;
         int                     fVertexCount;
diff --git a/gpu/include/GrPaint.h b/gpu/include/GrPaint.h
index 770647a..a34cbaf 100644
--- a/gpu/include/GrPaint.h
+++ b/gpu/include/GrPaint.h
@@ -18,8 +18,8 @@
 #define GrPaint_DEFINED
 
 #include "GrTexture.h"
+#include "GrColor.h"
 #include "GrSamplerState.h"
-#include "GrDrawTarget.h"
 
 /**
  * The paint describes how pixels are colored when the context draws to
@@ -29,8 +29,8 @@
 public:
 
     // All the paint fields are public except texture (it's ref-counted)
-    GrDrawTarget::BlendCoeff    fSrcBlendCoeff;
-    GrDrawTarget::BlendCoeff    fDstBlendCoeff;
+    GrBlendCoeff                fSrcBlendCoeff;
+    GrBlendCoeff                fDstBlendCoeff;
     bool                        fAntiAlias;
     bool                        fDither;
 
@@ -80,8 +80,8 @@
     GrTexture*      fTexture;
 
     void resetBlend() {
-        fSrcBlendCoeff = GrDrawTarget::kOne_BlendCoeff;
-        fDstBlendCoeff = GrDrawTarget::kZero_BlendCoeff;
+        fSrcBlendCoeff = kOne_BlendCoeff;
+        fDstBlendCoeff = kZero_BlendCoeff;
     }
 
     void resetOptions() {
diff --git a/gpu/include/GrTextContext.h b/gpu/include/GrTextContext.h
index 3dc9c7a..a598251 100644
--- a/gpu/include/GrTextContext.h
+++ b/gpu/include/GrTextContext.h
@@ -26,6 +26,7 @@
 class GrContext;
 class GrTextStrike;
 class GrFontScaler;
+class GrDrawTarget;
 
 class GrTextContext {
 public:
diff --git a/gpu/include/GrTypes.h b/gpu/include/GrTypes.h
index 8311239..02a652a 100644
--- a/gpu/include/GrTypes.h
+++ b/gpu/include/GrTypes.h
@@ -160,6 +160,47 @@
  */
 typedef uint16_t GrVertexLayout;
 
+/**
+ * Path filling rules
+ */
+enum GrPathFill {
+    kWinding_PathFill,
+    kEvenOdd_PathFill,
+    kInverseWinding_PathFill,
+    kInverseEvenOdd_PathFill,
+    kHairLine_PathFill,
+
+    kPathFillCount
+};
+
+/**
+* Geometric primitives used for drawing.
+*/
+enum GrPrimitiveType {
+    kTriangles_PrimitiveType,
+    kTriangleStrip_PrimitiveType,
+    kTriangleFan_PrimitiveType,
+    kPoints_PrimitiveType,
+    kLines_PrimitiveType,
+    kLineStrip_PrimitiveType
+};
+
+/**
+ * Coeffecients for alpha-blending.
+ */
+enum GrBlendCoeff {
+    kZero_BlendCoeff,    //<! 0
+    kOne_BlendCoeff,     //<! 1
+    kSC_BlendCoeff,      //<! src color
+    kISC_BlendCoeff,     //<! one minus src color
+    kDC_BlendCoeff,      //<! dst color
+    kIDC_BlendCoeff,     //<! one minus dst color
+    kSA_BlendCoeff,      //<! src alpha
+    kISA_BlendCoeff,     //<! one minus src alpha
+    kDA_BlendCoeff,      //<! dst alpha
+    kIDA_BlendCoeff,     //<! one minus dst alpha
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 
 // this is included only to make it easy to use this debugging facility
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index 7ce8f35..dbc7f6c 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -24,6 +24,7 @@
 #include "GrIndexBuffer.h"
 #include "GrInOrderDrawBuffer.h"
 #include "GrBufferAllocPool.h"
+#include "GrPathRenderer.h"
 
 #define DEFER_TEXT_RENDERING 1
 
@@ -62,6 +63,7 @@
     delete fDrawBuffer;
     delete fDrawBufferVBAllocPool;
     delete fDrawBufferVBAllocPool;
+    delete fPathRenderer;
 }
 
 void GrContext::abandonAllTextures() {
@@ -146,7 +148,7 @@
             fGpu->setStencilPass(GrDrawTarget::kNone_StencilPass);
             fGpu->setViewMatrix(GrMatrix::I());
             fGpu->setAlpha(0xff);
-            fGpu->setBlendFunc(GrDrawTarget::kOne_BlendCoeff, GrDrawTarget::kZero_BlendCoeff);
+            fGpu->setBlendFunc(kOne_BlendCoeff, kZero_BlendCoeff);
             fGpu->disableState(GrDrawTarget::kDither_StateBit |
                                GrDrawTarget::kClip_StateBit   |
                                GrDrawTarget::kAntialias_StateBit);
@@ -166,7 +168,7 @@
                                      texture->height(),
                                      2*sizeof(GrPoint));
                 verts[1].setIRectFan(0, 0, 1, 1, 2*sizeof(GrPoint));
-                fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType,
+                fGpu->drawNonIndexed(kTriangleFan_PrimitiveType,
                                      0, 4);
                 entry = fTextureCache->createAndLock(*key, texture);
             }
@@ -349,18 +351,18 @@
             return;
         }
 
-        GrDrawTarget::PrimitiveType primType;
+        GrPrimitiveType primType;
         int vertCount;
         GrPoint* vertex = geo.positions();
 
         if (width > 0) {
             vertCount = 10;
-            primType = GrDrawTarget::kTriangleStrip_PrimitiveType;
+            primType = kTriangleStrip_PrimitiveType;
             setStrokeRectStrip(vertex, rect, width);
         } else {
             // hairline
             vertCount = 5;
-            primType = GrDrawTarget::kLineStrip_PrimitiveType;
+            primType = kLineStrip_PrimitiveType;
             vertex[0].set(rect.fLeft, rect.fTop);
             vertex[1].set(rect.fRight, rect.fTop);
             vertex[2].set(rect.fRight, rect.fBottom);
@@ -398,7 +400,7 @@
             if (textured) {
                 target->preConcatSamplerMatrix(0, m);
             }
-            target->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, 4);
+            target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
         #else
             target->drawSimpleRect(rect, matrix, textured ? 1 : 0);
         #endif
@@ -443,7 +445,7 @@
     target->preConcatSamplerMatrix(0, m);
 
     target->setVertexSourceToBuffer(layout, fGpu->getUnitSquareVertexBuffer());
-    target->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, 4);
+    target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
 #else
 
     GrDrawTarget* target;
@@ -463,7 +465,7 @@
 }
 
 void GrContext::drawVertices(const GrPaint& paint,
-                             GrDrawTarget::PrimitiveType primitiveType,
+                             GrPrimitiveType primitiveType,
                              int vertexCount,
                              const GrPoint positions[],
                              const GrPoint texCoords[],
@@ -529,339 +531,19 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#define STENCIL_OFF     0   // Always disable stencil (even when needed)
-#define EVAL_TOL GR_Scalar1
-
-static const uint32_t MAX_POINTS_PER_CURVE = 1 << 10;
-
-static uint32_t quadratic_point_count(const GrPoint points[], GrScalar tol) {
-    GrScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]);
-    // TODO: fixed points sqrt
-    if (d < tol) {
-        return 1;
-    } else {
-        // Each time we subdivide, d should be cut in 4. So we need to
-        // subdivide x = log4(d/tol) times. x subdivisions creates 2^(x)
-        // points.
-        // 2^(log4(x)) = sqrt(x);
-        d = ceilf(sqrtf(d/tol));
-        return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
-    }
-}
-
-static uint32_t generate_quadratic_points(const GrPoint& p0,
-                                          const GrPoint& p1,
-                                          const GrPoint& p2,
-                                          GrScalar tolSqd,
-                                          GrPoint** points,
-                                          uint32_t pointsLeft) {
-    if (pointsLeft < 2 ||
-        (p1.distanceToLineSegmentBetweenSqd(p0, p2)) < tolSqd) {
-        (*points)[0] = p2;
-        *points += 1;
-        return 1;
-    }
-
-    GrPoint q[] = {
-        GrPoint(GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY)),
-        GrPoint(GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY)),
-    };
-    GrPoint r(GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY));
-
-    pointsLeft >>= 1;
-    uint32_t a = generate_quadratic_points(p0, q[0], r, tolSqd, points, pointsLeft);
-    uint32_t b = generate_quadratic_points(r, q[1], p2, tolSqd, points, pointsLeft);
-    return a + b;
-}
-
-static uint32_t cubic_point_count(const GrPoint points[], GrScalar tol) {
-    GrScalar d = GrMax(points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]),
-                       points[2].distanceToLineSegmentBetweenSqd(points[0], points[3]));
-    d = sqrtf(d);
-    if (d < tol) {
-        return 1;
-    } else {
-        d = ceilf(sqrtf(d/tol));
-        return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
-    }
-}
-
-static uint32_t generate_cubic_points(const GrPoint& p0,
-                                      const GrPoint& p1,
-                                      const GrPoint& p2,
-                                      const GrPoint& p3,
-                                      GrScalar tolSqd,
-                                      GrPoint** points,
-                                      uint32_t pointsLeft) {
-    if (pointsLeft < 2 ||
-        (p1.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd &&
-         p2.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd)) {
-            (*points)[0] = p3;
-            *points += 1;
-            return 1;
-        }
-    GrPoint q[] = {
-        GrPoint(GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY)),
-        GrPoint(GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY)),
-        GrPoint(GrScalarAve(p2.fX, p3.fX), GrScalarAve(p2.fY, p3.fY))
-    };
-    GrPoint r[] = {
-        GrPoint(GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY)),
-        GrPoint(GrScalarAve(q[1].fX, q[2].fX), GrScalarAve(q[1].fY, q[2].fY))
-    };
-    GrPoint s(GrScalarAve(r[0].fX, r[1].fX), GrScalarAve(r[0].fY, r[1].fY));
-    pointsLeft >>= 1;
-    uint32_t a = generate_cubic_points(p0, q[0], r[0], s, tolSqd, points, pointsLeft);
-    uint32_t b = generate_cubic_points(s, r[1], q[2], p3, tolSqd, points, pointsLeft);
-    return a + b;
-}
-
-static int worst_case_point_count(GrPathIter* path,
-                                  int* subpaths,
-                                  GrScalar tol) {
-    int pointCount = 0;
-    *subpaths = 1;
-
-    bool first = true;
-
-    GrPathIter::Command cmd;
-
-    GrPoint pts[4];
-    while ((cmd = path->next(pts)) != GrPathIter::kEnd_Command) {
-
-        switch (cmd) {
-            case GrPathIter::kLine_Command:
-                pointCount += 1;
-                break;
-            case GrPathIter::kQuadratic_Command:
-                pointCount += quadratic_point_count(pts, tol);
-                break;
-            case GrPathIter::kCubic_Command:
-                pointCount += cubic_point_count(pts, tol);
-                break;
-            case GrPathIter::kMove_Command:
-                pointCount += 1;
-                if (!first) {
-                    ++(*subpaths);
-                }
-                break;
-            default:
-                break;
-        }
-        first = false;
-    }
-    return pointCount;
-}
-
-static inline bool single_pass_path(const GrPathIter& path,
-                                    GrContext::PathFills fill,
-                                    const GrDrawTarget& target) {
-#if STENCIL_OFF
-    return true;
-#else
-    if (GrContext::kEvenOdd_PathFill == fill) {
-        GrPathIter::ConvexHint hint = path.hint();
-        return hint == GrPathIter::kConvex_ConvexHint ||
-               hint == GrPathIter::kNonOverlappingConvexPieces_ConvexHint;
-    } else if (GrContext::kWinding_PathFill == fill) {
-        GrPathIter::ConvexHint hint = path.hint();
-        return hint == GrPathIter::kConvex_ConvexHint ||
-               hint == GrPathIter::kNonOverlappingConvexPieces_ConvexHint ||
-               (hint == GrPathIter::kSameWindingConvexPieces_ConvexHint &&
-                target.canDisableBlend() && !target.isDitherState());
-
-    }
-    return false;
-#endif
-}
-
 void GrContext::drawPath(const GrPaint& paint,
                          GrPathIter* path,
-                         PathFills fill,
+                         GrPathFill fill,
                          const GrPoint* translate) {
 
 
     GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
 
-    GrDrawTarget::AutoStateRestore asr(target);
-
-    GrMatrix viewM = target->getViewMatrix();
-    // In order to tesselate the path we get a bound on how much the matrix can
-    // stretch when mapping to screen coordinates.
-    GrScalar stretch = viewM.getMaxStretch();
-    bool useStretch = stretch > 0;
-    GrScalar tol = EVAL_TOL;
-    if (!useStretch) {
-        // TODO: deal with perspective in some better way.
-        tol /= 10;
-    } else {
-        // TODO: fixed point divide
-        GrScalar sinv = 1 / stretch;
-        tol = GrMul(tol, sinv);
-    }
-    GrScalar tolSqd = GrMul(tol, tol);
-
-    int subpathCnt;
-    int maxPts = worst_case_point_count(path,
-                                        &subpathCnt,
-                                        tol);
-    GrVertexLayout layout = 0;
-
+    GrDrawTarget::StageBitfield enabledStages = 0;
     if (NULL != paint.getTexture()) {
-        layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+        enabledStages |= 1;
     }
-    // add 4 to hold the bounding rect
-    GrDrawTarget::AutoReleaseGeometry arg(target, layout, maxPts + 4, 0);
-
-    GrPoint* base = (GrPoint*) arg.vertices();
-    GrPoint* vert = base;
-    GrPoint* subpathBase = base;
-
-    GrAutoSTMalloc<8, uint16_t> subpathVertCount(subpathCnt);
-
-    path->rewind();
-
-    // TODO: use primitve restart if available rather than multiple draws
-    GrDrawTarget::PrimitiveType type;
-    int                         passCount = 0;
-    GrDrawTarget::StencilPass   passes[3];
-    bool                        reverse = false;
-
-    if (kHairLine_PathFill == fill) {
-        type = GrDrawTarget::kLineStrip_PrimitiveType;
-        passCount = 1;
-        passes[0] = GrDrawTarget::kNone_StencilPass;
-    } else {
-        type = GrDrawTarget::kTriangleFan_PrimitiveType;
-        if (single_pass_path(*path, fill, *target)) {
-            passCount = 1;
-            passes[0] = GrDrawTarget::kNone_StencilPass;
-        } else {
-            switch (fill) {
-                case kInverseEvenOdd_PathFill:
-                    reverse = true;
-                    // fallthrough
-                case kEvenOdd_PathFill:
-                    passCount = 2;
-                    passes[0] = GrDrawTarget::kEvenOddStencil_StencilPass;
-                    passes[1] = GrDrawTarget::kEvenOddColor_StencilPass;
-                    break;
-
-                case kInverseWinding_PathFill:
-                    reverse = true;
-                    // fallthrough
-                case kWinding_PathFill:
-                    passes[0] = GrDrawTarget::kWindingStencil1_StencilPass;
-                    if (fGpu->supportsSingleStencilPassWinding()) {
-                        passes[1] = GrDrawTarget::kWindingColor_StencilPass;
-                        passCount = 2;
-                    } else {
-                        passes[1] = GrDrawTarget::kWindingStencil2_StencilPass;
-                        passes[2] = GrDrawTarget::kWindingColor_StencilPass;
-                        passCount = 3;
-                    }
-                    break;
-                default:
-                    GrAssert(!"Unknown path fill!");
-                    return;
-            }
-        }
-    }
-    target->setReverseFill(reverse);
-
-    GrPoint pts[4];
-
-    bool first = true;
-    int subpath = 0;
-
-    for (;;) {
-        GrPathIter::Command cmd = path->next(pts);
-        switch (cmd) {
-            case GrPathIter::kMove_Command:
-                if (!first) {
-                    subpathVertCount[subpath] = vert-subpathBase;
-                    subpathBase = vert;
-                    ++subpath;
-                }
-                *vert = pts[0];
-                vert++;
-                break;
-            case GrPathIter::kLine_Command:
-                *vert = pts[1];
-                vert++;
-                break;
-            case GrPathIter::kQuadratic_Command: {
-                generate_quadratic_points(pts[0], pts[1], pts[2],
-                                          tolSqd, &vert,
-                                          quadratic_point_count(pts, tol));
-                break;
-            }
-            case GrPathIter::kCubic_Command: {
-                generate_cubic_points(pts[0], pts[1], pts[2], pts[3],
-                                      tolSqd, &vert,
-                                      cubic_point_count(pts, tol));
-                break;
-            }
-            case GrPathIter::kClose_Command:
-                break;
-            case GrPathIter::kEnd_Command:
-                subpathVertCount[subpath] = vert-subpathBase;
-                ++subpath; // this could be only in debug
-                goto FINISHED;
-        }
-        first = false;
-    }
-FINISHED:
-    GrAssert(subpath == subpathCnt);
-    GrAssert((vert - base) <= maxPts);
-
-    if (translate) {
-        int count = vert - base;
-        for (int i = 0; i < count; i++) {
-            base[i].offset(translate->fX, translate->fY);
-        }
-    }
-
-    // arbitrary path complexity cutoff
-    bool useBounds = fill != kHairLine_PathFill &&
-                    (reverse || (vert - base) > 8);
-    GrPoint* boundsVerts = base + maxPts;
-    if (useBounds) {
-        GrRect bounds;
-        if (reverse) {
-            GrAssert(NULL != target->getRenderTarget());
-            // draw over the whole world.
-            bounds.setLTRB(0, 0,
-                           GrIntToScalar(target->getRenderTarget()->width()),
-                           GrIntToScalar(target->getRenderTarget()->height()));
-            GrMatrix vmi;
-            if (target->getViewInverse(&vmi)) {
-                vmi.mapRect(&bounds);
-            }
-        } else {
-            bounds.setBounds((GrPoint*)base, vert - base);
-        }
-        boundsVerts[0].setRectFan(bounds.fLeft, bounds.fTop, bounds.fRight,
-                                  bounds.fBottom);
-    }
-
-    for (int p = 0; p < passCount; ++p) {
-        target->setStencilPass(passes[p]);
-        if (useBounds && (GrDrawTarget::kEvenOddColor_StencilPass == passes[p] ||
-                          GrDrawTarget::kWindingColor_StencilPass == passes[p])) {
-            target->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType,
-                                 maxPts, 4);
-
-        } else {
-            int baseVertex = 0;
-            for (int sp = 0; sp < subpathCnt; ++sp) {
-                target->drawNonIndexed(type,
-                                     baseVertex,
-                                     subpathVertCount[sp]);
-                baseVertex += subpathVertCount[sp];
-            }
-        }
-    }
+    fPathRenderer->drawPath(target, enabledStages, path, fill, translate);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -918,8 +600,8 @@
 
     fGpu->disableState(GrDrawTarget::kClip_StateBit);
     fGpu->setAlpha(0xFF);
-    fGpu->setBlendFunc(GrDrawTarget::kOne_BlendCoeff,
-                       GrDrawTarget::kZero_BlendCoeff);
+    fGpu->setBlendFunc(kOne_BlendCoeff,
+                       kZero_BlendCoeff);
     fGpu->setTexture(0, texture);
 
     GrSamplerState sampler;
@@ -936,7 +618,7 @@
         return;
     }
     ((GrPoint*)geo.vertices())->setIRectFan(0, 0, width, height);
-    fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, VCOUNT);
+    fGpu->drawNonIndexed(kTriangleFan_PrimitiveType, 0, VCOUNT);
 }
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -1069,7 +751,7 @@
 #if BATCH_RECT_TO_RECT
     fDrawBuffer->setQuadIndexBuffer(this->getQuadIndexBuffer());
 #endif
-
+    fPathRenderer = new GrDefaultPathRenderer(fGpu->supportsSingleStencilPassWinding());
 }
 
 bool GrContext::finalizeTextureKey(GrTextureKey* key,
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index 63e59c4..ca525b3 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -374,8 +374,8 @@
     fCurrDrawState.fFlagBits &= ~(bits);
 }
 
-void GrDrawTarget::setBlendFunc(BlendCoeff srcCoef,
-                                BlendCoeff dstCoef) {
+void GrDrawTarget::setBlendFunc(GrBlendCoeff srcCoef,
+                                GrBlendCoeff dstCoef) {
     fCurrDrawState.fSrcBlend = srcCoef;
     fCurrDrawState.fDstBlend = dstCoef;
 }
@@ -515,12 +515,10 @@
 ///////////////////////////////////////////////////////////////////////////////
 void GrDrawTarget::drawRect(const GrRect& rect, 
                             const GrMatrix* matrix,
-                            int stageEnableMask,
+                            StageBitfield stageEnableBitfield,
                             const GrRect* srcRects[],
                             const GrMatrix* srcMatrices[]) {
-    GR_STATIC_ASSERT(8*sizeof(int) >= kNumStages);
-
-    GrVertexLayout layout = GetRectVertexLayout(stageEnableMask, srcRects);
+    GrVertexLayout layout = GetRectVertexLayout(stageEnableBitfield, srcRects);
 
     AutoReleaseGeometry geo(this, layout, 4, 0);
 
@@ -530,13 +528,13 @@
     drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
 }
 
-GrVertexLayout GrDrawTarget::GetRectVertexLayout(int stageEnableMask, 
+GrVertexLayout GrDrawTarget::GetRectVertexLayout(StageBitfield stageEnableBitfield, 
                                                  const GrRect* srcRects[]) {
     GrVertexLayout layout = 0;
 
     for (int i = 0; i < kNumStages; ++i) {
         int numTC = 0;
-        if (stageEnableMask & (1 << i)) {
+        if (stageEnableBitfield & (1 << i)) {
             if (NULL != srcRects && NULL != srcRects[i]) {
                 layout |= StageTexCoordVertexLayoutBit(i, numTC);
                 ++numTC;
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
index 9e9c185..019c99f 100644
--- a/gpu/src/GrGpu.cpp
+++ b/gpu/src/GrGpu.cpp
@@ -167,7 +167,7 @@
     }
 }
 
-bool GrGpu::setupClipAndFlushState(PrimitiveType type) {
+bool GrGpu::setupClipAndFlushState(GrPrimitiveType type) {
     const GrIRect* r = NULL;
 
     // we check this early because we need a valid
@@ -254,7 +254,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGpu::drawIndexed(PrimitiveType type,
+void GrGpu::drawIndexed(GrPrimitiveType type,
                         int startVertex,
                         int startIndex,
                         int vertexCount,
@@ -282,7 +282,7 @@
                       vertexCount, indexCount);
 }
 
-void GrGpu::drawNonIndexed(PrimitiveType type,
+void GrGpu::drawNonIndexed(GrPrimitiveType type,
                            int startVertex,
                            int vertexCount) {
     GrAssert(kReserved_GeometrySrcType != fGeometrySrc.fVertexSrc ||
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index 8cfc4a0..edcadb4 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -443,8 +443,8 @@
     fHWDrawState.fFlagBits = 0;
 
     // illegal values
-    fHWDrawState.fSrcBlend = (BlendCoeff)-1;
-    fHWDrawState.fDstBlend = (BlendCoeff)-1;
+    fHWDrawState.fSrcBlend = (GrBlendCoeff)-1;
+    fHWDrawState.fDstBlend = (GrBlendCoeff)-1;
     fHWDrawState.fColor = GrColor_ILLEGAL;
 
     fHWDrawState.fViewMatrix = GrMatrix::InvalidMatrix();
@@ -1183,7 +1183,7 @@
     GL_LINE_STRIP
 };
 
-void GrGpuGL::drawIndexedHelper(PrimitiveType type,
+void GrGpuGL::drawIndexedHelper(GrPrimitiveType type,
                                 uint32_t startVertex,
                                 uint32_t startIndex,
                                 uint32_t vertexCount,
@@ -1203,7 +1203,7 @@
                        GL_UNSIGNED_SHORT, indices));
 }
 
-void GrGpuGL::drawNonIndexedHelper(PrimitiveType type,
+void GrGpuGL::drawNonIndexedHelper(GrPrimitiveType type,
                                    uint32_t startVertex,
                                    uint32_t vertexCount) {
     GrAssert((size_t)type < GR_ARRAY_COUNT(gPrimitiveType2GLMode));
@@ -1458,7 +1458,7 @@
     }
 }
 
-bool GrGpuGL::flushGLStateCommon(PrimitiveType type) {
+bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) {
 
     // GrGpu::setupClipAndFlushState should have already checked this
     // and bailed if not true.
diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h
index 017d9ea..f6216c5 100644
--- a/gpu/src/GrGpuGL.h
+++ b/gpu/src/GrGpuGL.h
@@ -98,12 +98,12 @@
     GrGLExts fExts;
 
     // GrGpu overrides
-    virtual void drawIndexedHelper(PrimitiveType type,
+    virtual void drawIndexedHelper(GrPrimitiveType type,
                                    uint32_t startVertex,
                                    uint32_t startIndex,
                                    uint32_t vertexCount,
                                    uint32_t indexCount);
-    virtual void drawNonIndexedHelper(PrimitiveType type,
+    virtual void drawNonIndexedHelper(GrPrimitiveType type,
                                       uint32_t vertexCount,
                                       uint32_t numVertices);
     virtual void flushScissor(const GrIRect* rect);
@@ -127,7 +127,7 @@
     // sampler state (filtering, tiling)
     // FBO binding
     // line width
-    bool flushGLStateCommon(PrimitiveType type);
+    bool flushGLStateCommon(GrPrimitiveType type);
 
     // adjusts texture matrix to account for orientation, size, and npotness
     static void AdjustTextureMatrix(const GrGLTexture* texture,
diff --git a/gpu/src/GrGpuGLFixed.cpp b/gpu/src/GrGpuGLFixed.cpp
index efb0990..516381e 100644
--- a/gpu/src/GrGpuGLFixed.cpp
+++ b/gpu/src/GrGpuGLFixed.cpp
@@ -128,7 +128,7 @@
     GR_GL(LoadMatrixf(mat));
 }
 
-bool GrGpuGLFixed::flushGraphicsState(PrimitiveType type) {
+bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) {
 
     bool usingTextures[kNumStages];
 
diff --git a/gpu/src/GrGpuGLFixed.h b/gpu/src/GrGpuGLFixed.h
index e5d472d..5b81ea6 100644
--- a/gpu/src/GrGpuGLFixed.h
+++ b/gpu/src/GrGpuGLFixed.h
@@ -30,7 +30,7 @@
 
 protected:
     // overrides from GrGpu
-    virtual bool flushGraphicsState(PrimitiveType type);
+    virtual bool flushGraphicsState(GrPrimitiveType type);
     virtual void setupGeometry(int* startVertex,
                                int* startIndex,
                                int vertexCount,
diff --git a/gpu/src/GrGpuGLShaders2.cpp b/gpu/src/GrGpuGLShaders2.cpp
index 34e7c87..14134e7 100644
--- a/gpu/src/GrGpuGLShaders2.cpp
+++ b/gpu/src/GrGpuGLShaders2.cpp
@@ -979,7 +979,7 @@
     program->fViewMatrix = GrMatrix::InvalidMatrix();
 }
 
-void GrGpuGLShaders2::getProgramDesc(PrimitiveType primType, ProgramDesc* desc) {
+void GrGpuGLShaders2::getProgramDesc(GrPrimitiveType primType, ProgramDesc* desc) {
 
     // Must initialize all fields or cache will have false negatives!
     desc->fVertexLayout = fGeometrySrc.fVertexLayout;
@@ -1220,7 +1220,7 @@
                      unis));
 }
 
-void GrGpuGLShaders2::flushProgram(PrimitiveType type) {
+void GrGpuGLShaders2::flushProgram(GrPrimitiveType type) {
     ProgramDesc desc;
     getProgramDesc(type, &desc);
     fProgram = fProgramCache->getProgram(desc);
@@ -1234,7 +1234,7 @@
     }
 }
 
-bool GrGpuGLShaders2::flushGraphicsState(PrimitiveType type) {
+bool GrGpuGLShaders2::flushGraphicsState(GrPrimitiveType type) {
 
     if (!flushGLStateCommon(type)) {
         return false;
diff --git a/gpu/src/GrGpuGLShaders2.h b/gpu/src/GrGpuGLShaders2.h
index 2647e23..e8785c9 100644
--- a/gpu/src/GrGpuGLShaders2.h
+++ b/gpu/src/GrGpuGLShaders2.h
@@ -30,7 +30,7 @@
 
 protected:
     // overrides from GrGpu
-    virtual bool flushGraphicsState(PrimitiveType type);
+    virtual bool flushGraphicsState(GrPrimitiveType type);
     virtual void setupGeometry(int* startVertex,
                                int* startIndex,
                                int vertexCount,
@@ -54,7 +54,7 @@
     void flushRadial2(int stage);
 
     // called at flush time to setup the appropriate program
-    void flushProgram(PrimitiveType type);
+    void flushProgram(GrPrimitiveType type);
 
     struct Program;
 
@@ -69,7 +69,7 @@
     class ProgramCache;
 
     // gets a description of needed shader
-    void getProgramDesc(PrimitiveType primType, ProgramDesc* desc);
+    void getProgramDesc(GrPrimitiveType primType, ProgramDesc* desc);
 
     // generates and compiles a program from a description and vertex layout
     // will change GL's bound program
diff --git a/gpu/src/GrInOrderDrawBuffer.cpp b/gpu/src/GrInOrderDrawBuffer.cpp
index 25e74e3..68590fc 100644
--- a/gpu/src/GrInOrderDrawBuffer.cpp
+++ b/gpu/src/GrInOrderDrawBuffer.cpp
@@ -74,7 +74,7 @@
 
 void GrInOrderDrawBuffer::drawRect(const GrRect& rect, 
                                    const GrMatrix* matrix,
-                                   int stageEnableMask,
+                                   StageBitfield stageEnableBitfield,
                                    const GrRect* srcRects[],
                                    const GrMatrix* srcMatrices[]) {
     
@@ -87,7 +87,7 @@
     if (fMaxQuads) {
         
         bool appendToPreviousDraw = false;
-        GrVertexLayout layout = GetRectVertexLayout(stageEnableMask, srcRects);
+        GrVertexLayout layout = GetRectVertexLayout(stageEnableBitfield, srcRects);
         AutoReleaseGeometry geo(this, layout, 4, 0);
         AutoViewMatrixRestore avmr(this);
         GrMatrix combinedMatrix = this->getViewMatrix();
@@ -167,13 +167,12 @@
         if (disabledClip) {
             this->enableState(kClip_StateBit);
         }
-this->enableState(kClip_StateBit);
     } else {
-        INHERITED::drawRect(rect, matrix, stageEnableMask, srcRects, srcMatrices);
+        INHERITED::drawRect(rect, matrix, stageEnableBitfield, srcRects, srcMatrices);
     }
 }
 
-void GrInOrderDrawBuffer::drawIndexed(PrimitiveType primitiveType,
+void GrInOrderDrawBuffer::drawIndexed(GrPrimitiveType primitiveType,
                                       int startVertex,
                                       int startIndex,
                                       int vertexCount,
@@ -239,7 +238,7 @@
     draw.fIndexBuffer->ref();
 }
 
-void GrInOrderDrawBuffer::drawNonIndexed(PrimitiveType primitiveType,
+void GrInOrderDrawBuffer::drawNonIndexed(GrPrimitiveType primitiveType,
                                          int startVertex,
                                          int vertexCount) {
     if (!vertexCount) {
diff --git a/gpu/src/GrPathRenderer.cpp b/gpu/src/GrPathRenderer.cpp
new file mode 100644
index 0000000..c47b6e5
--- /dev/null
+++ b/gpu/src/GrPathRenderer.cpp
@@ -0,0 +1,352 @@
+#include "GrPathRenderer.h"
+
+#include "GrPoint.h"
+#include "GrDrawTarget.h"
+#include "GrPathIter.h"
+#include "GrMemory.h"
+#include "GrTexture.h"
+
+
+
+GrDefaultPathRenderer::GrDefaultPathRenderer(bool singlePassWindingStencil)
+    : fSinglePassWindingStencil(singlePassWindingStencil) {
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Helpers for draw Path
+
+#define STENCIL_OFF     0   // Always disable stencil (even when needed)
+static const GrScalar gTolerance = GR_Scalar1;
+
+static const uint32_t MAX_POINTS_PER_CURVE = 1 << 10;
+
+static uint32_t quadratic_point_count(const GrPoint points[], GrScalar tol) {
+    GrScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]);
+    if (d < tol) {
+        return 1;
+    } else {
+        // Each time we subdivide, d should be cut in 4. So we need to
+        // subdivide x = log4(d/tol) times. x subdivisions creates 2^(x)
+        // points.
+        // 2^(log4(x)) = sqrt(x);
+        d = ceilf(sqrtf(d/tol));
+        return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
+    }
+}
+
+static uint32_t generate_quadratic_points(const GrPoint& p0,
+                                          const GrPoint& p1,
+                                          const GrPoint& p2,
+                                          GrScalar tolSqd,
+                                          GrPoint** points,
+                                          uint32_t pointsLeft) {
+    if (pointsLeft < 2 ||
+        (p1.distanceToLineSegmentBetweenSqd(p0, p2)) < tolSqd) {
+        (*points)[0] = p2;
+        *points += 1;
+        return 1;
+    }
+
+    GrPoint q[] = {
+        GrPoint(GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY)),
+        GrPoint(GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY)),
+    };
+    GrPoint r(GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY));
+
+    pointsLeft >>= 1;
+    uint32_t a = generate_quadratic_points(p0, q[0], r, tolSqd, points, pointsLeft);
+    uint32_t b = generate_quadratic_points(r, q[1], p2, tolSqd, points, pointsLeft);
+    return a + b;
+}
+
+static uint32_t cubic_point_count(const GrPoint points[], GrScalar tol) {
+    GrScalar d = GrMax(points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]),
+                       points[2].distanceToLineSegmentBetweenSqd(points[0], points[3]));
+    d = sqrtf(d);
+    if (d < tol) {
+        return 1;
+    } else {
+        d = ceilf(sqrtf(d/tol));
+        return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
+    }
+}
+
+static uint32_t generate_cubic_points(const GrPoint& p0,
+                                      const GrPoint& p1,
+                                      const GrPoint& p2,
+                                      const GrPoint& p3,
+                                      GrScalar tolSqd,
+                                      GrPoint** points,
+                                      uint32_t pointsLeft) {
+    if (pointsLeft < 2 ||
+        (p1.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd &&
+         p2.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd)) {
+            (*points)[0] = p3;
+            *points += 1;
+            return 1;
+        }
+    GrPoint q[] = {
+        GrPoint(GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY)),
+        GrPoint(GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY)),
+        GrPoint(GrScalarAve(p2.fX, p3.fX), GrScalarAve(p2.fY, p3.fY))
+    };
+    GrPoint r[] = {
+        GrPoint(GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY)),
+        GrPoint(GrScalarAve(q[1].fX, q[2].fX), GrScalarAve(q[1].fY, q[2].fY))
+    };
+    GrPoint s(GrScalarAve(r[0].fX, r[1].fX), GrScalarAve(r[0].fY, r[1].fY));
+    pointsLeft >>= 1;
+    uint32_t a = generate_cubic_points(p0, q[0], r[0], s, tolSqd, points, pointsLeft);
+    uint32_t b = generate_cubic_points(s, r[1], q[2], p3, tolSqd, points, pointsLeft);
+    return a + b;
+}
+
+static int worst_case_point_count(GrPathIter* path,
+                                  int* subpaths,
+                                  GrScalar tol) {
+    int pointCount = 0;
+    *subpaths = 1;
+
+    bool first = true;
+
+    GrPathIter::Command cmd;
+
+    GrPoint pts[4];
+    while ((cmd = path->next(pts)) != GrPathIter::kEnd_Command) {
+
+        switch (cmd) {
+            case GrPathIter::kLine_Command:
+                pointCount += 1;
+                break;
+            case GrPathIter::kQuadratic_Command:
+                pointCount += quadratic_point_count(pts, tol);
+                break;
+            case GrPathIter::kCubic_Command:
+                pointCount += cubic_point_count(pts, tol);
+                break;
+            case GrPathIter::kMove_Command:
+                pointCount += 1;
+                if (!first) {
+                    ++(*subpaths);
+                }
+                break;
+            default:
+                break;
+        }
+        first = false;
+    }
+    return pointCount;
+}
+
+static inline bool single_pass_path(const GrPathIter& path,
+                                    GrPathFill fill,
+                                    const GrDrawTarget& target) {
+#if STENCIL_OFF
+    return true;
+#else
+    if (kEvenOdd_PathFill == fill) {
+        GrPathIter::ConvexHint hint = path.hint();
+        return hint == GrPathIter::kConvex_ConvexHint ||
+               hint == GrPathIter::kNonOverlappingConvexPieces_ConvexHint;
+    } else if (kWinding_PathFill == fill) {
+        GrPathIter::ConvexHint hint = path.hint();
+        return hint == GrPathIter::kConvex_ConvexHint ||
+               hint == GrPathIter::kNonOverlappingConvexPieces_ConvexHint ||
+               (hint == GrPathIter::kSameWindingConvexPieces_ConvexHint &&
+                target.canDisableBlend() && !target.isDitherState());
+
+    }
+    return false;
+#endif
+}
+
+void GrDefaultPathRenderer::drawPath(GrDrawTarget* target,
+                                     GrDrawTarget::StageBitfield stages,
+                                     GrPathIter* path,
+                                     GrPathFill fill,
+                                     const GrPoint* translate) {
+
+    GrDrawTarget::AutoStateRestore asr(target);
+
+    GrMatrix viewM = target->getViewMatrix();
+    // In order to tesselate the path we get a bound on how much the matrix can
+    // stretch when mapping to screen coordinates.
+    GrScalar stretch = viewM.getMaxStretch();
+    bool useStretch = stretch > 0;
+    GrScalar tol = gTolerance;
+
+    if (!useStretch) {
+        // TODO: deal with perspective in some better way.
+        tol /= 10;
+    } else {
+        GrScalar sinv = GR_Scalar1 / stretch;
+        tol = GrMul(tol, sinv);
+    }
+    GrScalar tolSqd = GrMul(tol, tol);
+
+    int subpathCnt;
+    int maxPts = worst_case_point_count(path,
+                                        &subpathCnt,
+                                        tol);
+
+    GrVertexLayout layout = 0;
+    for (int s = 0; s < GrDrawTarget::kNumStages; ++s) {
+        if ((1 << s) & stages) {
+            layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(s);
+        }
+    }
+
+    // add 4 to hold the bounding rect
+    GrDrawTarget::AutoReleaseGeometry arg(target, layout, maxPts + 4, 0);
+
+    GrPoint* base = (GrPoint*) arg.vertices();
+    GrPoint* vert = base;
+    GrPoint* subpathBase = base;
+
+    GrAutoSTMalloc<8, uint16_t> subpathVertCount(subpathCnt);
+
+    path->rewind();
+
+    // TODO: use primitve restart if available rather than multiple draws
+    GrPrimitiveType             type;
+    int                         passCount = 0;
+    GrDrawTarget::StencilPass   passes[3];
+    bool                        reverse = false;
+
+    if (kHairLine_PathFill == fill) {
+        type = kLineStrip_PrimitiveType;
+        passCount = 1;
+        passes[0] = GrDrawTarget::kNone_StencilPass;
+    } else {
+        type = kTriangleFan_PrimitiveType;
+        if (single_pass_path(*path, fill, *target)) {
+            passCount = 1;
+            passes[0] = GrDrawTarget::kNone_StencilPass;
+        } else {
+            switch (fill) {
+                case kInverseEvenOdd_PathFill:
+                    reverse = true;
+                    // fallthrough
+                case kEvenOdd_PathFill:
+                    passCount = 2;
+                    passes[0] = GrDrawTarget::kEvenOddStencil_StencilPass;
+                    passes[1] = GrDrawTarget::kEvenOddColor_StencilPass;
+                    break;
+
+                case kInverseWinding_PathFill:
+                    reverse = true;
+                    // fallthrough
+                case kWinding_PathFill:
+                    passes[0] = GrDrawTarget::kWindingStencil1_StencilPass;
+                    if (fSinglePassWindingStencil) {
+                        passes[1] = GrDrawTarget::kWindingColor_StencilPass;
+                        passCount = 2;
+                    } else {
+                        passes[1] = GrDrawTarget::kWindingStencil2_StencilPass;
+                        passes[2] = GrDrawTarget::kWindingColor_StencilPass;
+                        passCount = 3;
+                    }
+                    break;
+                default:
+                    GrAssert(!"Unknown path fill!");
+                    return;
+            }
+        }
+    }
+    target->setReverseFill(reverse);
+
+    GrPoint pts[4];
+
+    bool first = true;
+    int subpath = 0;
+
+    for (;;) {
+        GrPathIter::Command cmd = path->next(pts);
+        switch (cmd) {
+            case GrPathIter::kMove_Command:
+                if (!first) {
+                    subpathVertCount[subpath] = vert-subpathBase;
+                    subpathBase = vert;
+                    ++subpath;
+                }
+                *vert = pts[0];
+                vert++;
+                break;
+            case GrPathIter::kLine_Command:
+                *vert = pts[1];
+                vert++;
+                break;
+            case GrPathIter::kQuadratic_Command: {
+                generate_quadratic_points(pts[0], pts[1], pts[2],
+                                          tolSqd, &vert,
+                                          quadratic_point_count(pts, tol));
+                break;
+            }
+            case GrPathIter::kCubic_Command: {
+                generate_cubic_points(pts[0], pts[1], pts[2], pts[3],
+                                      tolSqd, &vert,
+                                      cubic_point_count(pts, tol));
+                break;
+            }
+            case GrPathIter::kClose_Command:
+                break;
+            case GrPathIter::kEnd_Command:
+                subpathVertCount[subpath] = vert-subpathBase;
+                ++subpath; // this could be only in debug
+                goto FINISHED;
+        }
+        first = false;
+    }
+FINISHED:
+    GrAssert(subpath == subpathCnt);
+    GrAssert((vert - base) <= maxPts);
+
+    if (translate) {
+        int count = vert - base;
+        for (int i = 0; i < count; i++) {
+            base[i].offset(translate->fX, translate->fY);
+        }
+    }
+
+    // arbitrary path complexity cutoff
+    bool useBounds = fill != kHairLine_PathFill &&
+                    (reverse || (vert - base) > 8);
+    GrPoint* boundsVerts = base + maxPts;
+    if (useBounds) {
+        GrRect bounds;
+        if (reverse) {
+            GrAssert(NULL != target->getRenderTarget());
+            // draw over the whole world.
+            bounds.setLTRB(0, 0,
+                           GrIntToScalar(target->getRenderTarget()->width()),
+                           GrIntToScalar(target->getRenderTarget()->height()));
+            GrMatrix vmi;
+            if (target->getViewInverse(&vmi)) {
+                vmi.mapRect(&bounds);
+            }
+        } else {
+            bounds.setBounds((GrPoint*)base, vert - base);
+        }
+        boundsVerts[0].setRectFan(bounds.fLeft, bounds.fTop, bounds.fRight,
+                                  bounds.fBottom);
+    }
+
+    for (int p = 0; p < passCount; ++p) {
+        target->setStencilPass(passes[p]);
+        if (useBounds && (GrDrawTarget::kEvenOddColor_StencilPass == passes[p] ||
+                          GrDrawTarget::kWindingColor_StencilPass == passes[p])) {
+            target->drawNonIndexed(kTriangleFan_PrimitiveType,
+                                 maxPts, 4);
+
+        } else {
+            int baseVertex = 0;
+            for (int sp = 0; sp < subpathCnt; ++sp) {
+                target->drawNonIndexed(type,
+                                     baseVertex,
+                                     subpathVertCount[sp]);
+                baseVertex += subpathVertCount[sp];
+            }
+        }
+    }
+}
diff --git a/gpu/src/GrPathRenderer.h b/gpu/src/GrPathRenderer.h
new file mode 100644
index 0000000..e3fd715
--- /dev/null
+++ b/gpu/src/GrPathRenderer.h
@@ -0,0 +1,64 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrPathRenderer_DEFINED
+#define GrPathRenderer_DEFINED
+
+#include "GrDrawTarget.h"
+
+class GrPathIter;
+struct GrPoint;
+
+/**
+ * A path renderer.
+ */
+class GrPathRenderer {
+public:
+    /**
+     * Draws a path into the draw target. The target will already have its draw
+     * state configured for the draw.
+     * @param target                the target to draw into.
+     * @param stages                indicates which stages the are already
+     *                              in use. All enabled stages expect positions
+     *                              as texture coordinates. The path renderer
+     *                              use the remaining stages for its path 
+     *                              filling algorithm.
+     * @param path                  the path to draw.
+     * @param fill                  the fill rule to apply.
+     * @param translate             optional additional translation to apply to
+     *                              the path NULL means (0,0).
+     */
+    virtual void drawPath(GrDrawTarget* target,
+                          GrDrawTarget::StageBitfield stages,
+                          GrPathIter* path,
+                          GrPathFill fill,
+                          const GrPoint* translate) = 0;
+};
+
+class GrDefaultPathRenderer : public GrPathRenderer {
+public:
+    GrDefaultPathRenderer(bool singlePassWindingStencil);
+
+    virtual void drawPath(GrDrawTarget* target,
+                          GrDrawTarget::StageBitfield stages,
+                          GrPathIter* path,
+                          GrPathFill fill,
+                          const GrPoint* translate);
+private:
+    bool    fSinglePassWindingStencil;
+};
+
+#endif
\ No newline at end of file
diff --git a/gpu/src/GrTextContext.cpp b/gpu/src/GrTextContext.cpp
index 0f244a2..8ce45e4 100644
--- a/gpu/src/GrTextContext.cpp
+++ b/gpu/src/GrTextContext.cpp
@@ -23,6 +23,7 @@
 #include "GrFontScaler.h"
 #include "GrIndexBuffer.h"
 #include "GrGpuVertex.h"
+#include "GrDrawTarget.h"
 
 static const int TEXT_STAGE = 1;
 
@@ -47,7 +48,7 @@
         fDrawTarget->setTexture(TEXT_STAGE, fCurrTexture);
         fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
 
-        fDrawTarget->drawIndexed(GrDrawTarget::kTriangles_PrimitiveType,
+        fDrawTarget->drawIndexed(kTriangles_PrimitiveType,
                                  0, 0, fCurrVertex, nIndices);
         fDrawTarget->releaseReservedGeometry();
         fVertices = NULL;
@@ -178,7 +179,7 @@
         GrPoint translate;
         translate.set(GrFixedToScalar(vx - GrIntToFixed(glyph->fBounds.fLeft)),
                       GrFixedToScalar(vy - GrIntToFixed(glyph->fBounds.fTop)));
-        fContext->drawPath(fPaint, &iter, GrContext::kWinding_PathFill,
+        fContext->drawPath(fPaint, &iter, kWinding_PathFill,
                            &translate);
         return;
     }
diff --git a/gpu/src/gr_files.mk b/gpu/src/gr_files.mk
index e6d6997..88aa84b 100644
--- a/gpu/src/gr_files.mk
+++ b/gpu/src/gr_files.mk
@@ -21,4 +21,5 @@
     GrTextureCache.cpp \
     GrTextContext.cpp \
     GrTextStrike.cpp \
-    GrBufferAllocPool.cpp
+    GrBufferAllocPool.cpp\
+    GrPathRenderer.cpp
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index 2987639..ccdd400 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -77,18 +77,18 @@
 
 #define sk_tile_mode_to_grwrap(X) ((GrSamplerState::WrapMode)(X))
 
-GR_STATIC_ASSERT((int)GrGpu::kZero_BlendCoeff == (int)SkXfermode::kZero_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kOne_BlendCoeff  == (int)SkXfermode::kOne_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kSC_BlendCoeff   == (int)SkXfermode::kSC_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kISC_BlendCoeff  == (int)SkXfermode::kISC_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kDC_BlendCoeff   == (int)SkXfermode::kDC_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kIDC_BlendCoeff  == (int)SkXfermode::kIDC_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kSA_BlendCoeff   == (int)SkXfermode::kSA_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kISA_BlendCoeff  == (int)SkXfermode::kISA_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kDA_BlendCoeff   == (int)SkXfermode::kDA_Coeff);
-GR_STATIC_ASSERT((int)GrGpu::kIDA_BlendCoeff  == (int)SkXfermode::kIDA_Coeff);
+GR_STATIC_ASSERT((int)kZero_BlendCoeff == (int)SkXfermode::kZero_Coeff);
+GR_STATIC_ASSERT((int)kOne_BlendCoeff  == (int)SkXfermode::kOne_Coeff);
+GR_STATIC_ASSERT((int)kSC_BlendCoeff   == (int)SkXfermode::kSC_Coeff);
+GR_STATIC_ASSERT((int)kISC_BlendCoeff  == (int)SkXfermode::kISC_Coeff);
+GR_STATIC_ASSERT((int)kDC_BlendCoeff   == (int)SkXfermode::kDC_Coeff);
+GR_STATIC_ASSERT((int)kIDC_BlendCoeff  == (int)SkXfermode::kIDC_Coeff);
+GR_STATIC_ASSERT((int)kSA_BlendCoeff   == (int)SkXfermode::kSA_Coeff);
+GR_STATIC_ASSERT((int)kISA_BlendCoeff  == (int)SkXfermode::kISA_Coeff);
+GR_STATIC_ASSERT((int)kDA_BlendCoeff   == (int)SkXfermode::kDA_Coeff);
+GR_STATIC_ASSERT((int)kIDA_BlendCoeff  == (int)SkXfermode::kIDA_Coeff);
 
-#define sk_blend_to_grblend(X) ((GrGpu::BlendCoeff)(X))
+#define sk_blend_to_grblend(X) ((GrBlendCoeff)(X))
 
 GR_STATIC_ASSERT((int)SkPath::kMove_Verb  == (int)GrPathIter::kMove_Command);
 GR_STATIC_ASSERT((int)SkPath::kLine_Verb  == (int)GrPathIter::kLine_Command);
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index faa31f6..3bf157b 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -584,10 +584,10 @@
 }
 
 // must be in SkCanvas::PointMode order
-static const GrDrawTarget::PrimitiveType gPointMode2PrimtiveType[] = {
-    GrDrawTarget::kPoints_PrimitiveType,
-    GrDrawTarget::kLines_PrimitiveType,
-    GrDrawTarget::kLineStrip_PrimitiveType
+static const GrPrimitiveType gPointMode2PrimtiveType[] = {
+    kPoints_PrimitiveType,
+    kLines_PrimitiveType,
+    kLineStrip_PrimitiveType
 };
 
 void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
@@ -774,21 +774,21 @@
         return;
     }
 
-    GrContext::PathFills fill = GrContext::kHairLine_PathFill;
+    GrPathFill fill = kHairLine_PathFill;
 
     if (doFill) {
         switch (pathPtr->getFillType()) {
             case SkPath::kWinding_FillType:
-                fill = GrContext::kWinding_PathFill;
+                fill = kWinding_PathFill;
                 break;
             case SkPath::kEvenOdd_FillType:
-                fill = GrContext::kEvenOdd_PathFill;
+                fill = kEvenOdd_PathFill;
                 break;
             case SkPath::kInverseWinding_FillType:
-                fill = GrContext::kInverseWinding_PathFill;
+                fill = kInverseWinding_PathFill;
                 break;
             case SkPath::kInverseEvenOdd_FillType:
-                fill = GrContext::kInverseEvenOdd_PathFill;
+                fill = kInverseEvenOdd_PathFill;
                 break;
             default:
                 SkDebugf("Unsupported path fill type\n");
@@ -986,10 +986,10 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 // must be in SkCanvas::VertexMode order
-static const GrDrawTarget::PrimitiveType gVertexMode2PrimitiveType[] = {
-    GrDrawTarget::kTriangles_PrimitiveType,
-    GrDrawTarget::kTriangleStrip_PrimitiveType,
-    GrDrawTarget::kTriangleFan_PrimitiveType,
+static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
+    kTriangles_PrimitiveType,
+    kTriangleStrip_PrimitiveType,
+    kTriangleFan_PrimitiveType,
 };
 
 void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
diff --git a/xcode/gpu/gpu.xcodeproj/project.pbxproj b/xcode/gpu/gpu.xcodeproj/project.pbxproj
index 2254155..58a6358 100644
--- a/xcode/gpu/gpu.xcodeproj/project.pbxproj
+++ b/xcode/gpu/gpu.xcodeproj/project.pbxproj
@@ -92,6 +92,8 @@
 		D53904A112EA026E0025F3D6 /* GrPaint.h in Headers */ = {isa = PBXBuildFile; fileRef = D53904A012EA026E0025F3D6 /* GrPaint.h */; };
 		D58CAF9A12E7212100CB9277 /* GrGLUtil.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D58CAF9812E7212100CB9277 /* GrGLUtil.cpp */; };
 		D5ED886F1313F92C00B98D64 /* GrRedBlackTree.h in Headers */ = {isa = PBXBuildFile; fileRef = D5ED886E1313F92C00B98D64 /* GrRedBlackTree.h */; };
+		D5ED88EB13144FD600B98D64 /* GrPathRenderer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D5ED88E913144FD600B98D64 /* GrPathRenderer.cpp */; };
+		D5ED88EC13144FD600B98D64 /* GrPathRenderer.h in Headers */ = {isa = PBXBuildFile; fileRef = D5ED88EA13144FD600B98D64 /* GrPathRenderer.h */; };
 		D5FAF20C130726C6001550A4 /* GrGeometryBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = D5FAF20B130726C6001550A4 /* GrGeometryBuffer.h */; };
 		D5FAF22313072C27001550A4 /* GrBufferAllocPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D5FAF22113072C27001550A4 /* GrBufferAllocPool.cpp */; };
 		D5FAF22413072C27001550A4 /* GrBufferAllocPool.h in Headers */ = {isa = PBXBuildFile; fileRef = D5FAF22213072C27001550A4 /* GrBufferAllocPool.h */; };
@@ -184,6 +186,8 @@
 		D53904A012EA026E0025F3D6 /* GrPaint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrPaint.h; path = ../../gpu/include/GrPaint.h; sourceTree = SOURCE_ROOT; };
 		D58CAF9812E7212100CB9277 /* GrGLUtil.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GrGLUtil.cpp; path = ../../gpu/src/GrGLUtil.cpp; sourceTree = SOURCE_ROOT; };
 		D5ED886E1313F92C00B98D64 /* GrRedBlackTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrRedBlackTree.h; path = ../../gpu/src/GrRedBlackTree.h; sourceTree = SOURCE_ROOT; };
+		D5ED88E913144FD600B98D64 /* GrPathRenderer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GrPathRenderer.cpp; path = ../../gpu/src/GrPathRenderer.cpp; sourceTree = SOURCE_ROOT; };
+		D5ED88EA13144FD600B98D64 /* GrPathRenderer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrPathRenderer.h; path = ../../gpu/src/GrPathRenderer.h; sourceTree = SOURCE_ROOT; };
 		D5FAF20B130726C6001550A4 /* GrGeometryBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrGeometryBuffer.h; path = ../../gpu/include/GrGeometryBuffer.h; sourceTree = SOURCE_ROOT; };
 		D5FAF22113072C27001550A4 /* GrBufferAllocPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GrBufferAllocPool.cpp; path = ../../gpu/src/GrBufferAllocPool.cpp; sourceTree = SOURCE_ROOT; };
 		D5FAF22213072C27001550A4 /* GrBufferAllocPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrBufferAllocPool.h; path = ../../gpu/src/GrBufferAllocPool.h; sourceTree = SOURCE_ROOT; };
@@ -277,6 +281,8 @@
 		08FB7795FE84155DC02AAC07 /* Source */ = {
 			isa = PBXGroup;
 			children = (
+				D5ED88E913144FD600B98D64 /* GrPathRenderer.cpp */,
+				D5ED88EA13144FD600B98D64 /* GrPathRenderer.h */,
 				D5ED886E1313F92C00B98D64 /* GrRedBlackTree.h */,
 				D539049A12EA01E30025F3D6 /* GrContext_impl.h */,
 				00115DD812C1167A008296FE /* gr_unittests.cpp */,
@@ -398,6 +404,7 @@
 				D5FAF22413072C27001550A4 /* GrBufferAllocPool.h in Headers */,
 				00216E5E130F0B03009A2160 /* GrGLIRect.h in Headers */,
 				D5ED886F1313F92C00B98D64 /* GrRedBlackTree.h in Headers */,
+				D5ED88EC13144FD600B98D64 /* GrPathRenderer.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -475,6 +482,7 @@
 				00115E2912C1167A008296FE /* GrTextureCache.cpp in Sources */,
 				D58CAF9A12E7212100CB9277 /* GrGLUtil.cpp in Sources */,
 				D5FAF22313072C27001550A4 /* GrBufferAllocPool.cpp in Sources */,
+				D5ED88EB13144FD600B98D64 /* GrPathRenderer.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};