diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index 4a1f1da..f980702 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -585,9 +585,9 @@
 
     GrDrawTarget* prepareToDraw(const GrPaint& paint, DrawCategory drawType);
 
-    GrPathRenderer* getPathRenderer(const GrDrawTarget* target,
-                                    const GrPath& path,
-                                    GrPathFill fill);
+    GrPathRenderer* getPathRenderer(const GrPath& path,
+                                    GrPathFill fill,
+                                    bool antiAlias);
 
     struct OffscreenRecord;
 
diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp
index f16c8ef..35c4f20 100644
--- a/src/gpu/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/GrAAHairLinePathRenderer.cpp
@@ -106,20 +106,15 @@
     fQuadsIndexBuffer->unref();
 }
 
-bool GrAAHairLinePathRenderer::supportsAA(const GrDrawTarget* target,
-                                          const SkPath& path,
-                                          GrPathFill fill) const {
-    return kHairLine_PathFill == fill;
-}
-
-bool GrAAHairLinePathRenderer::canDrawPath(const GrDrawTarget* target,
+bool GrAAHairLinePathRenderer::canDrawPath(const GrDrawTarget::Caps& targetCaps,
                                            const SkPath& path,
-                                           GrPathFill fill) const {
+                                           GrPathFill fill,
+                                           bool antiAlias) const {
     static const uint32_t gReqDerivMask = SkPath::kCubic_SegmentMask |
                                           SkPath::kQuad_SegmentMask;
     return (kHairLine_PathFill == fill &&
-            target->isAntialiasState() &&
-            (target->getCaps().fShaderDerivativeSupport ||
+            antiAlias &&
+            (targetCaps.fShaderDerivativeSupport ||
              !(gReqDerivMask & path.getSegmentMasks())));
 }
 
diff --git a/src/gpu/GrAAHairLinePathRenderer.h b/src/gpu/GrAAHairLinePathRenderer.h
index 81cecf2..1d561fa 100644
--- a/src/gpu/GrAAHairLinePathRenderer.h
+++ b/src/gpu/GrAAHairLinePathRenderer.h
@@ -17,18 +17,16 @@
 
     static GrPathRenderer* Create(GrContext* context);
     // GrPathRenderer overrides
-    virtual bool supportsAA(const GrDrawTarget* target,
-                            const SkPath& path,
-                            GrPathFill fill) const;
-    virtual bool canDrawPath(const GrDrawTarget* target,
+    virtual bool canDrawPath(const GrDrawTarget::Caps& targetCaps,
                              const SkPath& path,
-                             GrPathFill fill) const;
-    virtual void drawPath(GrDrawTarget::StageBitfield stages);
+                             GrPathFill fill,
+                             bool antiAlias) const  SK_OVERRIDE;
+    virtual void drawPath(GrDrawTarget::StageBitfield stages) SK_OVERRIDE;
 
 protected:
 
     // GrPathRenderer overrides
-    virtual void pathWillClear();
+    virtual void pathWillClear()  SK_OVERRIDE;
 
 private:
     void resetGeom();
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index 5921838..d9dc3d2 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -333,7 +333,7 @@
             fGpu->setBlendFunc(kOne_BlendCoeff, kZero_BlendCoeff);
             fGpu->disableState(GrDrawTarget::kDither_StateBit |
                                GrDrawTarget::kClip_StateBit   |
-                               GrDrawTarget::kAntialias_StateBit);
+                               GrDrawTarget::kHWAntialias_StateBit);
             GrSamplerState::Filter filter;
             // if filtering is not desired then we want to ensure all
             // texels in the resampled image are copies of texels from
@@ -664,9 +664,6 @@
 #if !GR_USE_OFFSCREEN_AA
     return false;
 #else
-    if (!target->isAntialiasState()) {
-        return false;
-    }
     // Line primitves are always rasterized as 1 pixel wide.
     // Super-sampling would make them too thin but MSAA would be OK.
     if (isHairLines &&
@@ -778,6 +775,9 @@
     tempPaint.reset();
     SetPaint(tempPaint, target);
     target->setRenderTarget(offRT0);
+#if PREFER_MSAA_OFFSCREEN_AA
+    target->enableState(GrDrawTarget::kHWAntialias_StateBit);
+#endif
 
     GrMatrix transM;
     int left = boundRect.fLeft + tileX * record->fTileSizeX;
@@ -1166,16 +1166,12 @@
                              bool* useVertexCoverage) {
     // we use a simple alpha ramp to do aa on axis-aligned rects
     // do AA with alpha ramp if the caller requested AA, the rect 
-    // will be axis-aligned,the render target is not
-    // multisampled, and the rect won't land on integer coords.
-
-    if (!target->isAntialiasState()) {
-        return false;
-    }
+    // will be axis-aligned, and the rect won't land on integer coords.
 
     // we are keeping around the "tweak the alpha" trick because
     // it is our only hope for the fixed-pipe implementation.
     // In a shader implementation we can give a separate coverage input
+    // TODO: remove this ugliness when we drop the fixed-pipe impl
     *useVertexCoverage = false;
     if (!target->canTweakAlphaForCoverage()) {
         if (target->getCaps().fSupportPerVertexCoverage) {
@@ -1238,8 +1234,11 @@
     GrRect devRect = rect;
     GrMatrix combinedMatrix;
     bool useVertexCoverage;
-    bool doAA = apply_aa_to_rect(target, rect, width, matrix,
-                                 &combinedMatrix, &devRect, &useVertexCoverage);
+    bool needAA = paint.fAntiAlias &&
+                  !this->getRenderTarget()->isMultisampled();
+    bool doAA = needAA && apply_aa_to_rect(target, rect, width, matrix,
+                                           &combinedMatrix, &devRect,
+                                           &useVertexCoverage);
 
     if (doAA) {
         GrDrawTarget::AutoViewMatrixRestore avm(target);
@@ -1490,6 +1489,8 @@
 
     GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
 
+    bool prAA = paint.fAntiAlias && !this->getRenderTarget()->isMultisampled();
+
     // An Assumption here is that path renderer would use some form of tweaking
     // the src color (either the input alpha or in the frag shader) to implement
     // aa. If we have some future driver-mojo path AA that can do the right
@@ -1498,10 +1499,22 @@
 #if GR_DEBUG
         GrPrintf("Turning off AA to correctly apply blend.\n");
 #endif
-        target->disableState(GrDrawTarget::kAntialias_StateBit);
+        prAA = false;
     }
-    
-    GrPathRenderer* pr = this->getPathRenderer(target, path, fill);
+
+    bool doOSAA = false;
+    GrPathRenderer* pr = NULL;
+    if (prAA) {
+        pr = this->getPathRenderer(path, fill, true);
+        if (NULL == pr) {
+            prAA = false;
+            doOSAA = this->doOffscreenAA(target, kHairLine_PathFill == fill);
+            pr = this->getPathRenderer(path, fill, false);
+        }
+    } else {
+        pr = this->getPathRenderer(path, fill, false);
+    }
+
     if (NULL == pr) {
 #if GR_DEBUG
         GrPrintf("Unable to find path renderer compatible with path.\n");
@@ -1509,12 +1522,10 @@
         return;
     }
 
-    GrPathRenderer::AutoClearPath arp(pr, target, &path, fill, translate);
+    GrPathRenderer::AutoClearPath arp(pr, target, &path, fill, prAA, translate);
     GrDrawTarget::StageBitfield stageMask = paint.getActiveStageMask();
 
-    if (!pr->supportsAA(target, path, fill) &&
-        this->doOffscreenAA(target, kHairLine_PathFill == fill)) {
-
+    if (doOSAA) {
         bool needsStencil = pr->requiresStencilPass(target, path, fill);
 
         // compute bounds as intersection of rt size, clip, and path
@@ -1723,9 +1734,9 @@
         target->disableState(GrDrawTarget::kDither_StateBit);
     }
     if (paint.fAntiAlias) {
-        target->enableState(GrDrawTarget::kAntialias_StateBit);
+        target->enableState(GrDrawTarget::kHWAntialias_StateBit);
     } else {
-        target->disableState(GrDrawTarget::kAntialias_StateBit);
+        target->disableState(GrDrawTarget::kHWAntialias_StateBit);
     }
     target->setBlendFunc(paint.fSrcBlendCoeff, paint.fDstBlendCoeff);
     target->setColorFilter(paint.fColorFilterColor, paint.fColorFilterXfermode);
@@ -1763,14 +1774,15 @@
     return target;
 }
 
-GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target,
-                                           const GrPath& path,
-                                           GrPathFill fill) {
+GrPathRenderer* GrContext::getPathRenderer(const GrPath& path,
+                                           GrPathFill fill,
+                                           bool antiAlias) {
     if (NULL == fPathRendererChain) {
         fPathRendererChain = 
             new GrPathRendererChain(this, GrPathRendererChain::kNone_UsageFlag);
     }
-    return fPathRendererChain->getPathRenderer(target, path, fill);
+    return fPathRendererChain->getPathRenderer(fGpu->getCaps(), path,
+                                               fill, antiAlias);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/GrDefaultPathRenderer.cpp b/src/gpu/GrDefaultPathRenderer.cpp
index 14c032b..52decb4 100644
--- a/src/gpu/GrDefaultPathRenderer.cpp
+++ b/src/gpu/GrDefaultPathRenderer.cpp
@@ -25,6 +25,16 @@
     fTarget = NULL;
 }
 
+bool GrDefaultPathRenderer::canDrawPath(const GrDrawTarget::Caps& targetCaps,
+                                        const SkPath& path,
+                                        GrPathFill fill,
+                                        bool antiAlias) const {
+    // this class can draw any path with any fill but doesn't do any 
+    // anti-aliasing.
+    return !antiAlias; 
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // Stencil rules for paths
 
@@ -187,7 +197,7 @@
 }
 
 bool GrDefaultPathRenderer::requiresStencilPass(const GrDrawTarget* target,
-                                                const GrPath& path, 
+                                                const GrPath& path,
                                                 GrPathFill fill) const {
     return !single_pass_path(*target, path, fill);
 }
diff --git a/src/gpu/GrDefaultPathRenderer.h b/src/gpu/GrDefaultPathRenderer.h
index dd59641..2a34a3d 100644
--- a/src/gpu/GrDefaultPathRenderer.h
+++ b/src/gpu/GrDefaultPathRenderer.h
@@ -20,16 +20,17 @@
     GrDefaultPathRenderer(bool separateStencilSupport,
                           bool stencilWrapOpsSupport);
 
-    virtual bool canDrawPath(const GrDrawTarget* target,
+    virtual bool canDrawPath(const GrDrawTarget::Caps& targetCaps,
                              const SkPath& path,
-                             GrPathFill fill) const { return true; }
+                             GrPathFill fill,
+                             bool antiAlias) const SK_OVERRIDE;
 
     virtual bool requiresStencilPass(const GrDrawTarget* target,
                                      const SkPath& path,
-                                     GrPathFill fill) const;
+                                     GrPathFill fill) const SK_OVERRIDE;
 
-    virtual void drawPath(GrDrawTarget::StageBitfield stages);
-    virtual void drawPathToStencil();
+    virtual void drawPath(GrDrawTarget::StageBitfield stages) SK_OVERRIDE;
+    virtual void drawPathToStencil() SK_OVERRIDE;
 
 protected:
     virtual void pathWillClear();
diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrDrawTarget.cpp
index 0ba7ead..986dbd6 100644
--- a/src/gpu/GrDrawTarget.cpp
+++ b/src/gpu/GrDrawTarget.cpp
@@ -999,7 +999,7 @@
     // but not in a premul-alpha way. So we only use them when our alpha
     // is 0xff and tweaking the color for partial coverage is OK
     if (!fCaps.fHWAALineSupport ||
-        !(kAntialias_StateBit & fCurrDrawState.fFlagBits)) {
+        !(kHWAntialias_StateBit & fCurrDrawState.fFlagBits)) {
         return false;
     }
     BlendOptFlags opts = this->getBlendOpts();
diff --git a/src/gpu/GrDrawTarget.h b/src/gpu/GrDrawTarget.h
index 10633f5..c85fc35 100644
--- a/src/gpu/GrDrawTarget.h
+++ b/src/gpu/GrDrawTarget.h
@@ -114,23 +114,31 @@
      *  default to disabled.
      */
     enum StateBits {
-        kDither_StateBit        = 0x01, //<! Perform color dithering
-        kAntialias_StateBit     = 0x02, //<! Perform anti-aliasing. The render-
-                                        //   target must support some form of AA
-                                        //   (msaa, coverage sampling, etc). For
-                                        //   GrGpu-created rendertarget/textures
-                                        //   this is controlled by parameters
-                                        //   passed to createTexture.
-        kClip_StateBit          = 0x04, //<! Controls whether drawing is clipped
-                                        //   against the region specified by
-                                        //   setClip.
-        kNoColorWrites_StateBit = 0x08, //<! If set it disables writing colors.
-                                        //   Useful while performing stencil
-                                        //   ops.
-        kEdgeAAConcave_StateBit =  0x10,//<! If set, edge AA will test edge
-                                        //   pairs for convexity while 
-                                        //   rasterizing.  Set this if the
-                                        //   source polygon is non-convex.
+        /**
+         * Perform dithering. TODO: Re-evaluate whether we need this bit
+         */
+        kDither_StateBit        = 0x01,
+        /**
+         * Perform HW anti-aliasing. This means either HW FSAA, if supported
+         * by the render target, or smooth-line rendering if a line primitive
+         * is drawn and line smoothing is supported by the 3D API.
+         */
+        kHWAntialias_StateBit   = 0x02,
+        /**
+         * Draws will respect the clip, otherwise the clip is ignored.
+         */
+        kClip_StateBit          = 0x04,
+        /**
+         * Disables writing to the color buffer. Useful when performing stencil
+         * operations.
+         */
+        kNoColorWrites_StateBit = 0x08,
+        /**
+         * Modifies the behavior of edge AA specified by setEdgeAA. If set, 
+         * will test edge pairs for convexity when rasterizing. Set this if the 
+         * source polygon is non-convex.
+         */
+        kEdgeAAConcave_StateBit =  0x10,
         // subclass may use additional bits internally
         kDummyStateBit,
         kLastPublicStateBit = kDummyStateBit-1
@@ -477,8 +485,8 @@
         return 0 != (fCurrDrawState.fFlagBits & kDither_StateBit);
     }
 
-    bool isAntialiasState() const {
-        return 0 != (fCurrDrawState.fFlagBits & kAntialias_StateBit);
+    bool isHWAntialiasState() const {
+        return 0 != (fCurrDrawState.fFlagBits & kHWAntialias_StateBit);
     }
 
     bool isClipState() const {
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index b05f2c0..f0808d3 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -600,7 +600,7 @@
                     }
                     canRenderDirectToStencil =
                         !pr->requiresStencilPass(this, *clipPath, fill);
-                    arp.set(pr, this, clipPath, fill, NULL);
+                    arp.set(pr, this, clipPath, fill, false, NULL);
                 }
 
                 GrSetOp op = (c == start) ? startOp : clip.getOp(c);
@@ -684,7 +684,8 @@
             new GrPathRendererChain(this->getContext(),
                                     GrPathRendererChain::kNonAAOnly_UsageFlag);
     }
-    return fPathRendererChain->getPathRenderer(this, path, fill);
+    return fPathRendererChain->getPathRenderer(this->getCaps(),
+                                               path, fill, false);
 }
 
 
diff --git a/src/gpu/GrGpuGL.cpp b/src/gpu/GrGpuGL.cpp
index b27815b..077cdd9 100644
--- a/src/gpu/GrGpuGL.cpp
+++ b/src/gpu/GrGpuGL.cpp
@@ -1798,7 +1798,7 @@
                 fHWAAState.fMSAAEnabled = false;
             }
         } else if (fCurrDrawState.fRenderTarget->isMultisampled() &&
-                   !!(kAntialias_StateBit & fCurrDrawState.fFlagBits) !=
+                   SkToBool(kHWAntialias_StateBit & fCurrDrawState.fFlagBits) !=
                    fHWAAState.fMSAAEnabled) {
             if (fHWAAState.fMSAAEnabled) {
                 GL_CALL(Disable(GR_GL_MULTISAMPLE));
diff --git a/src/gpu/GrPathRenderer.cpp b/src/gpu/GrPathRenderer.cpp
index 929941a..a4f7d0c 100644
--- a/src/gpu/GrPathRenderer.cpp
+++ b/src/gpu/GrPathRenderer.cpp
@@ -16,6 +16,7 @@
 void GrPathRenderer::setPath(GrDrawTarget* target,
                              const SkPath* path,
                              GrPathFill fill,
+                             bool antiAlias,
                              const GrPoint* translate) {
     GrAssert(NULL == fPath);
     GrAssert(NULL == fTarget);
@@ -24,6 +25,7 @@
     fTarget = target;
     fPath = path;
     fFill = fill;
+    fAntiAlias = antiAlias;
     if (NULL != translate) {
         fTranslate = *translate;
     } else {
diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h
index d95cc85..a7205e5 100644
--- a/src/gpu/GrPathRenderer.h
+++ b/src/gpu/GrPathRenderer.h
@@ -24,7 +24,7 @@
  *  Paths may be drawn multiple times as when tiling for supersampling. The 
  *  calls on GrPathRenderer to draw a path will look like this:
  *  
- *  pr->setPath(target, path, fill, translate); // sets the path to draw
+ *  pr->setPath(target, path, fill, aa, translate); // sets the path to draw
  *      pr->drawPath(...);  // draw the path
  *      pr->drawPath(...);
  *      ...
@@ -54,27 +54,20 @@
      * Returns true if this path renderer is able to render the path.
      * Returning false allows the caller to fallback to another path renderer.
      * When searching for a path renderer capable of rendering a path this
-     * function is called. The path renderer can examine the path, fill rule,
-     * and draw settings that will be used (via the targetparameter). If "true"
-     * is reported note that the caller is permitted to make modifications to
-     * the following settings of the target between the calls to canDrawPath and
-     * drawPath:
-     *     1. view matrix: The matrix at drawPath time may have additional scale
-     *                     scale and translation applied
-     *     2. render target: The render target may change between canDrawPath 
-     *                       and drawPath.
-     * The GrPathRenderer subclass's decision about whether to return true
-     * or false in its implementation of this function should consider these
-     * possible state changes.
+     * function is called.
      *
-     * @param path      The path to draw
-     * @param fill      The fill rule to use
+     * @param targetCaps The caps of the draw target that will be used to draw
+     *                   the path.
+     * @param path       The path to draw
+     * @param fill       The fill rule to use
+     * @param antiAlias  True if anti-aliasing is required.
      *
      * @return  true if the path can be drawn by this object, false otherwise.
      */
-    virtual bool canDrawPath(const GrDrawTarget* target,
+    virtual bool canDrawPath(const GrDrawTarget::Caps& targetCaps,
                              const SkPath& path,
-                             GrPathFill fill) const = 0;
+                             GrPathFill fill,
+                             bool antiAlias) const = 0;
 
     /**
      * For complex clips Gr uses the stencil buffer. The path renderer must be
@@ -102,15 +95,6 @@
                                      GrPathFill fill) const { return false; }
 
     /**
-     * @return true if the path renderer can perform anti-aliasing (aside from
-     * having FSAA enabled for a render target). Target is provided to
-     * communicate the draw state (blend mode, stage settings, etc).
-     */
-    virtual bool supportsAA(const GrDrawTarget* target,
-                            const SkPath& path,
-                            GrPathFill fill) const { return false; }
-
-    /**
      * Sets the path to render and target to render into. All calls to drawPath
      * and drawPathToStencil must occur between setPath and clearPath. The
      * path cannot be modified externally between setPath and clearPath. The
@@ -125,12 +109,14 @@
      * @param target                the target to draw into.
      * @param path                  the path to draw.
      * @param fill                  the fill rule to apply.
+     * @param antiAlias             perform antiAliasing when drawing the path.
      * @param translate             optional additional translation to apply to
      *                              the path. NULL means (0,0).
      */
     void setPath(GrDrawTarget* target,
                  const SkPath* path,
                  GrPathFill fill,
+                 bool antiAlias,
                  const GrPoint* translate);
 
     /**
@@ -179,24 +165,26 @@
             fPathRenderer = NULL;
         }
         AutoClearPath(GrPathRenderer* pr,
-                       GrDrawTarget* target,
-                       const SkPath* path,
-                       GrPathFill fill,
-                       const GrPoint* translate) {
+                      GrDrawTarget* target,
+                      const SkPath* path,
+                      GrPathFill fill,
+                      bool antiAlias,
+                      const GrPoint* translate) {
             GrAssert(NULL != pr);
-            pr->setPath(target, path, fill, translate);
+            pr->setPath(target, path, fill, antiAlias, translate);
             fPathRenderer = pr;
         }
         void set(GrPathRenderer* pr,
                  GrDrawTarget* target,
                  const SkPath* path,
                  GrPathFill fill,
+                 bool antiAlias,
                  const GrPoint* translate) {
             if (NULL != fPathRenderer) {
                 fPathRenderer->clearPath();
             }
             GrAssert(NULL != pr);
-            pr->setPath(target, path, fill, translate);
+            pr->setPath(target, path, fill, antiAlias, translate);
             fPathRenderer = pr;
         }
         ~AutoClearPath() {
@@ -219,6 +207,7 @@
     GrDrawTarget*               fTarget;
     GrPathFill                  fFill;
     GrPoint                     fTranslate;
+    bool                        fAntiAlias;
 
 private:
 
diff --git a/src/gpu/GrPathRendererChain.cpp b/src/gpu/GrPathRendererChain.cpp
index 7a064e8..a45437b 100644
--- a/src/gpu/GrPathRendererChain.cpp
+++ b/src/gpu/GrPathRendererChain.cpp
@@ -32,25 +32,20 @@
     return pr;
 }
 
-GrPathRenderer* GrPathRendererChain::getPathRenderer(const GrDrawTarget* target,
-                                                     const GrPath& path,
-                                                     GrPathFill fill) {
+GrPathRenderer* GrPathRendererChain::getPathRenderer(
+                                        const GrDrawTarget::Caps& targetCaps,
+                                        const GrPath& path,
+                                        GrPathFill fill,
+                                        bool antiAlias) {
     if (!fInit) {
         this->init();
     }
-    bool preferAA = target->isAntialiasState() && 
-                    !target->getRenderTarget()->isMultisampled();
-    GrPathRenderer* nonAAPR = NULL;
     for (int i = 0; i < fChain.count(); ++i) {
-        if (fChain[i]->canDrawPath(target, path, fill)) {
-            if (!preferAA || fChain[i]->supportsAA(target, path, fill)) {
-                return fChain[i];
-            } else {
-                nonAAPR = fChain[i];
-            }
+        if (fChain[i]->canDrawPath(targetCaps, path, fill, antiAlias)) {
+            return fChain[i];
         }
     }
-    return nonAAPR;
+    return NULL;
 }
 
 void GrPathRendererChain::init() {
diff --git a/src/gpu/GrPathRendererChain.h b/src/gpu/GrPathRendererChain.h
index 5719484..8f95ea3 100644
--- a/src/gpu/GrPathRendererChain.h
+++ b/src/gpu/GrPathRendererChain.h
@@ -10,11 +10,12 @@
 #ifndef GrPathRendererChain_DEFINED
 #define GrPathRendererChain_DEFINED
 
+#include "GrDrawTarget.h"
 #include "GrRefCnt.h"
 #include "SkTArray.h"
 
 class GrContext;
-class GrDrawTarget;
+
 class SkPath;
 class GrPathRenderer;
 
@@ -39,9 +40,10 @@
     // takes a ref and unrefs in destructor
     GrPathRenderer* addPathRenderer(GrPathRenderer* pr);
 
-    GrPathRenderer* getPathRenderer(const GrDrawTarget* target,
+    GrPathRenderer* getPathRenderer(const GrDrawTarget::Caps& targetCaps,
                                     const SkPath& path,
-                                    GrPathFill fill);
+                                    GrPathFill fill,
+                                    bool antiAlias);
 
 private:
 
diff --git a/src/gpu/GrTesselatedPathRenderer.cpp b/src/gpu/GrTesselatedPathRenderer.cpp
index 3c4bb01..5c5a50e 100644
--- a/src/gpu/GrTesselatedPathRenderer.cpp
+++ b/src/gpu/GrTesselatedPathRenderer.cpp
@@ -457,7 +457,7 @@
     }
 
     if (subpathCnt == 1 && !inverted && fPath->isConvex()) {
-        if (fTarget->isAntialiasState()) {
+        if (fAntiAlias) {
             GrEdgeArray edges;
             GrMatrix inverse, matrix = fTarget->getViewMatrix();
             fTarget->getViewInverse(&inverse);
@@ -492,7 +492,7 @@
         return;
     }
 
-    if (fTarget->isAntialiasState()) {
+    if (fAntiAlias) {
         // Run the tesselator once to get the boundaries.
         GrBoundaryTess btess(count, fill_type_to_glu_winding_rule(fFill));
         btess.addVertices(base, subpathVertCount, subpathCnt);
@@ -590,9 +590,10 @@
     }
 }
 
-bool GrTesselatedPathRenderer::canDrawPath(const GrDrawTarget* target,
+bool GrTesselatedPathRenderer::canDrawPath(const GrDrawTarget::Caps& caps,
                                            const SkPath& path,
-                                           GrPathFill fill) const {
+                                           GrPathFill fill,
+                                           bool antiAlias) const {
     return kHairLine_PathFill != fill;
 }
 
@@ -600,8 +601,3 @@
     GrAlwaysAssert(!"multipass stencil should not be needed");
 }
 
-bool GrTesselatedPathRenderer::supportsAA(const GrDrawTarget* target,
-                                          const SkPath& path,
-                                          GrPathFill fill) const {
-    return true;
-}
diff --git a/src/gpu/GrTesselatedPathRenderer.h b/src/gpu/GrTesselatedPathRenderer.h
index d4f2243..18cead2 100644
--- a/src/gpu/GrTesselatedPathRenderer.h
+++ b/src/gpu/GrTesselatedPathRenderer.h
@@ -17,17 +17,11 @@
     GrTesselatedPathRenderer();
 
     virtual void drawPath(GrDrawTarget::StageBitfield stages);
-    virtual bool canDrawPath(const GrDrawTarget* target,
+    virtual bool canDrawPath(const GrDrawTarget::Caps& targetCaps,
                              const GrPath& path,
-                             GrPathFill fill) const;
-
-    virtual bool requiresStencilPass(const GrDrawTarget* target,
-                                     const GrPath& path,
-                                     GrPathFill fill) const { return false; }
-    virtual void drawPathToStencil();
-    virtual bool supportsAA(const GrDrawTarget* target,
-                            const GrPath& path,
-                            GrPathFill fill) const;
+                             GrPathFill fill,
+                             bool antiAlias) const SK_OVERRIDE;
+    virtual void drawPathToStencil() SK_OVERRIDE;
 };
 
 #endif