Revert "Reland "Remove antialiasing control from GrPaint.""

This reverts commit 3944484020d98ff8f386378296106c321279482b.

Reason for revert: Merges badly with a recent change. Will rebase and reland.

Original change's description:
> Reland "Remove antialiasing control from GrPaint."
> 
> This contains fixes for GLPrograms test and mixed samples rendering.
> 
> This reverts commit 419d81eed4a010e6080db199795117cbedf9e6e4.
> 
> BUG=skia:
> 
> Change-Id: If8f002fbfaaaab6d1607403f2b15ccc7f1e17e87
> Reviewed-on: https://skia-review.googlesource.com/5763
> Commit-Queue: Brian Salomon <bsalomon@google.com>
> Reviewed-by: Robert Phillips <robertphillips@google.com>
> 

TBR=bsalomon@google.com,robertphillips@google.com,reviews@skia.org
BUG=skia:
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Change-Id: Iff9657041e28604a845bc5a9acec7c9b248c53bd
Reviewed-on: https://skia-review.googlesource.com/5772
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>

55 files changed, 519 insertions, 514 deletions

diff --git a/src/core/SkGpuBlurUtils.cpp b/src/core/SkGpuBlurUtils.cpp
index e3463a4b78..2ae398df85 100644
--- a/src/core/SkGpuBlurUtils.cpp
+++ b/src/core/SkGpuBlurUtils.cpp
@@ -84,7 +84,7 @@ static void convolve_gaussian_1d(GrRenderTargetContext* renderTargetContext,
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
     SkMatrix localMatrix = SkMatrix::MakeTrans(-SkIntToScalar(srcOffset.x()),
                                                -SkIntToScalar(srcOffset.y()));
-    renderTargetContext->fillRectWithLocalMatrix(clip, paint, GrAA::kNo, SkMatrix::I(),
+    renderTargetContext->fillRectWithLocalMatrix(clip, paint, SkMatrix::I(),
                                                  SkRect::Make(dstRect), localMatrix);
 }
 
@@ -112,7 +112,7 @@ static void convolve_gaussian_2d(GrRenderTargetContext* renderTargetContext,
             true, sigmaX, sigmaY));
     paint.addColorFragmentProcessor(std::move(conv));
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
-    renderTargetContext->fillRectWithLocalMatrix(clip, paint, GrAA::kNo, SkMatrix::I(),
+    renderTargetContext->fillRectWithLocalMatrix(clip, paint, SkMatrix::I(),
                                                  SkRect::Make(dstRect), localMatrix);
 }
 
@@ -289,7 +289,7 @@ sk_sp<GrRenderTargetContext> GaussianBlur(GrContext* context,
         paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
         shrink_irect_by_2(&dstRect, i < scaleFactorX, i < scaleFactorY);
 
-        dstRenderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(),
+        dstRenderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(),
                                                SkRect::Make(dstRect), SkRect::Make(srcRect));
 
         srcRenderTargetContext = dstRenderTargetContext;
@@ -381,7 +381,7 @@ sk_sp<GrRenderTargetContext> GaussianBlur(GrContext* context,
         SkIRect dstRect(srcRect);
         scale_irect(&dstRect, scaleFactorX, scaleFactorY);
 
-        dstRenderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(),
+        dstRenderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(),
                                                SkRect::Make(dstRect), SkRect::Make(srcRect));
 
         srcRenderTargetContext = dstRenderTargetContext;
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index 2ec441f108..df46a13d3c 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -297,7 +297,7 @@ sk_sp<SkSpecialImage> SkImageFilter::DrawWithFP(GrContext* context,
     SkRect srcRect = SkRect::Make(bounds);
     SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height());
     GrFixedClip clip(dstIRect);
-    renderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(), dstRect, srcRect);
+    renderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
 
     return SkSpecialImage::MakeDeferredFromGpu(context, dstIRect,
                                                kNeedNewImageUniqueID_SpecialImage,
diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index 6cf1ce61e4..43751e1199 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -114,7 +114,7 @@ sk_sp<GrTextureProxy> SkAlphaThresholdFilterImpl::createMaskTexture(GrContext* c
     GrFixedClip clip(SkIRect::MakeWH(bounds.width(), bounds.height()));
     while (!iter.done()) {
         SkRect rect = SkRect::Make(iter.rect());
-        rtContext->drawRect(clip, grPaint, GrAA::kNo, inMatrix, rect);
+        rtContext->drawRect(clip, grPaint, inMatrix, rect);
         iter.next();
     }
 
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 0b1d1db6fb..e8867ead76 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -1060,8 +1060,7 @@ bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider,
         return false;
     }
 
-    renderTargetContext->fillRectWithLocalMatrix(clip, *grp, GrAA::kNo, SkMatrix::I(), rect,
-                                                 inverse);
+    renderTargetContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), rect, inverse);
     return true;
 }
 
@@ -1104,7 +1103,8 @@ private:
 static sk_sp<GrTexture> find_or_create_rrect_blur_mask(GrContext* context,
                                                        const SkRRect& rrectToDraw,
                                                        const SkISize& size,
-                                                       float xformedSigma) {
+                                                       float xformedSigma,
+                                                       bool doAA) {
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey key;
     GrUniqueKey::Builder builder(&key, kDomain, 9);
@@ -1129,10 +1129,10 @@ static sk_sp<GrTexture> find_or_create_rrect_blur_mask(GrContext* context,
         }
 
         GrPaint grPaint;
+        grPaint.setAntiAlias(doAA);
 
         rtc->clear(nullptr, 0x0, true);
-        rtc->drawRRect(GrNoClip(), grPaint, GrAA::kYes, SkMatrix::I(), rrectToDraw,
-                       GrStyle::SimpleFill());
+        rtc->drawRRect(GrNoClip(), grPaint, SkMatrix::I(), rrectToDraw, GrStyle::SimpleFill());
 
         sk_sp<GrTexture> srcTexture(rtc->asTexture());
         if (!srcTexture) {
@@ -1192,7 +1192,8 @@ sk_sp<GrFragmentProcessor> GrRRectBlurEffect::Make(GrContext* context,
         return nullptr;
     }
 
-    sk_sp<GrTexture> mask(find_or_create_rrect_blur_mask(context, rrectToDraw, size, xformedSigma));
+    sk_sp<GrTexture> mask(find_or_create_rrect_blur_mask(context, rrectToDraw, size,
+                                                         xformedSigma, true));
     if (!mask) {
         return nullptr;
     }
@@ -1379,11 +1380,12 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context,
 
         GrPaint newPaint(*grp);
         newPaint.addCoverageFragmentProcessor(std::move(fp));
+        newPaint.setAntiAlias(false);
 
         SkRect srcProxyRect = srcRRect.rect();
         srcProxyRect.outset(3.0f*fSigma, 3.0f*fSigma);
 
-        renderTargetContext->drawRect(clip, newPaint, GrAA::kNo, viewMatrix, srcProxyRect);
+        renderTargetContext->drawRect(clip, newPaint, viewMatrix, srcProxyRect);
         return true;
     }
 
@@ -1395,6 +1397,7 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context,
 
     GrPaint newPaint(*grp);
     newPaint.addCoverageFragmentProcessor(std::move(fp));
+    newPaint.setAntiAlias(false);
 
     if (!this->ignoreXform()) {
         SkRect srcProxyRect = srcRRect.rect();
@@ -1441,8 +1444,8 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context,
         proxyRect.outset(extra, extra);
 
 
-        renderTargetContext->fillRectWithLocalMatrix(clip, newPaint, GrAA::kNo, SkMatrix::I(),
-                                                     proxyRect, inverse);
+        renderTargetContext->fillRectWithLocalMatrix(clip, newPaint, SkMatrix::I(), proxyRect,
+                                                     inverse);
     }
 
     return true;
@@ -1535,8 +1538,7 @@ bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src,
             paint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
         }
 
-        renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(),
-                                      SkRect::Make(clipRect));
+        renderTargetContext->drawRect(GrNoClip(), paint, SkMatrix::I(), SkRect::Make(clipRect));
     }
 
     *result = renderTargetContext->asTexture().release();
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index 661dacd53b..2d79f9ac87 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -360,8 +360,7 @@ sk_sp<SkSpecialImage> SkDisplacementMapEffect::onFilterImage(SkSpecialImage* sou
         }
         paint.setGammaCorrect(renderTargetContext->isGammaCorrect());
 
-        renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, matrix,
-                                      SkRect::Make(colorBounds));
+        renderTargetContext->drawRect(GrNoClip(), paint, matrix, SkRect::Make(colorBounds));
 
         offset->fX = bounds.left();
         offset->fY = bounds.top();
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 52c8947cc4..75947e8711 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -400,7 +400,7 @@ void SkLightingImageFilterInternal::drawRect(GrRenderTargetContext* renderTarget
                                                               boundaryMode));
     paint.addColorFragmentProcessor(std::move(fp));
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
-    renderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(), dstRect, srcRect);
+    renderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
 }
 
 sk_sp<SkSpecialImage> SkLightingImageFilterInternal::filterImageGPU(
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index 130f099d85..2fa67a4aeb 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -407,8 +407,7 @@ static void apply_morphology_rect(GrTextureProvider* provider,
     paint.addColorFragmentProcessor(GrMorphologyEffect::Make(tex, direction, radius, morphType,
                                                              bounds));
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
-    renderTargetContext->fillRectToRect(clip, paint, GrAA::kNo,
-                                        SkMatrix::I(), SkRect::Make(dstRect),
+    renderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
                                         SkRect::Make(srcRect));
 }
 
@@ -429,8 +428,8 @@ static void apply_morphology_rect_no_bounds(GrTextureProvider* provider,
     }
     paint.addColorFragmentProcessor(GrMorphologyEffect::Make(tex, direction, radius, morphType));
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
-    renderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(),
-                                        SkRect::Make(dstRect), SkRect::Make(srcRect));
+    renderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
+                                        SkRect::Make(srcRect));
 }
 
 static void apply_morphology_pass(GrTextureProvider* provider,
diff --git a/src/effects/SkShadowMaskFilter.cpp b/src/effects/SkShadowMaskFilter.cpp
index 5c54072f4e..958ab170a7 100755
--- a/src/effects/SkShadowMaskFilter.cpp
+++ b/src/effects/SkShadowMaskFilter.cpp
@@ -252,6 +252,7 @@ bool SkShadowMaskFilterImpl::directFilterRRectMaskGPU(GrContext*,
         const SkScalar devSpaceAmbientRadius = srcSpaceAmbientRadius * scaleFactor;
 
         GrPaint newPaint(*grp);
+        newPaint.setAntiAlias(true);
         GrColor4f color = newPaint.getColor4f();
         color.fRGBA[3] *= fAmbientAlpha;
         newPaint.setColor4f(color);
@@ -310,6 +311,7 @@ bool SkShadowMaskFilterImpl::directFilterRRectMaskGPU(GrContext*,
                               (spotShadowRRect.width() + srcSpaceSpotRadius);
 
         GrPaint newPaint(*grp);
+        newPaint.setAntiAlias(true);
         GrColor4f color = newPaint.getColor4f();
         color.fRGBA[3] *= fSpotAlpha;
         newPaint.setColor4f(color);
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index 3a1e6e28e3..82d5156a28 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -303,7 +303,7 @@ sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::filterImageGPU(
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
-    renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, matrix, SkRect::Make(bounds));
+    renderTargetContext->drawRect(GrNoClip(), paint, matrix, SkRect::Make(bounds));
 
     return SkSpecialImage::MakeDeferredFromGpu(context,
                                                SkIRect::MakeWH(bounds.width(), bounds.height()),
diff --git a/src/gpu/GrBlurUtils.cpp b/src/gpu/GrBlurUtils.cpp
index 768860525f..4d89bef63c 100644
--- a/src/gpu/GrBlurUtils.cpp
+++ b/src/gpu/GrBlurUtils.cpp
@@ -45,8 +45,8 @@ static bool draw_mask(GrRenderTargetContext* renderTargetContext,
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
-    renderTargetContext->fillRectWithLocalMatrix(clip, *grp, GrAA::kNo, SkMatrix::I(),
-                                                 SkRect::Make(maskRect), inverse);
+    renderTargetContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), SkRect::Make(maskRect),
+                                                 inverse);
     return true;
 }
 
@@ -98,9 +98,9 @@ static sk_sp<GrTextureProxy> create_mask_GPU(GrContext* context,
                                              const SkIRect& maskRect,
                                              const SkPath& devPath,
                                              SkStrokeRec::InitStyle fillOrHairline,
-                                             GrAA aa,
+                                             bool doAA,
                                              int sampleCnt) {
-    if (GrAA::kNo == aa) {
+    if (!doAA) {
         // Don't need MSAA if mask isn't AA
         sampleCnt = 0;
     }
@@ -115,6 +115,7 @@ static sk_sp<GrTextureProxy> create_mask_GPU(GrContext* context,
     rtContext->priv().absClear(nullptr, 0x0);
 
     GrPaint tempPaint;
+    tempPaint.setAntiAlias(doAA);
     tempPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
 
     // setup new clip
@@ -125,7 +126,7 @@ static sk_sp<GrTextureProxy> create_mask_GPU(GrContext* context,
     // the origin using tempPaint.
     SkMatrix translate;
     translate.setTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop));
-    rtContext->drawPath(clip, tempPaint, aa, translate, devPath, GrStyle(fillOrHairline));
+    rtContext->drawPath(clip, tempPaint, translate, devPath, GrStyle(fillOrHairline));
     return sk_ref_sp(rtContext->asDeferredTexture());
 }
 
@@ -133,7 +134,6 @@ static void draw_path_with_mask_filter(GrContext* context,
                                        GrRenderTargetContext* renderTargetContext,
                                        const GrClip& clip,
                                        GrPaint* paint,
-                                       GrAA aa,
                                        const SkMatrix& viewMatrix,
                                        const SkMaskFilter* maskFilter,
                                        const GrStyle& style,
@@ -211,7 +211,7 @@ static void draw_path_with_mask_filter(GrContext* context,
                                                         finalIRect,
                                                         *path,
                                                         fillOrHairline,
-                                                        aa,
+                                                        paint->isAntiAlias(),
                                                         renderTargetContext->numColorSamples()));
         if (maskProxy) {
             GrTexture* filtered;
@@ -242,12 +242,11 @@ void GrBlurUtils::drawPathWithMaskFilter(GrContext* context,
                                          const GrClip& clip,
                                          const SkPath& path,
                                          GrPaint* paint,
-                                         GrAA aa,
                                          const SkMatrix& viewMatrix,
                                          const SkMaskFilter* mf,
                                          const GrStyle& style,
                                          bool pathIsMutable) {
-    draw_path_with_mask_filter(context, renderTargetContext, clip, paint, aa, viewMatrix, mf,
+    draw_path_with_mask_filter(context, renderTargetContext, clip, paint, viewMatrix, mf,
                                style, &path, pathIsMutable);
 }
 
@@ -291,14 +290,14 @@ void GrBlurUtils::drawPathWithMaskFilter(GrContext* context,
     if (!SkPaintToGrPaint(context, renderTargetContext, paint, viewMatrix, &grPaint)) {
         return;
     }
-    GrAA aa = GrBoolToAA(paint.isAntiAlias());
+
     SkMaskFilter* mf = paint.getMaskFilter();
     if (mf && !mf->asFragmentProcessor(nullptr, nullptr, viewMatrix)) {
         // The MaskFilter wasn't already handled in SkPaintToGrPaint
-        draw_path_with_mask_filter(context, renderTargetContext, clip, &grPaint, aa, viewMatrix,
+        draw_path_with_mask_filter(context, renderTargetContext, clip, &grPaint, viewMatrix,
                                    mf, style,
                                    path, pathIsMutable);
     } else {
-        renderTargetContext->drawPath(clip, grPaint, aa, viewMatrix, *path, style);
+        renderTargetContext->drawPath(clip, grPaint, viewMatrix, *path, style);
     }
 }
diff --git a/src/gpu/GrBlurUtils.h b/src/gpu/GrBlurUtils.h
index be0d2fb33c..090448fb6e 100644
--- a/src/gpu/GrBlurUtils.h
+++ b/src/gpu/GrBlurUtils.h
@@ -8,13 +8,11 @@
 #ifndef GrBlurUtils_DEFINED
 #define GrBlurUtils_DEFINED
 
-#include "GrTypes.h"
-
 class GrClip;
 class GrContext;
+class GrRenderTargetContext;
 class GrPaint;
 class GrRenderTarget;
-class GrRenderTargetContext;
 class GrStyle;
 struct SkIRect;
 class SkMaskFilter;
@@ -50,7 +48,6 @@ namespace GrBlurUtils {
                                 const GrClip&,
                                 const SkPath& path,
                                 GrPaint*,
-                                GrAA,
                                 const SkMatrix& viewMatrix,
                                 const SkMaskFilter*,
                                 const GrStyle&,
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index 1172bc6a7b..e2ce0464f0 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -42,7 +42,7 @@ bool GrClipStackClip::quickContains(const SkRRect& rrect) const {
                                                   SkIntToScalar(fOrigin.fY)));
 }
 
-bool GrClipStackClip::isRRect(const SkRect& origRTBounds, SkRRect* rr, GrAA* aa) const {
+bool GrClipStackClip::isRRect(const SkRect& origRTBounds, SkRRect* rr, bool* aa) const {
     if (!fStack) {
         return false;
     }
@@ -54,9 +54,7 @@ bool GrClipStackClip::isRRect(const SkRect& origRTBounds, SkRRect* rr, GrAA* aa)
         tempRTBounds.offset(SkIntToScalar(fOrigin.fX), SkIntToScalar(fOrigin.fY));
         rtBounds = &tempRTBounds;
     }
-    bool isAA;
-    if (fStack->isRRect(*rtBounds, rr, &isAA)) {
-        *aa = GrBoolToAA(isAA);
+    if (fStack->isRRect(*rtBounds, rr, aa)) {
         if (origin) {
             rr->offset(-SkIntToScalar(fOrigin.fX), -SkIntToScalar(fOrigin.fY));
         }
@@ -134,16 +132,9 @@ bool GrClipStackClip::PathNeedsSWRenderer(GrContext* context,
         canDrawArgs.fShaderCaps = context->caps()->shaderCaps();
         canDrawArgs.fViewMatrix = &viewMatrix;
         canDrawArgs.fShape = &shape;
-        if (!element->isAA()) {
-            canDrawArgs.fAAType = GrAAType::kNone;
-        } else if (renderTargetContext->isUnifiedMultisampled()) {
-            canDrawArgs.fAAType = GrAAType::kMSAA;
-        } else if (renderTargetContext->isStencilBufferMultisampled()){
-            canDrawArgs.fAAType = GrAAType::kMixedSamples;
-        } else {
-            canDrawArgs.fAAType = GrAAType::kCoverage;
-        }
+        canDrawArgs.fAntiAlias = element->isAA();
         canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
+        canDrawArgs.fIsStencilBufferMSAA = renderTargetContext->isStencilBufferMultisampled();
 
         // the 'false' parameter disallows use of the SW path renderer
         GrPathRenderer* pr =
@@ -459,7 +450,6 @@ sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texP
     for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkClipOp op = element->getOp();
-        GrAA aa = GrBoolToAA(element->isAA());
 
         if (kIntersect_SkClipOp == op || kReverseDifference_SkClipOp == op) {
             // Intersect and reverse difference require modifying pixels outside of the geometry
@@ -469,25 +459,25 @@ sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texP
             if (kReverseDifference_SkClipOp == op) {
                 SkRect temp = SkRect::Make(reducedClip.ibounds());
                 // invert the entire scene
-                helper.drawRect(temp, SkRegion::kXOR_Op, GrAA::kNo, 0xFF);
+                helper.drawRect(temp, SkRegion::kXOR_Op, false, 0xFF);
             }
             SkPath clipPath;
             element->asPath(&clipPath);
             clipPath.toggleInverseFillType();
             GrShape shape(clipPath, GrStyle::SimpleFill());
-            helper.drawShape(shape, SkRegion::kReplace_Op, aa, 0x00);
+            helper.drawShape(shape, SkRegion::kReplace_Op, element->isAA(), 0x00);
             continue;
         }
 
         // The other ops (union, xor, diff) only affect pixels inside
         // the geometry so they can just be drawn normally
         if (Element::kRect_Type == element->getType()) {
-            helper.drawRect(element->getRect(), (SkRegion::Op)op, aa, 0xFF);
+            helper.drawRect(element->getRect(), (SkRegion::Op)op, element->isAA(), 0xFF);
         } else {
             SkPath path;
             element->asPath(&path);
             GrShape shape(path, GrStyle::SimpleFill());
-            helper.drawShape(shape, (SkRegion::Op)op, aa, 0xFF);
+            helper.drawShape(shape, (SkRegion::Op)op, element->isAA(), 0xFF);
         }
     }
 
diff --git a/src/gpu/GrClipStackClip.h b/src/gpu/GrClipStackClip.h
index 42bd373b09..afda3eb43c 100644
--- a/src/gpu/GrClipStackClip.h
+++ b/src/gpu/GrClipStackClip.h
@@ -38,7 +38,7 @@ public:
     bool apply(GrContext*, GrRenderTargetContext*, bool useHWAA, bool hasUserStencilSettings,
                GrAppliedClip* out) const final;
 
-    bool isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA* aa) const override;
+    bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const override;
 
 private:
     static bool PathNeedsSWRenderer(GrContext* context,
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index ff5b0266e6..34b9abff68 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -366,7 +366,7 @@ bool GrContext::writeSurfacePixels(GrSurface* surface,
             paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
             paint.setAllowSRGBInputs(true);
             SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
-            renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, matrix, rect, nullptr);
+            renderTargetContext->drawRect(GrNoClip(), paint, matrix, rect, nullptr);
 
             if (kFlushWrites_PixelOp & pixelOpsFlags) {
                 this->flushSurfaceWrites(surface);
@@ -486,7 +486,7 @@ bool GrContext::readSurfacePixels(GrSurface* src,
                 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
                 paint.setAllowSRGBInputs(true);
                 SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
-                tempRTC->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), rect, nullptr);
+                tempRTC->drawRect(GrNoClip(), paint, SkMatrix::I(), rect, nullptr);
                 surfaceToRead.reset(tempRTC->asTexture().release());
                 left = 0;
                 top = 0;
diff --git a/src/gpu/GrDrawingManager.cpp b/src/gpu/GrDrawingManager.cpp
index 9cbdbbe93a..c82f49ab7f 100644
--- a/src/gpu/GrDrawingManager.cpp
+++ b/src/gpu/GrDrawingManager.cpp
@@ -222,9 +222,7 @@ GrPathRenderer* GrDrawingManager::getPathRenderer(const GrPathRenderer::CanDrawP
                     new GrSoftwarePathRenderer(fContext->textureProvider(),
                                                fOptionsForPathRendererChain.fAllowPathMaskCaching);
         }
-        if (fSoftwarePathRenderer->canDrawPath(args)) {
-            pr = fSoftwarePathRenderer;
-        }
+        pr = fSoftwarePathRenderer;
     }
 
     return pr;
diff --git a/src/gpu/GrFixedClip.cpp b/src/gpu/GrFixedClip.cpp
index d584ee119e..79e26624d2 100644
--- a/src/gpu/GrFixedClip.cpp
+++ b/src/gpu/GrFixedClip.cpp
@@ -29,7 +29,7 @@ void GrFixedClip::getConservativeBounds(int w, int h, SkIRect* devResult, bool*
     }
 }
 
-bool GrFixedClip::isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA* aa) const {
+bool GrFixedClip::isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const {
     if (fWindowRectsState.enabled()) {
         return false;
     }
@@ -39,7 +39,7 @@ bool GrFixedClip::isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA* aa) const {
             return false;
         }
         rr->setRect(rect);
-        *aa = GrAA::kNo;
+        *aa = false;
         return true;
     }
     return false;
diff --git a/src/gpu/GrFixedClip.h b/src/gpu/GrFixedClip.h
index 7f18c2667f..6c350d5cba 100644
--- a/src/gpu/GrFixedClip.h
+++ b/src/gpu/GrFixedClip.h
@@ -42,7 +42,7 @@ public:
 
     bool quickContains(const SkRect&) const override;
     void getConservativeBounds(int w, int h, SkIRect* devResult, bool* iior) const override;
-    bool isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA*) const override;
+    bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const override;
     bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip* out) const override;
 
     static const GrFixedClip& Disabled();
diff --git a/src/gpu/GrPaint.cpp b/src/gpu/GrPaint.cpp
index 0954505b80..d5f8d3d0c1 100644
--- a/src/gpu/GrPaint.cpp
+++ b/src/gpu/GrPaint.cpp
@@ -13,7 +13,8 @@
 #include "effects/GrSimpleTextureEffect.h"
 
 GrPaint::GrPaint()
-    : fDisableOutputConversionToSRGB(false)
+    : fAntiAlias(false)
+    , fDisableOutputConversionToSRGB(false)
     , fAllowSRGBInputs(false)
     , fUsesDistanceVectorField(false)
     , fColor(GrColor4f::OpaqueWhite()) {}
diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h
index c002c12889..2b5ccdc883 100644
--- a/src/gpu/GrPathRenderer.h
+++ b/src/gpu/GrPathRenderer.h
@@ -78,16 +78,17 @@ public:
      * fPipelineBuilder  The pipelineBuilder
      * fViewMatrix       The viewMatrix
      * fShape            The shape to draw
-     * fAntiAlias        The type of anti aliasing required.
+     * fAntiAlias        True if anti-aliasing is required.
      */
     struct CanDrawPathArgs {
         const GrShaderCaps*         fShaderCaps;
         const SkMatrix*             fViewMatrix;
         const GrShape*              fShape;
-        GrAAType                    fAAType;
+        bool                        fAntiAlias;
 
         // These next two are only used by GrStencilAndCoverPathRenderer
         bool                        fHasUserStencilSettings;
+        bool                        fIsStencilBufferMSAA;
 
 #ifdef SK_DEBUG
         void validate() const {
@@ -120,7 +121,7 @@ public:
      * fColor                 Color to render with
      * fViewMatrix            The viewMatrix
      * fShape                 The shape to draw
-     * fAAtype                true if anti-aliasing is required.
+     * fAntiAlias             true if anti-aliasing is required.
      * fGammaCorrect          true if gamma-correct rendering is to be used.
      */
     struct DrawPathArgs {
@@ -132,7 +133,7 @@ public:
         const GrClip*               fClip;
         const SkMatrix*             fViewMatrix;
         const GrShape*              fShape;
-        GrAAType                    fAAType;
+        bool                        fAntiAlias;
         bool                        fGammaCorrect;
 #ifdef SK_DEBUG
         void validate() const {
@@ -158,13 +159,10 @@ public:
         canArgs.fShaderCaps = args.fResourceProvider->caps()->shaderCaps();
         canArgs.fViewMatrix = args.fViewMatrix;
         canArgs.fShape = args.fShape;
-        canArgs.fAAType = args.fAAType;
+        canArgs.fAntiAlias = args.fAntiAlias;
 
         canArgs.fHasUserStencilSettings = !args.fUserStencilSettings->isUnused();
-        SkASSERT(!(canArgs.fAAType == GrAAType::kMSAA &&
-                   !args.fRenderTargetContext->isUnifiedMultisampled()));
-        SkASSERT(!(canArgs.fAAType == GrAAType::kMixedSamples &&
-                   !args.fRenderTargetContext->isStencilBufferMultisampled()));
+        canArgs.fIsStencilBufferMSAA = args.fRenderTargetContext->isStencilBufferMultisampled();
         SkASSERT(this->canDrawPath(canArgs));
         if (!args.fUserStencilSettings->isUnused()) {
             SkPath path;
@@ -182,14 +180,14 @@ public:
      * fRenderTargetContext   The target of the draws
      * fViewMatrix            Matrix applied to the path.
      * fPath                  The path to draw.
-     * fAAType                The type of AA, cannot be kCoverage.
+     * fIsAA                  Is the path to be drawn AA (only set when MSAA is available)
      */
     struct StencilPathArgs {
         GrResourceProvider*    fResourceProvider;
         GrRenderTargetContext* fRenderTargetContext;
         const GrClip*          fClip;
         const SkMatrix*        fViewMatrix;
-        GrAAType               fAAType;
+        bool                   fIsAA;
         const GrShape*         fShape;
 
 #ifdef SK_DEBUG
@@ -199,7 +197,6 @@ public:
             SkASSERT(fViewMatrix);
             SkASSERT(fShape);
             SkASSERT(fShape->style().isSimpleFill());
-            SkASSERT(GrAAType::kCoverage != fAAType);
             SkPath path;
             fShape->asPath(&path);
             SkASSERT(!path.isInverseFillType());
@@ -286,7 +283,7 @@ private:
         drawArgs.fRenderTargetContext = args.fRenderTargetContext;
         drawArgs.fViewMatrix = args.fViewMatrix;
         drawArgs.fShape = args.fShape;
-        drawArgs.fAAType = args.fAAType;
+        drawArgs.fAntiAlias = false;  // In this case the MSAA handles the AA so we want to draw BW
         drawArgs.fGammaCorrect = false;
         this->drawPath(drawArgs);
     }
diff --git a/src/gpu/GrPipelineBuilder.cpp b/src/gpu/GrPipelineBuilder.cpp
index f2dd1acc4e..fac5752f70 100644
--- a/src/gpu/GrPipelineBuilder.cpp
+++ b/src/gpu/GrPipelineBuilder.cpp
@@ -15,10 +15,15 @@
 #include "batches/GrOp.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 
-GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrAAType aaType)
-        : fFlags(0x0)
-        , fUserStencilSettings(&GrUserStencilSettings::kUnused)
-        , fDrawFace(GrDrawFace::kBoth) {
+GrPipelineBuilder::GrPipelineBuilder()
+    : fFlags(0x0)
+    , fUserStencilSettings(&GrUserStencilSettings::kUnused)
+    , fDrawFace(GrDrawFace::kBoth) {
+    SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
+}
+
+GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, bool useHWAA)
+    : GrPipelineBuilder() {
     SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
 
     for (int i = 0; i < paint.numColorFragmentProcessors(); ++i) {
@@ -31,8 +36,7 @@ GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrAAType aaType)
 
     fXPFactory.reset(SkSafeRef(paint.getXPFactory()));
 
-    this->setState(GrPipelineBuilder::kHWAntialias_Flag, GrAAType::kMSAA == aaType ||
-                                                         GrAAType::kMixedSamples == aaType);
+    this->setState(GrPipelineBuilder::kHWAntialias_Flag, useHWAA);
     this->setState(GrPipelineBuilder::kDisableOutputConversionToSRGB_Flag,
                    paint.getDisableOutputConversionToSRGB());
     this->setState(GrPipelineBuilder::kAllowSRGBInputs_Flag,
diff --git a/src/gpu/GrPipelineBuilder.h b/src/gpu/GrPipelineBuilder.h
index 69aa45491a..fcff2adafd 100644
--- a/src/gpu/GrPipelineBuilder.h
+++ b/src/gpu/GrPipelineBuilder.h
@@ -29,14 +29,15 @@ class GrTexture;
 
 class GrPipelineBuilder : public SkNoncopyable {
 public:
-//    GrPipelineBuilder();
+    GrPipelineBuilder();
+
     /**
      * Initializes the GrPipelineBuilder based on a GrPaint and MSAA availability. Note
      * that GrPipelineBuilder encompasses more than GrPaint. Aspects of GrPipelineBuilder that have
      * no GrPaint equivalents are set to default values with the exception of vertex attribute state
      * which is unmodified by this function and clipping which will be enabled.
      */
-    GrPipelineBuilder(const GrPaint& paint, GrAAType aaType);
+    GrPipelineBuilder(const GrPaint&, bool useHWAA = false);
 
     virtual ~GrPipelineBuilder();
 
diff --git a/src/gpu/GrReducedClip.cpp b/src/gpu/GrReducedClip.cpp
index 8b9090f427..c5d764d3b7 100644
--- a/src/gpu/GrReducedClip.cpp
+++ b/src/gpu/GrReducedClip.cpp
@@ -529,7 +529,8 @@ static bool stencil_element(GrRenderTargetContext* rtc,
                             const GrUserStencilSettings* ss,
                             const SkMatrix& viewMatrix,
                             const SkClipStack::Element* element) {
-    GrAA aa = GrBoolToAA(element->isAA());
+
+    // TODO: Draw rrects directly here.
     switch (element->getType()) {
         case Element::kEmpty_Type:
             SkDEBUGFAIL("Should never get here with an empty element.");
@@ -537,7 +538,9 @@ static bool stencil_element(GrRenderTargetContext* rtc,
         case Element::kRect_Type:
             return rtc->priv().drawAndStencilRect(clip, ss,
                                                   (SkRegion::Op)element->getOp(),
-                                                  element->isInverseFilled(), aa, viewMatrix,
+                                                  element->isInverseFilled(),
+                                                  element->isAA(),
+                                                  viewMatrix,
                                                   element->getRect());
             break;
         default: {
@@ -547,8 +550,11 @@ static bool stencil_element(GrRenderTargetContext* rtc,
                 path.toggleInverseFillType();
             }
 
-            return rtc->priv().drawAndStencilPath(clip, ss, (SkRegion::Op)element->getOp(),
-                                                  element->isInverseFilled(), aa, viewMatrix, path);
+            return rtc->priv().drawAndStencilPath(clip, ss,
+                                                  (SkRegion::Op)element->getOp(),
+                                                  element->isInverseFilled(),
+                                                  element->isAA(), viewMatrix,
+                                                  path);
             break;
         }
     }
@@ -559,7 +565,6 @@ static bool stencil_element(GrRenderTargetContext* rtc,
 static void draw_element(GrRenderTargetContext* rtc,
                          const GrClip& clip, // TODO: can this just always be WideOpen?
                          const GrPaint &paint,
-                         GrAA aa,
                          const SkMatrix& viewMatrix,
                          const SkClipStack::Element* element) {
 
@@ -569,7 +574,7 @@ static void draw_element(GrRenderTargetContext* rtc,
             SkDEBUGFAIL("Should never get here with an empty element.");
             break;
         case Element::kRect_Type:
-            rtc->drawRect(clip, paint, aa, viewMatrix, element->getRect());
+            rtc->drawRect(clip, paint, viewMatrix, element->getRect());
             break;
         default: {
             SkPath path;
@@ -578,7 +583,7 @@ static void draw_element(GrRenderTargetContext* rtc,
                 path.toggleInverseFillType();
             }
 
-            rtc->drawPath(clip, paint, aa, viewMatrix, path, GrStyle::SimpleFill());
+            rtc->drawPath(clip, paint, viewMatrix, path, GrStyle::SimpleFill());
             break;
         }
     }
@@ -607,7 +612,6 @@ bool GrReducedClip::drawAlphaClipMask(GrRenderTargetContext* rtc) const {
     for (ElementList::Iter iter(fElements); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkRegion::Op op = (SkRegion::Op)element->getOp();
-        GrAA aa = GrBoolToAA(element->isAA());
         bool invert = element->isInverseFilled();
         if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
             // draw directly into the result with the stencil set to make the pixels affected
@@ -635,16 +639,17 @@ bool GrReducedClip::drawAlphaClipMask(GrRenderTargetContext* rtc) const {
                      GrUserStencilOp::kZero,
                      0xffff>()
             );
-            if (!rtc->priv().drawAndStencilRect(clip, &kDrawOutsideElement, op, !invert, GrAA::kNo,
+            if (!rtc->priv().drawAndStencilRect(clip, &kDrawOutsideElement, op, !invert, false,
                                                 translate, SkRect::Make(fIBounds))) {
                 return false;
             }
         } else {
             // all the remaining ops can just be directly draw into the accumulation buffer
             GrPaint paint;
+            paint.setAntiAlias(element->isAA());
             paint.setCoverageSetOpXPFactory(op, false);
 
-            draw_element(rtc, clip, paint, aa, translate, element);
+            draw_element(rtc, clip, paint, translate, element);
         }
     }
 
@@ -671,7 +676,7 @@ private:
     void getConservativeBounds(int width, int height, SkIRect* bounds, bool* iior) const override {
         fFixedClip.getConservativeBounds(width, height, bounds, iior);
     }
-    bool isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA*) const override {
+    bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const override {
         return false;
     }
     bool apply(GrContext* context, GrRenderTargetContext* renderTargetContext, bool useHWAA,
@@ -706,13 +711,11 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context,
     SkMatrix viewMatrix;
     viewMatrix.setTranslate(SkIntToScalar(-clipOrigin.x()), SkIntToScalar(-clipOrigin.y()));
 
-    // walk through each clip element and perform its set op with the existing clip.
+    // walk through each clip element and perform its set op
+    // with the existing clip.
     for (ElementList::Iter iter(fElements); iter.get(); iter.next()) {
         const Element* element = iter.get();
-        GrAAType aaType = GrAAType::kNone;
-        if (element->isAA() && renderTargetContext->isStencilBufferMultisampled()) {
-            aaType = GrAAType::kMSAA;
-        }
+        bool useHWAA = element->isAA() && renderTargetContext->isStencilBufferMultisampled();
 
         bool fillInverted = false;
 
@@ -739,8 +742,9 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context,
             canDrawArgs.fShaderCaps = context->caps()->shaderCaps();
             canDrawArgs.fViewMatrix = &viewMatrix;
             canDrawArgs.fShape = &shape;
-            canDrawArgs.fAAType = aaType;
+            canDrawArgs.fAntiAlias = false;
             canDrawArgs.fHasUserStencilSettings = false;
+            canDrawArgs.fIsStencilBufferMSAA = renderTargetContext->isStencilBufferMultisampled();
 
             GrDrawingManager* dm = context->contextPriv().drawingManager();
             pr = dm->getPathRenderer(canDrawArgs, false,
@@ -774,13 +778,14 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context,
             );
             if (Element::kRect_Type == element->getType()) {
                 renderTargetContext->priv().stencilRect(stencilClip.fixedClip(), &kDrawToStencil,
-                                                        aaType, viewMatrix, element->getRect());
+                                                        useHWAA, viewMatrix, element->getRect());
             } else {
                 if (!clipPath.isEmpty()) {
                     GrShape shape(clipPath, GrStyle::SimpleFill());
                     if (canRenderDirectToStencil) {
                         GrPaint paint;
                         paint.setXPFactory(GrDisableColorXPFactory::Make());
+                        paint.setAntiAlias(element->isAA());
 
                         GrPathRenderer::DrawPathArgs args;
                         args.fResourceProvider = context->resourceProvider();
@@ -790,7 +795,7 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context,
                         args.fClip = &stencilClip.fixedClip();
                         args.fViewMatrix = &viewMatrix;
                         args.fShape = &shape;
-                        args.fAAType = aaType;
+                        args.fAntiAlias = false;
                         args.fGammaCorrect = false;
                         pr->drawPath(args);
                     } else {
@@ -799,7 +804,7 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context,
                         args.fRenderTargetContext = renderTargetContext;
                         args.fClip = &stencilClip.fixedClip();
                         args.fViewMatrix = &viewMatrix;
-                        args.fAAType = aaType;
+                        args.fIsAA = element->isAA();
                         args.fShape = &shape;
                         pr->stencilPath(args);
                     }
@@ -812,12 +817,13 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context,
         for (GrUserStencilSettings const* const* pass = stencilPasses; *pass; ++pass) {
             if (drawDirectToClip) {
                 if (Element::kRect_Type == element->getType()) {
-                    renderTargetContext->priv().stencilRect(stencilClip, *pass, aaType, viewMatrix,
+                    renderTargetContext->priv().stencilRect(stencilClip, *pass, useHWAA, viewMatrix,
                                                             element->getRect());
                 } else {
                     GrShape shape(clipPath, GrStyle::SimpleFill());
                     GrPaint paint;
                     paint.setXPFactory(GrDisableColorXPFactory::Make());
+                    paint.setAntiAlias(element->isAA());
                     GrPathRenderer::DrawPathArgs args;
                     args.fResourceProvider = context->resourceProvider();
                     args.fPaint = &paint;
@@ -826,14 +832,14 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context,
                     args.fClip = &stencilClip;
                     args.fViewMatrix = &viewMatrix;
                     args.fShape = &shape;
-                    args.fAAType = aaType;
+                    args.fAntiAlias = false;
                     args.fGammaCorrect = false;
                     pr->drawPath(args);
                 }
             } else {
                 // The view matrix is setup to do clip space -> stencil space translation, so
                 // draw rect in clip space.
-                renderTargetContext->priv().stencilRect(stencilClip, *pass, aaType, viewMatrix,
+                renderTargetContext->priv().stencilRect(stencilClip, *pass, false, viewMatrix,
                                                         SkRect::Make(fIBounds));
             }
         }
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 6ef34d22bb..ebdf810c8f 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -324,7 +324,7 @@ void GrRenderTargetContext::internalClear(const GrFixedClip& clip,
         paint.setColor4f(GrColor4f::FromGrColor(color));
         paint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
 
-        this->drawRect(clip, paint, GrAA::kNo, SkMatrix::I(), SkRect::Make(clearRect));
+        this->drawRect(clip, paint, SkMatrix::I(), SkRect::Make(clearRect));
     } else if (isFull) {
         if (this->accessRenderTarget()) {
             this->getOpList()->fullClear(this->accessRenderTarget(), color);
@@ -342,7 +342,7 @@ void GrRenderTargetContext::internalClear(const GrFixedClip& clip,
 }
 
 void GrRenderTargetContext::drawPaint(const GrClip& clip,
-                                      const GrPaint& paint,
+                                      const GrPaint& origPaint,
                                       const SkMatrix& viewMatrix) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
@@ -353,19 +353,26 @@ void GrRenderTargetContext::drawPaint(const GrClip& clip,
     // don't overflow fixed-point implementations
 
     SkRect r = fRenderTargetProxy->getBoundsRect();
+    SkTCopyOnFirstWrite<GrPaint> paint(origPaint);
 
     SkRRect rrect;
-    GrAA aa;
+    bool aaRRect;
     // Check if we can replace a clipRRect()/drawPaint() with a drawRRect(). We only do the
     // transformation for non-rect rrects. Rects caused a performance regression on an Android
     // test that needs investigation. We also skip cases where there are fragment processors
     // because they may depend on having correct local coords and this path draws in device space
     // without a local matrix.
-    if (!paint.numTotalFragmentProcessors() && clip.isRRect(r, &rrect, &aa) && !rrect.isRect()) {
-        this->drawRRect(GrNoClip(), paint, aa, SkMatrix::I(), rrect, GrStyle::SimpleFill());
+    if (!paint->numTotalFragmentProcessors() &&
+        clip.isRRect(r, &rrect, &aaRRect) && !rrect.isRect()) {
+        paint.writable()->setAntiAlias(aaRRect);
+        this->drawRRect(GrNoClip(), *paint, SkMatrix::I(), rrect, GrStyle::SimpleFill());
         return;
     }
 
+    // by definition this fills the entire clip, no need for AA
+    if (paint->isAntiAlias()) {
+        paint.writable()->setAntiAlias(false);
+    }
 
     bool isPerspective = viewMatrix.hasPerspective();
 
@@ -377,7 +384,7 @@ void GrRenderTargetContext::drawPaint(const GrClip& clip,
             SkDebugf("Could not invert matrix\n");
             return;
         }
-        this->drawRect(clip, paint, GrAA::kNo, viewMatrix, r);
+        this->drawRect(clip, *paint, viewMatrix, r);
     } else {
         SkMatrix localMatrix;
         if (!viewMatrix.invert(&localMatrix)) {
@@ -387,8 +394,8 @@ void GrRenderTargetContext::drawPaint(const GrClip& clip,
 
         AutoCheckFlush acf(fDrawingManager);
 
-        this->drawNonAAFilledRect(clip, paint, SkMatrix::I(), r, nullptr, &localMatrix,
-                                  nullptr, GrAAType::kNone);
+        this->drawNonAAFilledRect(clip, *paint, SkMatrix::I(), r, nullptr, &localMatrix, nullptr,
+                                  false /* useHWAA */);
     }
 }
 
@@ -401,6 +408,21 @@ static bool view_matrix_ok_for_aa_fill_rect(const SkMatrix& viewMatrix) {
     return viewMatrix.preservesRightAngles();
 }
 
+static bool should_apply_coverage_aa(const GrPaint& paint, GrRenderTargetProxy* rtp,
+                                     bool* useHWAA = nullptr) {
+    if (!paint.isAntiAlias()) {
+        if (useHWAA) {
+            *useHWAA = false;
+        }
+        return false;
+    } else {
+        if (useHWAA) {
+            *useHWAA = rtp->isUnifiedMultisampled();
+        }
+        return !rtp->isUnifiedMultisampled();
+    }
+}
+
 // Attempts to crop a rect and optional local rect to the clip boundaries.
 // Returns false if the draw can be skipped entirely.
 static bool crop_filled_rect(int width, int height, const GrClip& clip,
@@ -448,7 +470,6 @@ static bool crop_filled_rect(int width, int height, const GrClip& clip,
 
 bool GrRenderTargetContext::drawFilledRect(const GrClip& clip,
                                            const GrPaint& paint,
-                                           GrAA aa,
                                            const SkMatrix& viewMatrix,
                                            const SkRect& rect,
                                            const GrUserStencilSettings* ss) {
@@ -458,14 +479,14 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip,
     }
 
     sk_sp<GrDrawOp> op;
-    GrAAType aaType;
+    bool useHWAA;
 
     if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) {
         InstancedRendering* ir = this->getOpList()->instancedRendering();
-        op.reset(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), aa,
-                                fInstancedPipelineInfo, &aaType));
+        op.reset(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), paint.isAntiAlias(),
+                                fInstancedPipelineInfo, &useHWAA));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             if (ss) {
                 pipelineBuilder.setUserStencil(ss);
             }
@@ -473,8 +494,8 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip,
             return true;
         }
     }
-    aaType = this->decideAAType(aa);
-    if (GrAAType::kCoverage == aaType) {
+
+    if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) {
         // The fill path can handle rotation but not skew.
         if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
             SkRect devBoundRect;
@@ -483,7 +504,7 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip,
             op.reset(GrRectBatchFactory::CreateAAFill(paint, viewMatrix, rect, croppedRect,
                                                       devBoundRect));
             if (op) {
-                GrPipelineBuilder pipelineBuilder(paint, aaType);
+                GrPipelineBuilder pipelineBuilder(paint, useHWAA);
                 if (ss) {
                     pipelineBuilder.setUserStencil(ss);
                 }
@@ -493,7 +514,7 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip,
         }
     } else {
         this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr, nullptr, ss,
-                                  aaType);
+                                  useHWAA);
         return true;
     }
 
@@ -502,7 +523,6 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip,
 
 void GrRenderTargetContext::drawRect(const GrClip& clip,
                                      const GrPaint& paint,
-                                     GrAA aa,
                                      const SkMatrix& viewMatrix,
                                      const SkRect& rect,
                                      const GrStyle* style) {
@@ -549,7 +569,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
             }
         }
 
-        if (this->drawFilledRect(clip, paint, aa, viewMatrix, rect, nullptr)) {
+        if (this->drawFilledRect(clip, paint, viewMatrix, rect, nullptr)) {
             return;
         }
     } else if (stroke.getStyle() == SkStrokeRec::kStroke_Style ||
@@ -560,7 +580,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
             // TODO: Move these stroke->fill fallbacks to GrShape?
             switch (stroke.getJoin()) {
                 case SkPaint::kMiter_Join:
-                    this->drawRect(clip, paint, aa, viewMatrix,
+                    this->drawRect(clip, paint, viewMatrix,
                                    {rect.fLeft - r, rect.fTop - r,
                                     rect.fRight + r, rect.fBottom + r},
                                    &GrStyle::SimpleFill());
@@ -569,16 +589,16 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
                     // Raster draws nothing when both dimensions are empty.
                     if (rect.width() || rect.height()){
                         SkRRect rrect = SkRRect::MakeRectXY(rect.makeOutset(r, r), r, r);
-                        this->drawRRect(clip, paint, aa, viewMatrix, rrect, GrStyle::SimpleFill());
+                        this->drawRRect(clip, paint, viewMatrix, rrect, GrStyle::SimpleFill());
                         return;
                     }
                 case SkPaint::kBevel_Join:
                     if (!rect.width()) {
-                        this->drawRect(clip, paint, aa, viewMatrix,
+                        this->drawRect(clip, paint, viewMatrix,
                                        {rect.fLeft - r, rect.fTop, rect.fRight + r, rect.fBottom},
                                        &GrStyle::SimpleFill());
                     } else {
-                        this->drawRect(clip, paint, aa, viewMatrix,
+                        this->drawRect(clip, paint, viewMatrix,
                                        {rect.fLeft, rect.fTop - r, rect.fRight, rect.fBottom + r},
                                        &GrStyle::SimpleFill());
                     }
@@ -586,12 +606,12 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
                 }
         }
 
+        bool useHWAA;
         bool snapToPixelCenters = false;
         sk_sp<GrDrawOp> op;
 
         GrColor color = paint.getColor();
-        GrAAType aaType = this->decideAAType(aa);
-        if (GrAAType::kCoverage == aaType) {
+        if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) {
             // The stroke path needs the rect to remain axis aligned (no rotation or skew).
             if (viewMatrix.rectStaysRect()) {
                 op.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect, stroke));
@@ -607,7 +627,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
         }
 
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
 
             if (snapToPixelCenters) {
                 pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
@@ -622,7 +642,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
-    this->internalDrawPath(clip, paint, aa, viewMatrix, path, *style);
+    this->internalDrawPath(clip, paint, viewMatrix, path, *style);
 }
 
 int GrRenderTargetContextPriv::maxWindowRectangles() const {
@@ -646,17 +666,16 @@ void GrRenderTargetContextPriv::clearStencilClip(const GrFixedClip& clip, bool i
 }
 
 void GrRenderTargetContextPriv::stencilPath(const GrClip& clip,
-                                            GrAAType aaType,
+                                            bool useHWAA,
                                             const SkMatrix& viewMatrix,
                                             const GrPath* path) {
-    SkASSERT(aaType != GrAAType::kCoverage);
-    fRenderTargetContext->getOpList()->stencilPath(fRenderTargetContext, clip, aaType, viewMatrix,
+    fRenderTargetContext->getOpList()->stencilPath(fRenderTargetContext, clip, useHWAA, viewMatrix,
                                                    path);
 }
 
 void GrRenderTargetContextPriv::stencilRect(const GrClip& clip,
                                             const GrUserStencilSettings* ss,
-                                            GrAAType aaType,
+                                            bool useHWAA,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& rect) {
     ASSERT_SINGLE_OWNER_PRIV
@@ -664,21 +683,22 @@ void GrRenderTargetContextPriv::stencilRect(const GrClip& clip,
     SkDEBUGCODE(fRenderTargetContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail,
                               "GrRenderTargetContext::stencilRect");
-    SkASSERT(GrAAType::kCoverage != aaType);
+
     AutoCheckFlush acf(fRenderTargetContext->fDrawingManager);
 
     GrPaint paint;
+    paint.setAntiAlias(useHWAA);
     paint.setXPFactory(GrDisableColorXPFactory::Make());
 
     fRenderTargetContext->drawNonAAFilledRect(clip, paint, viewMatrix, rect, nullptr, nullptr, ss,
-                                              aaType);
+                                              useHWAA);
 }
 
 bool GrRenderTargetContextPriv::drawAndStencilRect(const GrClip& clip,
                                                    const GrUserStencilSettings* ss,
                                                    SkRegion::Op op,
                                                    bool invert,
-                                                   GrAA aa,
+                                                   bool doAA,
                                                    const SkMatrix& viewMatrix,
                                                    const SkRect& rect) {
     ASSERT_SINGLE_OWNER_PRIV
@@ -690,20 +710,21 @@ bool GrRenderTargetContextPriv::drawAndStencilRect(const GrClip& clip,
     AutoCheckFlush acf(fRenderTargetContext->fDrawingManager);
 
     GrPaint paint;
+    paint.setAntiAlias(doAA);
     paint.setCoverageSetOpXPFactory(op, invert);
 
-    if (fRenderTargetContext->drawFilledRect(clip, paint, aa, viewMatrix, rect, ss)) {
+    if (fRenderTargetContext->drawFilledRect(clip, paint, viewMatrix, rect, ss)) {
         return true;
     }
+
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
-    return this->drawAndStencilPath(clip, ss, op, invert, aa, viewMatrix, path);
+    return this->drawAndStencilPath(clip, ss, op, invert, doAA, viewMatrix, path);
 }
 
 void GrRenderTargetContext::fillRectToRect(const GrClip& clip,
                                            const GrPaint& paint,
-                                           GrAA aa,
                                            const SkMatrix& viewMatrix,
                                            const SkRect& rectToDraw,
                                            const SkRect& localRect) {
@@ -720,30 +741,30 @@ void GrRenderTargetContext::fillRectToRect(const GrClip& clip,
     }
 
     AutoCheckFlush acf(fDrawingManager);
-    GrAAType aaType;
+    bool useHWAA;
 
     if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) {
         InstancedRendering* ir = this->getOpList()->instancedRendering();
         sk_sp<GrDrawOp> op(ir->recordRect(croppedRect, viewMatrix, paint.getColor(),
-                                          croppedLocalRect, aa, fInstancedPipelineInfo, &aaType));
+                                          croppedLocalRect, paint.isAntiAlias(),
+                                          fInstancedPipelineInfo, &useHWAA));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
             return;
         }
     }
 
-    aaType = this->decideAAType(aa);
-    if (GrAAType::kCoverage != aaType) {
-        this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, &croppedLocalRect, nullptr,
-                                  nullptr, aaType);
+    if (!should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) {
+        this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, &croppedLocalRect,
+                                  nullptr, nullptr, useHWAA);
         return;
     }
 
     if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         sk_sp<GrDrawOp> op(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(), viewMatrix,
                                                                   croppedRect, croppedLocalRect));
-        GrPipelineBuilder pipelineBuilder(paint, aaType);
+        GrPipelineBuilder pipelineBuilder(paint, useHWAA);
         this->addDrawOp(pipelineBuilder, clip, op.get());
         return;
     }
@@ -758,12 +779,11 @@ void GrRenderTargetContext::fillRectToRect(const GrClip& clip,
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(localRect);
-    this->internalDrawPath(clip, paint, aa, viewAndUnLocalMatrix, path, GrStyle());
+    this->internalDrawPath(clip, paint, viewAndUnLocalMatrix, path, GrStyle());
 }
 
 void GrRenderTargetContext::fillRectWithLocalMatrix(const GrClip& clip,
                                                     const GrPaint& paint,
-                                                    GrAA aa,
                                                     const SkMatrix& viewMatrix,
                                                     const SkRect& rectToDraw,
                                                     const SkMatrix& localMatrix) {
@@ -778,30 +798,29 @@ void GrRenderTargetContext::fillRectWithLocalMatrix(const GrClip& clip,
     }
 
     AutoCheckFlush acf(fDrawingManager);
-    GrAAType aaType;
+    bool useHWAA;
 
     if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) {
         InstancedRendering* ir = this->getOpList()->instancedRendering();
         sk_sp<GrDrawOp> op(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), localMatrix,
-                                          aa, fInstancedPipelineInfo, &aaType));
+                                          paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
             return;
         }
     }
 
-    aaType = this->decideAAType(aa);
-    if (GrAAType::kCoverage != aaType) {
-        this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr, &localMatrix,
-                                  nullptr, aaType);
+    if (!should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) {
+        this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr,
+                                  &localMatrix, nullptr, useHWAA);
         return;
     }
 
     if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         sk_sp<GrDrawOp> op(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix,
                                                      croppedRect));
-        GrPipelineBuilder pipelineBuilder(paint, aaType);
+        GrPipelineBuilder pipelineBuilder(paint, useHWAA);
         this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
         return;
     }
@@ -817,7 +836,7 @@ void GrRenderTargetContext::fillRectWithLocalMatrix(const GrClip& clip,
     path.setIsVolatile(true);
     path.addRect(rectToDraw);
     path.transform(localMatrix);
-    this->internalDrawPath(clip, paint, aa, viewAndUnLocalMatrix, path, GrStyle());
+    this->internalDrawPath(clip, paint, viewAndUnLocalMatrix, path, GrStyle());
 }
 
 void GrRenderTargetContext::drawVertices(const GrClip& clip,
@@ -850,7 +869,7 @@ void GrRenderTargetContext::drawVertices(const GrClip& clip,
                                                positions, vertexCount, indices, indexCount, colors,
                                                texCoords, bounds));
 
-    GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone);
+    GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint));
     this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
 }
 
@@ -873,7 +892,7 @@ void GrRenderTargetContext::drawAtlas(const GrClip& clip,
     sk_sp<GrDrawOp> op(new GrDrawAtlasBatch(paint.getColor(), viewMatrix, spriteCount, xform,
                                             texRect, colors));
 
-    GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone);
+    GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint));
     this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
 }
 
@@ -881,7 +900,6 @@ void GrRenderTargetContext::drawAtlas(const GrClip& clip,
 
 void GrRenderTargetContext::drawRRect(const GrClip& origClip,
                                       const GrPaint& paint,
-                                      GrAA aa,
                                       const SkMatrix& viewMatrix,
                                       const SkRRect& rrect,
                                       const GrStyle& style) {
@@ -910,22 +928,21 @@ void GrRenderTargetContext::drawRRect(const GrClip& origClip,
 
     AutoCheckFlush acf(fDrawingManager);
     const SkStrokeRec stroke = style.strokeRec();
-    GrAAType aaType;
+    bool useHWAA;
 
     if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport() &&
         stroke.isFillStyle()) {
         InstancedRendering* ir = this->getOpList()->instancedRendering();
-        sk_sp<GrDrawOp> op(ir->recordRRect(rrect, viewMatrix, paint.getColor(), aa,
-                                           fInstancedPipelineInfo, &aaType));
+        sk_sp<GrDrawOp> op(ir->recordRRect(rrect, viewMatrix, paint.getColor(), paint.isAntiAlias(),
+                                           fInstancedPipelineInfo, &useHWAA));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getOpList()->addDrawOp(pipelineBuilder, this, *clip, op.get());
             return;
         }
     }
 
-    aaType = this->decideAAType(aa);
-    if (GrAAType::kCoverage == aaType) {
+    if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
         sk_sp<GrDrawOp> op(GrOvalRenderer::CreateRRectBatch(paint.getColor(),
                                                             paint.usesDistanceVectorField(),
@@ -934,7 +951,7 @@ void GrRenderTargetContext::drawRRect(const GrClip& origClip,
                                                             stroke,
                                                             shaderCaps));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getOpList()->addDrawOp(pipelineBuilder, this, *clip, op.get());
             return;
         }
@@ -943,7 +960,7 @@ void GrRenderTargetContext::drawRRect(const GrClip& origClip,
     SkPath path;
     path.setIsVolatile(true);
     path.addRRect(rrect);
-    this->internalDrawPath(*clip, paint, aa, viewMatrix, path, style);
+    this->internalDrawPath(*clip, paint, viewMatrix, path, style);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -966,55 +983,72 @@ void GrRenderTargetContext::drawShadowRRect(const GrClip& clip,
 
     AutoCheckFlush acf(fDrawingManager);
     const SkStrokeRec stroke = style.strokeRec();
-    // TODO: add instancing support?
-
-    const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-    sk_sp<GrDrawOp> op(CreateShadowRRectBatch(paint.getColor(),
-                                              viewMatrix,
-                                              rrect,
-                                              blurRadius,
-                                              stroke,
-                                              shaderCaps));
-    if (op) {
-        GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone);
-        this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
-        return;
+    bool useHWAA;
+
+    // TODO: add instancing support
+    //if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport() &&
+    //    stroke.isFillStyle()) {
+    //    InstancedRendering* ir = this->getOpList()->instancedRendering();
+    //    SkAutoTUnref<GrDrawOp> op(ir->recordRRect(rrect, viewMatrix, paint.getColor(),
+    //                                              paint.isAntiAlias(), fInstancedPipelineInfo,
+    //                                              &useHWAA));
+    //    if (op) {
+    //        GrPipelineBuilder pipelineBuilder(paint, useHWAA);
+    //        this->getOpList()->addDrawOp(pipelineBuilder, this, *clip, op);
+    //        return;
+    //    }
+    //}
+
+    if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) {
+        const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
+        sk_sp<GrDrawOp> op(CreateShadowRRectBatch(paint.getColor(),
+                                                  viewMatrix,
+                                                  rrect,
+                                                  blurRadius,
+                                                  stroke,
+                                                  shaderCaps));
+        if (op) {
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
+            this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
+            return;
+        }
     }
+
+    SkPath path;
+    path.setIsVolatile(true);
+    path.addRRect(rrect);
+    this->internalDrawPath(clip, paint, viewMatrix, path, style);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrRenderTargetContext::drawFilledDRRect(const GrClip& clip,
                                              const GrPaint& paintIn,
-                                             GrAA aa,
                                              const SkMatrix& viewMatrix,
                                              const SkRRect& origOuter,
                                              const SkRRect& origInner) {
     SkASSERT(!origInner.isEmpty());
     SkASSERT(!origOuter.isEmpty());
-    GrAAType aaType;
 
     if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) {
+        bool useHWAA;
         InstancedRendering* ir = this->getOpList()->instancedRendering();
         sk_sp<GrDrawOp> op(ir->recordDRRect(origOuter, origInner, viewMatrix, paintIn.getColor(),
-                                            aa, fInstancedPipelineInfo, &aaType));
+                                            paintIn.isAntiAlias(), fInstancedPipelineInfo,
+                                            &useHWAA));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paintIn, aaType);
+            GrPipelineBuilder pipelineBuilder(paintIn, useHWAA);
             this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
             return true;
         }
     }
 
-    aaType = this->decideAAType(aa);
+    bool applyAA = paintIn.isAntiAlias() && !fRenderTargetProxy->isUnifiedMultisampled();
 
-    GrPrimitiveEdgeType innerEdgeType, outerEdgeType;
-    if (GrAAType::kCoverage == aaType) {
-        innerEdgeType = kInverseFillAA_GrProcessorEdgeType;
-        outerEdgeType = kFillAA_GrProcessorEdgeType;
-    } else {
-        innerEdgeType = kInverseFillBW_GrProcessorEdgeType;
-        outerEdgeType = kFillBW_GrProcessorEdgeType;
-    }
+    GrPrimitiveEdgeType innerEdgeType = applyAA ? kInverseFillAA_GrProcessorEdgeType :
+                                                  kInverseFillBW_GrProcessorEdgeType;
+    GrPrimitiveEdgeType outerEdgeType = applyAA ? kFillAA_GrProcessorEdgeType :
+                                                  kFillBW_GrProcessorEdgeType;
 
     SkTCopyOnFirstWrite<SkRRect> inner(origInner), outer(origOuter);
     SkMatrix inverseVM;
@@ -1033,6 +1067,7 @@ bool GrRenderTargetContext::drawFilledDRRect(const GrClip& clip,
     }
 
     GrPaint grPaint(paintIn);
+    grPaint.setAntiAlias(false);
 
     // TODO these need to be a geometry processors
     sk_sp<GrFragmentProcessor> innerEffect(GrRRectEffect::Make(innerEdgeType, *inner));
@@ -1049,17 +1084,16 @@ bool GrRenderTargetContext::drawFilledDRRect(const GrClip& clip,
     grPaint.addCoverageFragmentProcessor(std::move(outerEffect));
 
     SkRect bounds = outer->getBounds();
-    if (GrAAType::kCoverage == aaType) {
+    if (applyAA) {
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
     }
 
-    this->fillRectWithLocalMatrix(clip, grPaint, GrAA::kNo, SkMatrix::I(), bounds, inverseVM);
+    this->fillRectWithLocalMatrix(clip, grPaint, SkMatrix::I(), bounds, inverseVM);
     return true;
 }
 
 void GrRenderTargetContext::drawDRRect(const GrClip& clip,
                                        const GrPaint& paint,
-                                       GrAA aa,
                                        const SkMatrix& viewMatrix,
                                        const SkRRect& outer,
                                        const SkRRect& inner) {
@@ -1073,7 +1107,7 @@ void GrRenderTargetContext::drawDRRect(const GrClip& clip,
 
     AutoCheckFlush acf(fDrawingManager);
 
-    if (this->drawFilledDRRect(clip, paint, aa, viewMatrix, outer, inner)) {
+    if (this->drawFilledDRRect(clip, paint, viewMatrix, outer, inner)) {
         return;
     }
 
@@ -1083,7 +1117,7 @@ void GrRenderTargetContext::drawDRRect(const GrClip& clip,
     path.addRRect(outer);
     path.setFillType(SkPath::kEvenOdd_FillType);
 
-    this->internalDrawPath(clip, paint, aa, viewMatrix, path, GrStyle::SimpleFill());
+    this->internalDrawPath(clip, paint, viewMatrix, path, GrStyle::SimpleFill());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1094,7 +1128,6 @@ static inline bool is_int(float x) {
 
 void GrRenderTargetContext::drawRegion(const GrClip& clip,
                                        const GrPaint& paint,
-                                       GrAA aa,
                                        const SkMatrix& viewMatrix,
                                        const SkRegion& region,
                                        const GrStyle& style) {
@@ -1103,30 +1136,28 @@ void GrRenderTargetContext::drawRegion(const GrClip& clip,
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrRenderTargetContext::drawRegion");
 
-    if (GrAA::kYes == aa) {
+    bool needsAA = false;
+    if (paint.isAntiAlias()) {
         // GrRegionBatch performs no antialiasing but is much faster, so here we check the matrix
         // to see whether aa is really required.
-        if (!SkToBool(viewMatrix.getType() & ~(SkMatrix::kTranslate_Mask)) &&
-            is_int(viewMatrix.getTranslateX()) &&
-            is_int(viewMatrix.getTranslateY())) {
-            aa = GrAA::kNo;
-        }
+        needsAA = SkToBool(viewMatrix.getType() & ~(SkMatrix::kTranslate_Mask)) ||
+                  !is_int(viewMatrix.getTranslateX()) ||
+                  !is_int(viewMatrix.getTranslateY());
     }
     bool complexStyle = !style.isSimpleFill();
-    if (complexStyle || GrAA::kYes == aa) {
+    if (complexStyle || needsAA) {
         SkPath path;
         region.getBoundaryPath(&path);
-        return this->drawPath(clip, paint, aa, viewMatrix, path, style);
+        return this->drawPath(clip, paint, viewMatrix, path, style);
     }
 
     sk_sp<GrDrawOp> op(GrRegionBatch::Create(paint.getColor(), viewMatrix, region));
-    GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone);
+    GrPipelineBuilder pipelineBuilder(paint, false);
     this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
 }
 
 void GrRenderTargetContext::drawOval(const GrClip& clip,
                                      const GrPaint& paint,
-                                     GrAA aa,
                                      const SkMatrix& viewMatrix,
                                      const SkRect& oval,
                                      const GrStyle& style) {
@@ -1143,22 +1174,21 @@ void GrRenderTargetContext::drawOval(const GrClip& clip,
 
     AutoCheckFlush acf(fDrawingManager);
     const SkStrokeRec& stroke = style.strokeRec();
-    GrAAType aaType;
+    bool useHWAA;
 
     if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport() &&
         stroke.isFillStyle()) {
         InstancedRendering* ir = this->getOpList()->instancedRendering();
-        sk_sp<GrDrawOp> op(ir->recordOval(oval, viewMatrix, paint.getColor(), aa,
-                                          fInstancedPipelineInfo, &aaType));
+        sk_sp<GrDrawOp> op(ir->recordOval(oval, viewMatrix, paint.getColor(), paint.isAntiAlias(),
+                                          fInstancedPipelineInfo, &useHWAA));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
             return;
         }
     }
 
-    aaType = this->decideAAType(aa);
-    if (GrAAType::kCoverage == aaType) {
+    if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
         sk_sp<GrDrawOp> op(GrOvalRenderer::CreateOvalBatch(paint.getColor(),
                                                            viewMatrix,
@@ -1166,7 +1196,7 @@ void GrRenderTargetContext::drawOval(const GrClip& clip,
                                                            stroke,
                                                            shaderCaps));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
             return;
         }
@@ -1175,20 +1205,19 @@ void GrRenderTargetContext::drawOval(const GrClip& clip,
     SkPath path;
     path.setIsVolatile(true);
     path.addOval(oval);
-    this->internalDrawPath(clip, paint, aa, viewMatrix, path, style);
+    this->internalDrawPath(clip, paint, viewMatrix, path, style);
 }
 
 void GrRenderTargetContext::drawArc(const GrClip& clip,
                                     const GrPaint& paint,
-                                    GrAA aa,
                                     const SkMatrix& viewMatrix,
                                     const SkRect& oval,
                                     SkScalar startAngle,
                                     SkScalar sweepAngle,
                                     bool useCenter,
                                     const GrStyle& style) {
-    GrAAType aaType = this->decideAAType(aa);
-    if (GrAAType::kCoverage == aaType) {
+    bool useHWAA;
+    if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
         sk_sp<GrDrawOp> op(GrOvalRenderer::CreateArcBatch(paint.getColor(),
                                                           viewMatrix,
@@ -1199,7 +1228,7 @@ void GrRenderTargetContext::drawArc(const GrClip& clip,
                                                           style,
                                                           shaderCaps));
         if (op) {
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
             return;
         }
@@ -1207,7 +1236,8 @@ void GrRenderTargetContext::drawArc(const GrClip& clip,
     SkPath path;
     SkPathPriv::CreateDrawArcPath(&path, oval, startAngle, sweepAngle, useCenter,
                                   style.isSimpleFill());
-    this->internalDrawPath(clip, paint, aa, viewMatrix, path, style);
+    this->internalDrawPath(clip, paint, viewMatrix, path, style);
+    return;
 }
 
 void GrRenderTargetContext::drawImageLattice(const GrClip& clip,
@@ -1227,7 +1257,7 @@ void GrRenderTargetContext::drawImageLattice(const GrClip& clip,
     sk_sp<GrDrawOp> op(GrNinePatch::CreateNonAA(paint.getColor(), viewMatrix, imageWidth,
                                                 imageHeight, std::move(iter), dst));
 
-    GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone);
+    GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint));
     this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
 }
 
@@ -1256,12 +1286,11 @@ void GrRenderTargetContext::drawNonAAFilledRect(const GrClip& clip,
                                                 const SkRect* localRect,
                                                 const SkMatrix* localMatrix,
                                                 const GrUserStencilSettings* ss,
-                                                GrAAType hwOrNoneAAType) {
-    SkASSERT(GrAAType::kCoverage != hwOrNoneAAType);
-    SkASSERT(hwOrNoneAAType == GrAAType::kNone || this->isStencilBufferMultisampled());
+                                                bool useHWAA) {
+    SkASSERT(!useHWAA || this->isStencilBufferMultisampled());
     sk_sp<GrDrawOp> op( GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect,
                                                             localRect, localMatrix));
-    GrPipelineBuilder pipelineBuilder(paint, hwOrNoneAAType);
+    GrPipelineBuilder pipelineBuilder(paint, useHWAA);
     if (ss) {
         pipelineBuilder.setUserStencil(ss);
     }
@@ -1363,7 +1392,6 @@ static bool fills_as_nested_rects(const SkMatrix& viewMatrix, const SkPath& path
 
 void GrRenderTargetContext::drawPath(const GrClip& clip,
                                      const GrPaint& paint,
-                                     GrAA aa,
                                      const SkMatrix& viewMatrix,
                                      const SkPath& path,
                                      const GrStyle& style) {
@@ -1381,8 +1409,9 @@ void GrRenderTargetContext::drawPath(const GrClip& clip,
 
     AutoCheckFlush acf(fDrawingManager);
 
-    GrAAType aaType = this->decideAAType(aa);
-    if (GrAAType::kCoverage == aaType && !style.pathEffect()) {
+    bool useHWAA;
+    if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA) &&
+                                                                            !style.pathEffect()) {
         if (style.isSimpleFill() && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
@@ -1390,8 +1419,8 @@ void GrRenderTargetContext::drawPath(const GrClip& clip,
             if (fills_as_nested_rects(viewMatrix, path, rects)) {
                 sk_sp<GrDrawOp> op(GrRectBatchFactory::CreateAAFillNestedRects(
                     paint.getColor(), viewMatrix, rects));
-              if (op) {
-                    GrPipelineBuilder pipelineBuilder(paint, aaType);
+                if (op) {
+                    GrPipelineBuilder pipelineBuilder(paint, useHWAA);
                     this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
                 }
                 return;
@@ -1408,7 +1437,7 @@ void GrRenderTargetContext::drawPath(const GrClip& clip,
                                                                style.strokeRec(),
                                                                shaderCaps));
             if (op) {
-                GrPipelineBuilder pipelineBuilder(paint, aaType);
+                GrPipelineBuilder pipelineBuilder(paint, useHWAA);
                 this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get());
                 return;
             }
@@ -1420,24 +1449,23 @@ void GrRenderTargetContext::drawPath(const GrClip& clip,
     // cache. This presents a potential hazard for buffered drawing. However,
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
-    this->internalDrawPath(clip, paint, aa, viewMatrix, path, style);
+    this->internalDrawPath(clip, paint, viewMatrix, path, style);
 }
 
 bool GrRenderTargetContextPriv::drawAndStencilPath(const GrClip& clip,
                                                    const GrUserStencilSettings* ss,
                                                    SkRegion::Op op,
                                                    bool invert,
-                                                   GrAA aa,
+                                                   bool doAA,
                                                    const SkMatrix& viewMatrix,
                                                    const SkPath& path) {
     ASSERT_SINGLE_OWNER_PRIV
     RETURN_FALSE_IF_ABANDONED_PRIV
     SkDEBUGCODE(fRenderTargetContext->validate();)
-    GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail,
-                              "GrRenderTargetContextPriv::drawAndStencilPath");
+    GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail, "GrRenderTargetContext::drawPath");
 
     if (path.isEmpty() && path.isInverseFillType()) {
-        this->drawAndStencilRect(clip, ss, op, invert, GrAA::kNo, SkMatrix::I(),
+        this->drawAndStencilRect(clip, ss, op, invert, false, SkMatrix::I(),
                                  SkRect::MakeIWH(fRenderTargetContext->width(),
                                                  fRenderTargetContext->height()));
         return true;
@@ -1449,12 +1477,13 @@ bool GrRenderTargetContextPriv::drawAndStencilPath(const GrClip& clip,
     // 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.
-    GrAAType aaType = fRenderTargetContext->decideAAType(aa);
+    bool useCoverageAA = doAA && !fRenderTargetContext->isUnifiedMultisampled();
     bool hasUserStencilSettings = !ss->isUnused();
+    bool isStencilBufferMSAA = fRenderTargetContext->isStencilBufferMultisampled();
 
-    const GrPathRendererChain::DrawType type = (GrAAType::kCoverage == aaType)
-                                               ? GrPathRendererChain::kColorAntiAlias_DrawType
-                                               : GrPathRendererChain::kColor_DrawType;
+    const GrPathRendererChain::DrawType type =
+        useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType
+                      : GrPathRendererChain::kColor_DrawType;
 
     GrShape shape(path, GrStyle::SimpleFill());
     GrPathRenderer::CanDrawPathArgs canDrawArgs;
@@ -1462,8 +1491,9 @@ bool GrRenderTargetContextPriv::drawAndStencilPath(const GrClip& clip,
         fRenderTargetContext->fDrawingManager->getContext()->caps()->shaderCaps();
     canDrawArgs.fViewMatrix = &viewMatrix;
     canDrawArgs.fShape = &shape;
-    canDrawArgs.fAAType = aaType;
+    canDrawArgs.fAntiAlias = useCoverageAA;
     canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
+    canDrawArgs.fIsStencilBufferMSAA = isStencilBufferMSAA;
 
     // Don't allow the SW renderer
     GrPathRenderer* pr = fRenderTargetContext->fDrawingManager->getPathRenderer(canDrawArgs, false,
@@ -1484,7 +1514,7 @@ bool GrRenderTargetContextPriv::drawAndStencilPath(const GrClip& clip,
     args.fClip = &clip;
     args.fViewMatrix = &viewMatrix;
     args.fShape = &shape;
-    args.fAAType = aaType;
+    args.fAntiAlias = useCoverageAA;
     args.fGammaCorrect = fRenderTargetContext->isGammaCorrect();
     pr->drawPath(args);
     return true;
@@ -1504,71 +1534,55 @@ SkBudgeted GrRenderTargetContextPriv::isBudgeted() const {
 
 void GrRenderTargetContext::internalDrawPath(const GrClip& clip,
                                              const GrPaint& paint,
-                                             GrAA aa,
                                              const SkMatrix& viewMatrix,
                                              const SkPath& path,
                                              const GrStyle& style) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkASSERT(!path.isEmpty());
-    GrShape shape;
 
-    GrAAType aaType = this->decideAAType(aa, /*allowMixedSamples*/ true);
-    if (style.isSimpleHairline() && aaType == GrAAType::kMixedSamples) {
-        // NVPR cannot handle hairlines, so this will would get picked up by a different stencil and
-        // cover path renderer (i.e. default path renderer). The hairline renderer produces much
-        // smoother hairlines than MSAA.
-        aaType = GrAAType::kCoverage;
+    bool useCoverageAA = should_apply_coverage_aa(paint, fRenderTargetProxy.get());
+    constexpr bool kHasUserStencilSettings = false;
+    bool isStencilBufferMSAA = this->isStencilBufferMultisampled();
+
+    const GrPathRendererChain::DrawType type =
+        useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType
+                      : GrPathRendererChain::kColor_DrawType;
+
+    GrShape shape(path, style);
+    if (shape.isEmpty()) {
+        return;
     }
     GrPathRenderer::CanDrawPathArgs canDrawArgs;
     canDrawArgs.fShaderCaps = fDrawingManager->getContext()->caps()->shaderCaps();
     canDrawArgs.fViewMatrix = &viewMatrix;
     canDrawArgs.fShape = &shape;
-    canDrawArgs.fHasUserStencilSettings = false;
+    canDrawArgs.fAntiAlias = useCoverageAA;
+    canDrawArgs.fHasUserStencilSettings = kHasUserStencilSettings;
+    canDrawArgs.fIsStencilBufferMSAA = isStencilBufferMSAA;
 
-    GrPathRenderer* pr;
-    do {
-        const GrPathRendererChain::DrawType type = GrAAType::kCoverage == aaType
-                ? GrPathRendererChain::kColorAntiAlias_DrawType
-                : GrPathRendererChain::kColor_DrawType;
+    // Try a 1st time without applying any of the style to the geometry (and barring sw)
+    GrPathRenderer* pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type);
+    SkScalar styleScale =  GrStyle::MatrixToScaleFactor(viewMatrix);
 
-        shape = GrShape(path, style);
+    if (!pr && shape.style().pathEffect()) {
+        // It didn't work above, so try again with the path effect applied.
+        shape = shape.applyStyle(GrStyle::Apply::kPathEffectOnly, styleScale);
         if (shape.isEmpty()) {
             return;
         }
-
-        canDrawArgs.fAAType = aaType;
-
-        // Try a 1st time without applying any of the style to the geometry (and barring sw)
         pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type);
-        SkScalar styleScale =  GrStyle::MatrixToScaleFactor(viewMatrix);
-
-        if (!pr && shape.style().pathEffect()) {
-            // It didn't work above, so try again with the path effect applied.
-            shape = shape.applyStyle(GrStyle::Apply::kPathEffectOnly, styleScale);
+    }
+    if (!pr) {
+        if (shape.style().applies()) {
+            shape = shape.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, styleScale);
             if (shape.isEmpty()) {
                 return;
             }
-            pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type);
-        }
-        if (!pr) {
-            if (shape.style().applies()) {
-                shape = shape.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, styleScale);
-                if (shape.isEmpty()) {
-                    return;
-                }
-            }
-            // This time, allow SW renderer
-            pr = fDrawingManager->getPathRenderer(canDrawArgs, true, type);
-        }
-        if (!pr && (aaType == GrAAType::kMixedSamples || aaType == GrAAType::kMSAA)) {
-            // There are exceptional cases where we may wind up falling back to coverage based AA
-            // when the target is MSAA (e.g. through disabling path renderers via GrContextOptions).
-            aaType = GrAAType::kCoverage;
-        } else {
-            break;
         }
-    } while(true);
+        // This time, allow SW renderer
+        pr = fDrawingManager->getPathRenderer(canDrawArgs, true, type);
+    }
 
     if (!pr) {
 #ifdef SK_DEBUG
@@ -1584,8 +1598,8 @@ void GrRenderTargetContext::internalDrawPath(const GrClip& clip,
     args.fRenderTargetContext = this;
     args.fClip = &clip;
     args.fViewMatrix = &viewMatrix;
-    args.fShape = &shape;
-    args.fAAType = aaType;
+    args.fShape = canDrawArgs.fShape;
+    args.fAntiAlias = useCoverageAA;
     args.fGammaCorrect = this->isGammaCorrect();
     pr->drawPath(args);
 }
diff --git a/src/gpu/GrRenderTargetContextPriv.h b/src/gpu/GrRenderTargetContextPriv.h
index d53bd5634b..b2e647d70b 100644
--- a/src/gpu/GrRenderTargetContextPriv.h
+++ b/src/gpu/GrRenderTargetContextPriv.h
@@ -66,33 +66,28 @@ public:
 
     void stencilRect(const GrClip& clip,
                      const GrUserStencilSettings* ss,
-                     GrAAType,
+                     bool useHWAA,
                      const SkMatrix& viewMatrix,
                      const SkRect& rect);
 
-    void stencilPath(const GrClip&, GrAAType, const SkMatrix& viewMatrix, const GrPath*);
+    void stencilPath(const GrClip&,
+                     bool useHWAA,
+                     const SkMatrix& viewMatrix,
+                     const GrPath*);
 
-    /**
-     * Draws a rect, either AA or not, and touches the stencil buffer with the user stencil settings
-     * for each color sample written.
-     */
     bool drawAndStencilRect(const GrClip&,
                             const GrUserStencilSettings*,
                             SkRegion::Op op,
                             bool invert,
-                            GrAA,
+                            bool doAA,
                             const SkMatrix& viewMatrix,
                             const SkRect&);
 
-    /**
-     * Draws a path, either AA or not, and touches the stencil buffer with the user stencil settings
-     * for each color sample written.
-     */
     bool drawAndStencilPath(const GrClip&,
                             const GrUserStencilSettings*,
                             SkRegion::Op op,
                             bool invert,
-                            GrAA,
+                            bool doAA,
                             const SkMatrix& viewMatrix,
                             const SkPath&);
 
@@ -109,7 +104,6 @@ public:
     }
 
     void testingOnly_drawBatch(const GrPaint&,
-                               GrAAType,
                                GrDrawOp* batch,
                                const GrUserStencilSettings* = nullptr,
                                bool snapToCenters = false);
diff --git a/src/gpu/GrRenderTargetOpList.cpp b/src/gpu/GrRenderTargetOpList.cpp
index 80b0a83610..41c0d4f9fd 100644
--- a/src/gpu/GrRenderTargetOpList.cpp
+++ b/src/gpu/GrRenderTargetOpList.cpp
@@ -351,10 +351,9 @@ void GrRenderTargetOpList::addDrawOp(const GrPipelineBuilder& pipelineBuilder,
 
 void GrRenderTargetOpList::stencilPath(GrRenderTargetContext* renderTargetContext,
                                        const GrClip& clip,
-                                       GrAAType aaType,
+                                       bool useHWAA,
                                        const SkMatrix& viewMatrix,
                                        const GrPath* path) {
-    bool useHWAA = (aaType == GrAAType::kMSAA || aaType == GrAAType::kMixedSamples);
     // TODO: extract portions of checkDraw that are relevant to path stenciling.
     SkASSERT(path);
     SkASSERT(this->caps()->shaderCaps()->pathRenderingSupport());
diff --git a/src/gpu/GrRenderTargetOpList.h b/src/gpu/GrRenderTargetOpList.h
index 7ee4470aac..d7f8ba1bab 100644
--- a/src/gpu/GrRenderTargetOpList.h
+++ b/src/gpu/GrRenderTargetOpList.h
@@ -95,7 +95,7 @@ public:
      */
     void stencilPath(GrRenderTargetContext*,
                      const GrClip&,
-                     GrAAType aa,
+                     bool useHWAA,
                      const SkMatrix& viewMatrix,
                      const GrPath*);
 
diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp
index 7351ecd547..ec76c48bf9 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -38,11 +38,12 @@ static SkBlendMode op_to_mode(SkRegion::Op op) {
 /**
  * Draw a single rect element of the clip stack into the accumulation bitmap
  */
-void GrSWMaskHelper::drawRect(const SkRect& rect, SkRegion::Op op, GrAA aa, uint8_t alpha) {
+void GrSWMaskHelper::drawRect(const SkRect& rect, SkRegion::Op op,
+                              bool antiAlias, uint8_t alpha) {
     SkPaint paint;
 
     paint.setBlendMode(op_to_mode(op));
-    paint.setAntiAlias(GrAA::kYes == aa);
+    paint.setAntiAlias(antiAlias);
     paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
 
     fDraw.drawRect(rect, paint);
@@ -51,11 +52,12 @@ void GrSWMaskHelper::drawRect(const SkRect& rect, SkRegion::Op op, GrAA aa, uint
 /**
  * Draw a single path element of the clip stack into the accumulation bitmap
  */
-void GrSWMaskHelper::drawShape(const GrShape& shape, SkRegion::Op op, GrAA aa, uint8_t alpha) {
+void GrSWMaskHelper::drawShape(const GrShape& shape, SkRegion::Op op, bool antiAlias,
+                               uint8_t alpha) {
     SkPaint paint;
     paint.setPathEffect(sk_ref_sp(shape.style().pathEffect()));
     shape.style().strokeRec().applyToPaint(&paint);
-    paint.setAntiAlias(GrAA::kYes == aa);
+    paint.setAntiAlias(antiAlias);
 
     SkPath path;
     shape.asPath(&path);
@@ -139,7 +141,7 @@ void GrSWMaskHelper::toSDF(unsigned char* sdf) {
 GrTexture* GrSWMaskHelper::DrawShapeMaskToTexture(GrTextureProvider* texProvider,
                                                   const GrShape& shape,
                                                   const SkIRect& resultBounds,
-                                                  GrAA aa,
+                                                  bool antiAlias,
                                                   TextureType textureType,
                                                   const SkMatrix* matrix) {
     GrSWMaskHelper helper(texProvider);
@@ -148,7 +150,7 @@ GrTexture* GrSWMaskHelper::DrawShapeMaskToTexture(GrTextureProvider* texProvider
         return nullptr;
     }
 
-    helper.drawShape(shape, SkRegion::kReplace_Op, aa, 0xFF);
+    helper.drawShape(shape, SkRegion::kReplace_Op, antiAlias, 0xFF);
 
     GrTexture* texture(helper.createTexture(textureType));
     if (!texture) {
@@ -183,7 +185,7 @@ void GrSWMaskHelper::DrawToTargetWithShapeMask(GrTexture* texture,
     maskMatrix.preTranslate(SkIntToScalar(-textureOriginInDeviceSpace.fX),
                             SkIntToScalar(-textureOriginInDeviceSpace.fY));
     maskMatrix.preConcat(viewMatrix);
-    GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone);
+    GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint));
     pipelineBuilder.setUserStencil(&userStencilSettings);
 
     pipelineBuilder.addCoverageFragmentProcessor(
diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h
index 0669db9f1b..1846733dd9 100644
--- a/src/gpu/GrSWMaskHelper.h
+++ b/src/gpu/GrSWMaskHelper.h
@@ -9,7 +9,6 @@
 #define GrSWMaskHelper_DEFINED
 
 #include "GrColor.h"
-#include "GrRenderTargetContext.h"
 #include "GrTextureProvider.h"
 #include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
@@ -52,10 +51,10 @@ public:
     bool init(const SkIRect& resultBounds, const SkMatrix* matrix);
 
     // Draw a single rect into the accumulation bitmap using the specified op
-    void drawRect(const SkRect& rect, SkRegion::Op op, GrAA, uint8_t alpha);
+    void drawRect(const SkRect& rect, SkRegion::Op op, bool antiAlias, uint8_t alpha);
 
     // Draw a single path into the accumuation bitmap using the specified op
-    void drawShape(const GrShape&, SkRegion::Op op, GrAA, uint8_t alpha);
+    void drawShape(const GrShape&, SkRegion::Op op, bool antiAlias, uint8_t alpha);
 
     // Move the mask generation results from the internal bitmap to the gpu.
     void toTexture(GrTexture* texture);
@@ -68,6 +67,7 @@ public:
         fPixels.erase(SkColorSetARGB(alpha, 0xFF, 0xFF, 0xFF));
     }
 
+
     enum class TextureType {
         kExactFit,
         kApproximateFit
@@ -78,7 +78,7 @@ public:
     static GrTexture* DrawShapeMaskToTexture(GrTextureProvider*,
                                              const GrShape&,
                                              const SkIRect& resultBounds,
-                                             GrAA,
+                                             bool antiAlias,
                                              TextureType,
                                              const SkMatrix* matrix);
 
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index 73080a6ba0..8b941ebaff 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -18,8 +18,7 @@
 bool GrSoftwarePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // Pass on any style that applies. The caller will apply the style if a suitable renderer is
     // not found and try again with the new GrShape.
-    return !args.fShape->style().applies() && SkToBool(fTexProvider) &&
-           (args.fAAType == GrAAType::kCoverage || args.fAAType == GrAAType::kNone);
+    return !args.fShape->style().applies() && SkToBool(fTexProvider);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -72,8 +71,9 @@ void GrSoftwarePathRenderer::DrawNonAARect(GrRenderTargetContext* renderTargetCo
                                                               viewMatrix, rect,
                                                               nullptr, &localMatrix));
 
-    GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone);
+    GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint));
     pipelineBuilder.setUserStencil(&userStencilSettings);
+
     renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get());
 }
 
@@ -135,7 +135,7 @@ bool GrSoftwarePathRenderer::onDrawPath(const DrawPathArgs& args) {
     // To prevent overloading the cache with entries during animations we limit the cache of masks
     // to cases where the matrix preserves axis alignment.
     bool useCache = fAllowCaching && !inverseFilled && args.fViewMatrix->preservesAxisAlignment() &&
-                    args.fShape->hasUnstyledKey() && GrAAType::kCoverage == args.fAAType;
+                    args.fShape->hasUnstyledKey() && args.fAntiAlias;
 
     if (!get_shape_and_clip_bounds(args.fRenderTargetContext->width(),
                                    args.fRenderTargetContext->height(),
@@ -193,8 +193,6 @@ bool GrSoftwarePathRenderer::onDrawPath(const DrawPathArgs& args) {
         builder[3] = SkFloat2Bits(ky);
         builder[4] = fracX | (fracY >> 8);
         args.fShape->writeUnstyledKey(&builder[5]);
-        // FIXME: Doesn't the key need to consider whether we're using AA or not? In practice that
-        // should always be true, though.
     }
 
     sk_sp<GrTexture> texture;
@@ -202,24 +200,25 @@ bool GrSoftwarePathRenderer::onDrawPath(const DrawPathArgs& args) {
         texture.reset(args.fResourceProvider->findAndRefTextureByUniqueKey(maskKey));
     }
     if (!texture) {
-        GrSWMaskHelper::TextureType type = useCache ? GrSWMaskHelper::TextureType::kExactFit
-                                                    : GrSWMaskHelper::TextureType::kApproximateFit;
-        GrAA aa = GrAAType::kCoverage == args.fAAType ? GrAA::kYes : GrAA::kNo;
-        texture.reset(GrSWMaskHelper::DrawShapeMaskToTexture(fTexProvider, *args.fShape,
-                                                             *boundsForMask, aa,
-                                                             type, args.fViewMatrix));
-        if (!texture) {
-            return false;
-        }
-        if (useCache) {
-            texture->resourcePriv().setUniqueKey(maskKey);
-        }
+         GrSWMaskHelper::TextureType type = useCache ? GrSWMaskHelper::TextureType::kExactFit
+                                                     : GrSWMaskHelper::TextureType::kApproximateFit;
+         texture.reset(GrSWMaskHelper::DrawShapeMaskToTexture(fTexProvider, *args.fShape,
+                                                              *boundsForMask, args.fAntiAlias,
+                                                              type, args.fViewMatrix));
+         if (!texture) {
+             return false;
+         }
+         if (useCache) {
+             texture->resourcePriv().setUniqueKey(maskKey);
+         }
     }
+
     GrSWMaskHelper::DrawToTargetWithShapeMask(texture.get(), args.fRenderTargetContext,
                                               *args.fPaint, *args.fUserStencilSettings,
                                               *args.fClip, *args.fViewMatrix,
                                               SkIPoint {boundsForMask->fLeft, boundsForMask->fTop},
                                               *boundsForMask);
+
     if (inverseFilled) {
         DrawAroundInvPath(args.fRenderTargetContext, *args.fPaint, *args.fUserStencilSettings,
                           *args.fClip,
diff --git a/src/gpu/GrTextureProducer.cpp b/src/gpu/GrTextureProducer.cpp
index 8b64feaed3..14e2c29bb8 100644
--- a/src/gpu/GrTextureProducer.cpp
+++ b/src/gpu/GrTextureProducer.cpp
@@ -69,7 +69,7 @@ GrTexture* GrTextureProducer::CopyOnGpu(GrTexture* inputTexture, const SkIRect*
     }
 
     SkRect dstRect = SkRect::MakeIWH(copyParams.fWidth, copyParams.fHeight);
-    copyRTC->fillRectToRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), dstRect, localRect);
+    copyRTC->fillRectToRect(GrNoClip(), paint, SkMatrix::I(), dstRect, localRect);
     return copyRTC->asTexture().release();
 }
 
diff --git a/src/gpu/GrTextureToYUVPlanes.cpp b/src/gpu/GrTextureToYUVPlanes.cpp
index 6268bef003..ff6c707621 100644
--- a/src/gpu/GrTextureToYUVPlanes.cpp
+++ b/src/gpu/GrTextureToYUVPlanes.cpp
@@ -43,7 +43,7 @@ static bool convert_texture(GrTexture* src, GrRenderTargetContext* dst, int dstW
     GrPaint paint;
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
     paint.addColorFragmentProcessor(std::move(fp));
-    dst->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), SkRect::MakeIWH(dstW, dstH));
+    dst->drawRect(GrNoClip(), paint, SkMatrix::I(), SkRect::MakeIWH(dstW, dstH));
     return true;
 }
 
diff --git a/src/gpu/GrYUVProvider.cpp b/src/gpu/GrYUVProvider.cpp
index 6fbad18841..13e84dad75 100644
--- a/src/gpu/GrYUVProvider.cpp
+++ b/src/gpu/GrYUVProvider.cpp
@@ -147,7 +147,7 @@ sk_sp<GrTexture> GrYUVProvider::refAsTexture(GrContext* ctx,
     const SkRect r = SkRect::MakeIWH(yuvInfo.fSizeInfo.fSizes[SkYUVSizeInfo::kY].fWidth,
             yuvInfo.fSizeInfo.fSizes[SkYUVSizeInfo::kY].fHeight);
 
-    renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), r);
+    renderTargetContext->drawRect(GrNoClip(), paint, SkMatrix::I(), r);
 
     return renderTargetContext->asTexture();
 }
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 8da4d63071..4e91f4a5f2 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -342,8 +342,7 @@ void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
         path.setIsVolatile(true);
         path.moveTo(pts[0]);
         path.lineTo(pts[1]);
-        fRenderTargetContext->drawPath(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()),
-                                       *draw.fMatrix, path, style);
+        fRenderTargetContext->drawPath(fClip, grPaint, *draw.fMatrix, path, style);
         return;
     }
 
@@ -419,13 +418,13 @@ void SkGpuDevice::drawRect(const SkDraw& draw, const SkRect& rect, const SkPaint
     }
 
     GrStyle style(paint);
-    fRenderTargetContext->drawRect(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix,
-                                   rect, &style);
+    fRenderTargetContext->drawRect(fClip, grPaint, *draw.fMatrix, rect, &style);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPaint& paint) {
+void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect,
+                            const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawRRect", fContext.get());
     CHECK_SHOULD_DRAW(draw);
@@ -484,8 +483,7 @@ void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPa
 
     SkASSERT(!style.pathEffect());
 
-    fRenderTargetContext->drawRRect(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix,
-                                    rrect, style);
+    fRenderTargetContext->drawRRect(fClip, grPaint, *draw.fMatrix, rrect, style);
 }
 
 
@@ -512,8 +510,7 @@ void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
             return;
         }
 
-        fRenderTargetContext->drawDRRect(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()),
-                                         *draw.fMatrix, outer, inner);
+        fRenderTargetContext->drawDRRect(fClip, grPaint, *draw.fMatrix, outer, inner);
         return;
     }
 
@@ -545,8 +542,7 @@ void SkGpuDevice::drawRegion(const SkDraw& draw, const SkRegion& region, const S
         return;
     }
 
-    fRenderTargetContext->drawRegion(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix,
-                                     region, GrStyle(paint));
+    fRenderTargetContext->drawRegion(fClip, grPaint, *draw.fMatrix, region, GrStyle(paint));
 }
 
 void SkGpuDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& paint) {
@@ -575,8 +571,7 @@ void SkGpuDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint
         return;
     }
 
-    fRenderTargetContext->drawOval(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix,
-                                   oval, GrStyle(paint));
+    fRenderTargetContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, GrStyle(paint));
 }
 
 void SkGpuDevice::drawArc(const SkDraw& draw, const SkRect& oval, SkScalar startAngle,
@@ -595,8 +590,8 @@ void SkGpuDevice::drawArc(const SkDraw& draw, const SkRect& oval, SkScalar start
         return;
     }
 
-    fRenderTargetContext->drawArc(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix,
-                                  oval, startAngle, sweepAngle, useCenter, GrStyle(paint));
+    fRenderTargetContext->drawArc(fClip, grPaint, *draw.fMatrix, oval, startAngle, sweepAngle,
+                                  useCenter, GrStyle(paint));
 }
 
 #include "SkMaskFilter.h"
@@ -652,9 +647,7 @@ void SkGpuDevice::drawStrokedLine(const SkPoint points[2],
         return;
     }
 
-    fRenderTargetContext->fillRectWithLocalMatrix(fClip, grPaint,
-                                                  GrBoolToAA(newPaint.isAntiAlias()), m, rect,
-                                                  local);
+    fRenderTargetContext->fillRectWithLocalMatrix(fClip, grPaint, m, rect, local);
 }
 
 void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
@@ -1104,10 +1097,7 @@ void SkGpuDevice::drawBitmapTile(const SkBitmap& bitmap,
         return;
     }
 
-    // Coverage-based AA would cause seams between tiles.
-    GrAA aa = GrBoolToAA(paint.isAntiAlias() &&
-                         fRenderTargetContext->isStencilBufferMultisampled());
-    fRenderTargetContext->drawRect(fClip, grPaint, aa, viewMatrix, dstRect);
+    fRenderTargetContext->drawRect(fClip, grPaint, viewMatrix, dstRect);
 }
 
 void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
@@ -1202,7 +1192,6 @@ void SkGpuDevice::drawSpecial(const SkDraw& draw,
 
     fRenderTargetContext->fillRectToRect(fClip,
                                          grPaint,
-                                         GrBoolToAA(paint.isAntiAlias()),
                                          SkMatrix::I(),
                                          SkRect::Make(SkIRect::MakeXYWH(left + offset.fX,
                                                                         top + offset.fY,
diff --git a/src/gpu/SkGpuDevice_drawTexture.cpp b/src/gpu/SkGpuDevice_drawTexture.cpp
index fe14f8ac87..93c9f18737 100644
--- a/src/gpu/SkGpuDevice_drawTexture.cpp
+++ b/src/gpu/SkGpuDevice_drawTexture.cpp
@@ -213,15 +213,15 @@ void SkGpuDevice::drawTextureProducerImpl(GrTextureProducer* producer,
                                      fp, producer->isAlphaOnly(), &grPaint)) {
         return;
     }
-    GrAA aa = GrBoolToAA(paint.isAntiAlias());
+
     if (canUseTextureCoordsAsLocalCoords) {
-        fRenderTargetContext->fillRectToRect(clip, grPaint, aa, viewMatrix, clippedDstRect,
+        fRenderTargetContext->fillRectToRect(clip, grPaint, viewMatrix, clippedDstRect,
                                              clippedSrcRect);
         return;
     }
 
     if (!mf) {
-        fRenderTargetContext->drawRect(clip, grPaint, aa, viewMatrix, clippedDstRect);
+        fRenderTargetContext->drawRect(clip, grPaint, viewMatrix, clippedDstRect);
         return;
     }
 
@@ -247,6 +247,6 @@ void SkGpuDevice::drawTextureProducerImpl(GrTextureProducer* producer,
     rectPath.addRect(clippedDstRect);
     rectPath.setIsVolatile(true);
     GrBlurUtils::drawPathWithMaskFilter(this->context(), fRenderTargetContext.get(), fClip,
-                                        rectPath, &grPaint, aa, viewMatrix, mf,
-                                        GrStyle::SimpleFill(), true);
+                                        rectPath, &grPaint, viewMatrix, mf, GrStyle::SimpleFill(),
+                                        true);
 }
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 4d62e6fd02..6ce9caed19 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -558,6 +558,7 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context,
                                            SkBlendMode* primColorMode,
                                            bool primitiveIsSrc,
                                            GrPaint* grPaint) {
+    grPaint->setAntiAlias(skPaint.isAntiAlias());
     grPaint->setAllowSRGBInputs(rtc->isGammaCorrect());
 
     // Convert SkPaint color to 4f format, including optional linearizing and gamut conversion.
diff --git a/src/gpu/batches/GrAAConvexPathRenderer.cpp b/src/gpu/batches/GrAAConvexPathRenderer.cpp
index cc31f4973a..56a5e7ae14 100644
--- a/src/gpu/batches/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/batches/GrAAConvexPathRenderer.cpp
@@ -672,7 +672,7 @@ sk_sp<GrGeometryProcessor> QuadEdgeEffect::TestCreate(GrProcessorTestData* d) {
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAAConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
-    return (args.fShaderCaps->shaderDerivativeSupport() && (GrAAType::kCoverage == args.fAAType) &&
+    return (args.fShaderCaps->shaderDerivativeSupport() && args.fAntiAlias &&
             args.fShape->style().isSimpleFill() && !args.fShape->inverseFilled() &&
             args.fShape->knownToBeConvex());
 }
@@ -1002,7 +1002,7 @@ bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
 
     sk_sp<GrDrawOp> batch(new AAConvexPathBatch(args.fPaint->getColor(), *args.fViewMatrix, path));
 
-    GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
+    GrPipelineBuilder pipelineBuilder(*args.fPaint);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
     args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get());
diff --git a/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp b/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp
index 71b9000482..0aa451df86 100644
--- a/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp
+++ b/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp
@@ -90,8 +90,8 @@ bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) c
     if (!args.fShape->style().isSimpleFill()) {
         return false;
     }
-    // This does non-inverse coverage-based antialiased fills.
-    if (GrAAType::kCoverage != args.fAAType) {
+    // This does non-inverse antialiased fills.
+    if (!args.fAntiAlias) {
         return false;
     }
     // TODO: Support inverse fill
@@ -128,6 +128,7 @@ public:
 
     AADistanceFieldPathBatch(GrColor color,
                              const GrShape& shape,
+                             bool antiAlias,
                              const SkMatrix& viewMatrix,
                              GrBatchAtlas* atlas,
                              ShapeCache* shapeCache, ShapeDataList* shapeList,
@@ -135,7 +136,7 @@ public:
             : INHERITED(ClassID()) {
         SkASSERT(shape.hasUnstyledKey());
         fBatch.fViewMatrix = viewMatrix;
-        fGeoData.emplace_back(Geometry{color, shape});
+        fGeoData.emplace_back(Geometry{color, shape, antiAlias});
 
         fAtlas = atlas;
         fShapeCache = shapeCache;
@@ -156,7 +157,7 @@ public:
     SkString dumpInfo() const override {
         SkString string;
         for (const auto& geo : fGeoData) {
-            string.appendf("Color: 0x%08x\n", geo.fColor);
+            string.appendf("Color: 0x%08x AA:%d\n", geo.fColor, geo.fAntiAlias);
         }
         string.append(DumpPipelineInfo(*this->pipeline()));
         string.append(INHERITED::dumpInfo());
@@ -273,6 +274,7 @@ private:
                                           atlas,
                                           shapeData,
                                           args.fShape,
+                                          args.fAntiAlias,
                                           desiredDimension,
                                           scale)) {
                     delete shapeData;
@@ -298,8 +300,8 @@ private:
     }
 
     bool addPathToAtlas(GrMeshDrawOp::Target* target, FlushInfo* flushInfo, GrBatchAtlas* atlas,
-                        ShapeData* shapeData, const GrShape& shape, uint32_t dimension,
-                        SkScalar scale) const {
+                        ShapeData* shapeData, const GrShape& shape, bool antiAlias,
+                        uint32_t dimension, SkScalar scale) const {
         const SkRect& bounds = shape.bounds();
 
         // generate bounding rect for bitmap draw
@@ -346,7 +348,7 @@ private:
         // rasterize path
         SkPaint paint;
         paint.setStyle(SkPaint::kFill_Style);
-        paint.setAntiAlias(true);
+        paint.setAntiAlias(antiAlias);
 
         SkDraw draw;
         sk_bzero(&draw, sizeof(draw));
@@ -500,6 +502,7 @@ private:
     struct Geometry {
         GrColor fColor;
         GrShape fShape;
+        bool fAntiAlias;
     };
 
     BatchTracker fBatch;
@@ -515,6 +518,8 @@ private:
 bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
                               "GrAADistanceFieldPathRenderer::onDrawPath");
+    SkASSERT(!args.fRenderTargetContext->isUnifiedMultisampled());
+    SkASSERT(args.fShape->style().isSimpleFill());
 
     // we've already bailed on inverse filled paths, so this is safe
     SkASSERT(!args.fShape->isEmpty());
@@ -531,10 +536,11 @@ bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) {
     }
 
     sk_sp<GrDrawOp> batch(new AADistanceFieldPathBatch(args.fPaint->getColor(),
-                                                       *args.fShape, *args.fViewMatrix,
+                                                       *args.fShape,
+                                                       args.fAntiAlias, *args.fViewMatrix,
                                                        fAtlas.get(), &fShapeCache, &fShapeList,
                                                        args.fGammaCorrect));
-    GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
+    GrPipelineBuilder pipelineBuilder(*args.fPaint);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
     args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get());
@@ -608,9 +614,11 @@ DRAW_BATCH_TEST_DEFINE(AADistanceFieldPathBatch) {
 
     // This path renderer only allows fill styles.
     GrShape shape(GrTest::TestPath(random), GrStyle::SimpleFill());
+    bool antiAlias = random->nextBool();
 
     return new AADistanceFieldPathBatch(color,
                                         shape,
+                                        antiAlias,
                                         viewMatrix,
                                         gTestStruct.fAtlas.get(),
                                         &gTestStruct.fShapeCache,
diff --git a/src/gpu/batches/GrAAHairLinePathRenderer.cpp b/src/gpu/batches/GrAAHairLinePathRenderer.cpp
index 732d694b45..662010f7c9 100644
--- a/src/gpu/batches/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/batches/GrAAHairLinePathRenderer.cpp
@@ -617,7 +617,7 @@ static void add_line(const SkPoint p[2],
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAAHairLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
-    if (GrAAType::kCoverage != args.fAAType) {
+    if (!args.fAntiAlias) {
         return false;
     }
 
@@ -981,7 +981,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
                                                 *args.fViewMatrix, path,
                                                 args.fShape->style(), devClipBounds));
 
-    GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
+    GrPipelineBuilder pipelineBuilder(*args.fPaint);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
     args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get());
 
diff --git a/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp
index cbf526c807..f961c5eb74 100644
--- a/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp
@@ -37,7 +37,7 @@ GrAALinearizingConvexPathRenderer::GrAALinearizingConvexPathRenderer() {
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAALinearizingConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
-    if (GrAAType::kCoverage != args.fAAType) {
+    if (!args.fAntiAlias) {
         return false;
     }
     if (!args.fShape->knownToBeConvex()) {
@@ -361,7 +361,7 @@ bool GrAALinearizingConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
                                                           stroke.getStyle(),
                                                           join, miterLimit));
 
-    GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
+    GrPipelineBuilder pipelineBuilder(*args.fPaint);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
     args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get());
diff --git a/src/gpu/batches/GrDashLinePathRenderer.cpp b/src/gpu/batches/GrDashLinePathRenderer.cpp
index 9304885c9d..d2a420d4be 100644
--- a/src/gpu/batches/GrDashLinePathRenderer.cpp
+++ b/src/gpu/batches/GrDashLinePathRenderer.cpp
@@ -16,9 +16,6 @@ bool GrDashLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     SkPoint pts[2];
     bool inverted;
     if (args.fShape->style().isDashed() && args.fShape->asLine(pts, &inverted)) {
-        if (args.fAAType == GrAAType::kMixedSamples) {
-            return false;
-        }
         // We should never have an inverse dashed case.
         SkASSERT(!inverted);
         return GrDashingEffect::CanDrawDashLine(pts, args.fShape->style(), *args.fViewMatrix);
@@ -29,19 +26,16 @@ bool GrDashLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
 bool GrDashLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
                               "GrDashLinePathRenderer::onDrawPath");
-    GrDashingEffect::AAMode aaMode = GrDashingEffect::AAMode::kNone;
-    switch (args.fAAType) {
-        case GrAAType::kNone:
-            break;
-        case GrAAType::kCoverage:
-        case GrAAType::kMixedSamples:
-            aaMode = GrDashingEffect::AAMode::kCoverage;
-            break;
-        case GrAAType::kMSAA:
-            // In this mode we will use aa between dashes but the outer border uses MSAA. Otherwise,
-            // we can wind up with external edges antialiased and internal edges unantialiased.
-            aaMode = GrDashingEffect::AAMode::kCoverageWithMSAA;
-            break;
+    bool useHWAA = args.fRenderTargetContext->isUnifiedMultisampled();
+    GrDashingEffect::AAMode aaMode;
+    if (useHWAA) {
+        // We ignore args.fAntiAlias here and force anti aliasing when using MSAA. Otherwise,
+        // we can wind up with external edges antialiased and internal edges unantialiased.
+        aaMode = GrDashingEffect::AAMode::kCoverageWithMSAA;
+    } else if (args.fAntiAlias) {
+        aaMode = GrDashingEffect::AAMode::kCoverage;
+    } else {
+        aaMode = GrDashingEffect::AAMode::kNone;
     }
     SkPoint pts[2];
     SkAssertResult(args.fShape->asLine(pts, nullptr));
@@ -54,7 +48,7 @@ bool GrDashLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
         return false;
     }
 
-    GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
+    GrPipelineBuilder pipelineBuilder(*args.fPaint, useHWAA);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
     args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get());
diff --git a/src/gpu/batches/GrDefaultPathRenderer.cpp b/src/gpu/batches/GrDefaultPathRenderer.cpp
index 0b688c5305..f3f9e73155 100644
--- a/src/gpu/batches/GrDefaultPathRenderer.cpp
+++ b/src/gpu/batches/GrDefaultPathRenderer.cpp
@@ -424,13 +424,11 @@ private:
 
 bool GrDefaultPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetContext,
                                              const GrPaint& paint,
-                                             GrAAType aaType,
                                              const GrUserStencilSettings& userStencilSettings,
                                              const GrClip& clip,
                                              const SkMatrix& viewMatrix,
                                              const GrShape& shape,
                                              bool stencilOnly) {
-    SkASSERT(GrAAType::kCoverage != aaType);
     SkPath path;
     shape.asPath(&path);
 
@@ -569,20 +567,23 @@ bool GrDefaultPathRenderer::internalDrawPath(GrRenderTargetContext* renderTarget
                                                         &localMatrix));
 
             SkASSERT(GrDrawFace::kBoth == drawFace[p]);
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint));
             pipelineBuilder.setDrawFace(drawFace[p]);
             pipelineBuilder.setUserStencil(passes[p]);
+
             renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get());
         } else {
             sk_sp<GrDrawOp> batch(new DefaultPathBatch(paint.getColor(), path, srcSpaceTol,
                                                        newCoverage, viewMatrix, isHairline,
                                                        devBounds));
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+
+            GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint));
             pipelineBuilder.setDrawFace(drawFace[p]);
             pipelineBuilder.setUserStencil(passes[p]);
             if (passCount > 1) {
                 pipelineBuilder.setDisableColorXPFactory();
             }
+
             renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get());
         }
     }
@@ -590,8 +591,8 @@ bool GrDefaultPathRenderer::internalDrawPath(GrRenderTargetContext* renderTarget
 }
 
 bool GrDefaultPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
-    // This can draw any path with any simple fill style but doesn't do coverage-based antialiasing.
-    return GrAAType::kCoverage != args.fAAType &&
+    // this class can draw any path with any simple fill style but doesn't do any anti-aliasing.
+    return !args.fAntiAlias &&
            (args.fShape->style().isSimpleFill() ||
             IsStrokeHairlineOrEquivalent(args.fShape->style(), *args.fViewMatrix, nullptr));
 }
@@ -601,7 +602,6 @@ bool GrDefaultPathRenderer::onDrawPath(const DrawPathArgs& args) {
                               "GrDefaultPathRenderer::onDrawPath");
     return this->internalDrawPath(args.fRenderTargetContext,
                                   *args.fPaint,
-                                  args.fAAType,
                                   *args.fUserStencilSettings,
                                   *args.fClip,
                                   *args.fViewMatrix,
@@ -616,10 +616,10 @@ void GrDefaultPathRenderer::onStencilPath(const StencilPathArgs& args) {
 
     GrPaint paint;
     paint.setXPFactory(GrDisableColorXPFactory::Make());
+    paint.setAntiAlias(args.fIsAA);
 
-    this->internalDrawPath(args.fRenderTargetContext, paint, args.fAAType,
-                           GrUserStencilSettings::kUnused, *args.fClip, *args.fViewMatrix,
-                           *args.fShape, true);
+    this->internalDrawPath(args.fRenderTargetContext, paint, GrUserStencilSettings::kUnused,
+                           *args.fClip, *args.fViewMatrix, *args.fShape, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/batches/GrDefaultPathRenderer.h b/src/gpu/batches/GrDefaultPathRenderer.h
index 8e192478b1..243d4e7d92 100644
--- a/src/gpu/batches/GrDefaultPathRenderer.h
+++ b/src/gpu/batches/GrDefaultPathRenderer.h
@@ -32,7 +32,6 @@ private:
 
     bool internalDrawPath(GrRenderTargetContext*,
                           const GrPaint&,
-                          GrAAType,
                           const GrUserStencilSettings&,
                           const GrClip&,
                           const SkMatrix& viewMatrix,
diff --git a/src/gpu/batches/GrMSAAPathRenderer.cpp b/src/gpu/batches/GrMSAAPathRenderer.cpp
index 930f7f926a..f073db0a28 100644
--- a/src/gpu/batches/GrMSAAPathRenderer.cpp
+++ b/src/gpu/batches/GrMSAAPathRenderer.cpp
@@ -562,7 +562,6 @@ private:
 
 bool GrMSAAPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetContext,
                                           const GrPaint& paint,
-                                          GrAAType aaType,
                                           const GrUserStencilSettings& userStencilSettings,
                                           const GrClip& clip,
                                           const SkMatrix& viewMatrix,
@@ -663,7 +662,7 @@ bool GrMSAAPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetCon
                     GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewM, bounds, nullptr,
                                                         &localMatrix));
 
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint));
             pipelineBuilder.setUserStencil(passes[p]);
 
             renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get());
@@ -674,11 +673,12 @@ bool GrMSAAPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetCon
                 return false;
             }
 
-            GrPipelineBuilder pipelineBuilder(paint, aaType);
+            GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint));
             pipelineBuilder.setUserStencil(passes[p]);
             if (passCount > 1) {
                 pipelineBuilder.setDisableColorXPFactory();
             }
+
             renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get());
         }
     }
@@ -689,7 +689,7 @@ bool GrMSAAPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // This path renderer only fills and relies on MSAA for antialiasing. Stroked shapes are
     // handled by passing on the original shape and letting the caller compute the stroked shape
     // which will have a fill style.
-    return args.fShape->style().isSimpleFill() && (GrAAType::kCoverage != args.fAAType);
+    return args.fShape->style().isSimpleFill() && !args.fAntiAlias;
 }
 
 bool GrMSAAPathRenderer::onDrawPath(const DrawPathArgs& args) {
@@ -704,7 +704,6 @@ bool GrMSAAPathRenderer::onDrawPath(const DrawPathArgs& args) {
     }
     return this->internalDrawPath(args.fRenderTargetContext,
                                   *args.fPaint,
-                                  args.fAAType,
                                   *args.fUserStencilSettings,
                                   *args.fClip,
                                   *args.fViewMatrix,
@@ -720,10 +719,10 @@ void GrMSAAPathRenderer::onStencilPath(const StencilPathArgs& args) {
 
     GrPaint paint;
     paint.setXPFactory(GrDisableColorXPFactory::Make());
+    paint.setAntiAlias(args.fIsAA);
 
-    this->internalDrawPath(args.fRenderTargetContext, paint, args.fAAType,
-                           GrUserStencilSettings::kUnused, *args.fClip, *args.fViewMatrix,
-                           *args.fShape, true);
+    this->internalDrawPath(args.fRenderTargetContext, paint, GrUserStencilSettings::kUnused,
+                           *args.fClip, *args.fViewMatrix, *args.fShape, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/batches/GrMSAAPathRenderer.h b/src/gpu/batches/GrMSAAPathRenderer.h
index a112c6253b..3a70bcb059 100644
--- a/src/gpu/batches/GrMSAAPathRenderer.h
+++ b/src/gpu/batches/GrMSAAPathRenderer.h
@@ -23,7 +23,6 @@ private:
 
     bool internalDrawPath(GrRenderTargetContext*,
                           const GrPaint&,
-                          GrAAType,
                           const GrUserStencilSettings&,
                           const GrClip&,
                           const SkMatrix& viewMatrix,
diff --git a/src/gpu/batches/GrPLSPathRenderer.cpp b/src/gpu/batches/GrPLSPathRenderer.cpp
index 269fde166c..6dd2199671 100644
--- a/src/gpu/batches/GrPLSPathRenderer.cpp
+++ b/src/gpu/batches/GrPLSPathRenderer.cpp
@@ -758,7 +758,7 @@ bool GrPLSPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // seams. Disable in the presence of even-odd for now.
     SkPath path;
     args.fShape->asPath(&path);
-    return args.fShaderCaps->shaderDerivativeSupport() && GrAAType::kCoverage == args.fAAType &&
+    return args.fShaderCaps->shaderDerivativeSupport() && args.fAntiAlias &&
             args.fShape->style().isSimpleFill() && !path.isInverseFillType() &&
             path.getFillType() == SkPath::FillType::kWinding_FillType;
 }
@@ -936,10 +936,13 @@ bool GrPLSPathRenderer::onDrawPath(const DrawPathArgs& args) {
     args.fShape->asPath(&path);
 
     sk_sp<GrDrawOp> batch(new PLSPathBatch(args.fPaint->getColor(), path, *args.fViewMatrix));
-    GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
+
+    GrPipelineBuilder pipelineBuilder(*args.fPaint,
+                                      args.fRenderTargetContext->mustUseHWAA(*args.fPaint));
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
     args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get());
+
     SkDEBUGCODE(inPLSDraw = false;)
     return true;
 
diff --git a/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp b/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp
index ac9ed9035e..97287d2c86 100644
--- a/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp
@@ -44,8 +44,11 @@ bool GrStencilAndCoverPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) c
     if (args.fHasUserStencilSettings) {
         return false;
     }
-    // doesn't do per-path AA, relies on the target having MSAA.
-    return (GrAAType::kCoverage != args.fAAType);
+    if (args.fAntiAlias) {
+        return args.fIsStencilBufferMSAA;
+    } else {
+        return true; // doesn't do per-path AA, relies on the target having MSAA
+    }
 }
 
 static GrPath* get_gr_path(GrResourceProvider* resourceProvider, const GrShape& shape) {
@@ -77,14 +80,18 @@ static GrPath* get_gr_path(GrResourceProvider* resourceProvider, const GrShape&
 void GrStencilAndCoverPathRenderer::onStencilPath(const StencilPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
                               "GrStencilAndCoverPathRenderer::onStencilPath");
+    SkASSERT(!args.fIsAA || args.fRenderTargetContext->isStencilBufferMultisampled());
+
     sk_sp<GrPath> p(get_gr_path(fResourceProvider, *args.fShape));
-    args.fRenderTargetContext->priv().stencilPath(*args.fClip, args.fAAType,
+    args.fRenderTargetContext->priv().stencilPath(*args.fClip, args.fIsAA,
                                                   *args.fViewMatrix, p.get());
 }
 
 bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
                               "GrStencilAndCoverPathRenderer::onDrawPath");
+    SkASSERT(!args.fPaint->isAntiAlias() ||
+             args.fRenderTargetContext->isStencilBufferMultisampled());
     SkASSERT(!args.fShape->style().strokeRec().isHairlineStyle());
 
     const SkMatrix& viewMatrix = *args.fViewMatrix;
@@ -118,8 +125,8 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
                                                     nullptr, &invert));
 
         // fake inverse with a stencil and cover
-        args.fRenderTargetContext->priv().stencilPath(*args.fClip, args.fAAType, viewMatrix,
-                                                      path.get());
+        args.fRenderTargetContext->priv().stencilPath(*args.fClip, args.fPaint->isAntiAlias(),
+                                                      viewMatrix, path.get());
 
         {
             static constexpr GrUserStencilSettings kInvertedCoverPass(
@@ -134,13 +141,10 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
                     GrUserStencilOp::kZero,
                     0xffff>()
             );
-            // We have to suppress enabling MSAA for mixed samples or we will get seams due to
-            // coverage modulation along the edge where two triangles making up the rect meet.
-            GrAAType coverAAType = args.fAAType;
-            if (GrAAType::kMixedSamples == coverAAType) {
-                coverAAType = GrAAType::kNone;
-            }
-            GrPipelineBuilder pipelineBuilder(*args.fPaint, coverAAType);
+
+            GrPipelineBuilder pipelineBuilder(*args.fPaint,
+                                              args.fPaint->isAntiAlias() &&
+                                              !args.fRenderTargetContext->hasMixedSamples());
             pipelineBuilder.setUserStencil(&kInvertedCoverPass);
 
             args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, coverBatch.get());
@@ -159,8 +163,13 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
         sk_sp<GrDrawOp> batch(GrDrawPathBatch::Create(viewMatrix, args.fPaint->getColor(),
                                                       path.get()));
 
-        GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
+        GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fPaint->isAntiAlias());
         pipelineBuilder.setUserStencil(&kCoverPass);
+        if (args.fAntiAlias) {
+            SkASSERT(args.fRenderTargetContext->isStencilBufferMultisampled());
+            pipelineBuilder.enableState(GrPipelineBuilder::kHWAntialias_Flag);
+        }
+
         args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get());
     }
 
diff --git a/src/gpu/batches/GrTessellatingPathRenderer.cpp b/src/gpu/batches/GrTessellatingPathRenderer.cpp
index 4b3ef00193..afa9fe7148 100644
--- a/src/gpu/batches/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/batches/GrTessellatingPathRenderer.cpp
@@ -140,7 +140,7 @@ bool GrTessellatingPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) cons
     if (!args.fShape->style().isSimpleFill() || args.fShape->knownToBeConvex()) {
         return false;
     }
-    if (GrAAType::kCoverage == args.fAAType) {
+    if (args.fAntiAlias) {
 #ifdef SK_DISABLE_SCREENSPACE_TESS_AA_PATH_RENDERER
         return false;
 #else
@@ -364,10 +364,14 @@ bool GrTessellatingPathRenderer::onDrawPath(const DrawPathArgs& args) {
                                                         *args.fShape,
                                                         *args.fViewMatrix,
                                                         clipBoundsI,
-                                                        GrAAType::kCoverage == args.fAAType));
-    GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
+                                                        args.fAntiAlias));
+
+    GrPipelineBuilder pipelineBuilder(*args.fPaint,
+                                      args.fRenderTargetContext->mustUseHWAA(*args.fPaint));
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
+
     args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get());
+
     return true;
 }
 
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index f6f8334dfd..f7003121d7 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -237,19 +237,19 @@ void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context
         paint1.addColorFragmentProcessor(std::move(pmToUPM1));
         paint1.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
-        readRTC->fillRectToRect(GrNoClip(), paint1, GrAA::kNo, SkMatrix::I(), kDstRect, kSrcRect);
+        readRTC->fillRectToRect(GrNoClip(), paint1, SkMatrix::I(), kDstRect, kSrcRect);
 
         readRTC->asTexture()->readPixels(0, 0, kSize, kSize, kConfig, firstRead);
 
         paint2.addColorFragmentProcessor(std::move(upmToPM));
         paint2.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
-        tempRTC->fillRectToRect(GrNoClip(), paint2, GrAA::kNo, SkMatrix::I(), kDstRect, kSrcRect);
+        tempRTC->fillRectToRect(GrNoClip(), paint2, SkMatrix::I(), kDstRect, kSrcRect);
 
         paint3.addColorFragmentProcessor(std::move(pmToUPM2));
         paint3.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
-        readRTC->fillRectToRect(GrNoClip(), paint3, GrAA::kNo, SkMatrix::I(), kDstRect, kSrcRect);
+        readRTC->fillRectToRect(GrNoClip(), paint3, SkMatrix::I(), kDstRect, kSrcRect);
 
         readRTC->asTexture()->readPixels(0, 0, kSize, kSize, kConfig, secondRead);
 
diff --git a/src/gpu/instanced/InstancedRendering.cpp b/src/gpu/instanced/InstancedRendering.cpp
index faecfe5eed..135a0610ad 100644
--- a/src/gpu/instanced/InstancedRendering.cpp
+++ b/src/gpu/instanced/InstancedRendering.cpp
@@ -22,27 +22,28 @@ InstancedRendering::InstancedRendering(GrGpu* gpu)
 }
 
 GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
-                                         GrColor color, GrAA aa,
-                                         const GrInstancedPipelineInfo& info, GrAAType* aaType) {
-    return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, aa, info, aaType);
+                                         GrColor color, bool antialias,
+                                         const GrInstancedPipelineInfo& info, bool* useHWAA) {
+    return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, antialias, info,
+                             useHWAA);
 }
 
 GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
-                                         GrColor color, const SkRect& localRect, GrAA aa,
-                                         const GrInstancedPipelineInfo& info, GrAAType* aaType) {
-    return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, localRect, aa, info,
-                             aaType);
+                                         GrColor color, const SkRect& localRect, bool antialias,
+                                         const GrInstancedPipelineInfo& info, bool* useHWAA) {
+    return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, localRect, antialias, info,
+                             useHWAA);
 }
 
 GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
                                          GrColor color, const SkMatrix& localMatrix,
-                                         GrAA aa, const GrInstancedPipelineInfo& info,
-                                         GrAAType* aaType) {
+                                         bool antialias, const GrInstancedPipelineInfo& info,
+                                         bool* useHWAA) {
     if (localMatrix.hasPerspective()) {
         return nullptr; // Perspective is not yet supported in the local matrix.
     }
-    if (Batch* batch = this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, aa,
-                                         info, aaType)) {
+    if (Batch* batch = this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, antialias,
+                                         info, useHWAA)) {
         batch->getSingleInstance().fInfo |= kLocalMatrix_InfoFlag;
         batch->appendParamsTexel(localMatrix.getScaleX(), localMatrix.getSkewX(),
                                  localMatrix.getTranslateX());
@@ -55,16 +56,17 @@ GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& vie
 }
 
 GrDrawOp* InstancedRendering::recordOval(const SkRect& oval, const SkMatrix& viewMatrix,
-                                         GrColor color, GrAA aa,
-                                         const GrInstancedPipelineInfo& info, GrAAType* aaType) {
-    return this->recordShape(ShapeType::kOval, oval, viewMatrix, color, oval, aa, info, aaType);
+                                         GrColor color, bool antialias,
+                                         const GrInstancedPipelineInfo& info, bool* useHWAA) {
+    return this->recordShape(ShapeType::kOval, oval, viewMatrix, color, oval, antialias, info,
+                             useHWAA);
 }
 
 GrDrawOp* InstancedRendering::recordRRect(const SkRRect& rrect, const SkMatrix& viewMatrix,
-                                          GrColor color, GrAA aa,
-                                          const GrInstancedPipelineInfo& info, GrAAType* aaType) {
+                                          GrColor color, bool antialias,
+                                          const GrInstancedPipelineInfo& info, bool* useHWAA) {
     if (Batch* batch = this->recordShape(GetRRectShapeType(rrect), rrect.rect(), viewMatrix, color,
-                                         rrect.rect(), aa, info, aaType)) {
+                                         rrect.rect(), antialias, info, useHWAA)) {
         batch->appendRRectParams(rrect);
         return batch;
     }
@@ -73,16 +75,16 @@ GrDrawOp* InstancedRendering::recordRRect(const SkRRect& rrect, const SkMatrix&
 
 GrDrawOp* InstancedRendering::recordDRRect(const SkRRect& outer, const SkRRect& inner,
                                            const SkMatrix& viewMatrix, GrColor color,
-                                           GrAA aa, const GrInstancedPipelineInfo& info,
-                                           GrAAType* aaType) {
+                                           bool antialias, const GrInstancedPipelineInfo& info,
+                                           bool* useHWAA) {
     if (inner.getType() > SkRRect::kSimple_Type) {
        return nullptr; // Complex inner round rects are not yet supported.
     }
     if (SkRRect::kEmpty_Type == inner.getType()) {
-        return this->recordRRect(outer, viewMatrix, color, aa, info, aaType);
+        return this->recordRRect(outer, viewMatrix, color, antialias, info, useHWAA);
     }
     if (Batch* batch = this->recordShape(GetRRectShapeType(outer), outer.rect(), viewMatrix, color,
-                                         outer.rect(), aa, info, aaType)) {
+                                         outer.rect(), antialias, info, useHWAA)) {
         batch->appendRRectParams(outer);
         ShapeType innerShapeType = GetRRectShapeType(inner);
         batch->fInfo.fInnerShapeTypes |= GetShapeFlag(innerShapeType);
@@ -97,9 +99,9 @@ GrDrawOp* InstancedRendering::recordDRRect(const SkRRect& outer, const SkRRect&
 InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const SkRect& bounds,
                                                            const SkMatrix& viewMatrix,
                                                            GrColor color, const SkRect& localRect,
-                                                           GrAA aa,
+                                                           bool antialias,
                                                            const GrInstancedPipelineInfo& info,
-                                                           GrAAType* aaType) {
+                                                           bool* useHWAA) {
     SkASSERT(State::kRecordingDraws == fState);
 
     if (info.fIsRenderingToFloat && fGpu->caps()->avoidInstancedDrawsToFPTargets()) {
@@ -107,7 +109,7 @@ InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const
     }
 
     AntialiasMode antialiasMode;
-    if (!this->selectAntialiasMode(viewMatrix, aa, info, aaType, &antialiasMode)) {
+    if (!this->selectAntialiasMode(viewMatrix, antialias, info, useHWAA, &antialiasMode)) {
         return nullptr;
     }
 
@@ -191,28 +193,27 @@ InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const
     return batch;
 }
 
-inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, GrAA aa,
+inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias,
                                                     const GrInstancedPipelineInfo& info,
-                                                    GrAAType* aaType,
-                                                    AntialiasMode* antialiasMode) {
+                                                    bool* useHWAA, AntialiasMode* antialiasMode) {
     SkASSERT(!info.fColorDisabled || info.fDrawingShapeToStencil);
     SkASSERT(!info.fIsMixedSampled || info.fIsMultisampled);
     SkASSERT(GrCaps::InstancedSupport::kNone != fGpu->caps()->instancedSupport());
 
     if (!info.fIsMultisampled || fGpu->caps()->multisampleDisableSupport()) {
-        if (GrAA::kNo == aa) {
+        if (!antialias) {
             if (info.fDrawingShapeToStencil && !info.fCanDiscard) {
                 // We can't draw to the stencil buffer without discard (or sample mask if MSAA).
                 return false;
             }
             *antialiasMode = AntialiasMode::kNone;
-            *aaType = GrAAType::kNone;
+            *useHWAA = false;
             return true;
         }
 
         if (info.canUseCoverageAA() && viewMatrix.preservesRightAngles()) {
             *antialiasMode = AntialiasMode::kCoverage;
-            *aaType = GrAAType::kCoverage;
+            *useHWAA = false;
             return true;
         }
     }
@@ -221,12 +222,12 @@ inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix,
         fGpu->caps()->instancedSupport() >= GrCaps::InstancedSupport::kMultisampled) {
         if (!info.fIsMixedSampled || info.fColorDisabled) {
             *antialiasMode = AntialiasMode::kMSAA;
-            *aaType = GrAAType::kMSAA;
+            *useHWAA = true;
             return true;
         }
         if (fGpu->caps()->instancedSupport() >= GrCaps::InstancedSupport::kMixedSampled) {
             *antialiasMode = AntialiasMode::kMixedSamples;
-            *aaType = GrAAType::kMixedSamples;
+            *useHWAA = true;
             return true;
         }
     }
diff --git a/src/gpu/instanced/InstancedRendering.h b/src/gpu/instanced/InstancedRendering.h
index 903697436c..d3a01523a6 100644
--- a/src/gpu/instanced/InstancedRendering.h
+++ b/src/gpu/instanced/InstancedRendering.h
@@ -46,25 +46,28 @@ public:
      * draws between beginFlush() and endFlush().
      */
     GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor,
-                                               GrAA, const GrInstancedPipelineInfo&, GrAAType*);
+                                               bool antialias, const GrInstancedPipelineInfo&,
+                                               bool* useHWAA);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor,
-                                               const SkRect& localRect, GrAA,
-                                               const GrInstancedPipelineInfo&, GrAAType*);
+                                               const SkRect& localRect, bool antialias,
+                                               const GrInstancedPipelineInfo&, bool* useHWAA);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor,
-                                               const SkMatrix& localMatrix, GrAA,
-                                               const GrInstancedPipelineInfo&, GrAAType*);
+                                               const SkMatrix& localMatrix, bool antialias,
+                                               const GrInstancedPipelineInfo&, bool* useHWAA);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordOval(const SkRect&, const SkMatrix&, GrColor,
-                                               GrAA, const GrInstancedPipelineInfo&, GrAAType*);
+                                               bool antialias, const GrInstancedPipelineInfo&,
+                                               bool* useHWAA);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordRRect(const SkRRect&, const SkMatrix&, GrColor,
-                                                GrAA, const GrInstancedPipelineInfo&, GrAAType*);
+                                                bool antialias, const GrInstancedPipelineInfo&,
+                                                bool* useHWAA);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordDRRect(const SkRRect& outer, const SkRRect& inner,
-                                                 const SkMatrix&, GrColor, GrAA,
-                                                 const GrInstancedPipelineInfo&, GrAAType*);
+                                                 const SkMatrix&, GrColor, bool antialias,
+                                                 const GrInstancedPipelineInfo&, bool* useHWAA);
 
     /**
      * Compiles all recorded draws into GPU buffers and allows the client to begin flushing the
@@ -179,11 +182,11 @@ private:
 
     Batch* SK_WARN_UNUSED_RESULT recordShape(ShapeType, const SkRect& bounds,
                                              const SkMatrix& viewMatrix, GrColor,
-                                             const SkRect& localRect, GrAA aa,
-                                             const GrInstancedPipelineInfo&, GrAAType*);
+                                             const SkRect& localRect, bool antialias,
+                                             const GrInstancedPipelineInfo&, bool* requireHWAA);
 
-    bool selectAntialiasMode(const SkMatrix& viewMatrix, GrAA aa, const GrInstancedPipelineInfo&,
-                             GrAAType*, AntialiasMode*);
+    bool selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias,
+                             const GrInstancedPipelineInfo&, bool* useHWAA, AntialiasMode*);
 
     virtual Batch* createBatch() = 0;
 
diff --git a/src/gpu/instanced/InstancedRenderingTypes.h b/src/gpu/instanced/InstancedRenderingTypes.h
index 2ed269a8cf..97f8946d03 100644
--- a/src/gpu/instanced/InstancedRenderingTypes.h
+++ b/src/gpu/instanced/InstancedRenderingTypes.h
@@ -42,7 +42,6 @@ enum class Attrib : uint8_t {
 };
 constexpr int kNumAttribs = 1 + (int)Attrib::kLocalRect;
 
-// TODO: replace with GrAAType?
 enum class AntialiasMode : uint8_t {
     kNone,
     kCoverage,
diff --git a/src/gpu/text/GrAtlasTextBlob.cpp b/src/gpu/text/GrAtlasTextBlob.cpp
index 1fb4f2cdda..5b35f845c1 100644
--- a/src/gpu/text/GrAtlasTextBlob.cpp
+++ b/src/gpu/text/GrAtlasTextBlob.cpp
@@ -323,7 +323,8 @@ void GrAtlasTextBlob::flushRun(GrRenderTargetContext* rtc, const GrPaint& grPain
                                                 distanceAdjustTable,
                                                 rtc->isGammaCorrect(),
                                                 cache));
-        GrPipelineBuilder pipelineBuilder(grPaint, GrAAType::kNone);
+
+        GrPipelineBuilder pipelineBuilder(grPaint, rtc->mustUseHWAA(grPaint));
 
         rtc->addDrawOp(pipelineBuilder, clip, batch.get());
     }
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.cpp b/src/gpu/text/GrStencilAndCoverTextContext.cpp
index b573b83f62..ba98784c71 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.cpp
+++ b/src/gpu/text/GrStencilAndCoverTextContext.cpp
@@ -224,8 +224,10 @@ void GrStencilAndCoverTextContext::drawTextBlob(GrContext* context, GrRenderTarg
 
     TextBlob::Iter iter(blob);
     for (TextRun* run = iter.get(); run; run = iter.next()) {
-        run->draw(context, rtc, paint, clip, viewMatrix, props,  x, y, clipBounds,
-                  fFallbackTextContext, skPaint);
+        // The run's "font" overrides the anti-aliasing of the passed in paint!
+        paint.setAntiAlias(run->isAntiAlias());
+        run->draw(context, rtc, paint, clip, viewMatrix, props,  x, y,
+                  clipBounds, fFallbackTextContext, skPaint);
         run->releaseGlyphCache();
     }
 }
@@ -603,9 +605,8 @@ void GrStencilAndCoverTextContext::TextRun::draw(GrContext* ctx,
                                                  const SkIRect& clipBounds,
                                                  GrAtlasTextContext* fallbackTextContext,
                                                  const SkPaint& originalSkPaint) const {
-    GrAA runAA = this->isAntiAlias();
     SkASSERT(fInstanceData);
-    SkASSERT(renderTargetContext->isStencilBufferMultisampled() || GrAA::kNo == runAA);
+    SkASSERT(renderTargetContext->isStencilBufferMultisampled() || !grPaint.isAntiAlias());
 
     if (fInstanceData->count()) {
         static constexpr GrUserStencilSettings kCoverPass(
@@ -639,16 +640,8 @@ void GrStencilAndCoverTextContext::TextRun::draw(GrContext* ctx,
                                          GrPathRendering::kWinding_FillType, glyphs.get(),
                                          fInstanceData.get(), bounds));
 
-        // The run's "font" overrides the anti-aliasing of the passed in SkPaint!
-        GrAAType aaType = GrAAType::kNone;
-        if (GrAA::kYes == runAA) {
-            if (renderTargetContext->isUnifiedMultisampled()) {
-                aaType = GrAAType::kMSAA;
-            } else if (renderTargetContext->isStencilBufferMultisampled()) {
-                aaType = GrAAType::kMixedSamples;
-            }
-        }
-        GrPipelineBuilder pipelineBuilder(grPaint, aaType);
+        GrPipelineBuilder pipelineBuilder(grPaint);
+        pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, grPaint.isAntiAlias());
         pipelineBuilder.setUserStencil(&kCoverPass);
 
         renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get());
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.h b/src/gpu/text/GrStencilAndCoverTextContext.h
index 1ba113b59b..f4773ffa5b 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.h
+++ b/src/gpu/text/GrStencilAndCoverTextContext.h
@@ -88,7 +88,7 @@ private:
 
         size_t computeSizeInCache() const;
 
-        GrAA isAntiAlias() const { return fFont.isAntiAlias() ? GrAA::kYes : GrAA::kNo; }
+        bool isAntiAlias() const { return fFont.isAntiAlias(); }
 
     private:
         typedef GrDrawPathRangeBatch::InstanceData InstanceData;
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index bce67e0fc4..24e5c1df83 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -277,7 +277,7 @@ static sk_sp<SkImage> make_from_yuv_textures_copy(GrContext* ctx, SkYUVColorSpac
 
     const SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
 
-    renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), rect);
+    renderTargetContext->drawRect(GrNoClip(), paint, SkMatrix::I(), rect);
 
     if (!renderTargetContext->accessRenderTarget()) {
         return nullptr;