diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
index 37ac1c4..eeb96cc 100644
--- a/gpu/include/GrContext.h
+++ b/gpu/include/GrContext.h
@@ -592,8 +592,7 @@
     struct OffscreenRecord;
 
     // determines whether offscreen AA should be applied
-    bool doOffscreenAA(GrDrawTarget* target, 
-                       const GrPaint& paint,
+    bool doOffscreenAA(GrDrawTarget* target,
                        bool isHairLines) const;
 
     // attempts to setup offscreen AA. All paint state must be transferred to
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index ee38d72..23ad9e1 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -29,6 +29,10 @@
 
 #define BATCH_RECT_TO_RECT (1 && !GR_STATIC_RECT_VB)
 
+// When we're using coverage AA but the blend is incompatible (given gpu
+// limitations) should we disable AA or draw wrong?
+#define DISABLE_COVERAGE_AA_FOR_BLEND 0
+
 static const size_t MAX_TEXTURE_CACHE_COUNT = 256;
 static const size_t MAX_TEXTURE_CACHE_BYTES = 16 * 1024 * 1024;
 
@@ -632,6 +636,12 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
+namespace {
+inline bool disable_coverage_aa_for_blend(GrDrawTarget* target) {
+    return DISABLE_COVERAGE_AA_FOR_BLEND && !target->canApplyCoverage();
+}
+}
+
 struct GrContext::OffscreenRecord {
     enum Downsample {
         k4x4TwoPass_Downsample,
@@ -650,12 +660,11 @@
 };
 
 bool GrContext::doOffscreenAA(GrDrawTarget* target,
-                              const GrPaint& paint,
                               bool isHairLines) const {
 #if !GR_USE_OFFSCREEN_AA
     return false;
 #else
-    if (!paint.fAntiAlias) {
+    if (!target->isAntialiasState()) {
         return false;
     }
     // Line primitves are always rasterized as 1 pixel wide.
@@ -667,14 +676,7 @@
     if (target->getRenderTarget()->isMultisampled()) {
         return false;
     }
-    // we have to be sure that the blend equation is expressible
-    // as simple src / dst coeffecients when the source 
-    // is already modulated by the coverage fraction.
-    // We could use dual-source blending to get the correct per-pixel
-    // dst coeffecient for the remaining cases.
-    if (kISC_BlendCoeff != paint.fDstBlendCoeff &&
-        kOne_BlendCoeff != paint.fDstBlendCoeff &&
-        kISA_BlendCoeff != paint.fDstBlendCoeff) {
+    if (disable_coverage_aa_for_blend(target)) {
         return false;
     }
     return true;
@@ -1139,7 +1141,6 @@
 }
 
 static bool apply_aa_to_rect(GrDrawTarget* target,
-                             const GrPaint& paint,
                              const GrRect& rect,
                              GrScalar width, 
                              const GrMatrix* matrix,
@@ -1150,7 +1151,11 @@
     // will be axis-aligned,the render target is not
     // multisampled, and the rect won't land on integer coords.
 
-    if (!paint.fAntiAlias) {
+    if (!target->isAntialiasState()) {
+        return false;
+    }
+
+    if (!target->canTweakAlphaForCoverage()) {
         return false;
     }
 
@@ -1198,7 +1203,7 @@
 
     GrRect devRect = rect;
     GrMatrix combinedMatrix;
-    bool doAA = apply_aa_to_rect(target, paint, rect, width, matrix,
+    bool doAA = apply_aa_to_rect(target, rect, width, matrix,
                                  &combinedMatrix, &devRect);
 
     if (doAA) {
@@ -1440,6 +1445,15 @@
                          GrPathFill fill, const GrPoint* translate) {
 
     GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+
+    // 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
+    // thing WRT to the blend then we'll need some query on the PR.
+    if (disable_coverage_aa_for_blend(target)) {
+        target->disableState(GrDrawTarget::kAntialias_StateBit);
+    }
+    
     GrPathRenderer* pr = this->getPathRenderer(target, path, fill);
     if (NULL == pr) {
         GrPrintf("Unable to find path renderer compatible with path.\n");
@@ -1450,7 +1464,7 @@
     GrDrawTarget::StageBitfield stageMask = paint.getActiveStageMask();
 
     if (!pr->supportsAA(target, path, fill) &&
-        this->doOffscreenAA(target, paint, kHairLine_PathFill == fill)) {
+        this->doOffscreenAA(target, kHairLine_PathFill == fill)) {
 
         bool needsStencil = pr->requiresStencilPass(target, path, fill);
 
@@ -1666,6 +1680,10 @@
     }
     target->setBlendFunc(paint.fSrcBlendCoeff, paint.fDstBlendCoeff);
     target->setColorFilter(paint.fColorFilterColor, paint.fColorFilterXfermode);
+
+    if (paint.getActiveMaskStageMask() && !target->canApplyCoverage()) {
+        GrPrintf("Partial pixel coverage will be incorrectly blended.\n");
+    }
 }
 
 GrDrawTarget* GrContext::prepareToDraw(const GrPaint& paint,
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index bfcc07d..59661d8 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -744,6 +744,25 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
+// Some blend modes allow folding a partial coverage value into the color's
+// alpha channel, while others will blend incorrectly.
+bool GrDrawTarget::CanTweakAlphaForCoverage(GrBlendCoeff dstCoeff) {
+    /**
+     * The fractional coverage is f
+     * The src and dst coeffs are Cs and Cd
+     * The dst and src colors are S and D
+     * We want the blend to compute: f*Cs*S + (f*Cd + (1-f))D
+     * By tweaking the source color's alpha we're replacing S with S'=fS. It's
+     * obvious that that first term will always be ok. The second term can be
+     * rearranged as [1-(1-Cd)f]D. By substituing in the various possbilities
+     * for Cd we find that only 1, ISA, and ISC produce the correct depth
+     * coeffecient in terms of S' and D.
+     */
+    return kOne_BlendCoeff == dstCoeff ||
+           kISA_BlendCoeff == dstCoeff ||
+           kISC_BlendCoeff == dstCoeff;
+}
+
 bool GrDrawTarget::CanDisableBlend(GrVertexLayout layout, const DrState& state) {
     // If we compute a coverage value (using edge AA or a coverage stage) then
     // we can't force blending off.
@@ -808,9 +827,15 @@
     // there is a conflict between using smooth lines and our use of
     // premultiplied alpha. Smooth lines tweak the incoming alpha value
     // but not in a premul-alpha way. So we only use them when our alpha
-    // is 0xff.
+    // is 0xff and tweaking the color for partial coverage is OK
     return (kAntialias_StateBit & state.fFlagBits) &&
-           CanDisableBlend(layout, state);
+           CanDisableBlend(layout, state) &&
+           CanTweakAlphaForCoverage(state.fDstBlend);
+}
+
+bool GrDrawTarget::canApplyCoverage() const {
+    return this->getCaps().fDualSourceBlendingSupport ||
+           CanTweakAlphaForCoverage(fCurrDrawState.fDstBlend);
 }
 
 bool GrDrawTarget::canDisableBlend() const {
diff --git a/gpu/src/GrDrawTarget.h b/gpu/src/GrDrawTarget.h
index a57ff81..f1c98e8 100644
--- a/gpu/src/GrDrawTarget.h
+++ b/gpu/src/GrDrawTarget.h
@@ -595,6 +595,28 @@
      */
     bool canDisableBlend() const;
 
+    /**
+     * Color alpha and coverage are two inputs to the drawing pipeline. For some
+     * blend modes it is safe to fold the coverage into constant or per-vertex
+     * color alpha value. For other blend modes they must be handled separately.
+     * Depending on features available in the underlying 3D API this may or may
+     * not be possible.
+     *
+     * This function looks at the current blend on the draw target and the draw
+     * target's capabilities to determine whether coverage can be handled
+     * correctly.
+     */
+    bool canApplyCoverage() const;
+
+    /**
+     * Determines whether incorporating partial pixel coverage into the constant
+     * color specified by setColor or per-vertex colors will give the right
+     * blending result.
+     */
+    bool canTweakAlphaForCoverage() const {
+        return CanTweakAlphaForCoverage(fCurrDrawState.fDstBlend);
+    }
+
      /**
       * Determines the interpretation per-vertex edge data when the
       * kEdge_VertexLayoutBit is set (see below). When per-vertex edges are not
@@ -1227,6 +1249,10 @@
 
 protected:
 
+    // Determines whether it is correct to apply partial pixel coverage
+    // by multiplying the src color by the fractional coverage.
+    static bool CanTweakAlphaForCoverage(GrBlendCoeff dstCoeff);
+    
     // determines whether HW blending can be disabled or not
     static bool CanDisableBlend(GrVertexLayout layout, const DrState& state);