diff --git a/gpu/include/GrClip.h b/gpu/include/GrClip.h
index 8e3030c..414a6d6 100644
--- a/gpu/include/GrClip.h
+++ b/gpu/include/GrClip.h
@@ -20,96 +20,116 @@
 
 #include "GrClipIterator.h"
 #include "GrRect.h"
-#include "GrTDArray.h"
+#include "GrPath.h"
+#include "GrTArray.h"
+
 
 class GrClip {
 public:
     GrClip();
     GrClip(const GrClip& src);
-    GrClip(GrClipIterator* iter);
+    GrClip(GrClipIterator* iter, const GrRect* bounds = NULL);
+    GrClip(const GrIRect& rect);
+    GrClip(const GrRect& rect);
+
     ~GrClip();
 
     GrClip& operator=(const GrClip& src);
 
-    bool isEmpty() const { return fBounds.isEmpty(); }
-    bool isComplex() const { return fList.count() > 0; }
-    bool isRect() const {
-        return !this->isEmpty() && !this->isComplex();
+    bool hasBounds() const { return fBoundsValid; }
+
+    const GrRect& getBounds() const { return fBounds; }
+
+    int getElementCount() const { return fList.count(); }
+
+    GrClipType getElementType(int i) const { return fList[i].fType; }
+
+    const GrPath& getPath(int i) const {
+        GrAssert(kPath_ClipType == fList[i].fType);
+        return fList[i].fPath;
     }
-    
-    const GrIRect& getBounds() const { return fBounds; }
+
+    GrPathFill getPathFill(int i) const {
+        GrAssert(kPath_ClipType == fList[i].fType);
+        return fList[i].fPathFill;
+    }
+
+    const GrRect& getRect(int i) const {
+        GrAssert(kRect_ClipType == fList[i].fType);
+        return fList[i].fRect;
+    }
+
+    const GrSetOp getOp(int i) const { return fList[i].fOp; }
+
+    bool isRect() const {
+        if (1 == fList.count() && kRect_ClipType == fList[0].fType) {
+            GrAssert(fBoundsValid);
+            GrAssert(fBounds == fList[0].fRect);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    bool isEmpty() const { return 0 == fList.count(); }
 
     /**
-     *  Resets this clip to be empty (fBounds is empty, and fList is empty)
+     *  Resets this clip to be empty
      */
     void setEmpty();
-
-    /**
-     *  Resets this clip to have fBounds == rect, and fList is empty.
-     */
-    void setRect(const GrIRect& rect);
-
-    /**
-     *  Append a rect to an existing clip. The call must ensure that rect does
-     *  not overlap with any previous rect in this clip (either from setRect
-     *  or addRect). fBounds is automatically updated to reflect the union of
-     *  all rects that have been added.
-     */
-    void addRect(const GrIRect&);
-
-    void setFromIterator(GrClipIterator* iter);
+    void setFromIterator(GrClipIterator* iter, const GrRect* bounds = NULL);
+    void setFromRect(const GrRect& rect);
+    void setFromIRect(const GrIRect& rect);
 
     friend bool operator==(const GrClip& a, const GrClip& b) {
-        return a.fBounds == b.fBounds && a.fList == b.fList;
+        if (a.fList.count() != b.fList.count()) {
+            return false;
+        }
+        int count = a.fList.count();
+        for (int i = 0; i < count; ++i) {
+            if (a.fList[i] != b.fList[i]) {
+                return false;
+            }
+        }
+        return true;
     }
     friend bool operator!=(const GrClip& a, const GrClip& b) {
         return !(a == b);
     }
 
-    /**
-     *  Return the number of rects in this clip: 0 for empty, 1 for a rect,
-     *  or N for a complex clip.
-     */
-    int countRects() const {
-        return this->isEmpty() ? 0 : GrMax<int>(1, fList.count());
-    }
-
-    /**
-     *  Return an array of rects for this clip. Use countRects() to know the
-     *  number of entries.
-     */
-    const GrIRect* getRects() const {
-        return fList.count() > 0 ? fList.begin() : &fBounds;
-    }
-
-#if GR_DEBUG
-    void validate() const;
-#else
-    void validate() const {}
-#endif
-
 private:
-    GrTDArray<GrIRect>  fList;
-    GrIRect             fBounds;
-};
+    struct Element {
+        GrClipType  fType;
+        GrRect      fRect;
+        GrPath      fPath;
+        GrPathFill  fPathFill;
+        GrSetOp     fOp;
+        bool operator ==(const Element& e) const {
+            if (e.fType != fType || e.fOp != fOp) {
+                return false;
+            }
+            switch (fType) {
+                case kRect_ClipType:
+                    return fRect == e.fRect;
+                    break;
+                case kPath_ClipType:
+                    return fPath == e.fPath;
+                default:
+                    GrCrash("Unknown clip element type.");
+                    return false; // suppress warning
+            }
+        }
+        bool operator !=(const Element& e) const { return !(*this == e); }
+    };
 
-class GrClipIter : public GrClipIterator {
-public:
-    GrClipIter(const GrClip& clip) : fClip(&clip), fIndex(0) {}
-    GrClipIter() : fClip(NULL), fIndex(0) {}
-    
-    void reset(const GrClip& clip);
-    
-    virtual bool isDone();
-    virtual void rewind();
-    virtual void getRect(GrIRect* r);
-    virtual void next();
-    virtual void computeBounds(GrIRect* r);
-    
-private:
-    const GrClip*   fClip;
-    int             fIndex;
-};
+    GrRect              fBounds;
+    bool                fBoundsValid;
 
+    enum {
+        kPreAllocElements = 4,
+    };
+    uint8_t             fListMemory[sizeof(Element) * kPreAllocElements];
+    GrTArray<Element>   fList;
+};
 #endif
 
diff --git a/gpu/include/GrClipIterator.h b/gpu/include/GrClipIterator.h
index d1fe4dd..abad619 100644
--- a/gpu/include/GrClipIterator.h
+++ b/gpu/include/GrClipIterator.h
@@ -18,54 +18,60 @@
 #ifndef GrClipIterator_DEFINED
 #define GrClipIterator_DEFINED
 
+#include "GrPath.h"
 #include "GrRect.h"
 
+/**
+ * A clip is a list of paths and/or rects with set operations to combine them.
+ */
 class GrClipIterator {
 public:
-    GrClipIterator() : fNeedBounds(true) {}
     virtual ~GrClipIterator() {}
 
     /**
      *  Returns true if there are no more rects to process
      */
-    virtual bool isDone() = 0;
+    virtual bool isDone() const = 0;
 
     /**
-     *  Rewind the iterate to replay the set of rects again
+     *  Rewind the iterator to replay the set of clip elements again
      */
     virtual void rewind() = 0;
 
     /**
-     *  Return the current rect. It is an error to call this when done() is true
+     * Get the type of the current clip element
      */
-    virtual void getRect(GrIRect*) = 0;
+    virtual GrClipType getType() const = 0;
 
     /**
-     *  Call to move to the next rect in the set
+     * Return the current path. It is an error to call this when isDone() is
+     * true or when getType() is kRect_Type.
+     */
+    virtual GrPathIter* getPathIter() = 0;
+
+    /**
+     * Return the fill rule for the path. It is an error to call this when
+     * isDone() is true or when getType is kRect_Type.
+     */
+    virtual GrPathFill getPathFill() const = 0;
+
+    /**
+    * Return the current rect. It is an error to call this when isDone is true
+    * or when getType() is kPath_Type.
+    */
+    virtual void getRect(GrRect* rect) const = 0;
+
+    /**
+     * Gets the operation used to apply the current item to previously iterated
+     * items. Iterators should not produce a Replace op.
+     */
+    virtual GrSetOp getOp() const = 0;
+
+    /**
+     *  Call to move to the next rect in the set, previous path iter can be made
+     *  invalid.
      */
     virtual void next() = 0;
-
-    /**
-     *  Set bounds to be the bounds of the clip.
-     */
-    virtual void computeBounds(GrIRect* bounds) = 0;
-
-    /**
-     *  Subclass should call this whenever their underlying bounds has changed.
-     */
-    void invalidateBoundsCache() { fNeedBounds = true; }
-
-    const GrIRect& getBounds() {
-        if (fNeedBounds) {
-            this->computeBounds(&fBounds);
-            fNeedBounds = false;
-        }
-        return fBounds;
-    }
-
-private:
-    GrIRect fBounds;
-    bool    fNeedBounds;
 };
 
 /**
diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
index caba6ef..b43375c 100644
--- a/gpu/include/GrContext.h
+++ b/gpu/include/GrContext.h
@@ -278,16 +278,23 @@
                         const GrMatrix* srcMatrix = NULL);
 
     /**
-     * Tessellates and draws a path.
+     * Draws a path.
      *
      * @param paint         describes how to color pixels.
-     * @param path          the path to draw
+     * @param pathIter      the path to draw
      * @param fill          the path filling rule to use.
      * @param translate     optional additional translation applied to the
      *                      path.
      */
     void drawPath(const GrPaint& paint,
-                  GrPathIter* path,
+                  GrPathIter* pathIter,
+                  GrPathFill fill,
+                  const GrPoint* translate = NULL);
+    /**
+     * Helper version of drawPath that takes a GrPath
+     */
+    void drawPath(const GrPaint& paint,
+                  const GrPath& path,
                   GrPathFill fill,
                   const GrPoint* translate = NULL);
     /**
diff --git a/gpu/include/GrDrawTarget.h b/gpu/include/GrDrawTarget.h
index 10c6d48..576bd7a 100644
--- a/gpu/include/GrDrawTarget.h
+++ b/gpu/include/GrDrawTarget.h
@@ -23,9 +23,10 @@
 #include "GrRefCnt.h"
 #include "GrSamplerState.h"
 #include "GrClip.h"
+#include "GrTexture.h"
+#include "GrStencil.h"
 
 class GrTexture;
-class GrRenderTarget;
 class GrClipIterator;
 class GrVertexBuffer;
 class GrIndexBuffer;
@@ -72,56 +73,63 @@
         kClip_StateBit            = 0x4,//<! Controls whether drawing is clipped
                                         //   against the region specified by
                                         //   setClip.
+        kNoColorWrites_StateBit   = 0x8,//<! If set it disables writing colors.
+                                        //   Useful while performing stencil ops.
+
+        // subclass may use additional bits internally
+        kDummyStateBit,
+        kLastPublicStateBit = kDummyStateBit-1
+    };
+
+    enum DrawFace {
+        kBoth_DrawFace,
+        kCCW_DrawFace,
+        kCW_DrawFace,
     };
 
     /**
-     * StencilPass
-     *
-     * Sets the stencil state for subsequent draw calls. Used to fill paths.
-     *
-     * Winding requires two passes when the GPU/API doesn't support separate
-     * stencil.
-     *
-     * The color pass for path fill is used to zero out stencil bits used for
-     * path filling. Every pixel covere by a winding/EO stencil pass must get
-     * covered by the color pass in order to leave stencil buffer in the correct
-     * state for the next path draw.
-     *
-     * NOTE: Stencil-based Winding fill has alias-to-zero problems. (e.g. A
-     * winding count of 128,256,512,etc with a 8 bit stencil buffer
-     * will be unfilled)
+     * The DrawTarget may reserve some of the high bits of the stencil. The draw
+     * target will automatically trim reference and mask values so that the
+     * client doesn't overwrite these bits.
+     * The number of bits available is relative to the currently set render
+      *target.
+     * @return the number of bits usable by the draw target client.
      */
-    enum StencilPass {
-        kNone_StencilPass,            //<! Not drawing a path or clip.
-        kEvenOddStencil_StencilPass,  //<! records in/out in stencil buffer
-                                      //   using the Even/Odd fill rule.
-        kEvenOddColor_StencilPass,    //<! writes colors to color target in
-                                      //   pixels marked inside the fill by
-                                      //   kEOFillStencil_StencilPass. Clears
-                                      //   stencil in pixels covered by
-                                      //   geometry.
-        kWindingStencil1_StencilPass, //<! records in/out in stencil buffer
-                                      //   using the Winding fill rule.
-        kWindingStencil2_StencilPass, //<! records in/out in stencil buffer
-                                      //   using the Winding fill rule.
-                                      //   Run when single-stencil-pass winding
-                                      //   not supported (i.e. no separate
-                                      //   stencil support)
-        kWindingColor_StencilPass,    //<! writes colors to color target in
-                                      //   pixels marked inside the fill by
-                                      //   kWindFillStencil_StencilPass. Clears
-                                      //   stencil in pixels covered by
-                                      //   geometry.
-        kDrawTargetCount_StencilPass  //<! Subclass may extend this enum to use
-                                      //   the stencil for other purposes (e.g.
-                                      //   to do stencil-based clipping)
-                                      //   This value is provided as basis for
-                                      //   defining these extended enum values.
-    };
+    int getUsableStencilBits() const {
+        int bits = fCurrDrawState.fRenderTarget->stencilBits();
+        if (bits) {
+            return bits - 1;
+        } else {
+            return 0;
+        }
+    }
+
+    /**
+     * Sets the stencil settings to use for the next draw.
+     * @param settings  the stencil settings to use.
+     */
+    void setStencil(const GrStencilSettings& settings) {
+        fCurrDrawState.fStencilSettings = settings;
+    }
+
+    /**
+     * Shortcut to disable stencil testing and ops.
+     */
+    void disableStencil() {
+        fCurrDrawState.fStencilSettings.setDisabled();
+    }
 
 protected:
 
     struct DrState {
+        DrState() {
+            // make sure any pad is zero for memcmp
+            // all DrState members should default to something
+            // valid by the memset
+            memset(this, 0, sizeof(DrState));
+            GrAssert((intptr_t)(void*)NULL == 0LL);
+            GrAssert(fStencilSettings.isDisabled());
+        }
         uint32_t                fFlagBits;
         GrBlendCoeff            fSrcBlend;
         GrBlendCoeff            fDstBlend;
@@ -129,8 +137,9 @@
         GrSamplerState          fSamplerStates[kNumStages];
         GrRenderTarget*         fRenderTarget;
         GrColor                 fColor;
-        StencilPass             fStencilPass;
-        bool                    fReverseFill;
+        DrawFace                fDrawFace;
+
+        GrStencilSettings       fStencilSettings;
         GrMatrix                fViewMatrix;
         bool operator ==(const DrState& s) const {
             return 0 == memcmp(this, &s, sizeof(DrState));
@@ -196,7 +205,7 @@
     /**
      * Sets the sampler state for a stage used in subsequent draws.
      *
-     * The sampler state determines how texture coordinates are 
+     * The sampler state determines how texture coordinates are
      * intepretted and used to sample the texture.
      *
      * @param stage           the stage of the sampler to set
@@ -291,19 +300,17 @@
     void setAlpha(uint8_t alpha);
 
     /**
-     * Sets pass for path rendering
-     *
-     * @param pass of path rendering
+     * Controls whether clockwise, counterclockwise, or both faces are drawn.
+     * @param face  the face(s) to draw.
      */
-    void setStencilPass(StencilPass pass);
+    void setDrawFace(DrawFace face) { fCurrDrawState.fDrawFace = face; }
 
     /**
-     * Reveses the in/out decision of the fill rule for path rendering.
-     * Only affects kEOFillColor_StencilPass and kWindingFillColor_StencilPass
-     *
-     * @param reverse true to reverse, false otherwise
+     * Gets whether the target is drawing clockwise, counterclockwise,
+     * or both faces.
+     * @return the current draw face(s).
      */
-    void setReverseFill(bool reverse);
+    DrawFace getDrawFace() const { return fCurrDrawState.fDrawFace; }
 
     /**
      * Enable render state settings.
@@ -327,6 +334,10 @@
         return 0 != (fCurrDrawState.fFlagBits & kClip_StateBit);
     }
 
+    bool isColorWriteDisabled() const {
+        return 0 != (fCurrDrawState.fFlagBits & kNoColorWrites_StateBit);
+    }
+
     /**
      * Sets the blending function coeffecients.
      *
@@ -457,8 +468,8 @@
                                                 //   text [GrGpuTextVertex vs
                                                 //   GrPoint].)
         // for below assert
-        kDummy,
-        kHighVertexLayoutBit = kDummy - 1
+        kDummyVertexLayoutBit,
+        kHighVertexLayoutBit = kDummyVertexLayoutBit - 1
     };
     // make sure we haven't exceeded the number of bits in GrVertexLayout.
     GR_STATIC_ASSERT(kHighVertexLayoutBit < (1 << 8*sizeof(GrVertexLayout)));
@@ -648,7 +659,7 @@
      * have changed. They should be reestablished before the next drawIndexed
      * or drawNonIndexed. This cannot be called between reserving and releasing
      * geometry. The GrDrawTarget subclass may be able to perform additional
-     * optimizations if drawRect is used rather than drawIndexed or 
+     * optimizations if drawRect is used rather than drawIndexed or
      * drawNonIndexed.
      * @param rect      the rect to draw
      * @param matrix    optional matrix applied to rect (before viewMatrix)
@@ -665,18 +676,18 @@
      *                      srcMatrix[i]. srcMatrices can be NULL when no
      *                      srcMatrices are desired.
      */
-    virtual void drawRect(const GrRect& rect, 
+    virtual void drawRect(const GrRect& rect,
                           const GrMatrix* matrix,
                           StageBitfield stageEnableBitfield,
                           const GrRect* srcRects[],
                           const GrMatrix* srcMatrices[]);
 
     /**
-     * Helper for drawRect when the caller doesn't need separate src rects or 
+     * Helper for drawRect when the caller doesn't need separate src rects or
      * matrices.
      */
-    void drawSimpleRect(const GrRect& rect, 
-                        const GrMatrix* matrix, 
+    void drawSimpleRect(const GrRect& rect,
+                        const GrMatrix* matrix,
                         StageBitfield stageEnableBitfield) {
          drawRect(rect, matrix, stageEnableBitfield, NULL, NULL);
     }
@@ -912,20 +923,20 @@
      *                      Defaults to zero (corresponding to vertex position)
      * @return pointer to the vertex component as a GrPoint
      */
-    static GrPoint* GetVertexPoint(void* vertices, 
+    static GrPoint* GetVertexPoint(void* vertices,
                                    int vertexIndex,
                                    int vertexSize,
                                    int offset = 0) {
         intptr_t start = GrTCast<intptr_t>(vertices);
-        return GrTCast<GrPoint*>(start + offset + 
+        return GrTCast<GrPoint*>(start + offset +
                                  vertexIndex * vertexSize);
     }
     static const GrPoint* GetVertexPoint(const void* vertices,
                                          int vertexIndex,
-                                         int vertexSize, 
+                                         int vertexSize,
                                          int offset = 0) {
         intptr_t start = GrTCast<intptr_t>(vertices);
-        return GrTCast<const GrPoint*>(start + offset + 
+        return GrTCast<const GrPoint*>(start + offset +
                                        vertexIndex * vertexSize);
     }
 
@@ -937,20 +948,20 @@
      * @param offset        the offset in bytes of the vertex color
      * @return pointer to the vertex component as a GrColor
      */
-    static GrColor* GetVertexColor(void* vertices, 
+    static GrColor* GetVertexColor(void* vertices,
                                    int vertexIndex,
                                    int vertexSize,
                                    int offset) {
         intptr_t start = GrTCast<intptr_t>(vertices);
-        return GrTCast<GrColor*>(start + offset + 
+        return GrTCast<GrColor*>(start + offset +
                                  vertexIndex * vertexSize);
     }
     static const GrColor* GetVertexColor(const void* vertices,
                                          int vertexIndex,
-                                         int vertexSize, 
+                                         int vertexSize,
                                          int offset) {
         const intptr_t start = GrTCast<intptr_t>(vertices);
-        return GrTCast<const GrColor*>(start + offset + 
+        return GrTCast<const GrColor*>(start + offset +
                                        vertexIndex * vertexSize);
     }
 
@@ -985,10 +996,10 @@
                                               const GrRect* srcRects[]);
 
     static void SetRectVertices(const GrRect& rect,
-                                const GrMatrix* matrix, 
-                                const GrRect* srcRects[], 
+                                const GrMatrix* matrix,
+                                const GrRect* srcRects[],
                                 const GrMatrix* srcMatrices[],
-                                GrVertexLayout layout, 
+                                GrVertexLayout layout,
                                 void* vertices);
 
     enum GeometrySrcType {
@@ -997,7 +1008,7 @@
         kBuffer_GeometrySrcType     // src was set using set*SourceToBuffer
     };
 
-    struct {
+    struct ReservedGeometry {
         bool            fLocked;
         uint32_t        fVertexCount;
         uint32_t        fIndexCount;
diff --git a/gpu/include/GrGLTexture.h b/gpu/include/GrGLTexture.h
index fc12ee0..14370ab 100644
--- a/gpu/include/GrGLTexture.h
+++ b/gpu/include/GrGLTexture.h
@@ -36,9 +36,6 @@
     GLuint renderFBOID() const { return fRTFBOID; }
     GLuint textureFBOID() const { return fTexFBOID; }
 
-    GLuint getStencilBits() const { return fStencilBits; }
-
-    const GrGLIRect& viewport() const { return fViewport; }
     void   abandon();
 
 protected:
@@ -58,17 +55,13 @@
                      GrGpuGL* gl);
     
     void setViewport(const GrGLIRect& rect) { fViewport = rect; }
-    
-    virtual int width() const { return fViewport.fWidth; }
-    virtual int height() const { return fViewport.fHeight; }
-
+    const GrGLIRect& getViewport() const { return fViewport; }
 private:
     GrGpuGL*    fGL;
     GLuint      fRTFBOID;
     GLuint      fTexFBOID;    
     GLuint      fStencilRenderbufferID;
     GLuint      fMSColorRenderbufferID;
-    GLuint      fStencilBits;
    
     // Should this object delete IDs when it is destroyed or does someone
     // else own them.
diff --git a/gpu/include/GrGpu.h b/gpu/include/GrGpu.h
index 661708b..5a88ef4 100644
--- a/gpu/include/GrGpu.h
+++ b/gpu/include/GrGpu.h
@@ -25,6 +25,7 @@
 
 class GrVertexBufferAllocPool;
 class GrIndexBufferAllocPool;
+class GrPathRenderer;
 
 class GrGpu : public GrDrawTarget {
 
@@ -229,15 +230,21 @@
     bool supports8BitPalette() const { return f8bitPaletteSupport; }
 
     /**
-     * If single stencil pass winding is supported then one stencil pass
-     * (kWindingStencil1_PathPass) is required to do winding rule path filling
-     * (or inverse winding rule). Otherwise, two passes are required
-     * (kWindingStencil1_PathPass followed by kWindingStencil2_PathPass).
-     *
+     * returns true if two sided stenciling is supported. If false then only
+     * the front face values of the GrStencilSettings
      * @return    true if only a single stencil pass is needed.
      */
-    bool supportsSingleStencilPassWinding() const
-                                        { return fSingleStencilPassForWinding; }
+    bool supportsTwoSidedStencil() const
+                                        { return fTwoSidedStencilSupport; }
+
+    /**
+     * returns true if stencil wrap is supported. If false then
+     * kIncWrap_StencilOp and kDecWrap_StencilOp are treated as
+     * kIncClamp_StencilOp and kDecClamp_StencilOp, respectively.
+     * @return    true if stencil wrap ops are supported.
+     */
+    bool supportsStencilWrapOps() const
+                                        { return fStencilWrapOpsSupport; }
 
     /**
      * Checks whether locking vertex and index buffers is supported.
@@ -304,7 +311,7 @@
     const GrIndexBuffer* getQuadIndexBuffer() const;
 
     /**
-     * Returns a vertex buffer with four position-only vertices [(0,0), (1,0), 
+     * Returns a vertex buffer with four position-only vertices [(0,0), (1,0),
      * (1,1), (0,1)].
      * @ return unit square vertex buffer
      */
@@ -326,16 +333,12 @@
     void printStats() const;
 
 protected:
-    /**
-     * Extensions to GrDrawTarget::StencilPass to implement stencil clipping
-     */
-    enum GpuStencilPass {
-        kSetClip_StencilPass = kDrawTargetCount_StencilPass,
-                                        /* rendering a hard clip to the stencil
-                                           buffer. Subsequent draws with other
-                                           StencilPass values will be clipped
-                                           if kClip_StateBit is set. */
-        kGpuCount_StencilPass
+    enum PrivateStateBits {
+        kFirstBit = (kLastPublicStateBit << 1),
+
+        kModifyStencilClip_StateBit = kFirstBit, // allows draws to modify
+                                                 // stencil bits used for
+                                                 // clipping.
     };
 
     /**
@@ -344,7 +347,6 @@
     struct ClipState {
         bool            fClipInStencil;
         bool            fClipIsDirty;
-        GrRenderTarget* fStencilClipTarget;
     } fClipState;
 
     // GrDrawTarget override
@@ -353,6 +355,21 @@
     // prepares clip flushes gpu state before a draw
     bool setupClipAndFlushState(GrPrimitiveType type);
 
+    // Functions used to map clip-respecting stencil tests into normal
+    // stencil funcs supported by GPUs.
+    static GrStencilFunc ConvertStencilFunc(bool stencilInClip, 
+                                            GrStencilFunc func);
+    static void ConvertStencilFuncAndMask(GrStencilFunc func,
+                                          bool clipInStencil,
+                                          unsigned int clipBit,
+                                          unsigned int userBits,
+                                          unsigned int* ref,
+                                          unsigned int* mask);
+
+    // stencil settings to clip drawing when stencil clipping is in effect
+    // and the client isn't using the stencil test.
+    static const GrStencilSettings gClipStencilSettings;
+
     // defaults to false, subclass can set true to support palleted textures
     bool f8bitPaletteSupport;
 
@@ -360,10 +377,8 @@
     bool fNPOTTextureSupport;
     bool fNPOTTextureTileSupport;
     bool fNPOTRenderTargetSupport;
-
-    // True if only one stencil pass is required to implement the winding path
-    // fill rule. Subclass responsible for setting this value.
-    bool fSingleStencilPassForWinding;
+    bool fTwoSidedStencilSupport;
+    bool fStencilWrapOpsSupport;
 
     // set by subclass to true if index and vertex buffers can be locked, false
     // otherwise.
@@ -427,13 +442,15 @@
     virtual void flushScissor(const GrIRect* rect) = 0;
 
     // GrGpu subclass removes the clip from the stencil buffer
-    virtual void eraseStencilClip() = 0;
+    virtual void eraseStencilClip(const GrIRect& rect) = 0;
 
 private:
-
+    // readies the pools to provide vertex/index data.
     void prepareVertexPool();
     void prepareIndexPool();
 
+    GrPathRenderer* getPathRenderer();
+
     GrVertexBufferAllocPool*    fVertexPool;
 
     GrIndexBufferAllocPool*     fIndexPool;
@@ -443,6 +460,61 @@
 
     mutable GrVertexBuffer*     fUnitSquareVertexBuffer; // mutable so it can be
                                                          // created on-demand
+
+    GrPathRenderer*             fPathRenderer;
+
+    // when in an internal draw these indicate whether the pools are in use
+    // by one of the outer draws. If false then it is safe to reset the
+    // pool.
+    bool                        fVertexPoolInUse;
+    bool                        fIndexPoolInUse;
+
+    // used to save and restore state when the GrGpu needs
+    // to make its geometry pools available internally
+    class AutoInternalDrawGeomRestore {
+    public:
+        AutoInternalDrawGeomRestore(GrGpu* gpu) : fAgsr(gpu) {
+            fGpu = gpu;
+
+            fVertexPoolWasInUse = gpu->fVertexPoolInUse;
+            fIndexPoolWasInUse  = gpu->fIndexPoolInUse;
+
+            gpu->fVertexPoolInUse = fVertexPoolWasInUse ||
+                                   (kBuffer_GeometrySrcType !=
+                                    gpu->fGeometrySrc.fVertexSrc);
+            gpu->fIndexPoolInUse  = fIndexPoolWasInUse ||
+                                   (kBuffer_GeometrySrcType !=
+                                    gpu->fGeometrySrc.fIndexSrc);;
+
+            fSavedPoolVertexBuffer = gpu->fCurrPoolVertexBuffer;
+            fSavedPoolStartVertex  = gpu->fCurrPoolStartVertex;
+            fSavedPoolIndexBuffer  = gpu->fCurrPoolIndexBuffer;
+            fSavedPoolStartIndex   = gpu->fCurrPoolStartIndex;
+
+            fSavedReservedGeometry = gpu->fReservedGeometry;
+            gpu->fReservedGeometry.fLocked = false;
+        }
+        ~AutoInternalDrawGeomRestore() {
+            fGpu->fCurrPoolVertexBuffer = fSavedPoolVertexBuffer;
+            fGpu->fCurrPoolStartVertex  = fSavedPoolStartVertex;
+            fGpu->fCurrPoolIndexBuffer  = fSavedPoolIndexBuffer;
+            fGpu->fCurrPoolStartIndex   = fSavedPoolStartIndex;
+            fGpu->fVertexPoolInUse = fVertexPoolWasInUse;
+            fGpu->fIndexPoolInUse  = fIndexPoolWasInUse;
+            fGpu->fReservedGeometry = fSavedReservedGeometry;
+        }
+    private:
+        AutoGeometrySrcRestore  fAgsr;
+        GrGpu*                  fGpu;
+        const GrVertexBuffer*   fSavedPoolVertexBuffer;
+        int                     fSavedPoolStartVertex;
+        const GrIndexBuffer*    fSavedPoolIndexBuffer;
+        int                     fSavedPoolStartIndex;
+        bool                    fVertexPoolWasInUse;
+        bool                    fIndexPoolWasInUse;
+        ReservedGeometry        fSavedReservedGeometry;
+    };
+
     typedef GrDrawTarget INHERITED;
 };
 
diff --git a/gpu/include/GrPath.h b/gpu/include/GrPath.h
index cf7b97f..23fc4a8 100644
--- a/gpu/include/GrPath.h
+++ b/gpu/include/GrPath.h
@@ -35,6 +35,8 @@
 
     void resetFromIter(GrPathIter*);
 
+    bool operator ==(const GrPath& path) const;
+    bool operator !=(const GrPath& path) const { return !(*this == path); }
     // overrides from GrPathSink
 
     virtual void moveTo(GrScalar x, GrScalar y);
@@ -50,7 +52,7 @@
 
         // overrides from GrPathIter
         virtual Command next(GrPoint points[]);
-        virtual ConvexHint hint() const;
+        virtual ConvexHint convexHint() const;
         virtual Command next();
         virtual void rewind();
     private:
diff --git a/gpu/include/GrPathIter.h b/gpu/include/GrPathIter.h
index 028faaa..140cbcb 100644
--- a/gpu/include/GrPathIter.h
+++ b/gpu/include/GrPathIter.h
@@ -30,7 +30,7 @@
 class GrPathIter {
 public:
     /**
-     Returned by next(). Indicates the next piece of the path. 
+     Returned by next(). Indicates the next piece of the path.
      */
     enum Command {
         kMove_Command,      //!< next() returns 1 pt
@@ -44,35 +44,35 @@
                             //   Adds a cubic segment
         kClose_Command,     //!< next() returns 0 pts
         kEnd_Command        //!< next() returns 0 pts
-                            //   Implictly closes the last 
+                            //   Implictly closes the last
                             //   point
     };
-    
+
     enum ConvexHint {
-        kNone_ConvexHint,                         //<! No hint about convexity 
+        kNone_ConvexHint,                         //<! No hint about convexity
                                                   //   of the path
         kConvex_ConvexHint,                       //<! Path is one convex piece
-        kNonOverlappingConvexPieces_ConvexHint,   //<! Multiple convex pieces, 
+        kNonOverlappingConvexPieces_ConvexHint,   //<! Multiple convex pieces,
                                                   //   pieces are known to be
                                                   //   disjoint
-        kSameWindingConvexPieces_ConvexHint,      //<! Multiple convex pieces, 
+        kSameWindingConvexPieces_ConvexHint,      //<! Multiple convex pieces,
                                                   //   may or may not intersect,
-                                                  //   either all wind cw or all 
+                                                  //   either all wind cw or all
                                                   //   wind ccw.
-        kConcave_ConvexHint                       //<! Path is known to be 
+        kConcave_ConvexHint                       //<! Path is known to be
                                                   //   concave
     };
-    
+
     static int NumCommandPoints(Command cmd) {
         static const int numPoints[] = {
             1, 2, 3, 4, 0, 0
         };
         return numPoints[cmd];
     }
-    
+
     virtual ~GrPathIter() {};
 
-    /** 
+    /**
      Iterates through the path. Should not be called after
      kEnd_Command has been returned once. This version retrieves the
      points for the command.
@@ -85,14 +85,14 @@
     /**
      * If the host API has knowledge of the convexity of the path
      * it can be communicated by this hint. Ganesh can make these
-     * determinations itself. So it is not necessary to compute 
+     * determinations itself. So it is not necessary to compute
      * convexity status if it isn't already determined.
      *
      * @return a hint about the convexity of the path.
-     */     
-    virtual ConvexHint hint() const { return kNone_ConvexHint; }
+     */
+    virtual ConvexHint convexHint() const { return kNone_ConvexHint; }
 
-     /** 
+     /**
      Iterates through the path. Should not be called after
      kEnd_Command has been returned once. This version does not retrieve the
      points for the command.
diff --git a/gpu/include/GrRect.h b/gpu/include/GrRect.h
index e98913a..96d302f 100644
--- a/gpu/include/GrRect.h
+++ b/gpu/include/GrRect.h
@@ -22,7 +22,7 @@
 
 struct GrIRect {
     int32_t fLeft, fTop, fRight, fBottom;
-    
+
     GrIRect() {}
     GrIRect(int32_t left, int32_t top, int32_t right, int32_t bottom) {
         fLeft = left;
@@ -47,23 +47,22 @@
         fRight = x + w;
         fBottom = y + h;
     }
-    
+
     void setLTRB(int32_t l, int32_t t, int32_t r, int32_t b) {
         fLeft = l;
         fTop = t;
         fRight = r;
         fBottom = b;
     }
-    
+
     /**
      *  Make the largest representable rectangle
-
      */
     void setLargest() {
         fLeft = fTop = GR_Int32Min;
         fRight = fBottom = GR_Int32Max;
     }
-    
+
     bool quickReject(int l, int t, int r, int b) const {
         return l >= fRight || fLeft >= r || t >= fBottom || fTop >= b;
     }
@@ -75,10 +74,28 @@
         if (fBottom < r.fBottom) fBottom = r.fBottom;
     }
 
+    /**
+     * Sets this rect to the intersection with a clip rect. If there is no
+     * intersection then this rect will be made empty.
+     */
+    void intersectWith(const GrIRect& clipRect) {
+        if (fRight < clipRect.fLeft ||
+            fLeft > clipRect.fRight ||
+            fBottom < clipRect.fTop ||
+            fTop > clipRect.fBottom) {
+            this->setEmpty();
+        } else {
+            fLeft = GrMax(fLeft, clipRect.fLeft);
+            fRight = GrMin(fRight, clipRect.fRight);
+            fTop = GrMax(fTop, clipRect.fTop);
+            fBottom = GrMin(fBottom, clipRect.fBottom);
+        }
+    }
+
     friend bool operator==(const GrIRect& a, const GrIRect& b) {
         return 0 == memcmp(&a, &b, sizeof(a));
     }
-    
+
     friend bool operator!=(const GrIRect& a, const GrIRect& b) {
         return 0 != memcmp(&a, &b, sizeof(a));
     }
@@ -91,7 +108,7 @@
         return fLeft == x && fTop == y &&
                this->width() == w && this->height() == h;
     }
-    
+
     bool contains(const GrIRect& r) const {
         return fLeft   <= r.fLeft &&
                fRight  >= r.fRight &&
@@ -102,12 +119,12 @@
 
 struct GrIRect16 {
     int16_t fLeft, fTop, fRight, fBottom;
-    
+
     int width() const { return fRight - fLeft; }
     int height() const { return fBottom - fTop; }
     int area() const { return this->width() * this->height(); }
     bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
-    
+
     void set(const GrIRect& r) {
         fLeft   = GrToS16(r.fLeft);
         fTop    = GrToS16(r.fTop);
@@ -116,12 +133,12 @@
     }
 };
 
-/** 
+/**
  *  2D Rect struct
  */
 struct GrRect {
     GrScalar fLeft, fTop, fRight, fBottom;
-    
+
     /**
      *  Uninitialized rectangle.
      */
@@ -158,7 +175,7 @@
     GrScalar top() const { return fTop; }
     GrScalar right() const { return fRight; }
     GrScalar bottom() const { return fBottom; }
-    
+
     GrScalar diagonalLengthSqd() const {
         GrScalar w = width();
         GrScalar h = height();
@@ -169,18 +186,18 @@
         // TODO: fixed point sqrt
         return GrFloatToScalar(sqrtf(GrScalarToFloat(diagonalLengthSqd())));
     }
-    
+
     /**
      *  Returns true if the width or height is <= 0
      */
     bool isEmpty() const {
         return fLeft >= fRight || fTop >= fBottom;
     }
-    
+
     void setEmpty() {
         fLeft = fTop = fRight = fBottom = 0;
     }
-    
+
     /**
      *  returns true if the rectangle is inverted either in x or y
      */
@@ -192,7 +209,7 @@
         return point.fX >= fLeft && point.fX < fRight &&
                point.fY >= fTop && point.fY < fBottom;
     }
-    
+
     /**
      *  Initialize a rectangle to a point.
      *  @param pt the point used to initialize the rectangle.
@@ -226,16 +243,16 @@
 
     /**
      *  Make the largest representable rectangle
-     *  Set the rect to fLeft = fTop = GR_ScalarMin and 
+     *  Set the rect to fLeft = fTop = GR_ScalarMin and
      *  fRight = fBottom = GR_ScalarMax.
      */
     void setLargest() {
         fLeft = fTop = GR_ScalarMin;
         fRight = fBottom = GR_ScalarMax;
     }
-    
+
     /**
-     Set the rect to fLeft = fTop = GR_ScalarMax and 
+     Set the rect to fLeft = fTop = GR_ScalarMax and
      fRight = fBottom = GR_ScalarMin.
      Useful for initializing a bounding rectangle.
      */
@@ -243,24 +260,24 @@
         fLeft = fTop = GR_ScalarMax;
         fRight = fBottom = GR_ScalarMin;
     }
-    
-    void setLTRB(GrScalar left, 
-                 GrScalar top, 
-                 GrScalar right, 
+
+    void setLTRB(GrScalar left,
+                 GrScalar top,
+                 GrScalar right,
                  GrScalar bottom) {
         fLeft = left;
         fTop = top;
         fRight = right;
         fBottom = bottom;
     }
-    
+
     void setXYWH(GrScalar x, GrScalar y, GrScalar width, GrScalar height) {
         fLeft = x;
         fTop = y;
         fRight = x + width;
         fBottom = y + height;
     }
-    
+
     /**
      Expand the edges of the rectangle to include a point.
      Useful for constructing a bounding rectangle.
@@ -269,12 +286,43 @@
     void growToInclude(const GrPoint& pt) {
         fLeft  = GrMin(pt.fX, fLeft);
         fRight = GrMax(pt.fX, fRight);
-        
+
         fTop    = GrMin(pt.fY, fTop);
         fBottom = GrMax(pt.fY, fBottom);
     }
 
     /**
+     * Grows a rect to include another rect.
+     * @param rect the rect to include
+     */
+    void growToInclude(const GrRect& rect) {
+        GrAssert(!rect.isEmpty());
+        fLeft  = GrMin(rect.fLeft, fLeft);
+        fRight = GrMax(rect.fRight, fRight);
+
+        fTop    = GrMin(rect.fTop, fTop);
+        fBottom = GrMax(rect.fBottom, fBottom);
+    }
+
+    /**
+     * Sets this rect to the intersection with a clip rect. If there is no
+     * intersection then this rect will be made empty.
+     */
+    void intersectWith(const GrRect& clipRect) {
+        if (fRight < clipRect.fLeft ||
+            fLeft > clipRect.fRight ||
+            fBottom < clipRect.fTop ||
+            fTop > clipRect.fBottom) {
+            this->setEmpty();
+        } else {
+            fLeft = GrMax(fLeft, clipRect.fLeft);
+            fRight = GrMin(fRight, clipRect.fRight);
+            fTop = GrMax(fTop, clipRect.fTop);
+            fBottom = GrMin(fBottom, clipRect.fBottom);
+        }
+    }
+
+    /**
      *  Assigns 4 sequential points in order to construct a counter-clockwise
      *  triangle fan, given the corners of this rect. Returns the address of
      *  the next point, treating pts as an array.
@@ -283,6 +331,13 @@
         pts->setRectFan(fLeft, fTop, fRight, fBottom);
         return pts + 4;
     }
+
+    bool operator ==(const GrRect& r) const {
+        return fLeft == r.fLeft     &&
+               fTop == r.fTop       &&
+               fRight == r.fRight   &&
+               fBottom == r.fBottom;
+    }
 };
 
 #endif
diff --git a/gpu/include/GrStencil.h b/gpu/include/GrStencil.h
new file mode 100644
index 0000000..be3e0f6
--- /dev/null
+++ b/gpu/include/GrStencil.h
@@ -0,0 +1,211 @@
+/*
+    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 GrStencil_DEFINED
+#define GrStencil_DEFINED
+
+#include "GrTypes.h"
+/**
+ * Gr uses the stencil buffer to implement complex clipping inside the
+ * GrDrawTarget class. The GrDrawTarget makes a subset of the stencil buffer
+ * bits available for other uses by external code (clients). Client code can
+ * modify these bits. GrDrawTarget will ignore ref, mask, and writemask bits
+ * provided by clients that overlap the bits used to implement clipping. The
+ * client can use the getUsableStencilBits() function to find out how many
+ * client accessible stencil bits are available.
+ *
+ * When code outside the GrDrawTarget class uses the stencil buffer the contract
+ * is as follows:
+ *
+ * > Normal stencil funcs allow the GrGpu client to modify the client bits of
+ *   the stencil buffer outside of the clip.
+ * > Special functions allow a test against the clip. These are more limited
+ *   than the general stencil functions.
+ * > Client can assume all client bits are zero initially.
+ * > Client must ensure that after all its passes are finished it has only
+ *   written to the color buffer in the region inside the clip. Furthermore, it
+ *   must zero all client bits that were modifed (both inside and outside the
+ *   clip).
+ */
+
+/**
+ * Determines which pixels pass / fail the stencil test.
+ * Stencil test passes if (ref & mask) FUNC (stencil & mask) is true
+ */
+enum GrStencilFunc {
+    kAlways_StencilFunc = 0,
+    kNever_StencilFunc,
+    kGreater_StencilFunc,
+    kGEqual_StencilFunc,
+    kLess_StencilFunc,
+    kLEqual_StencilFunc,
+    kEqual_StencilFunc,
+    kNotEqual_StencilFunc,
+
+    // Gr stores the current clip in the
+    // stencil buffer in the high bits that
+    // are not directly accessible modifiable
+    // via the GrDrawTarget interface. The below
+    // stencil funcs test against the current
+    // clip in addition to the GrDrawTarget
+    // client's stencil bits.
+
+    // pass if inside the clip
+    kAlwaysIfInClip_StencilFunc,
+    kEqualIfInClip_StencilFunc,
+    kLessIfInClip_StencilFunc,
+    kLEqualIfInClip_StencilFunc,
+    kNonZeroIfInClip_StencilFunc, // this one forces the ref to be 0
+
+    // counts
+    kStencilFuncCount,
+    kClipStencilFuncCount = kNonZeroIfInClip_StencilFunc -
+                            kAlwaysIfInClip_StencilFunc + 1,
+    kBasicStencilFuncCount = kStencilFuncCount - kClipStencilFuncCount
+};
+
+/**
+ * Operations to perform based on whether stencil test passed failed.
+ */
+enum GrStencilOp {
+    kKeep_StencilOp = 0,    // preserve existing stencil value
+    kReplace_StencilOp,     // replace with reference value from stencl test
+    kIncWrap_StencilOp,     // increment and wrap at max
+    kIncClamp_StencilOp,    // increment and clamp at max
+    kDecWrap_StencilOp,     // decrement and wrap at 0
+    kDecClamp_StencilOp,    // decrement and clamp at 0
+    kZero_StencilOp,        // zero stencil bits
+    kInvert_StencilOp,      // invert stencil bits
+
+    kStencilOpCount
+};
+
+/**
+ * Struct representing stencil state.
+ */
+struct GrStencilSettings {
+    GrStencilOp   fFrontPassOp;     // op to perform when front faces pass
+    GrStencilOp   fBackPassOp;      // op to perform when back faces pass
+    GrStencilOp   fFrontFailOp;     // op to perform when front faces fail
+    GrStencilOp   fBackFailOp;      // op to perform when back faces fail
+    GrStencilFunc fFrontFunc;       // test function for front faces
+    GrStencilFunc fBackFunc;        // test function for back faces
+    unsigned int fFrontFuncMask;    // mask for front face test
+    unsigned int fBackFuncMask;     // mask for back face test
+    unsigned int fFrontFuncRef;     // reference value for front face test
+    unsigned int fBackFuncRef;      // reference value for back face test
+    unsigned int fFrontWriteMask;   // stencil write mask for front faces
+    unsigned int fBackWriteMask;    // stencil write mask for back faces
+
+    bool operator == (const GrStencilSettings& s) const {
+        // make sure this is tightly packed.
+        GR_STATIC_ASSERT(0 == sizeof(GrStencilOp)%4);
+        GR_STATIC_ASSERT(0 == sizeof(GrStencilFunc)%4);
+        GR_STATIC_ASSERT(sizeof(GrStencilSettings) ==
+                        4*sizeof(GrStencilOp) +
+                        2*sizeof(GrStencilFunc) +
+                        6*sizeof(unsigned int));
+        return 0 == memcmp(this, &s, sizeof(GrStencilSettings));
+    }
+
+    bool operator != (const GrStencilSettings& s) const {
+        return !(*this == s);
+    }
+
+    GrStencilSettings& operator =(const GrStencilSettings& s) {
+        memcpy(this, &s, sizeof(GrStencilSettings));
+        return *this;
+    }
+
+    void setSame(GrStencilOp passOp,
+                 GrStencilOp failOp,
+                 GrStencilFunc func,
+                 unsigned int funcMask,
+                 unsigned int funcRef,
+                 unsigned int writeMask) {
+        fFrontPassOp        = passOp;
+        fBackPassOp         = passOp;
+        fFrontFailOp        = failOp;
+        fBackFailOp         = failOp;
+        fFrontFunc          = func;
+        fBackFunc           = func;
+        fFrontFuncMask      = funcMask;
+        fBackFuncMask       = funcMask;
+        fFrontFuncRef       = funcRef;
+        fBackFuncRef        = funcRef;
+        fFrontWriteMask     = writeMask;
+        fBackWriteMask      = writeMask;
+    }
+
+    // canonical value for disabled stenciling
+    static const GrStencilSettings gDisabled;
+    void setDisabled() {
+        *this = gDisabled;
+    }
+    bool isDisabled() const {
+        return kKeep_StencilOp == fFrontPassOp   &&
+               kKeep_StencilOp == fBackPassOp    &&
+               kKeep_StencilOp == fFrontFailOp   &&
+               kKeep_StencilOp == fFrontFailOp   &&
+               kAlways_StencilFunc == fFrontFunc &&
+               kAlways_StencilFunc == fBackFunc;
+    }
+    void invalidate()  {
+        // just write an illegal value to the first member
+        fFrontPassOp = (GrStencilOp)-1;
+    }
+
+private:
+    friend class GrGpu;
+
+    enum {
+        kMaxStencilClipPasses = 2  // maximum number of passes to add a clip 
+                                   // element to the stencil buffer.
+    };
+
+    /**
+     * Given a thing to draw into the stencil clip, a fill type, and a set op
+     * this function determines:
+     *      1. Whether the thing can be draw directly to the stencil clip or
+     *      needs to be drawn to the client portion of the stencil first.
+     *      2. How many passes are needed.
+     *      3. What those passes are.
+     *      4. The fill rule that should actually be used to render (will 
+     *         always be non-inverted).
+     *
+     * @param op                the set op to combine this element with the 
+     *                          existing clip
+     * @param stencilClipMask   mask with just the stencil bit used for clipping
+     *                          enabled.
+     * @param fill              in: the fill rule of the element to draw.
+     *                          out: the fill rule that should be used to draw
+     * @param numPasses         out: the number of passes needed to add the 
+     *                               element to the clip.
+     * @param settings          out: the stencil settings to use for each pass
+     *
+     * @return true if the clip element's geometry can be drawn directly to the
+     *         stencil clip bit. Will only be true if canBeDirect is true.
+     *         numPasses will be 1 if return value is true.
+     */
+    static bool GetClipPasses(GrSetOp op, 
+                              bool canBeDirect,
+                              unsigned int stencilClipMask,
+                              GrPathFill* fill,
+                              int* numPasses,
+                              GrStencilSettings settings[kMaxStencilClipPasses]);
+};
+
+#endif
diff --git a/gpu/include/GrTArray.h b/gpu/include/GrTArray.h
index c31c820..6ef1a13 100644
--- a/gpu/include/GrTArray.h
+++ b/gpu/include/GrTArray.h
@@ -176,6 +176,8 @@
         }
     }
 
+    void reset() { this->pop_back_n(fCount); }
+
     int count() const { return fCount; }
 
     bool empty() const { return !fCount; }
diff --git a/gpu/include/GrTexture.h b/gpu/include/GrTexture.h
index 098ac59..2d3928c 100644
--- a/gpu/include/GrTexture.h
+++ b/gpu/include/GrTexture.h
@@ -19,6 +19,7 @@
 #define GrTexture_DEFINED
 
 #include "GrRefCnt.h"
+#include "GrClip.h"
 
 class GrTexture;
 
@@ -34,11 +35,16 @@
     /**
      * @return the width of the rendertarget
      */
-    virtual int width() const = 0;
+    int width() const { return fWidth; }
     /**
      * @return the height of the rendertarget
      */
-    virtual int height() const = 0;
+    int height() const { return fHeight; }
+
+    /**
+     * @return the number of stencil bits in the rendertarget
+     */
+    int stencilBits() const { return fStencilBits; }
 
     /**
      * @return the texture associated with the rendertarget, may be NULL.
@@ -46,8 +52,28 @@
     GrTexture* asTexture() {return fTexture;}
 
 protected:
-    GrRenderTarget(GrTexture* texture) : fTexture(texture) {}
+    GrRenderTarget(GrTexture* texture,
+                   int width,
+                   int height,
+                   int stencilBits)
+        : fTexture(texture),
+          fWidth(width),
+          fHeight(height),
+          fStencilBits(stencilBits) {}
+
+
     GrTexture* fTexture;
+    int        fWidth;
+    int        fHeight;
+    int        fStencilBits;
+
+private:
+    // GrGpu keeps a cached clip in the render target to avoid redundantly
+    // rendering the clip into the same stencil buffer.
+    friend class GrGpu;
+    GrClip     fLastStencilClip;
+
+    typedef GrRefCnt INHERITED;
 };
 
 class GrTexture : public GrRefCnt {
diff --git a/gpu/include/GrTypes.h b/gpu/include/GrTypes.h
index 02a652a..29e847f 100644
--- a/gpu/include/GrTypes.h
+++ b/gpu/include/GrTypes.h
@@ -201,6 +201,26 @@
     kIDA_BlendCoeff,     //<! one minus dst alpha
 };
 
+/**
+ * Set Operations used to construct clips.
+ */
+enum GrSetOp {
+    kReplace_SetOp,
+    kIntersect_SetOp,
+    kUnion_SetOp,
+    kXor_SetOp,
+    kDifference_SetOp,
+    kReverseDifference_SetOp,
+};
+
+/**
+ * Clips are composed from these objects.
+ */
+enum GrClipType {
+    kRect_ClipType,
+    kPath_ClipType
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 
 // this is included only to make it easy to use this debugging facility
diff --git a/gpu/src/GrClip.cpp b/gpu/src/GrClip.cpp
index b7a839b..924c01b 100644
--- a/gpu/src/GrClip.cpp
+++ b/gpu/src/GrClip.cpp
@@ -17,18 +17,30 @@
 
 #include "GrClip.h"
 
-GrClip::GrClip() {
+GrClip::GrClip()
+    : fList(fListMemory, kPreAllocElements) {
     fBounds.setEmpty();
-    this->validate();
+    fBoundsValid = true;
 }
 
-GrClip::GrClip(const GrClip& src) {
+GrClip::GrClip(const GrClip& src)
+    : fList(fListMemory, kPreAllocElements) {
     *this = src;
 }
 
-GrClip::GrClip(GrClipIterator* iter) {
-    fBounds.setEmpty();
-    this->setFromIterator(iter);
+GrClip::GrClip(const GrIRect& rect)
+    : fList(fListMemory, kPreAllocElements) {
+    this->setFromIRect(rect);
+}
+
+GrClip::GrClip(const GrRect& rect)
+    : fList(fListMemory, kPreAllocElements) {
+    this->setFromRect(rect);
+}
+
+GrClip::GrClip(GrClipIterator* iter, const GrRect* bounds)
+    : fList(fListMemory, kPreAllocElements) {
+    this->setFromIterator(iter, bounds);
 }
 
 GrClip::~GrClip() {}
@@ -36,101 +48,100 @@
 GrClip& GrClip::operator=(const GrClip& src) {
     fList = src.fList;
     fBounds = src.fBounds;
-    this->validate();
+    fBoundsValid = src.fBoundsValid;
     return *this;
 }
 
 void GrClip::setEmpty() {
     fList.reset();
     fBounds.setEmpty();
-    this->validate();
+    fBoundsValid = true;
 }
 
-void GrClip::setRect(const GrIRect& r) {
+void GrClip::setFromRect(const GrRect& r) {
+    fList.reset();
+    if (r.isEmpty()) {
+        // use a canonical empty rect for == testing.
+        setEmpty();
+    } else {
+        fList.push_back();
+        fList.back().fRect = r;
+        fList.back().fType = kRect_ClipType;
+        fBounds = r;
+        fBoundsValid = true;
+    }
+}
+
+void GrClip::setFromIRect(const GrIRect& r) {
+    fList.reset();
+    if (r.isEmpty()) {
+        // use a canonical empty rect for == testing.
+        setEmpty();
+    } else {
+        fList.push_back();
+        fList.back().fRect.set(r);
+        fList.back().fType = kRect_ClipType;
+        fBounds.set(r);
+        fBoundsValid = true;
+    }
+}
+
+void GrClip::setFromIterator(GrClipIterator* iter, const GrRect* bounds) {
     fList.reset();
 
-    // we need a canonical "empty" rect, so that our operator== will behave
-    // correctly with two empty clips.
-    if (r.isEmpty()) {
-        fBounds.setEmpty();
-    } else {
-        fBounds = r;
-    }
-    this->validate();
-}
+    int rectCount = 0;
 
-void GrClip::addRect(const GrIRect& r) {
-    if (!r.isEmpty()) {
-        this->validate();
-        if (this->isEmpty()) {
-            GrAssert(fList.count() == 0);
-            fBounds = r;
-        } else {
-            if (this->isRect()) {
-                *fList.append() = fBounds;
-            }
-            *fList.append() = r;
-            fBounds.unionWith(r);
-        }
-        this->validate();
-    }
-}
+    // compute bounds for common case of series of intersecting rects.
+    bool isectRectValid = true;
 
-void GrClip::setFromIterator(GrClipIterator* iter) {
-    this->setEmpty();
     if (iter) {
         for (iter->rewind(); !iter->isDone(); iter->next()) {
-            GrIRect r;
-            iter->getRect(&r);
-            this->addRect(r);
-        }
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void GrClipIter::reset(const GrClip& clip) { fClip = &clip; fIndex = 0; }
-
-bool GrClipIter::isDone() { 
-    return (NULL == fClip) || (fIndex >= fClip->countRects()); 
-}
-
-void GrClipIter::rewind() { fIndex = 0; }
-void GrClipIter::getRect(GrIRect* r) { *r = fClip->getRects()[fIndex]; }
-void GrClipIter::next() { fIndex += 1; }
-void GrClipIter::computeBounds(GrIRect* r) { 
-    if (NULL == fClip) {
-        r->setEmpty();
-    } else {
-        *r = fClip->getBounds();
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#if GR_DEBUG
-
-void GrClip::validate() const {
-    if (fBounds.isEmpty()) {
-        GrAssert(0 == fBounds.fLeft);
-        GrAssert(0 == fBounds.fTop);
-        GrAssert(0 == fBounds.fRight);
-        GrAssert(0 == fBounds.fBottom);
-        GrAssert(0 == fList.count());
-    } else {
-        int count = fList.count();
-        if (count > 0) {
-            GrAssert(count > 1);
-            GrAssert(!fList[0].isEmpty());
-            GrIRect bounds = fList[0];
-            for (int i = 1; i < count; i++) {
-                GrAssert(!fList[i].isEmpty());
-                bounds.unionWith(fList[i]);
+            Element& e = fList.push_back();
+            e.fType = iter->getType();
+            e.fOp = iter->getOp();
+            // iterators should not emit replace
+            GrAssert(kReplace_SetOp != e.fOp);
+            switch (e.fType) {
+                case kRect_ClipType:
+                    iter->getRect(&e.fRect);
+                    ++rectCount;
+                    if (isectRectValid) {
+                        if (1 == rectCount || kIntersect_SetOp == e.fOp) {
+                            GrAssert(fList.count() <= 2);
+                            if (fList.count() > 1) {
+                                GrAssert(2 == rectCount);
+                                rectCount = 1;
+                                fList.pop_back();
+                                GrAssert(kRect_ClipType == fList.back().fType);
+                                fList.back().fRect.intersectWith(e.fRect);
+                            }
+                        } else {
+                            isectRectValid = false;
+                        }
+                    }
+                    break;
+                case kPath_ClipType:
+                    e.fPath.resetFromIter(iter->getPathIter());
+                    e.fPathFill = iter->getPathFill();
+                    isectRectValid = false;
+                    break;
+                default:
+                    GrCrash("Unknown clip element type.");
             }
-            GrAssert(fBounds == bounds);
         }
     }
+    fBoundsValid = false;
+    if (NULL == bounds) {
+        if (isectRectValid) {
+            fBoundsValid = true;
+            if (rectCount > 0) {
+                fBounds = fList[0].fRect;
+            } else {
+                fBounds.setEmpty();
+            }
+        }
+    } else {
+        fBounds = *bounds;
+        fBoundsValid = true;
+    }
 }
-
-#endif
-
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index 840e773..a047895 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -145,7 +145,7 @@
             GrDrawTarget::AutoStateRestore asr(fGpu);
             fGpu->setRenderTarget(texture->asRenderTarget());
             fGpu->setTexture(0, clampEntry->texture());
-            fGpu->setStencilPass(GrDrawTarget::kNone_StencilPass);
+            fGpu->disableStencil();
             fGpu->setViewMatrix(GrMatrix::I());
             fGpu->setAlpha(0xff);
             fGpu->setBlendFunc(kOne_BlendCoeff, kZero_BlendCoeff);
@@ -284,7 +284,7 @@
 
 void GrContext::setClip(const GrIRect& rect) {
     GrClip clip;
-    clip.setRect(rect);
+    clip.setFromIRect(rect);
     fGpu->setClip(clip);
 }
 
@@ -297,7 +297,10 @@
 void GrContext::drawPaint(const GrPaint& paint) {
     // set rect to be big enough to fill the space, but not super-huge, so we
     // don't overflow fixed-point implementations
-    GrRect r(fGpu->getClip().getBounds());
+    GrRect r;
+    r.setLTRB(0, 0,
+              GrIntToScalar(getRenderTarget()->width()),
+              GrIntToScalar(getRenderTarget()->height()));
     GrMatrix inverse;
     if (fGpu->getViewInverse(&inverse)) {
         inverse.mapRect(&r);
@@ -546,6 +549,15 @@
     fPathRenderer->drawPath(target, enabledStages, path, fill, translate);
 }
 
+void GrContext::drawPath(const GrPaint& paint,
+                         const GrPath& path,
+                         GrPathFill fill,
+                         const GrPoint* translate) {
+    GrPath::Iter iter(path);
+    this->drawPath(paint, &iter, fill, translate);
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(bool flushRenderTarget) {
@@ -751,7 +763,8 @@
 #if BATCH_RECT_TO_RECT
     fDrawBuffer->setQuadIndexBuffer(this->getQuadIndexBuffer());
 #endif
-    fPathRenderer = new GrDefaultPathRenderer(fGpu->supportsSingleStencilPassWinding());
+    fPathRenderer = new GrDefaultPathRenderer(fGpu->supportsTwoSidedStencil(),
+                                              fGpu->supportsStencilWrapOps());
 }
 
 bool GrContext::finalizeTextureKey(GrTextureKey* key,
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index ca525b3..7973361 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -358,14 +358,6 @@
     fCurrDrawState.fSamplerStates[stage] = state;
 }
 
-void GrDrawTarget::setStencilPass(StencilPass pass) {
-    fCurrDrawState.fStencilPass = pass;
-}
-
-void GrDrawTarget::setReverseFill(bool reverse) {
-    fCurrDrawState.fReverseFill = reverse;
-}
-
 void GrDrawTarget::enableState(uint32_t bits) {
     fCurrDrawState.fFlagBits |= bits;
 }
diff --git a/gpu/src/GrGLTexture.cpp b/gpu/src/GrGLTexture.cpp
index 9fd1f57..ae991e8 100644
--- a/gpu/src/GrGLTexture.cpp
+++ b/gpu/src/GrGLTexture.cpp
@@ -22,12 +22,14 @@
                                    GLuint stencilBits,
                                    const GrGLIRect& viewport,
                                    GrGLTexture* texture,
-                                   GrGpuGL* gl) : INHERITED(texture) {
+                                   GrGpuGL* gl) : INHERITED(texture,
+                                                            viewport.fWidth,
+                                                            viewport.fHeight,
+                                                            stencilBits) {
     fGL                     = gl;
     fRTFBOID                = ids.fRTFBOID;
     fTexFBOID               = ids.fTexFBOID;
     fStencilRenderbufferID  = ids.fStencilRenderbufferID;
-    fStencilBits            = stencilBits;
     fMSColorRenderbufferID  = ids.fMSColorRenderbufferID;
     fNeedsResolve           = false;
     fViewport               = viewport;
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
index 019c99f..f42e316 100644
--- a/gpu/src/GrGpu.cpp
+++ b/gpu/src/GrGpu.cpp
@@ -22,12 +22,13 @@
 #include "GrIndexBuffer.h"
 #include "GrVertexBuffer.h"
 #include "GrBufferAllocPool.h"
+#include "GrPathRenderer.h"
 
 // probably makes no sense for this to be less than a page
 static const size_t VERTEX_POOL_VB_SIZE = 1 << 12;
 static const int VERTEX_POOL_VB_COUNT = 1;
 
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 size_t GrTexture::BytesPerPixel(PixelConfig config) {
     switch (config) {
@@ -56,7 +57,7 @@
 }
 
 
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 extern void gr_run_unittests();
 
@@ -68,7 +69,10 @@
                  fVertexPool(NULL),
                  fIndexPool(NULL),
                  fQuadIndexBuffer(NULL),
-                 fUnitSquareVertexBuffer(NULL) {
+                 fUnitSquareVertexBuffer(NULL),
+                 fPathRenderer(NULL),
+                 fVertexPoolInUse(false),
+                 fIndexPoolInUse(false) {
 #if GR_DEBUG
 //    gr_run_unittests();
 #endif
@@ -80,6 +84,7 @@
     GrSafeUnref(fUnitSquareVertexBuffer);
     delete fVertexPool;
     delete fIndexPool;
+    delete fPathRenderer;
 }
 
 void GrGpu::resetContext() {
@@ -91,7 +96,7 @@
 #endif
 }
 
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 static const int MAX_QUADS = 1 << 12; // max possible: (1 << 14) - 1;
 
@@ -159,7 +164,7 @@
     return fUnitSquareVertexBuffer;
 }
 
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 void GrGpu::clipWillBeSet(const GrClip& newClip) {
     if (newClip != fClip) {
@@ -167,8 +172,113 @@
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
+// stencil settings to use when clip is in stencil
+const GrStencilSettings GrGpu::gClipStencilSettings = {
+    kKeep_StencilOp,             kKeep_StencilOp,
+    kKeep_StencilOp,             kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc, kAlwaysIfInClip_StencilFunc,
+    0,                           0,
+    0,                           0,
+    0,                           0
+};
+
+// converts special stencil func to
+static const GrStencilFunc gGrClipToNormalStencilFunc[2][kClipStencilFuncCount] = {
+    {// Stencil-Clipping is DISABLED, effectively always inside the clip
+        // In the Clip Funcs
+        kAlways_StencilFunc,          // kAlwaysIfInClip_StencilFunc
+        kEqual_StencilFunc,           // kEqualIfInClip_StencilFunc
+        kLess_StencilFunc,            // kLessIfInClip_StencilFunc
+        kLEqual_StencilFunc,          // kLEqualIfInClip_StencilFunc
+        // Special in the clip func that forces user's ref to be 0.
+        kNotEqual_StencilFunc,        // kNonZeroIfInClip_StencilFunc
+                                      // make ref 0 and do normal nequal.
+    },
+    {// Stencil-Clipping is ENABLED
+        // In the Clip Funcs
+        kEqual_StencilFunc,           // kAlwaysIfInClip_StencilFunc
+                                      // eq stencil clip bit, mask
+                                      // out user bits.
+
+        kEqual_StencilFunc,           // kEqualIfInClip_StencilFunc
+                                      // add stencil bit to mask and ref
+
+        kLess_StencilFunc,            // kLessIfInClip_StencilFunc
+        kLEqual_StencilFunc,          // kLEqualIfInClip_StencilFunc
+                                      // for both of these we can add
+                                      // the clip bit to the mask and
+                                      // ref and compare as normal
+        // Special in the clip func that forces user's ref to be 0.
+        kLess_StencilFunc,            // kNonZeroIfInClip_StencilFunc
+                                      // make ref have only the clip bit set
+                                      // and make comparison be less
+                                      // 10..0 < 1..user_bits..
+    }
+};
+
+GrStencilFunc GrGpu::ConvertStencilFunc(bool stencilInClip, GrStencilFunc func) {
+    GrAssert(func >= 0);
+    if (func >= kBasicStencilFuncCount) {
+        GrAssert(func < kStencilFuncCount);
+        func = gGrClipToNormalStencilFunc[stencilInClip ? 1 : 0][func - kBasicStencilFuncCount];
+        GrAssert(func >= 0 && func < kBasicStencilFuncCount);
+    }
+    return func;
+}
+
+void GrGpu::ConvertStencilFuncAndMask(GrStencilFunc func,
+                                      bool clipInStencil,
+                                      unsigned int clipBit,
+                                      unsigned int userBits,
+                                      unsigned int* ref,
+                                      unsigned int* mask) {
+    if (func < kBasicStencilFuncCount) {
+        *mask &= userBits;
+        *ref &= userBits;
+    } else {
+        if (clipInStencil) {
+            switch (func) {
+                case kAlwaysIfInClip_StencilFunc:
+                    *mask = clipBit;
+                    *ref = clipBit;
+                    break;
+                case kEqualIfInClip_StencilFunc:
+                case kLessIfInClip_StencilFunc:
+                case kLEqualIfInClip_StencilFunc:
+                    *mask = (*mask & userBits) | clipBit;
+                    *ref = (*ref & userBits) | clipBit;
+                    break;
+                case kNonZeroIfInClip_StencilFunc:
+                    *mask = (*mask & userBits) | clipBit;
+                    *ref = clipBit;
+                    break;
+                default:
+                    GrCrash("Unknown stencil func");
+            }
+        } else {
+            *mask &= userBits;
+            *ref &= userBits;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#define VISUALIZE_COMPLEX_CLIP 0
+
+#if VISUALIZE_COMPLEX_CLIP
+    #include "GrRandom.h"
+    GrRandom gRandom;
+    #define SET_RANDOM_COLOR this->setColor(0xff000000 | gRandom.nextU());
+#else
+    #define SET_RANDOM_COLOR
+#endif
+
 bool GrGpu::setupClipAndFlushState(GrPrimitiveType type) {
     const GrIRect* r = NULL;
+    GrIRect clipRect;
 
     // we check this early because we need a valid
     // render target to setup stencil clipping
@@ -179,80 +289,135 @@
     }
 
     if (fCurrDrawState.fFlagBits & kClip_StateBit) {
-        fClipState.fClipInStencil = fClip.countRects() > 1;
+        GrRenderTarget& rt = *fCurrDrawState.fRenderTarget;
+
+        GrRect bounds;
+        GrRect rtRect;
+        rtRect.setLTRB(0, 0,
+                       GrIntToScalar(rt.width()), GrIntToScalar(rt.height()));
+        if (fClip.hasBounds()) {
+            bounds = fClip.getBounds();
+            bounds.intersectWith(rtRect);
+        } else {
+            bounds = rtRect;
+        }
+
+        bounds.roundOut(&clipRect);
+        if  (clipRect.isEmpty()) {
+            clipRect.setLTRB(0,0,0,0);
+        }
+        r = &clipRect;
+
+        fClipState.fClipInStencil = !fClip.isRect() &&
+                                    !fClip.isEmpty() &&
+                                    !bounds.isEmpty();
 
         if (fClipState.fClipInStencil &&
             (fClipState.fClipIsDirty ||
-             fClipState.fStencilClipTarget != fCurrDrawState.fRenderTarget)) {
+             fClip != rt.fLastStencilClip)) {
+
+            rt.fLastStencilClip = fClip;
+            // we set the current clip to the bounds so that our recursive
+            // draws are scissored to them. We use the copy of the complex clip
+            // in the rt to render
+            const GrClip& clip = rt.fLastStencilClip;
+            fClip.setFromRect(bounds);
 
             AutoStateRestore asr(this);
-            AutoGeometrySrcRestore agsr(this);
+            AutoInternalDrawGeomRestore aidgr(this);
 
-            // We have to use setVertexSourceToBuffer (and index) in order
-            // to ensure we correctly restore the client's geom sources.
-            // We tack the clip verts onto the vertex pool but we don't
-            // use the various helper functions because of their side effects.
-
-            int rectTotal = fClip.countRects();
-            if (NULL == fVertexPool) {
-                fVertexPool = new GrVertexBufferAllocPool(this,
-                                                          true,
-                                                          VERTEX_POOL_VB_SIZE,
-                                                          VERTEX_POOL_VB_COUNT);
-            } else if (kBuffer_GeometrySrcType == fGeometrySrc.fVertexSrc) {
-                // we can't reset if vertex source is array or reserved
-                // because then the client data is in the pool!
-                fVertexPool->reset();
-            }
-            const GrVertexBuffer* vertexBuffer;
-            int vStart;
-            GrPoint* rectVertices =
-                reinterpret_cast<GrPoint*>(fVertexPool->makeSpace(0,
-                                                                  rectTotal * 4,
-                                                                  &vertexBuffer,
-                                                                  &vStart));
-            for (int r = 0; r < rectTotal; ++r) {
-                const GrIRect& rect = fClip.getRects()[r];
-                rectVertices[4 * r].setIRectFan(rect.fLeft, rect.fTop,
-                                                rect.fRight, rect.fBottom);
-            }
-            fVertexPool->unlock();
-            this->setVertexSourceToBuffer(0, vertexBuffer);
-            this->setIndexSourceToBuffer(getQuadIndexBuffer());
             this->setViewMatrix(GrMatrix::I());
-            // don't clip the clip or recurse!
-            this->disableState(kClip_StateBit);
-            this->eraseStencilClip();
-            this->setStencilPass((GrDrawTarget::StencilPass)kSetClip_StencilPass);
-            int currRect = 0;
-            while (currRect < rectTotal) {
-                int rectCount = GrMin(MAX_QUADS,
-                                      rectTotal - currRect);
-                this->drawIndexed(kTriangles_PrimitiveType,
-                                  vStart + currRect * 4,
-                                  0,
-                                  rectCount*4,
-                                  rectCount*6);
-                currRect += rectCount;
+            this->eraseStencilClip(clipRect);
+            this->flushScissor(NULL);
+#if !VISUALIZE_COMPLEX_CLIP
+            this->enableState(kNoColorWrites_StateBit);
+#else
+            this->disableState(kNoColorWrites_StateBit);
+#endif
+            int count = clip.getElementCount();
+            int clipBit = rt.stencilBits();
+            clipBit = (1 << (clipBit-1));
+
+            // walk through each clip element and perform its set op
+            // with the existing clip.
+            for (int c = 0; c < count; ++c) {
+                GrPathFill fill;
+                // enabled at bottom of loop
+                this->disableState(kModifyStencilClip_StateBit);
+
+                bool canDrawDirectToClip;
+                if (kRect_ClipType == clip.getElementType(c)) {
+                    canDrawDirectToClip = true;
+                    fill = kEvenOdd_PathFill;
+                } else {
+                    fill = clip.getPathFill(c);
+                    canDrawDirectToClip = getPathRenderer()->requiresStencilPass(clip.getPath(c));
+                }
+
+                GrSetOp op = 0 == c ? kReplace_SetOp : clip.getOp(c);
+                int passes;
+                GrStencilSettings stencilSettings[GrStencilSettings::kMaxStencilClipPasses];
+
+                canDrawDirectToClip = GrStencilSettings::GetClipPasses(op,  canDrawDirectToClip,
+                                                                       clipBit, &fill,
+                                                                       &passes, stencilSettings);
+
+                // draw the element to the client stencil bits if necessary
+                if (!canDrawDirectToClip) {
+                    if (kRect_ClipType == clip.getElementType(c)) {
+                        static const GrStencilSettings gDrawToStencil = {
+                            kIncClamp_StencilOp, kIncClamp_StencilOp,
+                            kIncClamp_StencilOp, kIncClamp_StencilOp,
+                            kAlways_StencilFunc, kAlways_StencilFunc,
+                            0xffffffff,          0xffffffff,
+                            0x00000000,          0x00000000,
+                            0xffffffff,          0xffffffff,
+                        };
+                        this->setStencil(gDrawToStencil);
+                        SET_RANDOM_COLOR
+                        this->drawSimpleRect(clip.getRect(c), NULL, 0);
+                    } else {
+                        SET_RANDOM_COLOR
+                        getPathRenderer()->drawPathToStencil(this, clip.getPath(c), fill, NULL);
+                    }
+                }
+
+                // now we modify the clip bit by rendering either the clip
+                // element directly or a bounding rect of the entire clip.
+                this->enableState(kModifyStencilClip_StateBit);
+                for (int p = 0; p < passes; ++p) {
+                    this->setStencil(stencilSettings[p]);
+                    if (canDrawDirectToClip) {
+                        if (kRect_ClipType == clip.getElementType(c)) {
+                            SET_RANDOM_COLOR
+                            this->drawSimpleRect(clip.getRect(c), NULL, 0);
+                        } else {
+                            SET_RANDOM_COLOR
+                            getPathRenderer()->drawPath(this, 0, clip.getPath(c), fill, NULL);
+                        }
+                    } else {
+                        SET_RANDOM_COLOR
+                        this->drawSimpleRect(bounds, 0, NULL);
+                    }
+                }
             }
-            fClipState.fStencilClipTarget = fCurrDrawState.fRenderTarget;
+            fClip = clip;
+            // recusive draws would have disabled this.
+            fClipState.fClipInStencil = true;
         }
 
         fClipState.fClipIsDirty = false;
-        if (!fClipState.fClipInStencil) {
-            r = &fClip.getBounds();
-        }
     }
+
     // Must flush the scissor after graphics state
-    if (!flushGraphicsState(type)) {
+    if (!this->flushGraphicsState(type)) {
         return false;
     }
-    flushScissor(r);
+    this->flushScissor(r);
     return true;
 }
 
-
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 void GrGpu::drawIndexed(GrPrimitiveType type,
                         int startVertex,
@@ -314,10 +479,11 @@
 
 void GrGpu::prepareVertexPool() {
     if (NULL == fVertexPool) {
-        fVertexPool = new GrVertexBufferAllocPool(this, true, 
-                                                  VERTEX_POOL_VB_SIZE, 
+        fVertexPool = new GrVertexBufferAllocPool(this, true,
+                                                  VERTEX_POOL_VB_SIZE,
                                                   VERTEX_POOL_VB_COUNT);
-    } else {
+    } else if (!fVertexPoolInUse) {
+        // the client doesn't have valid data in the pool
         fVertexPool->reset();
     }
 }
@@ -325,7 +491,8 @@
 void GrGpu::prepareIndexPool() {
     if (NULL == fVertexPool) {
         fIndexPool = new GrIndexBufferAllocPool(this, true, 0, 1);
-    } else {
+    } else if (!fIndexPoolInUse) {
+        // the client doesn't have valid data in the pool
         fIndexPool->reset();
     }
 }
@@ -339,7 +506,7 @@
     if (fReservedGeometry.fVertexCount) {
         GrAssert(NULL != vertices);
 
-        prepareVertexPool();
+        this->prepareVertexPool();
 
         *vertices = fVertexPool->makeSpace(vertexLayout,
                                            fReservedGeometry.fVertexCount,
@@ -354,7 +521,7 @@
     if (fReservedGeometry.fIndexCount) {
         GrAssert(NULL != indices);
 
-        prepareIndexPool();
+        this->prepareIndexPool();
 
         *indices = fIndexPool->makeSpace(fReservedGeometry.fIndexCount,
                                          &fCurrPoolIndexBuffer,
@@ -397,7 +564,17 @@
     GR_DEBUGASSERT(success);
 }
 
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+GrPathRenderer* GrGpu::getPathRenderer() {
+    if (NULL == fPathRenderer) {
+        fPathRenderer = new GrDefaultPathRenderer(this->supportsTwoSidedStencil(),
+                                                  this->supportsStencilWrapOps());
+    }
+    return fPathRenderer;
+}
+
+////////////////////////////////////////////////////////////////////////////////
 
 const GrGpu::Stats& GrGpu::getStats() const {
     return fStats;
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index b30dd02..2574b15 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -49,8 +49,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGpuGL::AdjustTextureMatrix(const GrGLTexture* texture, 
-                                  GrSamplerState::SampleMode mode, 
+void GrGpuGL::AdjustTextureMatrix(const GrGLTexture* texture,
+                                  GrSamplerState::SampleMode mode,
                                   GrMatrix* matrix) {
     GrAssert(NULL != texture);
     GrAssert(NULL != matrix);
@@ -80,7 +80,7 @@
     }
 }
 
-bool GrGpuGL::TextureMatrixIsIdentity(const GrGLTexture* texture, 
+bool GrGpuGL::TextureMatrixIsIdentity(const GrGLTexture* texture,
                                       const GrSamplerState& sampler) {
     GrAssert(NULL != texture);
     if (!sampler.getMatrix().isIdentity()) {
@@ -104,7 +104,7 @@
 static bool gPrintStartupSpew;
 
 
-bool fbo_test(GrGLExts exts, int w, int h) {
+static bool fbo_test(GrGLExts exts, int w, int h) {
 
     GLint savedFBO;
     GLint savedTexUnit;
@@ -169,8 +169,6 @@
     GrAssert(maxTextureUnits > kNumStages);
 #endif
 
-    fCurrDrawState = fHWDrawState;
-
     ////////////////////////////////////////////////////////////////////////////
     // Check for supported features.
 
@@ -263,14 +261,24 @@
     // we could also look for GL_ATI_separate_stencil extension or
     // GL_EXT_stencil_two_side but they use different function signatures
     // than GL2.0+ (and than each other).
-    fSingleStencilPassForWinding = (major >= 2);
+    fTwoSidedStencilSupport = (major >= 2);
+    // supported on GL 1.4 and higher or by extension
+    fStencilWrapOpsSupport = (major > 1) ||
+                             (1 == major) && (minor >= 4) ||
+                              has_gl_extension("GL_EXT_stencil_wrap");
 #else
     // ES 2 has two sided stencil but 1.1 doesn't. There doesn't seem to be
     // an ES1 extension.
-    fSingleStencilPassForWinding = (major >= 2);
+    fTwoSidedStencilSupport = (major >= 2);
+    // stencil wrap support is in ES2, ES1 requires extension.
+    fStencilWrapOpsSupport = (major > 1) ||
+                              has_gl_extension("GL_OES_stencil_wrap");
+
 #endif
     if (gPrintStartupSpew) {
-        GrPrintf("Single Stencil Pass For Winding: %s\n", (fSingleStencilPassForWinding ? "YES" : "NO"));
+        GrPrintf("Stencil Caps: TwoSide: %s, Wrap: %s\n",
+                (fTwoSidedStencilSupport ? "YES" : "NO"),
+                (fStencilWrapOpsSupport ? "YES" : "NO"));
     }
 
 #if GR_SUPPORT_GLDESKTOP
@@ -424,8 +432,9 @@
     fHWBlendDisabled = false;
     GR_GL(Enable(GL_BLEND));
 
-    // this is always disabled
     GR_GL(Disable(GL_CULL_FACE));
+    GR_GL(FrontFace(GL_CCW));
+    fHWDrawState.fDrawFace = kBoth_DrawFace;
 
     GR_GL(Disable(GL_DITHER));
 #if GR_SUPPORT_GLDESKTOP
@@ -434,14 +443,15 @@
     GR_GL(Disable(GL_MULTISAMPLE));
 #endif
 
+    GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
+    fHWDrawState.fFlagBits = 0;
+
     // we only ever use lines in hairline mode
     GR_GL(LineWidth(1));
 
     // invalid
     fActiveTextureUnitIdx = -1;
 
-    fHWDrawState.fFlagBits = 0;
-
     // illegal values
     fHWDrawState.fSrcBlend = (GrBlendCoeff)-1;
     fHWDrawState.fDstBlend = (GrBlendCoeff)-1;
@@ -454,7 +464,7 @@
         fHWDrawState.fSamplerStates[s].setRadial2Params(-GR_ScalarMax,
                                                         -GR_ScalarMax,
                                                         true);
-        
+
         fHWDrawState.fSamplerStates[s].setMatrix(GrMatrix::InvalidMatrix());
     }
 
@@ -463,16 +473,9 @@
     GR_GL(Disable(GL_SCISSOR_TEST));
     fHWBounds.fViewportRect.invalidate();
 
-    // disabling the stencil test also disables
-    // stencil buffer writes
-    GR_GL(Disable(GL_STENCIL_TEST));
-    GR_GL(StencilMask(0xffffffff));
-    GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
-    fHWDrawState.fReverseFill = false;
-    fHWDrawState.fStencilPass = kNone_StencilPass;
+    fHWDrawState.fStencilSettings.invalidate();
     fHWStencilClip = false;
     fClipState.fClipIsDirty = true;
-    fClipState.fStencilClipTarget = NULL;
 
     fHWGeometryState.fIndexBuffer = NULL;
     fHWGeometryState.fVertexBuffer = NULL;
@@ -480,6 +483,7 @@
     GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
     fHWGeometryState.fArrayPtrsDirty = true;
 
+    GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
     fHWDrawState.fRenderTarget = NULL;
 }
 
@@ -491,7 +495,7 @@
 GrRenderTarget* GrGpuGL::createPlatformRenderTarget(
                                                 intptr_t platformRenderTarget,
                                                 int stencilBits,
-                                                int width, 
+                                                int width,
                                                 int height) {
     GrGLRenderTarget::GLRenderTargetIDs rtIDs;
     rtIDs.fStencilRenderbufferID = 0;
@@ -1030,11 +1034,11 @@
 void GrGpuGL::flushScissor(const GrIRect* rect) {
     GrAssert(NULL != fCurrDrawState.fRenderTarget);
     const GrGLIRect& vp =
-            ((GrGLRenderTarget*)fCurrDrawState.fRenderTarget)->viewport();
+            ((GrGLRenderTarget*)fCurrDrawState.fRenderTarget)->getViewport();
 
     GrGLIRect scissor;
     if (NULL != rect) {
-        scissor.setRelativeTo(vp, rect->fLeft, rect->fTop, 
+        scissor.setRelativeTo(vp, rect->fLeft, rect->fTop,
                               rect->width(), rect->height());
         if (scissor.contains(vp)) {
             rect = NULL;
@@ -1068,12 +1072,12 @@
         fHWBounds.fScissorEnabled = false;
     }
     GR_GL(ColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE));
+    fHWDrawState.fFlagBits &= ~kNoColorWrites_StateBit;
     GR_GL(ClearColor(GrColorUnpackR(color)/255.f,
                      GrColorUnpackG(color)/255.f,
                      GrColorUnpackB(color)/255.f,
                      GrColorUnpackA(color)/255.f));
     GR_GL(Clear(GL_COLOR_BUFFER_BIT));
-    fDirtyFlags.fWriteMaskChanged = true;
 }
 
 void GrGpuGL::eraseStencil(uint32_t value, uint32_t mask) {
@@ -1088,15 +1092,21 @@
     GR_GL(StencilMask(mask));
     GR_GL(ClearStencil(value));
     GR_GL(Clear(GL_STENCIL_BUFFER_BIT));
-    fDirtyFlags.fWriteMaskChanged = true;
+    fHWDrawState.fStencilSettings.invalidate();
 }
 
-void GrGpuGL::eraseStencilClip() {    
+void GrGpuGL::eraseStencilClip(const GrIRect& rect) {
     GrAssert(NULL != fCurrDrawState.fRenderTarget);
-    GLint stencilBitCount = ((GrGLRenderTarget*)fCurrDrawState.fRenderTarget)->getStencilBits();
+    GLint stencilBitCount = fCurrDrawState.fRenderTarget->stencilBits();
     GrAssert(stencilBitCount > 0);
     GLint clipStencilMask  = (1 << (stencilBitCount - 1));
-    eraseStencil(0, clipStencilMask);
+
+    flushRenderTarget();
+    flushScissor(&rect);
+    GR_GL(StencilMask(clipStencilMask));
+    GR_GL(ClearStencil(0));
+    GR_GL(Clear(GL_STENCIL_BUFFER_BIT));
+    fHWDrawState.fStencilSettings.invalidate();
 }
 
 void GrGpuGL::forceRenderTargetFlush() {
@@ -1117,13 +1127,13 @@
     }
     flushRenderTarget();
 
-    const GrGLIRect& glvp = ((GrGLRenderTarget*)fCurrDrawState.fRenderTarget)->viewport();
-    
+    const GrGLIRect& glvp = ((GrGLRenderTarget*)fCurrDrawState.fRenderTarget)->getViewport();
+
     // the read rect is viewport-relative
     GrGLIRect readRect;
     readRect.setRelativeTo(glvp, left, top, width, height);
     GR_GL(ReadPixels(readRect.fLeft, readRect.fBottom,
-                     readRect.fWidth, readRect.fHeight, 
+                     readRect.fWidth, readRect.fHeight,
                      format, type, buffer));
 
     // now reverse the order of the rows, since GL's are bottom-to-top, but our
@@ -1166,7 +1176,7 @@
     #endif
         fDirtyFlags.fRenderTargetChanged = true;
         fHWDrawState.fRenderTarget = fCurrDrawState.fRenderTarget;
-        const GrGLIRect& vp = rt->viewport();
+        const GrGLIRect& vp = rt->getViewport();
         if (true || fHWBounds.fViewportRect != vp) {
             vp.pushToGLViewport();
             fHWBounds.fViewportRect = vp;
@@ -1183,6 +1193,27 @@
     GL_LINE_STRIP
 };
 
+#define SWAP_PER_DRAW 0
+
+#if SWAP_PER_DRAW 
+    #if GR_MAC_BUILD
+        #include <AGL/agl.h>
+    #elif GR_WIN32_BUILD
+        void SwapBuf() {
+            DWORD procID = GetCurrentProcessId();
+            HWND hwnd = GetTopWindow(GetDesktopWindow());
+            while(hwnd) {
+                DWORD wndProcID = 0;
+                GetWindowThreadProcessId(hwnd, &wndProcID);
+                if(wndProcID == procID) {
+                    SwapBuffers(GetDC(hwnd));
+                }
+                hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
+            }
+         }
+    #endif
+#endif
+
 void GrGpuGL::drawIndexedHelper(GrPrimitiveType type,
                                 uint32_t startVertex,
                                 uint32_t startIndex,
@@ -1201,6 +1232,18 @@
 
     GR_GL(DrawElements(gPrimitiveType2GLMode[type], indexCount,
                        GL_UNSIGNED_SHORT, indices));
+#if SWAP_PER_DRAW
+    glFlush();
+    #if GR_MAC_BUILD
+        aglSwapBuffers(aglGetCurrentContext());
+        int set_a_break_pt_here = 9;
+        aglSwapBuffers(aglGetCurrentContext());
+    #elif GR_WIN32_BUILD
+        SwapBuf();
+        int set_a_break_pt_here = 9;
+        SwapBuf();
+    #endif
+#endif
 }
 
 void GrGpuGL::drawNonIndexedHelper(GrPrimitiveType type,
@@ -1218,6 +1261,18 @@
     // account for startVertex in the DrawElements case. So we always
     // rely on setupGeometry to have accounted for startVertex.
     GR_GL(DrawArrays(gPrimitiveType2GLMode[type], 0, vertexCount));
+#if SWAP_PER_DRAW
+    glFlush();
+    #if GR_MAC_BUILD
+        aglSwapBuffers(aglGetCurrentContext());
+        int set_a_break_pt_here = 9;
+        aglSwapBuffers(aglGetCurrentContext());
+    #elif GR_WIN32_BUILD
+        SwapBuf();
+        int set_a_break_pt_here = 9;
+        SwapBuf();
+    #endif
+#endif
 }
 
 void GrGpuGL::resolveTextureRenderTarget(GrGLTexture* texture) {
@@ -1257,203 +1312,162 @@
     }
 }
 
+static const GLenum grToGLStencilFunc[] = {
+    GL_ALWAYS,           // kAlways_StencilFunc
+    GL_NEVER,            // kNever_StencilFunc
+    GL_GREATER,          // kGreater_StencilFunc
+    GL_GEQUAL,           // kGEqual_StencilFunc
+    GL_LESS,             // kLess_StencilFunc
+    GL_LEQUAL,           // kLEqual_StencilFunc,
+    GL_EQUAL,            // kEqual_StencilFunc,
+    GL_NOTEQUAL,         // kNotEqual_StencilFunc,
+};
+GR_STATIC_ASSERT(GR_ARRAY_COUNT(grToGLStencilFunc) == kBasicStencilFuncCount);
+GR_STATIC_ASSERT(0 == kAlways_StencilFunc);
+GR_STATIC_ASSERT(1 == kNever_StencilFunc);
+GR_STATIC_ASSERT(2 == kGreater_StencilFunc);
+GR_STATIC_ASSERT(3 == kGEqual_StencilFunc);
+GR_STATIC_ASSERT(4 == kLess_StencilFunc);
+GR_STATIC_ASSERT(5 == kLEqual_StencilFunc);
+GR_STATIC_ASSERT(6 == kEqual_StencilFunc);
+GR_STATIC_ASSERT(7 == kNotEqual_StencilFunc);
+
+static const GLenum grToGLStencilOp[] = {
+    GL_KEEP,        // kKeep_StencilOp
+    GL_REPLACE,     // kReplace_StencilOp
+    GL_INCR_WRAP,   // kIncWrap_StencilOp
+    GL_INCR,        // kIncClamp_StencilOp
+    GL_DECR_WRAP,   // kDecWrap_StencilOp
+    GL_DECR,        // kDecClamp_StencilOp
+    GL_ZERO,        // kZero_StencilOp
+    GL_INVERT,      // kInvert_StencilOp
+};
+GR_STATIC_ASSERT(GR_ARRAY_COUNT(grToGLStencilOp) == kStencilOpCount);
+GR_STATIC_ASSERT(0 == kKeep_StencilOp);
+GR_STATIC_ASSERT(1 == kReplace_StencilOp);
+GR_STATIC_ASSERT(2 == kIncWrap_StencilOp);
+GR_STATIC_ASSERT(3 == kIncClamp_StencilOp);
+GR_STATIC_ASSERT(4 == kDecWrap_StencilOp);
+GR_STATIC_ASSERT(5 == kDecClamp_StencilOp);
+GR_STATIC_ASSERT(6 == kZero_StencilOp);
+GR_STATIC_ASSERT(7 == kInvert_StencilOp);
+
 void GrGpuGL::flushStencil() {
+    const GrStencilSettings* settings = &fCurrDrawState.fStencilSettings;
 
     // use stencil for clipping if clipping is enabled and the clip
     // has been written into the stencil.
     bool stencilClip = fClipState.fClipInStencil &&
                        (kClip_StateBit & fCurrDrawState.fFlagBits);
-    bool stencilChange =
-        fDirtyFlags.fWriteMaskChanged                             ||
-        fHWStencilClip != stencilClip                             ||
-        fHWDrawState.fStencilPass != fCurrDrawState.fStencilPass  ||
-        (kNone_StencilPass != fCurrDrawState.fStencilPass &&
-         (StencilPass)kSetClip_StencilPass != fCurrDrawState.fStencilPass &&
-         fHWDrawState.fReverseFill != fCurrDrawState.fReverseFill);
+    bool stencilChange = fHWStencilClip != stencilClip  ||
+                         fHWDrawState.fStencilSettings != *settings ||
+                         ((fHWDrawState.fFlagBits & kModifyStencilClip_StateBit) !=
+                          (fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit));
 
     if (stencilChange) {
-        GLint clipStencilMask;
-        GLint pathStencilMask;
-        GLint stencilBitCount = ((GrGLRenderTarget*)fCurrDrawState.fRenderTarget)->getStencilBits();
-        GrAssert(stencilBitCount > 0 ||
-                 kNone_StencilPass == fCurrDrawState.fStencilPass);
-        clipStencilMask  = (1 << (stencilBitCount - 1));
-        pathStencilMask = clipStencilMask - 1;
-        switch (fCurrDrawState.fStencilPass) {
-            case kNone_StencilPass:
-                if (stencilClip) {
-                    GR_GL(Enable(GL_STENCIL_TEST));
-                    GR_GL(StencilFunc(GL_EQUAL,
-                                      clipStencilMask,
-                                      clipStencilMask));
-                    GR_GL(StencilOp(GL_KEEP, GL_KEEP, GL_KEEP));
-                } else {
-                    GR_GL(Disable(GL_STENCIL_TEST));
-                }
-                GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
-                if (!fSingleStencilPassForWinding) {
-                    GR_GL(Disable(GL_CULL_FACE));
-                }
-                break;
-            case kEvenOddStencil_StencilPass:
-                GR_GL(Enable(GL_STENCIL_TEST));
-                if (stencilClip) {
-                    GR_GL(StencilFunc(GL_EQUAL, clipStencilMask, clipStencilMask));
-                } else {
-                    GR_GL(StencilFunc(GL_ALWAYS, 0x0, 0x0));
-                }
-                GR_GL(StencilMask(pathStencilMask));
-                GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
-                GR_GL(StencilOp(GL_KEEP, GL_INVERT, GL_INVERT));
-                GR_GL(ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE));
-                if (!fSingleStencilPassForWinding) {
-                    GR_GL(Disable(GL_CULL_FACE));
-                }
-                break;
-            case kEvenOddColor_StencilPass: {
-                GR_GL(Enable(GL_STENCIL_TEST));
-                GLint  funcRef  = 0;
-                GLuint funcMask = pathStencilMask;
-                if (stencilClip) {
-                    funcRef  |= clipStencilMask;
-                    funcMask |= clipStencilMask;
-                }
-                if (!fCurrDrawState.fReverseFill) {
-                    funcRef |= pathStencilMask;
-                }
 
-                GR_GL(StencilFunc(GL_EQUAL, funcRef, funcMask));
-                GR_GL(StencilMask(pathStencilMask));
-                GR_GL(StencilOp(GL_ZERO, GL_ZERO, GL_ZERO));
-                GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
-                if (!fSingleStencilPassForWinding) {
-                    GR_GL(Disable(GL_CULL_FACE));
-                }
-                } break;
-            case kWindingStencil1_StencilPass:
-                GR_GL(Enable(GL_STENCIL_TEST));
-                if (fHasStencilWrap) {
-                    if (stencilClip) {
-                        GR_GL(StencilFunc(GL_EQUAL,
-                                          clipStencilMask,
-                                          clipStencilMask));
-                    } else {
-                        GR_GL(StencilFunc(GL_ALWAYS, 0x0, 0x0));
-                    }
-                    if (fSingleStencilPassForWinding) {
-                        GR_GL(StencilOpSeparate(GL_FRONT, GL_KEEP,
-                                                GL_INCR_WRAP, GL_INCR_WRAP));
-                        GR_GL(StencilOpSeparate(GL_BACK,  GL_KEEP,
-                                                GL_DECR_WRAP, GL_DECR_WRAP));
-                    } else {
-                        GR_GL(StencilOp(GL_KEEP, GL_INCR_WRAP, GL_INCR_WRAP));
-                        GR_GL(Enable(GL_CULL_FACE));
-                        GR_GL(CullFace(GL_BACK));
-                    }
-                } else {
-                    // If we don't have wrap then we use the Func to detect
-                    // values that would wrap (0 on decr and mask on incr). We
-                    // make the func fail on these values and use the sfail op
-                    // to effectively wrap by inverting.
-                    // This applies whether we are doing a two-pass (front faces
-                    // followed by back faces) or a single pass (separate func/op)
+        // we can't simultaneously perform stencil-clipping and modify the stencil clip
+        GrAssert(!stencilClip || !(fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit));
 
-                    // Note that in the case where we are also using stencil to
-                    // clip this means we will write into the path bits in clipped
-                    // out pixels. We still apply the clip bit in the color pass
-                    // stencil func so we don't draw color outside the clip.
-                    // We also will clear the stencil bits in clipped pixels by
-                    // using zero in the sfail op with write mask set to the
-                    // path mask.
-                    GR_GL(Enable(GL_STENCIL_TEST));
-                    if (fSingleStencilPassForWinding) {
-                        GR_GL(StencilFuncSeparate(GL_FRONT,
-                                                  GL_NOTEQUAL,
-                                                  pathStencilMask,
-                                                  pathStencilMask));
-                        GR_GL(StencilFuncSeparate(GL_BACK,
-                                                  GL_NOTEQUAL,
-                                                  0x0,
-                                                  pathStencilMask));
-                        GR_GL(StencilOpSeparate(GL_FRONT, GL_INVERT,
-                                                GL_INCR, GL_INCR));
-                        GR_GL(StencilOpSeparate(GL_BACK,  GL_INVERT,
-                                                GL_DECR, GL_DECR));
-                    } else {
-                        GR_GL(StencilFunc(GL_NOTEQUAL,
-                                          pathStencilMask,
-                                          pathStencilMask));
-                        GR_GL(StencilOp(GL_INVERT, GL_INCR, GL_INCR));
-                        GR_GL(Enable(GL_CULL_FACE));
-                        GR_GL(CullFace(GL_BACK));
-                    }
-                }
-                GR_GL(StencilMask(pathStencilMask));
-                GR_GL(ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE));
-                break;
-            case kWindingStencil2_StencilPass:
-                GrAssert(!fSingleStencilPassForWinding);
-                GR_GL(Enable(GL_STENCIL_TEST));
-                if (fHasStencilWrap) {
-                    if (stencilClip) {
-                        GR_GL(StencilFunc(GL_EQUAL,
-                                          clipStencilMask,
-                                          clipStencilMask));
-                    } else {
-                        GR_GL(StencilFunc(GL_ALWAYS, 0x0, 0x0));
-                    }
-                    GR_GL(StencilOp(GL_DECR_WRAP, GL_DECR_WRAP, GL_DECR_WRAP));
-                } else {
-                    GR_GL(StencilFunc(GL_NOTEQUAL, 0x0, pathStencilMask));
-                    GR_GL(StencilOp(GL_INVERT, GL_DECR, GL_DECR));
-                }
-                GR_GL(StencilMask(pathStencilMask));
-                GR_GL(Enable(GL_CULL_FACE));
-                GR_GL(CullFace(GL_FRONT));
-                GR_GL(ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE));
-                break;
-            case kWindingColor_StencilPass: {
-                GR_GL(Enable(GL_STENCIL_TEST));
-                GLint  funcRef   = 0;
-                GLuint funcMask  = pathStencilMask;
-                GLenum funcFunc;
-
-                if (stencilClip) {
-                    funcRef  |= clipStencilMask;
-                    funcMask |= clipStencilMask;
-                }
-                if (fCurrDrawState.fReverseFill) {
-                    funcFunc = GL_EQUAL;
-                } else {
-                    funcFunc = GL_LESS;
-                }
-                GR_GL(StencilFunc(funcFunc, funcRef, funcMask));
-                GR_GL(StencilMask(pathStencilMask));
-                // must zero in sfail because winding w/o wrap will write
-                // path stencil bits in clipped out pixels
-                GR_GL(StencilOp(GL_ZERO, GL_ZERO, GL_ZERO));
-                GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
-                if (!fSingleStencilPassForWinding) {
-                    GR_GL(Disable(GL_CULL_FACE));
-                }
-                } break;
-            case kSetClip_StencilPass:
-                GR_GL(Enable(GL_STENCIL_TEST));
-                GR_GL(StencilFunc(GL_ALWAYS, clipStencilMask, clipStencilMask));
-                GR_GL(StencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE));
-                GR_GL(StencilMask(clipStencilMask));
-                GR_GL(ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE));
-                if (!fSingleStencilPassForWinding) {
-                    GR_GL(Disable(GL_CULL_FACE));
-                }
-                break;
-            default:
-                GrAssert(!"Unexpected stencil pass.");
-                break;
-
+        if (settings->isDisabled()) {
+            if (stencilClip) {
+                settings = &gClipStencilSettings;
+            }
         }
-        fHWDrawState.fStencilPass = fCurrDrawState.fStencilPass;
-        fHWDrawState.fReverseFill = fCurrDrawState.fReverseFill;
+
+        if (settings->isDisabled()) {
+            GR_GL(Disable(GL_STENCIL_TEST));
+        } else {
+            GR_GL(Enable(GL_STENCIL_TEST));
+    #if GR_DEBUG
+            if (!fStencilWrapOpsSupport) {
+                GrAssert(settings->fFrontPassOp != kIncWrap_StencilOp);
+                GrAssert(settings->fFrontPassOp != kDecWrap_StencilOp);
+                GrAssert(settings->fFrontFailOp != kIncWrap_StencilOp);
+                GrAssert(settings->fBackFailOp != kDecWrap_StencilOp);
+                GrAssert(settings->fBackPassOp != kIncWrap_StencilOp);
+                GrAssert(settings->fBackPassOp != kDecWrap_StencilOp);
+                GrAssert(settings->fBackFailOp != kIncWrap_StencilOp);
+                GrAssert(settings->fFrontFailOp != kDecWrap_StencilOp);
+            }
+    #endif
+            int stencilBits = fCurrDrawState.fRenderTarget->stencilBits();
+            GrAssert(stencilBits ||
+                     (GrStencilSettings::gDisabled ==
+                      fCurrDrawState.fStencilSettings));
+            GLuint clipStencilMask = 1 << (stencilBits - 1);
+            GLuint userStencilMask = clipStencilMask - 1;
+
+            unsigned int frontRef  = settings->fFrontFuncRef;
+            unsigned int frontMask = settings->fFrontFuncMask;
+            unsigned int frontWriteMask = settings->fFrontWriteMask;
+            GLenum frontFunc;
+
+            if (fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit) {
+
+                GrAssert(settings->fFrontFunc < kBasicStencilFuncCount);
+                frontFunc = grToGLStencilFunc[settings->fFrontFunc];
+            } else {
+                frontFunc = grToGLStencilFunc[ConvertStencilFunc(stencilClip, settings->fFrontFunc)];
+
+                ConvertStencilFuncAndMask(settings->fFrontFunc,
+                                          stencilClip,
+                                          clipStencilMask,
+                                          userStencilMask,
+                                          &frontRef,
+                                          &frontMask);
+                frontWriteMask &= userStencilMask;
+            }
+            GrAssert(settings->fFrontFailOp >= 0 &&
+                     settings->fFrontFailOp < GR_ARRAY_COUNT(grToGLStencilOp));
+            GrAssert(settings->fFrontPassOp >= 0 &&
+                     settings->fFrontPassOp < GR_ARRAY_COUNT(grToGLStencilOp));
+            GrAssert(settings->fBackFailOp >= 0 &&
+                     settings->fBackFailOp < GR_ARRAY_COUNT(grToGLStencilOp));
+            GrAssert(settings->fBackPassOp >= 0 &&
+                     settings->fBackPassOp < GR_ARRAY_COUNT(grToGLStencilOp));
+            if (fTwoSidedStencilSupport) {
+                GLenum backFunc;
+
+                unsigned int backRef  = settings->fBackFuncRef;
+                unsigned int backMask = settings->fBackFuncMask;
+                unsigned int backWriteMask = settings->fBackWriteMask;
+
+
+                if (fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit) {
+                    GrAssert(settings->fBackFunc < kBasicStencilFuncCount);
+                    backFunc = grToGLStencilFunc[settings->fBackFunc];
+                } else {
+                    backFunc = grToGLStencilFunc[ConvertStencilFunc(stencilClip, settings->fBackFunc)];
+                    ConvertStencilFuncAndMask(settings->fBackFunc,
+                                              stencilClip,
+                                              clipStencilMask,
+                                              userStencilMask,
+                                              &backRef,
+                                              &backMask);
+                    backWriteMask &= userStencilMask;
+                }
+
+                GR_GL(StencilFuncSeparate(GL_FRONT, frontFunc, frontRef, frontMask));
+                GR_GL(StencilMaskSeparate(GL_FRONT, frontWriteMask));
+                GR_GL(StencilFuncSeparate(GL_BACK, backFunc, backRef, backMask));
+                GR_GL(StencilMaskSeparate(GL_BACK, backWriteMask));
+                GR_GL(StencilOpSeparate(GL_FRONT, grToGLStencilOp[settings->fFrontFailOp],
+                                                  grToGLStencilOp[settings->fFrontPassOp],
+                                                  grToGLStencilOp[settings->fFrontPassOp]));
+
+                GR_GL(StencilOpSeparate(GL_BACK,  grToGLStencilOp[settings->fBackFailOp],
+                                                  grToGLStencilOp[settings->fBackPassOp],
+                                                  grToGLStencilOp[settings->fBackPassOp]));
+            } else {
+                GR_GL(StencilFunc(frontFunc, frontRef, frontMask));
+                GR_GL(StencilMask(frontWriteMask));
+                GR_GL(StencilOp(grToGLStencilOp[settings->fFrontFailOp],
+                                grToGLStencilOp[settings->fFrontPassOp],
+                                grToGLStencilOp[settings->fFrontPassOp]));
+            }
+        }
+        fHWDrawState.fStencilSettings = fCurrDrawState.fStencilSettings;
         fHWStencilClip = stencilClip;
     }
 }
@@ -1544,6 +1558,17 @@
         }
     }
 
+    if ((fCurrDrawState.fFlagBits & kNoColorWrites_StateBit) !=
+        (fHWDrawState.fFlagBits & kNoColorWrites_StateBit)) {
+        GLenum mask;
+        if (fCurrDrawState.fFlagBits & kNoColorWrites_StateBit) {
+            mask = GL_FALSE;
+        } else {
+            mask = GL_TRUE;
+        }
+        GR_GL(ColorMask(mask, mask, mask, mask));
+    }
+
 #if GR_SUPPORT_GLDESKTOP
     // ES doesn't support toggling GL_MULTISAMPLE and doesn't have
     // smooth lines.
@@ -1592,6 +1617,25 @@
         }
     }
 
+    if (fHWDrawState.fDrawFace != fCurrDrawState.fDrawFace) {
+        switch (fCurrDrawState.fDrawFace) {
+            case kCCW_DrawFace:
+                glEnable(GL_CULL_FACE);
+                GR_GL(CullFace(GL_BACK));
+                break;
+            case kCW_DrawFace:
+                GR_GL(Enable(GL_CULL_FACE));
+                GR_GL(CullFace(GL_FRONT));
+                break;
+            case kBoth_DrawFace:
+                GR_GL(Disable(GL_CULL_FACE));
+                break;
+            default:
+                GrCrash("Unknown draw face.");
+        }
+        fHWDrawState.fDrawFace = fCurrDrawState.fDrawFace;
+    }
+
 #if GR_DEBUG
     // check for circular rendering
     for (int s = 0; s < kNumStages; ++s) {
@@ -1605,6 +1649,7 @@
 
     flushStencil();
 
+    // flushStencil may look at the private state bits, so keep it before this.
     fHWDrawState.fFlagBits = fCurrDrawState.fFlagBits;
     return true;
 }
@@ -1654,9 +1699,6 @@
     if (fHWDrawState.fRenderTarget == renderTarget) {
         fHWDrawState.fRenderTarget = NULL;
     }
-    if (fClipState.fStencilClipTarget == renderTarget) {
-        fClipState.fStencilClipTarget = NULL;
-    }
 }
 
 void GrGpuGL::notifyTextureDelete(GrGLTexture* texture) {
diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h
index f6216c5..a2905c5 100644
--- a/gpu/src/GrGpuGL.h
+++ b/gpu/src/GrGpuGL.h
@@ -80,7 +80,6 @@
     // call resetDirtyFlags after its flush is complete
     struct {
         bool fRenderTargetChanged : 1;
-        bool fWriteMaskChanged : 1;
         int  fTextureChangedMask;
     } fDirtyFlags;
     GR_STATIC_ASSERT(8 * sizeof(int) >= kNumStages);
@@ -108,7 +107,7 @@
                                       uint32_t numVertices);
     virtual void flushScissor(const GrIRect* rect);
     void eraseStencil(uint32_t value, uint32_t mask);
-    virtual void eraseStencilClip();
+    virtual void eraseStencilClip(const GrIRect& rect);
 
     // binds texture unit in GL
     void setTextureUnit(int unitIdx);
diff --git a/gpu/src/GrInOrderDrawBuffer.cpp b/gpu/src/GrInOrderDrawBuffer.cpp
index 68590fc..a249364 100644
--- a/gpu/src/GrInOrderDrawBuffer.cpp
+++ b/gpu/src/GrInOrderDrawBuffer.cpp
@@ -67,17 +67,17 @@
         fCurrQuad = 0;
         fMaxQuads = (NULL == indexBuffer) ? 0 : indexBuffer->maxQuads();
     } else {
-        GrAssert((NULL == indexBuffer && 0 == fMaxQuads) || 
+        GrAssert((NULL == indexBuffer && 0 == fMaxQuads) ||
                  (indexBuffer->maxQuads() == fMaxQuads));
     }
 }
 
-void GrInOrderDrawBuffer::drawRect(const GrRect& rect, 
+void GrInOrderDrawBuffer::drawRect(const GrRect& rect,
                                    const GrMatrix* matrix,
                                    StageBitfield stageEnableBitfield,
                                    const GrRect* srcRects[],
                                    const GrMatrix* srcMatrices[]) {
-    
+
     GrAssert(!(NULL == fQuadIndexBuffer && fCurrQuad));
     GrAssert(!(fDraws.empty() && fCurrQuad));
     GrAssert(!(0 != fMaxQuads && NULL == fQuadIndexBuffer));
@@ -85,7 +85,7 @@
     // if we have a quad IB then either append to the previous run of
     // rects or start a new run
     if (fMaxQuads) {
-        
+
         bool appendToPreviousDraw = false;
         GrVertexLayout layout = GetRectVertexLayout(stageEnableBitfield, srcRects);
         AutoReleaseGeometry geo(this, layout, 4, 0);
@@ -103,10 +103,14 @@
         // the rect.
         bool disabledClip = false;
         if (this->isClipState() && fClip.isRect()) {
-            GrRect clipRect = GrRect(*fClip.getRects());
+
+            // single rect clip should have bounds
+            GrAssert(fClip.hasBounds());
+
+            GrRect clipRect = GrRect(fClip.getBounds());
             // If the clip rect touches the edge of the viewport, extended it
             // out (close) to infinity to avoid bogus intersections.
-            // We might consider a more exact clip to viewport if this 
+            // We might consider a more exact clip to viewport if this
             // conservative test fails.
             const GrRenderTarget* target = this->getRenderTarget();
             if (0 >= clipRect.fLeft) {
@@ -135,11 +139,11 @@
                 disabledClip = true;
             }
         }
-        if (!needsNewClip() && !needsNewState() && fCurrQuad > 0 && 
+        if (!needsNewClip() && !needsNewState() && fCurrQuad > 0 &&
             fCurrQuad < fMaxQuads && layout == fLastRectVertexLayout) {
 
             int vsize = VertexSize(layout);
-        
+
             Draw& lastDraw = fDraws.back();
 
             GrAssert(lastDraw.fIndexBuffer == fQuadIndexBuffer);
@@ -500,7 +504,7 @@
     }
     this->saveCurrentDrawState(&fStates.push_back());
  }
- 
+
 bool GrInOrderDrawBuffer::needsNewClip() const {
    if (fCurrDrawState.fFlagBits & kClip_StateBit) {
        if (fClips.empty() || (fClipSet && fClips.back() != fClip)) {
@@ -509,12 +513,12 @@
     }
     return false;
 }
- 
+
 void GrInOrderDrawBuffer::pushClip() {
     fClips.push_back() = fClip;
     fClipSet = false;
 }
- 
+
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClip& newClip)  {
     fClipSet = true;
 }
diff --git a/gpu/src/GrPath.cpp b/gpu/src/GrPath.cpp
index 554b3b9..ca5c43b 100644
--- a/gpu/src/GrPath.cpp
+++ b/gpu/src/GrPath.cpp
@@ -3,6 +3,8 @@
 GrPath::GrPath() {}
 
 GrPath::GrPath(const GrPath& src) : INHERITED() {
+    GrPath::Iter iter(src);
+    this->resetFromIter(&iter);
 }
 
 GrPath::GrPath(GrPathIter& iter) {
@@ -12,6 +14,26 @@
 GrPath::~GrPath() {
 }
 
+bool GrPath::operator ==(const GrPath& path) const {
+    if (fVerbs.count() != path.fVerbs.count() ||
+        fPts.count() != path.fPts.count()) {
+        return false;
+    }
+
+    for (int v = 0; v < fVerbs.count(); ++v) {
+        if (fVerbs[v] != path.fVerbs[v]) {
+            return false;
+        }
+    }
+
+    for (int p = 0; p < fPts.count(); ++p) {
+        if (fPts[p] != path.fPts[p]) {
+            return false;
+        }
+    }
+    return true;
+}
+
 void GrPath::ensureMoveTo() {
     if (fVerbs.isEmpty() || this->wasLastVerb(kClose)) {
         *fVerbs.append() = kMove;
@@ -90,6 +112,7 @@
                 break;
         }
     }
+    fConvexHint = iter->convexHint();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -157,7 +180,7 @@
     return (GrPathIter::Command)cmd;
 }
 
-GrPathIter::ConvexHint GrPath::Iter::hint() const {
+GrPathIter::ConvexHint GrPath::Iter::convexHint() const {
     return fPath.getConvexHint();
 }
 
diff --git a/gpu/src/GrPathRenderer.cpp b/gpu/src/GrPathRenderer.cpp
index c47b6e5..3e2b4b3 100644
--- a/gpu/src/GrPathRenderer.cpp
+++ b/gpu/src/GrPathRenderer.cpp
@@ -6,15 +6,145 @@
 #include "GrMemory.h"
 #include "GrTexture.h"
 
-
-
-GrDefaultPathRenderer::GrDefaultPathRenderer(bool singlePassWindingStencil)
-    : fSinglePassWindingStencil(singlePassWindingStencil) {
+GrDefaultPathRenderer::GrDefaultPathRenderer(bool separateStencilSupport,
+                                             bool stencilWrapOpsSupport)
+    : fSeparateStencil(separateStencilSupport),
+      fStencilWrapOps(stencilWrapOpsSupport) {
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Helpers for draw Path
+// Stencil rules for paths
+
+////// Even/Odd
+
+static const GrStencilSettings gEOStencilPass = {
+    kInvert_StencilOp,           kInvert_StencilOp,
+    kKeep_StencilOp,             kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc, kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                  0xffffffff,
+    0xffffffff,                  0xffffffff,
+    0xffffffff,                  0xffffffff
+};
+
+// ok not to check clip b/c stencil pass only wrote inside clip
+static const GrStencilSettings gEOColorPass = {
+    kZero_StencilOp,          kZero_StencilOp,
+    kZero_StencilOp,          kZero_StencilOp,
+    kNotEqual_StencilFunc,    kNotEqual_StencilFunc,
+    0xffffffff,               0xffffffff,
+    0x0,                      0x0,
+    0xffffffff,               0xffffffff
+};
+
+// have to check clip b/c outside clip will always be zero.
+static const GrStencilSettings gInvEOColorPass = {
+    kZero_StencilOp,            kZero_StencilOp,
+    kZero_StencilOp,            kZero_StencilOp,
+    kEqualIfInClip_StencilFunc, kEqualIfInClip_StencilFunc,
+    0xffffffff,                 0xffffffff,
+    0x0,                        0x0,
+    0xffffffff,                 0xffffffff
+};
+
+////// Winding
+
+// when we have separate stencil we increment front faces / decrement back faces
+// when we don't have wrap incr and decr we use the stencil test to simulate
+// them.
+
+static const GrStencilSettings gWindStencilSeparateWithWrap = {
+    kIncWrap_StencilOp,             kDecWrap_StencilOp,
+    kKeep_StencilOp,                kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc,    kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff
+};
+
+// if inc'ing the max value, invert to make 0
+// if dec'ing zero invert to make all ones.
+// we can't avoid touching the stencil on both passing and
+// failing, so we can't resctrict ourselves to the clip.
+static const GrStencilSettings gWindStencilSeparateNoWrap = {
+    kInvert_StencilOp,              kInvert_StencilOp,
+    kIncClamp_StencilOp,            kDecClamp_StencilOp,
+    kEqual_StencilFunc,             kEqual_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0x0,
+    0xffffffff,                     0xffffffff
+};
+
+// When there are no separate faces we do two passes to setup the winding rule
+// stencil. First we draw the front faces and inc, then we draw the back faces
+// and dec. These are same as the above two split into the incrementing and
+// decrementing passes.
+static const GrStencilSettings gWindSingleStencilWithWrapInc = {
+    kIncWrap_StencilOp,             kIncWrap_StencilOp,
+    kKeep_StencilOp,                kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc,    kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff
+};
+static const GrStencilSettings gWindSingleStencilWithWrapDec = {
+    kDecWrap_StencilOp,             kDecWrap_StencilOp,
+    kKeep_StencilOp,                kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc,    kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff
+};
+static const GrStencilSettings gWindSingleStencilNoWrapInc = {
+    kInvert_StencilOp,              kInvert_StencilOp,
+    kIncClamp_StencilOp,            kIncClamp_StencilOp,
+    kEqual_StencilFunc,             kEqual_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff
+};
+static const GrStencilSettings gWindSingleStencilNoWrapDec = {
+    kInvert_StencilOp,              kInvert_StencilOp,
+    kDecClamp_StencilOp,            kDecClamp_StencilOp,
+    kEqual_StencilFunc,             kEqual_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0x0,                            0x0,
+    0xffffffff,                     0xffffffff
+};
+
+static const GrStencilSettings gWindColorPass = {
+    kZero_StencilOp,                kZero_StencilOp,
+    kZero_StencilOp,                kZero_StencilOp,
+    kNonZeroIfInClip_StencilFunc,   kNonZeroIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0x0,                            0x0,
+    0xffffffff,                     0xffffffff
+};
+
+static const GrStencilSettings gInvWindColorPass = {
+    kZero_StencilOp,                kZero_StencilOp,
+    kZero_StencilOp,                kZero_StencilOp,
+    kEqualIfInClip_StencilFunc,     kEqualIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0x0,                            0x0,
+    0xffffffff,                     0xffffffff
+};
+
+////// Normal render to stencil
+
+// Sometimes the default path renderer can draw a path directly to the stencil
+// buffer without having to first resolve the interior / exterior.
+static const GrStencilSettings gDirectToStencil = {
+    kZero_StencilOp,                kZero_StencilOp,
+    kIncClamp_StencilOp,            kIncClamp_StencilOp,
+    kAlwaysIfInClip_StencilFunc,    kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0x0,                            0x0,
+    0xffffffff,                     0xffffffff
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Helpers for drawPath
 
 #define STENCIL_OFF     0   // Always disable stencil (even when needed)
 static const GrScalar gTolerance = GR_Scalar1;
@@ -146,11 +276,11 @@
     return true;
 #else
     if (kEvenOdd_PathFill == fill) {
-        GrPathIter::ConvexHint hint = path.hint();
+        GrPathIter::ConvexHint hint = path.convexHint();
         return hint == GrPathIter::kConvex_ConvexHint ||
                hint == GrPathIter::kNonOverlappingConvexPieces_ConvexHint;
     } else if (kWinding_PathFill == fill) {
-        GrPathIter::ConvexHint hint = path.hint();
+        GrPathIter::ConvexHint hint = path.convexHint();
         return hint == GrPathIter::kConvex_ConvexHint ||
                hint == GrPathIter::kNonOverlappingConvexPieces_ConvexHint ||
                (hint == GrPathIter::kSameWindingConvexPieces_ConvexHint &&
@@ -161,13 +291,17 @@
 #endif
 }
 
-void GrDefaultPathRenderer::drawPath(GrDrawTarget* target,
-                                     GrDrawTarget::StageBitfield stages,
-                                     GrPathIter* path,
-                                     GrPathFill fill,
-                                     const GrPoint* translate) {
+void GrDefaultPathRenderer::drawPathHelper(GrDrawTarget* target,
+                                           GrDrawTarget::StageBitfield stages,
+                                           GrPathIter* path,
+                                           GrPathFill fill,
+                                           const GrPoint* translate,
+                                           bool stencilOnly) {
 
     GrDrawTarget::AutoStateRestore asr(target);
+    bool colorWritesWereDisabled = target->isColorWriteDisabled();
+    // face culling doesn't make sense here
+    GrAssert(GrDrawTarget::kBoth_DrawFace == target->getDrawFace());
 
     GrMatrix viewM = target->getViewMatrix();
     // In order to tesselate the path we get a bound on how much the matrix can
@@ -185,6 +319,8 @@
     }
     GrScalar tolSqd = GrMul(tol, tol);
 
+    path->rewind();
+
     int subpathCnt;
     int maxPts = worst_case_point_count(path,
                                         &subpathCnt,
@@ -211,42 +347,91 @@
     // TODO: use primitve restart if available rather than multiple draws
     GrPrimitiveType             type;
     int                         passCount = 0;
-    GrDrawTarget::StencilPass   passes[3];
+    const GrStencilSettings*    passes[3];
+    GrDrawTarget::DrawFace      drawFace[3];
     bool                        reverse = false;
+    bool                        lastPassIsBounds;
 
     if (kHairLine_PathFill == fill) {
         type = kLineStrip_PrimitiveType;
         passCount = 1;
-        passes[0] = GrDrawTarget::kNone_StencilPass;
+        if (stencilOnly) {
+            passes[0] = &gDirectToStencil;
+        } else {
+            passes[0] = &GrStencilSettings::gDisabled;
+        }
+        lastPassIsBounds = false;
+        drawFace[0] = GrDrawTarget::kBoth_DrawFace;
     } else {
         type = kTriangleFan_PrimitiveType;
         if (single_pass_path(*path, fill, *target)) {
             passCount = 1;
-            passes[0] = GrDrawTarget::kNone_StencilPass;
+            if (stencilOnly) {
+                passes[0] = &gDirectToStencil;
+            } else {
+                passes[0] = &GrStencilSettings::gDisabled;
+            }
+            drawFace[0] = GrDrawTarget::kBoth_DrawFace;
+            lastPassIsBounds = false;
         } else {
             switch (fill) {
                 case kInverseEvenOdd_PathFill:
                     reverse = true;
                     // fallthrough
                 case kEvenOdd_PathFill:
-                    passCount = 2;
-                    passes[0] = GrDrawTarget::kEvenOddStencil_StencilPass;
-                    passes[1] = GrDrawTarget::kEvenOddColor_StencilPass;
+                    passes[0] = &gEOStencilPass;
+                    if (stencilOnly) {
+                        passCount = 1;
+                        lastPassIsBounds = false;
+                    } else {
+                        passCount = 2;
+                        lastPassIsBounds = true;
+                        if (reverse) {
+                            passes[1] = &gInvEOColorPass;
+                        } else {
+                            passes[1] = &gEOColorPass;
+                        }
+                    }
+                    drawFace[0] = drawFace[1] = GrDrawTarget::kBoth_DrawFace;
                     break;
 
                 case kInverseWinding_PathFill:
                     reverse = true;
                     // fallthrough
                 case kWinding_PathFill:
-                    passes[0] = GrDrawTarget::kWindingStencil1_StencilPass;
-                    if (fSinglePassWindingStencil) {
-                        passes[1] = GrDrawTarget::kWindingColor_StencilPass;
+                    if (fSeparateStencil) {
+                        if (fStencilWrapOps) {
+                            passes[0] = &gWindStencilSeparateWithWrap;
+                        } else {
+                            passes[0] = &gWindStencilSeparateNoWrap;
+                        }
                         passCount = 2;
+                        drawFace[0] = GrDrawTarget::kBoth_DrawFace;
                     } else {
-                        passes[1] = GrDrawTarget::kWindingStencil2_StencilPass;
-                        passes[2] = GrDrawTarget::kWindingColor_StencilPass;
+                        if (fStencilWrapOps) {
+                            passes[0] = &gWindSingleStencilWithWrapInc;
+                            passes[1] = &gWindSingleStencilWithWrapDec;
+                        } else {
+                            passes[0] = &gWindSingleStencilNoWrapInc;
+                            passes[1] = &gWindSingleStencilNoWrapDec;
+                        }
+                        // which is cw and which is ccw is arbitrary.
+                        drawFace[0] = GrDrawTarget::kCW_DrawFace;
+                        drawFace[1] = GrDrawTarget::kCCW_DrawFace;
                         passCount = 3;
                     }
+                    if (stencilOnly) {
+                        lastPassIsBounds = false;
+                        --passCount;
+                    } else {
+                        lastPassIsBounds = true;
+                        drawFace[passCount-1] = GrDrawTarget::kBoth_DrawFace;
+                        if (reverse) {
+                            passes[passCount-1] = &gInvWindColorPass;
+                        } else {
+                            passes[passCount-1] = &gWindColorPass;
+                        }
+                    }
                     break;
                 default:
                     GrAssert(!"Unknown path fill!");
@@ -254,7 +439,6 @@
             }
         }
     }
-    target->setReverseFill(reverse);
 
     GrPoint pts[4];
 
@@ -309,11 +493,12 @@
         }
     }
 
-    // arbitrary path complexity cutoff
-    bool useBounds = fill != kHairLine_PathFill &&
-                    (reverse || (vert - base) > 8);
-    GrPoint* boundsVerts = base + maxPts;
-    if (useBounds) {
+    // if we're stenciling we will follow with a pass that draws
+    // a bounding rect to set the color. We're stenciling when
+    // passCount > 1.
+    const int& boundVertexStart = maxPts;
+    GrPoint* boundsVerts = base + boundVertexStart;
+    if (lastPassIsBounds) {
         GrRect bounds;
         if (reverse) {
             GrAssert(NULL != target->getRenderTarget());
@@ -333,20 +518,44 @@
     }
 
     for (int p = 0; p < passCount; ++p) {
-        target->setStencilPass(passes[p]);
-        if (useBounds && (GrDrawTarget::kEvenOddColor_StencilPass == passes[p] ||
-                          GrDrawTarget::kWindingColor_StencilPass == passes[p])) {
+        target->setDrawFace(drawFace[p]);
+        target->setStencil(*passes[p]);
+
+        if (lastPassIsBounds && (p == passCount-1)) {
+            if (!colorWritesWereDisabled) {
+                target->disableState(GrDrawTarget::kNoColorWrites_StateBit);
+            }
             target->drawNonIndexed(kTriangleFan_PrimitiveType,
-                                 maxPts, 4);
+                                   boundVertexStart, 4);
 
         } else {
+            if (passCount > 1) {
+                target->enableState(GrDrawTarget::kNoColorWrites_StateBit);
+            }
             int baseVertex = 0;
             for (int sp = 0; sp < subpathCnt; ++sp) {
                 target->drawNonIndexed(type,
-                                     baseVertex,
-                                     subpathVertCount[sp]);
+                                      baseVertex,
+                                      subpathVertCount[sp]);
                 baseVertex += subpathVertCount[sp];
             }
         }
     }
 }
+
+void GrDefaultPathRenderer::drawPath(GrDrawTarget* target,
+                                     GrDrawTarget::StageBitfield stages,
+                                     GrPathIter* path,
+                                     GrPathFill fill,
+                                     const GrPoint* translate) {
+    this->drawPathHelper(target, stages, path, fill, translate, false);
+}
+
+void GrDefaultPathRenderer::drawPathToStencil(GrDrawTarget* target,
+                                              GrPathIter* path,
+                                              GrPathFill fill,
+                                              const GrPoint* translate) {
+     GrAssert(kInverseEvenOdd_PathFill != fill);
+     GrAssert(kInverseWinding_PathFill != fill);
+     this->drawPathHelper(target, 0, path, fill, translate, true);
+ }
diff --git a/gpu/src/GrPathRenderer.h b/gpu/src/GrPathRenderer.h
index e3fd715..467b0a0 100644
--- a/gpu/src/GrPathRenderer.h
+++ b/gpu/src/GrPathRenderer.h
@@ -34,31 +34,107 @@
      * @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 
+     *                              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).
+     *                              the path. NULL means (0,0).
      */
     virtual void drawPath(GrDrawTarget* target,
                           GrDrawTarget::StageBitfield stages,
                           GrPathIter* path,
                           GrPathFill fill,
                           const GrPoint* translate) = 0;
+
+    void drawPath(GrDrawTarget* target,
+                  GrDrawTarget::StageBitfield stages,
+                  const GrPath& path,
+                  GrPathFill fill,
+                  const GrPoint* translate) {
+            GrPath::Iter iter(path);
+            this->drawPath(target, stages, &iter, fill, translate);
+    }
+
+    /**
+     * For complex clips Gr uses the stencil buffer. The path renderer must be
+     * able to render paths into the stencil buffer. However, the path renderer
+     * itself may require the stencil buffer to resolve the path fill rule. This
+     * function queries whether the path render requires its own stencil
+     * pass. If this returns false then drawPath() should not modify the
+     * the target's stencil settings.
+     *
+     * @return false if this path renderer can generate interior-only fragments
+     *         without changing the stencil settings on the target. If it
+     *         returns true the drawPathToStencil will be used when rendering
+     *         clips.
+     */
+    virtual bool requiresStencilPass(GrPathIter*) const { return false; }
+    
+    bool requiresStencilPass(const GrPath& path) const { 
+        GrPath::Iter iter(path);
+        return requiresStencilPass(&iter);
+    }
+
+    /**
+     * Draws a path to the stencil buffer. Assume the writable bits are zero
+     * prior and write a nonzero value in interior samples. The default
+     * implementation assumes the path filling algorithm doesn't require a
+     * separate stencil pass and so just calls drawPath.
+     *
+     * Fill will never be an inverse fill rule.
+     *
+     * @param target                the target to draw into.
+     * @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 drawPathToStencil(GrDrawTarget* target,
+                                   GrPathIter* path,
+                                   GrPathFill fill,
+                                   const GrPoint* translate) {
+        GrAssert(kInverseEvenOdd_PathFill != fill);
+        GrAssert(kInverseWinding_PathFill != fill);
+
+        this->drawPath(target, 0, path, fill, translate);
+    }
+
+    void drawPathToStencil(GrDrawTarget* target,
+                           const GrPath& path,
+                           GrPathFill fill,
+                           const GrPoint* translate) {
+        GrPath::Iter iter(path);
+        this->drawPathToStencil(target, &iter, fill, translate);
+    }
 };
 
 class GrDefaultPathRenderer : public GrPathRenderer {
 public:
-    GrDefaultPathRenderer(bool singlePassWindingStencil);
+    GrDefaultPathRenderer(bool separateStencilSupport,
+                          bool stencilWrapOpsSupport);
 
     virtual void drawPath(GrDrawTarget* target,
                           GrDrawTarget::StageBitfield stages,
                           GrPathIter* path,
                           GrPathFill fill,
                           const GrPoint* translate);
+    virtual bool requiresStencilPass(GrPath&) const { return true; }
+    virtual void drawPathToStencil(GrDrawTarget* target,
+                                   GrPathIter* path,
+                                   GrPathFill fill,
+                                   const GrPoint* translate);
 private:
-    bool    fSinglePassWindingStencil;
+
+    void drawPathHelper(GrDrawTarget* target,
+                        GrDrawTarget::StageBitfield stages,
+                        GrPathIter* path,
+                        GrPathFill fill,
+                        const GrPoint* translate,
+                        bool stencilOnly);
+
+    bool    fSeparateStencil;
+    bool    fStencilWrapOps;
 };
 
 #endif
\ No newline at end of file
diff --git a/gpu/src/GrStencil.cpp b/gpu/src/GrStencil.cpp
new file mode 100644
index 0000000..9d68c65
--- /dev/null
+++ b/gpu/src/GrStencil.cpp
@@ -0,0 +1,398 @@
+/*
+    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.
+ */
+
+#include "GrStencil.h"
+
+const GrStencilSettings GrStencilSettings::gDisabled = {};
+GR_STATIC_ASSERT(0 == kKeep_StencilOp);
+GR_STATIC_ASSERT(0 == kAlways_StencilFunc);
+
+////////////////////////////////////////////////////////////////////////////////
+// Stencil Rules for Merging user stencil space into clip
+
+// We can't include the clip bit in the ref or mask values because the division
+// between user and clip bits in the stencil depends on the number of stencil
+// bits in the runtime. Comments below indicate what the code should do to
+// incorporate the clip bit into these settings.
+
+///////
+// Replace
+
+// set the ref to be the clip bit, but mask it out for the test
+static const GrStencilSettings gUserToClipReplace = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+static const GrStencilSettings gInvUserToClipReplace = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+///////
+// Intersect
+static const GrStencilSettings gUserToClipIsect = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+static const GrStencilSettings gInvUserToClipIsect = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+///////
+// Difference
+static const GrStencilSettings gUserToClipDiff = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+static const GrStencilSettings gInvUserToClipDiff = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+///////
+// Union
+
+// first pass makes all the passing cases >= just clip bit set.
+static const GrStencilSettings gUserToClipUnionPass0 = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kKeep_StencilOp,     kKeep_StencilOp,
+    kLEqual_StencilFunc, kLEqual_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x00000001,          0x00000001,    // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+// second pass allows anything greater than just clip bit set to pass
+static const GrStencilSettings gUserToClipUnionPass1 = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLEqual_StencilFunc, kLEqual_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,    // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+// for inverse first pass finds non-zerp user with clip bit set
+// and converts it to just clip bit set
+static const GrStencilSettings gInvUserToClipUnionPass0 = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kKeep_StencilOp,     kKeep_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,    // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+// second pass lets anything through with a nonzero user portion
+// and writes a ref value with just the clip bit set to it.
+static const GrStencilSettings gInvUserToClipUnionPass1 = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x00000000,          0x00000000,    // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+///////
+// Xor
+static const GrStencilSettings gUserToClipXorPass0 = {
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kKeep_StencilOp,     kKeep_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x00000000,          0x00000000,
+    0xffffffff,          0xffffffff
+};
+
+static const GrStencilSettings gUserToClipXorPass1 = {
+    kReplace_StencilOp,   kReplace_StencilOp,
+    kZero_StencilOp,      kZero_StencilOp,
+    kGreater_StencilFunc, kGreater_StencilFunc,
+    0xffffffff,           0xffffffff,
+    0x00000000,           0x00000000,   // set clip bit
+    0xffffffff,           0xffffffff
+};
+
+static const GrStencilSettings gInvUserToClipXorPass0 = {
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kKeep_StencilOp,     kKeep_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x00000000,          0x00000000,
+    0xffffffff,          0xffffffff
+};
+
+static const GrStencilSettings gInvUserToClipXorPass1 = {
+    kReplace_StencilOp,   kReplace_StencilOp,
+    kZero_StencilOp,      kZero_StencilOp,
+    kLess_StencilFunc,    kLess_StencilFunc,
+    0xffffffff,           0xffffffff,
+    0x00000000,           0x00000000,   // set clip bit
+    0xffffffff,           0xffffffff
+};
+
+///////
+// Reverse Diff
+static const GrStencilSettings gUserToClipRDiffPass0 = {
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,  // unset clip bit
+    0x00000000,          0x00000000,  // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+static const GrStencilSettings gUserToClipRDiffPass1 = {
+    kReplace_StencilOp,   kReplace_StencilOp,
+    kZero_StencilOp,      kZero_StencilOp,
+    kEqual_StencilFunc,   kEqual_StencilFunc,
+    0x00000000,           0x00000000,   // set clip bit
+    0x00000000,           0x00000000,   // set clip bit
+    0xffffffff,           0xffffffff
+};
+
+static const GrStencilSettings gInvUserToClipRDiff = {
+    kInvert_StencilOp,    kInvert_StencilOp,
+    kZero_StencilOp,      kZero_StencilOp,
+    kEqual_StencilFunc,   kEqual_StencilFunc,
+    0xffffffff,           0xffffffff,
+    0x00000000,           0x00000000, 
+    0x00000000,           0x00000000    // set clip bit
+};
+///////
+// Direct to Stencil
+
+// We can render a clip element directly without first writing to the client
+// portion of the clip when the fill is not inverse and the set operation will
+// only modify the in/out status of samples covered by the clip element.
+
+// this one only works if used right after stencil clip was cleared.
+// Our GrClip doesn't allow midstream replace ops.
+static const GrStencilSettings gReplaceClip = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kAlways_StencilFunc, kAlways_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,    // set clip bit
+    0x00000000,          0x00000000     // set clipBit
+};
+
+static const GrStencilSettings gUnionClip = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kAlways_StencilFunc, kAlways_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,    // set clip bit
+    0x00000000,          0x00000000     // set clip bit
+};
+
+static const GrStencilSettings gXorClip = {
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kAlways_StencilFunc, kAlways_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,
+    0x00000000,          0x00000000     // set clip bit
+};
+
+static const GrStencilSettings gDiffClip = {
+    kZero_StencilOp,     kZero_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kAlways_StencilFunc, kAlways_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,
+    0x00000000,          0x00000000     // set clip bit
+};
+
+static const GrPathFill gNonInvertedFills[] = {
+    kWinding_PathFill, // kWinding_PathFill
+    kEvenOdd_PathFill, // kEvenOdd_PathFill
+    kWinding_PathFill, // kInverseWinding_PathFill
+    kEvenOdd_PathFill, // kInverseEvenOdd_PathFill
+    kWinding_PathFill, // kHairLine_PathFill
+};
+
+static const bool gIsFillInverted[] = {
+    false, // kWinding_PathFill
+    false, // kEvenOdd_PathFill
+    true,  // kInverseWinding_PathFill
+    true,  // kInverseEvenOdd_PathFill
+    false, // kHairLine_PathFill
+};
+GR_STATIC_ASSERT(0 == kWinding_PathFill);
+GR_STATIC_ASSERT(1 == kEvenOdd_PathFill);
+GR_STATIC_ASSERT(2 == kInverseWinding_PathFill);
+GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill);
+GR_STATIC_ASSERT(4 == kHairLine_PathFill);
+GR_STATIC_ASSERT(5 == kPathFillCount);
+
+bool GrStencilSettings::GetClipPasses(GrSetOp op, 
+                                      bool canBeDirect,
+                                      unsigned int stencilClipMask,
+                                      GrPathFill* fill,
+                                      int* numPasses,
+                                      GrStencilSettings settings[kMaxStencilClipPasses]) {
+    if (canBeDirect) {
+        if (!gIsFillInverted[*fill]) {
+            *numPasses = 0;
+            switch (op) {
+                case kReplace_SetOp:
+                    *numPasses = 1;
+                    settings[0] = gReplaceClip;
+                    break;
+                case kUnion_SetOp:
+                    *numPasses = 1;
+                    settings[0] = gUnionClip;
+                    break;
+                case kXor_SetOp:
+                    *numPasses = 1;
+                    settings[0] = gXorClip;
+                    break;
+                case kDifference_SetOp:
+                    *numPasses = 1;
+                    settings[0] = gDiffClip;
+                    break;
+                default: // suppress warning
+                    break;
+            }
+            if (1 == *numPasses) {
+                settings[0].fFrontFuncRef |= stencilClipMask;
+                settings[0].fFrontWriteMask |= stencilClipMask;
+                settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+                settings[0].fBackWriteMask = settings[0].fFrontWriteMask;
+                return true;
+            }
+        }
+    }
+    switch (op) {
+        case kReplace_SetOp:
+            *numPasses= 1;
+            settings[0] = gIsFillInverted[*fill] ? gInvUserToClipReplace : gUserToClipReplace;
+            settings[0].fFrontFuncMask &= ~stencilClipMask;
+            settings[0].fFrontFuncRef |= stencilClipMask;
+            settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+            settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+
+        case kIntersect_SetOp:
+            *numPasses = 1;
+            settings[0] = gIsFillInverted[*fill] ? gInvUserToClipIsect : gUserToClipIsect;
+            settings[0].fFrontFuncRef = stencilClipMask;
+            settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+            break;
+        case kUnion_SetOp:
+            *numPasses = 2;
+            if (gIsFillInverted[*fill]) {
+                settings[0] = gInvUserToClipUnionPass0;
+                settings[0].fFrontFuncRef |= stencilClipMask;
+                settings[0].fBackFuncRef = settings[0].fFrontFuncMask;
+
+                settings[1] = gInvUserToClipUnionPass1;
+                settings[1].fFrontFuncMask &= ~stencilClipMask;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncMask = settings[1].fFrontFuncMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+
+            } else {
+                settings[0] = gUserToClipUnionPass0;
+                settings[0].fFrontFuncMask &= ~stencilClipMask;
+                settings[0].fFrontFuncRef |= stencilClipMask;
+                settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+                settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+
+                settings[1] = gUserToClipUnionPass1;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+            }
+            break;
+        case kXor_SetOp:
+            *numPasses = 2;
+            if (gIsFillInverted[*fill]) {
+                settings[0] = gInvUserToClipXorPass0;
+                settings[0].fFrontFuncMask &= ~stencilClipMask;
+                settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+
+                settings[1] = gInvUserToClipXorPass1;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+            } else {
+                settings[0] = gUserToClipXorPass0;
+                settings[0].fFrontFuncMask &= ~stencilClipMask;
+                settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+
+                settings[1] = gUserToClipXorPass1;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+            }
+            break;
+        case kDifference_SetOp:
+            *numPasses = 1;
+            settings[0] = gIsFillInverted[*fill] ? gInvUserToClipDiff : gUserToClipDiff;
+            settings[0].fFrontFuncRef |= stencilClipMask;
+            settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+            break;
+        case kReverseDifference_SetOp:
+            if (gIsFillInverted[*fill]) {
+                *numPasses = 1;
+                settings[0] = gInvUserToClipRDiff;
+                settings[0].fFrontWriteMask |= stencilClipMask;
+                settings[0].fBackWriteMask = settings[0].fFrontWriteMask;
+            } else {
+                *numPasses = 2;
+                settings[0] = gUserToClipRDiffPass0;
+                settings[0].fFrontFuncMask &= ~stencilClipMask;
+                settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+                settings[0].fFrontFuncRef |= stencilClipMask;
+                settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+
+                settings[1] = gUserToClipRDiffPass1;
+                settings[1].fFrontFuncMask |= stencilClipMask;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncMask = settings[1].fFrontFuncMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+            }
+            break;
+        default:
+            GrCrash("Unknown set op");
+    }
+    *fill = gNonInvertedFills[*fill];
+    return false;
+}
\ No newline at end of file
diff --git a/gpu/src/GrTextContext.cpp b/gpu/src/GrTextContext.cpp
index 8ce45e4..802e3e3 100644
--- a/gpu/src/GrTextContext.cpp
+++ b/gpu/src/GrTextContext.cpp
@@ -67,21 +67,25 @@
 
     fCurrTexture = NULL;
     fCurrVertex = 0;
-    fClipRect = context->getClip().getBounds();
 
     if (NULL != extMatrix) {
         fExtMatrix = *extMatrix;
     } else {
         fExtMatrix = GrMatrix::I();
     }
-    if (!fExtMatrix.isIdentity()) {
-        GrMatrix inverse;
-        GrRect r;
-        r.set(fClipRect);
-        if (fExtMatrix.invert(&inverse)) {
-            inverse.mapRect(&r);
-            r.roundOut(&fClipRect);
+    if (context->getClip().hasBounds()) {
+        if (!fExtMatrix.isIdentity()) {
+            GrMatrix inverse;
+            GrRect r = context->getClip().getBounds();
+            if (fExtMatrix.invert(&inverse)) {
+                inverse.mapRect(&r);
+                r.roundOut(&fClipRect);
+            }
+        } else {
+            context->getClip().getBounds().roundOut(&fClipRect);
         }
+    } else {
+        fClipRect.setLargest();
     }
 
     // save the context's original matrix off and restore in destructor
diff --git a/gpu/src/gr_files.mk b/gpu/src/gr_files.mk
index 88aa84b..d0f41e7 100644
--- a/gpu/src/gr_files.mk
+++ b/gpu/src/gr_files.mk
@@ -22,4 +22,5 @@
     GrTextContext.cpp \
     GrTextStrike.cpp \
     GrBufferAllocPool.cpp\
-    GrPathRenderer.cpp
+    GrPathRenderer.cpp \
+    GrStencil.cpp
diff --git a/gpu/src/gr_unittests.cpp b/gpu/src/gr_unittests.cpp
index 8ef61b1..9caaa1f 100644
--- a/gpu/src/gr_unittests.cpp
+++ b/gpu/src/gr_unittests.cpp
@@ -73,71 +73,9 @@
     }
 }
 
-static void dump(const GrClip& clip, const char message[]) {
-    GrPrintf("--- dump clip %s\n", message);
-    GrClipIter iter(clip);
-    while (!iter.isDone()) {
-        GrIRect r;
-        iter.getRect(&r);
-        GrPrintf("--- [%d %d %d %d]\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
-        iter.next();
-    }
-}
-
-static void test_clip() {
-    GrClip  clip;
-    GrAssert(clip.isEmpty());
-    GrAssert(!clip.isRect());
-    GrAssert(!clip.isComplex());
-    GrAssert(clip.getBounds().equalsLTRB(0, 0, 0, 0));
-    GrAssert(0 == clip.countRects());
-
-    clip.setRect(GrIRect(10, 10, 10, 10));
-    GrAssert(clip.isEmpty());
-    GrAssert(!clip.isRect());
-    GrAssert(!clip.isComplex());
-    GrAssert(clip.getBounds().equalsLTRB(0, 0, 0, 0));
-    GrAssert(0 == clip.countRects());
-    dump(clip, "empty");
-
-    clip.setRect(GrIRect(10, 10, 20, 20));
-    GrAssert(!clip.isEmpty());
-    GrAssert(clip.isRect());
-    GrAssert(!clip.isComplex());
-    GrAssert(clip.getBounds().equalsLTRB(10, 10, 20, 20));
-    GrAssert(1 == clip.countRects());
-    GrAssert(clip.getRects()[0] == clip.getBounds());
-    dump(clip, "rect");
-
-    clip.addRect(GrIRect(20, 20, 25, 25));
-    GrAssert(!clip.isEmpty());
-    GrAssert(!clip.isRect());
-    GrAssert(clip.isComplex());
-    GrAssert(clip.getBounds().equalsLTRB(10, 10, 25, 25));
-    GrAssert(2 == clip.countRects());
-    dump(clip, "complex");
-
-    GrClip c1(clip);
-    GrAssert(c1 == clip);
-    GrClip c2;
-    GrAssert(c2 != c1);
-    c2 = clip;
-    GrAssert(c2 == clip);
-
-    clip.setEmpty();
-    GrAssert(clip.isEmpty());
-    GrAssert(!clip.isRect());
-    GrAssert(!clip.isComplex());
-    GrAssert(clip.getBounds().equalsLTRB(0, 0, 0, 0));
-
-    GrAssert(c1 != clip);
-    GrAssert(c2 != clip);
-}
-
 void gr_run_unittests() {
     test_tdarray();
     test_bsearch();
-    test_clip();
     GrMatrix::UnitTest();
     GrRedBlackTree<int>::UnitTest();
 }
diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h
index 1e15307..eef3aea 100644
--- a/include/core/SkCanvas.h
+++ b/include/core/SkCanvas.h
@@ -794,7 +794,8 @@
     SkDevice*   fLastDeviceToGainFocus;
     SkDeviceFactory* fDeviceFactory;
 
-    void prepareForDeviceDraw(SkDevice*, const SkMatrix&, const SkRegion&);
+    void prepareForDeviceDraw(SkDevice*, const SkMatrix&, const SkRegion&,
+                              const SkClipStack& clipStack);
 
     bool fDeviceCMDirty;            // cleared by updateDeviceCMCache()
     void updateDeviceCMCache();
diff --git a/include/core/SkClipStack.h b/include/core/SkClipStack.h
index fb94155..db42e4d 100644
--- a/include/core/SkClipStack.h
+++ b/include/core/SkClipStack.h
@@ -29,6 +29,11 @@
 
     class B2FIter {
     public:
+        /**
+         * Creates an uninitialized iterator. Must be reset()
+         */
+        B2FIter();
+
         B2FIter(const SkClipStack& stack);
 
         struct Clip {
@@ -48,6 +53,11 @@
          */
         const Clip* next();
 
+        /**
+         * Restarts the iterator on a clip stack.
+         */
+        void reset(const SkClipStack& stack);
+
     private:
         Clip             fClip;
         SkDeque::F2BIter fIter;
diff --git a/include/core/SkDeque.h b/include/core/SkDeque.h
index 99c8dd4..92d5153 100644
--- a/include/core/SkDeque.h
+++ b/include/core/SkDeque.h
@@ -52,9 +52,16 @@
 public:
     class F2BIter {
     public:
+        /**
+         * Creates an uninitialized iterator. Must be reset()
+         */
+        F2BIter();
+
         F2BIter(const SkDeque& d);
         void* next();
 
+        void reset(const SkDeque& d);
+
     private:
         SkDeque::Head*  fHead;
         char*           fPos;
diff --git a/include/core/SkDevice.h b/include/core/SkDevice.h
index a790399..c0d71c3 100644
--- a/include/core/SkDevice.h
+++ b/include/core/SkDevice.h
@@ -141,7 +141,8 @@
     /** Called when this device gains focus (i.e becomes the current device
         for drawing).
     */
-    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&) {}
+    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&,
+                           const SkClipStack&) {}
 
     /** Causes any deferred drawing to the device to be completed.
      */
diff --git a/include/core/SkRegion.h b/include/core/SkRegion.h
index 8d9ff01..58f4f3f 100644
--- a/include/core/SkRegion.h
+++ b/include/core/SkRegion.h
@@ -260,7 +260,7 @@
         bool rewind();
         // reset the iterator, using the new region
         void reset(const SkRegion&);
-        bool done() { return fDone; }
+        bool done() const { return fDone; }
         void next();
         const SkIRect& rect() const { return fRect; }
         // may return null
diff --git a/include/gpu/SkGpuDevice.h b/include/gpu/SkGpuDevice.h
index 2db3380..3fed99a 100644
--- a/include/gpu/SkGpuDevice.h
+++ b/include/gpu/SkGpuDevice.h
@@ -68,7 +68,8 @@
      *  Override from SkGpuDevice, so we can set our FBO to be the render target
      *  The canvas parameter must be a SkGpuCanvas
      */
-    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&);
+    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&,
+                           const SkClipStack& clipStack);
 
     virtual SkGpuTexture* accessTexture() { return (SkGpuTexture*)fTexture; }
 
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index ccdd400..d6a3fab 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -20,7 +20,7 @@
 
 #include <stddef.h>
 
-// tetrark headers
+// Gr headers
 #include "GrConfig.h"
 #include "GrContext.h"
 #include "GrFontScaler.h"
@@ -33,6 +33,7 @@
 #include "SkPoint.h"
 #include "SkRegion.h"
 #include "SkShader.h"
+#include "SkClipStack.h"
 
 #if (GR_DEBUG && defined(SK_RELEASE)) || (GR_RELEASE && defined(SK_DEBUG))
 //    #error "inconsistent GR_DEBUG and SK_DEBUG"
@@ -170,39 +171,99 @@
 
 class SkGrPathIter : public GrPathIter {
 public:
-    SkGrPathIter(const SkPath& path) : fIter(path, false), fPath(path) {}
+    SkGrPathIter() { fPath = NULL; }
+    SkGrPathIter(const SkPath& path) { reset(path); }
     virtual Command next(GrPoint pts[]);
     virtual Command next();
     virtual void rewind();
     virtual ConvexHint hint() const;
+
+    void reset(const SkPath& path) {
+        fPath = &path;
+        fIter.setPath(path, false);
+    }
 private:
 
 #if !SK_SCALAR_IS_GR_SCALAR
     SkPoint             fPoints[4];
 #endif
     SkPath::Iter        fIter;
-    const SkPath&       fPath;
+    const SkPath*       fPath;
 };
 
 class SkGrClipIterator : public GrClipIterator {
 public:
-    void reset(const SkRegion& clip) {
-        fIter.reset(clip);
-        this->invalidateBoundsCache();
+    SkGrClipIterator() { fClipStack = NULL;  fCurr = NULL; }
+    SkGrClipIterator(const SkClipStack& clipStack) { this->reset(clipStack); }
+
+    void reset(const SkClipStack& clipStack);
+
+    // overrides
+    virtual bool isDone() const { return NULL == fCurr; }
+    virtual void next() { fCurr = fIter.next(); }
+    virtual void rewind() { this->reset(*fClipStack); }
+    virtual GrClipType getType() const;
+
+    virtual GrSetOp getOp() const;
+
+    virtual void getRect(GrRect* rect) const {
+        *rect = Sk2Gr(*fCurr->fRect);
+    }
+
+    virtual GrPathIter* getPathIter() {
+        fPathIter.reset(*fCurr->fPath);
+        return &fPathIter;
+    }
+
+    virtual GrPathFill getPathFill() const;
+
+private:
+    const SkClipStack*                  fClipStack;
+    SkClipStack::B2FIter                fIter;
+    SkGrPathIter                        fPathIter;
+    // SkClipStack's auto advances on each get
+    // so we store the current pos here.
+    const SkClipStack::B2FIter::Clip*   fCurr;
+};
+
+class SkGrRegionIterator : public GrClipIterator {
+public:
+    SkGrRegionIterator() {}
+    SkGrRegionIterator(const SkRegion& region) { this->reset(region); }
+
+    void reset(const SkRegion& region) { 
+        fRegion = &region;
+        fIter.reset(region);
     }
 
     // overrides
-
-    virtual bool isDone() { return fIter.done(); }
-    virtual void getRect(GrIRect* rect) {
-        SkGr::SetIRect(rect, fIter.rect());
-    }
+    virtual bool isDone() const { return fIter.done(); }
     virtual void next() { fIter.next(); }
-    virtual void rewind() { fIter.rewind(); }
-    virtual void computeBounds(GrIRect* bounds);
+    virtual void rewind() { this->reset(*fRegion); }
+    virtual GrClipType getType() const { return kRect_ClipType; }
 
+    virtual GrSetOp getOp() const { return kUnion_SetOp; }
+
+    virtual void getRect(GrRect* rect) const {
+        const SkIRect& r = fIter.rect();
+        rect->fLeft   = GrIntToScalar(r.fLeft);
+        rect->fTop    = GrIntToScalar(r.fTop);
+        rect->fRight  = GrIntToScalar(r.fRight);
+        rect->fBottom = GrIntToScalar(r.fBottom);
+    }
+
+    virtual GrPathIter* getPathIter() {
+        SkASSERT(0);
+        return NULL;
+    }
+
+    virtual GrPathFill getPathFill() const {
+        SkASSERT(0);
+        return kWinding_PathFill;
+    }
 private:
-    SkRegion::Iterator fIter;
+    const SkRegion*     fRegion;
+    SkRegion::Iterator  fIter;
 };
 
 class SkGlyphCache;
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index e2d6af4..e636d2b 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -264,7 +264,7 @@
             }
             // fCurrLayer may be NULL now
 
-            fCanvas->prepareForDeviceDraw(fDevice, *fMatrix, *fClip);
+            fCanvas->prepareForDeviceDraw(fDevice, *fMatrix, *fClip, *fClipStack);
             return true;
         }
         return false;
@@ -632,10 +632,11 @@
 }
 
 void SkCanvas::prepareForDeviceDraw(SkDevice* device, const SkMatrix& matrix,
-                                    const SkRegion& clip) {
+                                    const SkRegion& clip,
+                                    const SkClipStack& clipStack) {
     SkASSERT(device);
     if (fLastDeviceToGainFocus != device) {
-        device->gainFocus(this, matrix, clip);
+        device->gainFocus(this, matrix, clip, clipStack);
         fLastDeviceToGainFocus = device;
     }
 }
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index 2b63aea..864f23a 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -116,7 +116,11 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkClipStack::B2FIter::B2FIter(const SkClipStack& stack) : fIter(stack.fDeque) {
+SkClipStack::B2FIter::B2FIter() {
+}
+
+SkClipStack::B2FIter::B2FIter(const SkClipStack& stack) {
+    this->reset(stack);
 }
 
 const SkClipStack::B2FIter::Clip* SkClipStack::B2FIter::next() {
@@ -142,3 +146,7 @@
     fClip.fOp = rec->fOp;
     return &fClip;
 }
+
+void SkClipStack::B2FIter::reset(const SkClipStack& stack) {
+    fIter.reset(stack.fDeque);
+}
diff --git a/src/core/SkDeque.cpp b/src/core/SkDeque.cpp
index 2c6ce64..9d685ee 100644
--- a/src/core/SkDeque.cpp
+++ b/src/core/SkDeque.cpp
@@ -225,12 +225,12 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkDeque::F2BIter::F2BIter(const SkDeque& d) : fElemSize(d.fElemSize) {
-    fHead = d.fFront;
-    while (fHead != NULL && fHead->fBegin == NULL) {
-        fHead = fHead->fNext;
-    }
-    fPos = fHead ? fHead->fBegin : NULL;
+SkDeque::F2BIter::F2BIter() {
+    fPos = NULL;
+}
+
+SkDeque::F2BIter::F2BIter(const SkDeque& d) {
+    this->reset(d);
 }
 
 void* SkDeque::F2BIter::next() {
@@ -250,3 +250,11 @@
     return pos;
 }
 
+void SkDeque::F2BIter::reset(const SkDeque& d) {
+    fElemSize = d.fElemSize;
+    fHead = d.fFront;
+    while (fHead != NULL && fHead->fBegin == NULL) {
+        fHead = fHead->fNext;
+    }
+    fPos = fHead ? fHead->fBegin : NULL;
+}
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 3dfe02a..e925e53 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -267,19 +267,30 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#define USE_CLIP_STACK 0
+
 static void convert_matrixclip(GrContext* context, const SkMatrix& matrix,
-                               const SkRegion& clip) {
+                               const SkClipStack& clipStack,
+                               const SkRegion& clipRegion) {
     GrMatrix grmat;
     SkGr::SkMatrix2GrMatrix(matrix, &grmat);
     context->setMatrix(grmat);
 
+#if USE_CLIP_STACK
     SkGrClipIterator iter;
-    iter.reset(clip);
-    GrClip grc(&iter);
-    if (context->getClip() == grc) {
-    } else {
-        context->setClip(grc);
-    }
+    iter.reset(clipStack);
+#else
+    SkGrRegionIterator iter;
+    iter.reset(clipRegion);
+#endif
+    const SkIRect& skBounds = clipRegion.getBounds();
+    GrRect bounds;
+    bounds.setLTRB(GrIntToScalar(skBounds.fLeft),
+                   GrIntToScalar(skBounds.fTop),
+                   GrIntToScalar(skBounds.fRight),
+                   GrIntToScalar(skBounds.fBottom));
+    GrClip grc(&iter, NULL);
+    context->setClip(grc);
 }
 
 // call this ever each draw call, to ensure that the context reflects our state,
@@ -289,7 +300,9 @@
         fContext->getRenderTarget() != fRenderTarget) {
 
         fContext->setRenderTarget(fRenderTarget);
-        convert_matrixclip(fContext, *draw.fMatrix, *draw.fClip);
+        SkASSERT(draw.fClipStack);
+        convert_matrixclip(fContext, *draw.fMatrix,
+                           *draw.fClipStack, *draw.fClip);
         fNeedPrepareRenderTarget = false;
     }
 }
@@ -298,16 +311,17 @@
                                 const SkClipStack& clipStack) {
     this->INHERITED::setMatrixClip(matrix, clip, clipStack);
 
-    convert_matrixclip(fContext, matrix, clip);
+    convert_matrixclip(fContext, matrix, clipStack, clip);
 }
 
 void SkGpuDevice::gainFocus(SkCanvas* canvas, const SkMatrix& matrix,
-                            const SkRegion& clip) {
+                            const SkRegion& clip, const SkClipStack& clipStack) {
+
     fContext->setRenderTarget(fRenderTarget);
 
-    this->INHERITED::gainFocus(canvas, matrix, clip);
+    this->INHERITED::gainFocus(canvas, matrix, clip, clipStack);
 
-    convert_matrixclip(fContext, matrix, clip);
+    convert_matrixclip(fContext, matrix, clipStack, clip);
 
     if (fNeedClear) {
         fContext->eraseColor(0x0);
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 41cf1bd..4c7bf6c 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -135,22 +135,80 @@
 }
 
 void SkGrPathIter::rewind() {
-    fIter.setPath(fPath, false);
+    fIter.setPath(*fPath, false);
 }
 
 GrPathIter::ConvexHint SkGrPathIter::hint() const {
-    return fPath.isConvex() ? GrPathIter::kConvex_ConvexHint :
-                              GrPathIter::kNone_ConvexHint;
+    return fPath->isConvex() ? GrPathIter::kConvex_ConvexHint :
+                               GrPathIter::kNone_ConvexHint;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkGrClipIterator::computeBounds(GrIRect* bounds) {
-    const SkRegion* rgn = fIter.rgn();
-    if (rgn) {
-        SkGr::SetIRect(bounds, rgn->getBounds());
+void SkGrClipIterator::reset(const SkClipStack& clipStack) {
+    fClipStack = &clipStack;
+    fIter.reset(clipStack);
+    // Gr has no notion of replace, skip to the
+    // last replace in the clip stack.
+    int lastReplace = 0;
+    int curr = 0;
+    while (NULL != (fCurr = fIter.next())) {
+        if (SkRegion::kReplace_Op == fCurr->fOp) {
+            lastReplace = curr;
+        }
+        ++curr;
+    }
+    fIter.reset(clipStack);
+    for (int i = 0; i < lastReplace+1; ++i) {
+        fCurr = fIter.next();
+    }
+}
+
+GrClipType SkGrClipIterator::getType() const {
+    GrAssert(!this->isDone());
+    if (NULL != fCurr->fRect) {
+        return kRect_ClipType;
     } else {
-        bounds->setEmpty();
+        GrAssert(NULL != fCurr->fPath);
+        return kPath_ClipType;
+    }
+}
+
+GrSetOp SkGrClipIterator::getOp() const {
+    // we skipped to the last "replace" op
+    // when this iter was reset.
+    // GrClip doesn't allow replace, so treat it as
+    // intersect.
+    GrSetOp skToGrOps[] = {
+        kDifference_SetOp,         // kDifference_Op
+        kIntersect_SetOp,          // kIntersect_Op
+        kUnion_SetOp,              // kUnion_Op
+        kXor_SetOp,                // kXOR_Op
+        kReverseDifference_SetOp,  // kReverseDifference_Op
+        kIntersect_SetOp           // kReplace_op
+    };
+    GR_STATIC_ASSERT(0 == SkRegion::kDifference_Op);
+    GR_STATIC_ASSERT(1 == SkRegion::kIntersect_Op);
+    GR_STATIC_ASSERT(2 == SkRegion::kUnion_Op);
+    GR_STATIC_ASSERT(3 == SkRegion::kXOR_Op);
+    GR_STATIC_ASSERT(4 == SkRegion::kReverseDifference_Op);
+    GR_STATIC_ASSERT(5 == SkRegion::kReplace_Op);
+    return skToGrOps[fCurr->fOp];
+}
+
+GrPathFill SkGrClipIterator::getPathFill() const {
+    switch (fCurr->fPath->getFillType()) {
+        case SkPath::kWinding_FillType:
+            return kWinding_PathFill;
+        case SkPath::kEvenOdd_FillType:
+            return  kEvenOdd_PathFill;
+        case SkPath::kInverseWinding_FillType:
+            return kInverseWinding_PathFill;
+        case SkPath::kInverseEvenOdd_FillType:
+            return kInverseEvenOdd_PathFill;
+        default:
+            GrCrash("Unsupported path fill in clip.");
+            return kWinding_PathFill; // suppress warning
     }
 }
 
diff --git a/src/utils/mac/SkOSWindow_Mac.cpp b/src/utils/mac/SkOSWindow_Mac.cpp
index 7716185..05f97a7 100644
--- a/src/utils/mac/SkOSWindow_Mac.cpp
+++ b/src/utils/mac/SkOSWindow_Mac.cpp
@@ -531,7 +531,6 @@
 
 void SkOSWindow::presentGL() {
     aglSwapBuffers((AGLContext)fAGLCtx);
-    glFlush();
 }
 
 #endif
diff --git a/src/utils/win/SkOSWindow_Win.cpp b/src/utils/win/SkOSWindow_Win.cpp
index 3594c2f..96a026d 100644
--- a/src/utils/win/SkOSWindow_Win.cpp
+++ b/src/utils/win/SkOSWindow_Win.cpp
@@ -444,10 +444,6 @@
         }
     }
     if (wglMakeCurrent(GetDC((HWND)fHWND), (HGLRC)fHGLRC)) {
-        glViewport(0, 0, this->width(), this->height());
-        glClearColor(0, 0, 0, 0);
-        glClearStencil(0);
-        glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
         fGLAttached = true;
         return true;
     }
@@ -462,9 +458,6 @@
 void SkOSWindow::presentGL() {
     glFlush();
     SwapBuffers(GetDC((HWND)fHWND));
-    glClearColor(0,0,0,0);
-    glClearStencil(0);
-    glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
 }
 
 IDirect3DDevice9* create_d3d9_device(HWND hwnd) {
diff --git a/vs/SampleApp/SampleApp.vcxproj b/vs/SampleApp/SampleApp.vcxproj
index 8c6fe83..8de34d0 100644
--- a/vs/SampleApp/SampleApp.vcxproj
+++ b/vs/SampleApp/SampleApp.vcxproj
@@ -133,6 +133,7 @@
     <ClInclude Include="..\..\gpu\include\GrRefCnt.h" />
     <ClInclude Include="..\..\gpu\include\GrSamplerState.h" />
     <ClInclude Include="..\..\gpu\include\GrScalar.h" />
+    <ClInclude Include="..\..\gpu\include\GrStencil.h" />
     <ClInclude Include="..\..\gpu\include\GrStopwatch.h" />
     <ClInclude Include="..\..\gpu\include\GrStringBuilder.h" />
     <ClInclude Include="..\..\gpu\include\GrTArray.h" />
@@ -233,6 +234,7 @@
     <ClCompile Include="..\..\gpu\src\GrPath.cpp" />
     <ClCompile Include="..\..\gpu\src\GrPathRenderer.cpp" />
     <ClCompile Include="..\..\gpu\src\GrRectanizer.cpp" />
+    <ClCompile Include="..\..\gpu\src\GrStencil.cpp" />
     <ClCompile Include="..\..\gpu\src\GrTextContext.cpp" />
     <ClCompile Include="..\..\gpu\src\GrTextStrike.cpp" />
     <ClCompile Include="..\..\gpu\src\GrTextureCache.cpp" />
@@ -246,6 +248,7 @@
     <ClCompile Include="..\..\samplecode\SampleBlur.cpp" />
     <ClCompile Include="..\..\samplecode\SampleCamera.cpp" />
     <ClCompile Include="..\..\samplecode\SampleCircle.cpp" />
+    <ClCompile Include="..\..\samplecode\SampleComplexClip.cpp" />
     <ClCompile Include="..\..\samplecode\SampleCull.cpp" />
     <ClCompile Include="..\..\samplecode\SampleDither.cpp" />
     <ClCompile Include="..\..\samplecode\SampleDitherBitmap.cpp" />
diff --git a/xcode/gpu/gpu.xcodeproj/project.pbxproj b/xcode/gpu/gpu.xcodeproj/project.pbxproj
index 58a6358..e891f26 100644
--- a/xcode/gpu/gpu.xcodeproj/project.pbxproj
+++ b/xcode/gpu/gpu.xcodeproj/project.pbxproj
@@ -90,6 +90,8 @@
 		00216E5E130F0B03009A2160 /* GrGLIRect.h in Headers */ = {isa = PBXBuildFile; fileRef = 00216E5D130F0B03009A2160 /* GrGLIRect.h */; };
 		D539049B12EA01E30025F3D6 /* GrContext_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = D539049A12EA01E30025F3D6 /* GrContext_impl.h */; };
 		D53904A112EA026E0025F3D6 /* GrPaint.h in Headers */ = {isa = PBXBuildFile; fileRef = D53904A012EA026E0025F3D6 /* GrPaint.h */; };
+		D542EAAD131C87E90065FC9D /* GrStencil.h in Headers */ = {isa = PBXBuildFile; fileRef = D542EAAC131C87E90065FC9D /* GrStencil.h */; };
+		D5558AE3131EB9BB00C71009 /* GrStencil.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D5558AE2131EB9BB00C71009 /* GrStencil.cpp */; };
 		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 */; };
@@ -184,6 +186,8 @@
 		D2AAC046055464E500DB518D /* libgpu.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgpu.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		D539049A12EA01E30025F3D6 /* GrContext_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrContext_impl.h; path = ../../gpu/include/GrContext_impl.h; sourceTree = SOURCE_ROOT; };
 		D53904A012EA026E0025F3D6 /* GrPaint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrPaint.h; path = ../../gpu/include/GrPaint.h; sourceTree = SOURCE_ROOT; };
+		D542EAAC131C87E90065FC9D /* GrStencil.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrStencil.h; path = ../../gpu/include/GrStencil.h; sourceTree = SOURCE_ROOT; };
+		D5558AE2131EB9BB00C71009 /* GrStencil.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GrStencil.cpp; path = ../../gpu/src/GrStencil.cpp; 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; };
@@ -263,6 +267,7 @@
 				00115E6D12C116CA008296FE /* GrUserConfig.h */,
 				00115E6E12C116CA008296FE /* GrVertexBuffer.h */,
 				D53904A012EA026E0025F3D6 /* GrPaint.h */,
+				D542EAAC131C87E90065FC9D /* GrStencil.h */,
 			);
 			name = include;
 			sourceTree = "<group>";
@@ -281,8 +286,6 @@
 		08FB7795FE84155DC02AAC07 /* Source */ = {
 			isa = PBXGroup;
 			children = (
-				D5ED88E913144FD600B98D64 /* GrPathRenderer.cpp */,
-				D5ED88EA13144FD600B98D64 /* GrPathRenderer.h */,
 				D5ED886E1313F92C00B98D64 /* GrRedBlackTree.h */,
 				D539049A12EA01E30025F3D6 /* GrContext_impl.h */,
 				00115DD812C1167A008296FE /* gr_unittests.cpp */,
@@ -308,8 +311,11 @@
 				00115DEE12C1167A008296FE /* GrMatrix.cpp */,
 				00115DEF12C1167A008296FE /* GrMemory.cpp */,
 				00115DF012C1167A008296FE /* GrPath.cpp */,
+				D5ED88EA13144FD600B98D64 /* GrPathRenderer.h */,
+				D5ED88E913144FD600B98D64 /* GrPathRenderer.cpp */,
 				00115DF412C1167A008296FE /* GrRectanizer_fifo.cpp */,
 				00115DF512C1167A008296FE /* GrRectanizer.cpp */,
+				D5558AE2131EB9BB00C71009 /* GrStencil.cpp */,
 				00115DF612C1167A008296FE /* GrTextContext.cpp */,
 				00115DF712C1167A008296FE /* GrTextStrike_impl.h */,
 				00115DF812C1167A008296FE /* GrTextStrike.cpp */,
@@ -405,6 +411,7 @@
 				00216E5E130F0B03009A2160 /* GrGLIRect.h in Headers */,
 				D5ED886F1313F92C00B98D64 /* GrRedBlackTree.h in Headers */,
 				D5ED88EC13144FD600B98D64 /* GrPathRenderer.h in Headers */,
+				D542EAAD131C87E90065FC9D /* GrStencil.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -483,6 +490,7 @@
 				D58CAF9A12E7212100CB9277 /* GrGLUtil.cpp in Sources */,
 				D5FAF22313072C27001550A4 /* GrBufferAllocPool.cpp in Sources */,
 				D5ED88EB13144FD600B98D64 /* GrPathRenderer.cpp in Sources */,
+				D5558AE3131EB9BB00C71009 /* GrStencil.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
diff --git a/xcode/sampleapp/SampleApp.xcodeproj/project.pbxproj b/xcode/sampleapp/SampleApp.xcodeproj/project.pbxproj
index 1a39d9a..2820546 100644
--- a/xcode/sampleapp/SampleApp.xcodeproj/project.pbxproj
+++ b/xcode/sampleapp/SampleApp.xcodeproj/project.pbxproj
@@ -30,7 +30,6 @@
 		0021F3A21120B29C0062682F /* SkStaticTextView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0021F3A11120B29C0062682F /* SkStaticTextView.cpp */; };
 		0021F3D31120B61F0062682F /* SampleUnitMapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00995E1510A079D80054AD6D /* SampleUnitMapper.cpp */; };
 		00244D1B10642BBA00B8F4D8 /* SampleStrokePath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0009E21F1057E96800B0DE6F /* SampleStrokePath.cpp */; };
-		00244D97106A539500B8F4D8 /* SampleXfermodes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007A7CB20F01658C00A2D6EE /* SampleXfermodes.cpp */; };
 		00244DE2106A681600B8F4D8 /* SampleShaders.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007A7CA80F01658C00A2D6EE /* SampleShaders.cpp */; };
 		00281C751083CF7E00BCCB06 /* libAnimator.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00281C711083CF6600BCCB06 /* libAnimator.a */; };
 		00281D071084ED1200BCCB06 /* SkXMLParser_expat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00281D061084ED1200BCCB06 /* SkXMLParser_expat.cpp */; };
@@ -81,7 +80,6 @@
 		009F9D1A12C3EB2600C7FD4A /* SampleGM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C4625412BFB2F300DBB1F6 /* SampleGM.cpp */; };
 		00A728270FD43D0400D5051F /* SampleMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2762F6760FCCCB01002BD8B4 /* SampleMovie.cpp */; };
 		00A7282F0FD43D3700D5051F /* SkMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00A7282D0FD43D3700D5051F /* SkMovie.cpp */; };
-		00A7295D0FD8397600D5051F /* SampleAll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2762F6740FCCCB01002BD8B4 /* SampleAll.cpp */; };
 		00AF787E0FE94433007F9650 /* SamplePath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00003C640EFC22A8000FF73A /* SamplePath.cpp */; };
 		00AF9B18103CD5EB00CBBCB3 /* SampleDitherBitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AF9B17103CD5EB00CBBCB3 /* SampleDitherBitmap.cpp */; };
 		00BB289B104781D00057BF7E /* SampleForth.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BB289A104781D00057BF7E /* SampleForth.cpp */; };
@@ -148,10 +146,13 @@
 		8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */; };
 		8D0C4E8E0486CD37000505A6 /* main.nib in Resources */ = {isa = PBXBuildFile; fileRef = 02345980000FD03B11CA0E72 /* main.nib */; };
 		8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 20286C33FDCF999611CA2CEA /* Carbon.framework */; };
+		D5558AEF131EBA1E00C71009 /* SampleComplexClip.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D5558AEE131EBA1E00C71009 /* SampleComplexClip.cpp */; };
+		D5558B29131EBC9C00C71009 /* SampleFillType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE270F00A12400695E8C /* SampleFillType.cpp */; };
 		D55BEE6712EF44B90055D6FD /* shadertext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D55BEE6612EF44B90055D6FD /* shadertext.cpp */; };
 		D5962B3A12EDFC7600B478DF /* SampleShaderText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D5962B3812EDFC7600B478DF /* SampleShaderText.cpp */; };
 		D5A682D712E9CE8500CDDDC6 /* SamplePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE340F00A12400695E8C /* SamplePatch.cpp */; };
-		D5F4A21F12E9D75300DE986A /* SampleFillType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE270F00A12400695E8C /* SampleFillType.cpp */; };
+		D5BF1C5A131D449500C4B94B /* SampleAll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2762F6740FCCCB01002BD8B4 /* SampleAll.cpp */; };
+		D5BF1CFD131D500A00C4B94B /* SampleXfermodes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007A7CB20F01658C00A2D6EE /* SampleXfermodes.cpp */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -414,6 +415,7 @@
 		4A9504CAFFE6A41611CA0CBA /* CoreServices.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreServices.framework; path = /System/Library/Frameworks/CoreServices.framework; sourceTree = "<absolute>"; };
 		8D0C4E960486CD37000505A6 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };
 		8D0C4E970486CD37000505A6 /* CICarbonSample.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = CICarbonSample.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		D5558AEE131EBA1E00C71009 /* SampleComplexClip.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleComplexClip.cpp; path = ../../samplecode/SampleComplexClip.cpp; sourceTree = SOURCE_ROOT; };
 		D55BEE6612EF44B90055D6FD /* shadertext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = shadertext.cpp; path = ../../gm/shadertext.cpp; sourceTree = SOURCE_ROOT; };
 		D5962B3812EDFC7600B478DF /* SampleShaderText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleShaderText.cpp; path = ../../samplecode/SampleShaderText.cpp; sourceTree = SOURCE_ROOT; };
 /* End PBXFileReference section */
@@ -442,6 +444,7 @@
 		00003C610EFC2287000FF73A /* samples */ = {
 			isa = PBXGroup;
 			children = (
+				D5558AEE131EBA1E00C71009 /* SampleComplexClip.cpp */,
 				27C4625412BFB2F300DBB1F6 /* SampleGM.cpp */,
 				003EE651111239D5001AB759 /* SampleWarp.cpp */,
 				27A34E8B119892DD00860515 /* SampleTextBox.cpp */,
@@ -937,7 +940,6 @@
 				2762F66E0FCCCABE002BD8B4 /* SkPageFlipper.cpp in Sources */,
 				00A728270FD43D0400D5051F /* SampleMovie.cpp in Sources */,
 				00A7282F0FD43D3700D5051F /* SkMovie.cpp in Sources */,
-				00A7295D0FD8397600D5051F /* SampleAll.cpp in Sources */,
 				00AF787E0FE94433007F9650 /* SamplePath.cpp in Sources */,
 				005E92DC0FF08507008965B9 /* SampleFilter2.cpp in Sources */,
 				27005D16100903C100E275B6 /* SampleLines.cpp in Sources */,
@@ -950,7 +952,6 @@
 				00EB4593104DBB18002B413E /* ForthTests.cpp in Sources */,
 				009887F1106142FC0020D19B /* SampleNinePatch.cpp in Sources */,
 				00244D1B10642BBA00B8F4D8 /* SampleStrokePath.cpp in Sources */,
-				00244D97106A539500B8F4D8 /* SampleXfermodes.cpp in Sources */,
 				00244DE2106A681600B8F4D8 /* SampleShaders.cpp in Sources */,
 				00281D071084ED1200BCCB06 /* SkXMLParser_expat.cpp in Sources */,
 				009230D8109F111F00AD3F12 /* OverView.cpp in Sources */,
@@ -1027,9 +1028,12 @@
 				009F9D0A12C3E8AF00C7FD4A /* SampleFilter.cpp in Sources */,
 				009F9D1A12C3EB2600C7FD4A /* SampleGM.cpp in Sources */,
 				D5A682D712E9CE8500CDDDC6 /* SamplePatch.cpp in Sources */,
-				D5F4A21F12E9D75300DE986A /* SampleFillType.cpp in Sources */,
 				D5962B3A12EDFC7600B478DF /* SampleShaderText.cpp in Sources */,
 				D55BEE6712EF44B90055D6FD /* shadertext.cpp in Sources */,
+				D5BF1C5A131D449500C4B94B /* SampleAll.cpp in Sources */,
+				D5BF1CFD131D500A00C4B94B /* SampleXfermodes.cpp in Sources */,
+				D5558AEF131EBA1E00C71009 /* SampleComplexClip.cpp in Sources */,
+				D5558B29131EBC9C00C71009 /* SampleFillType.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};