diff --git a/gm/windowrectangles.cpp b/gm/windowrectangles.cpp
index d9e4ae9..5b7f268 100644
--- a/gm/windowrectangles.cpp
+++ b/gm/windowrectangles.cpp
@@ -159,18 +159,9 @@
 };
 
 /**
- * Base class for GrClips that visualize a clip mask.
- */
-class MaskOnlyClipBase : public GrClip {
-private:
-    bool quickContains(const SkRect&) const final { return false; }
-    bool isRRect(SkRRect* rr, GrAA*) const final { return false; }
-};
-
-/**
  * This class clips a cover by an alpha mask. We use it to visualize the alpha clip mask.
  */
-class AlphaOnlyClip final : public MaskOnlyClipBase {
+class AlphaOnlyClip final : public GrClip {
 public:
     AlphaOnlyClip(GrSurfaceProxyView mask, int x, int y) : fMask(std::move(mask)), fX(x), fY(y) {}
 
@@ -178,9 +169,8 @@
     SkIRect getConservativeBounds() const final {
         return SkIRect::MakeXYWH(fX, fY, fMask.width(), fMask.height());
     }
-
-    bool apply(GrRecordingContext* ctx, GrRenderTargetContext*, bool, bool, GrAppliedClip* out,
-               SkRect* bounds) const override {
+    Effect apply(GrRecordingContext* ctx, GrRenderTargetContext*, bool, bool,
+                     GrAppliedClip* out, SkRect* bounds) const override {
         GrSamplerState samplerState(GrSamplerState::WrapMode::kClampToBorder,
                                     GrSamplerState::Filter::kNearest);
         auto m = SkMatrix::Translate(-fX, -fY);
@@ -190,7 +180,7 @@
                                               domain, *ctx->priv().caps());
         fp = GrDeviceSpaceEffect::Make(std::move(fp));
         out->addCoverageFP(std::move(fp));
-        return true;
+        return Effect::kClipped;
     }
     GrSurfaceProxyView fMask;
     int fX;
diff --git a/src/gpu/GrClip.h b/src/gpu/GrClip.h
index ee6935d..f9008ae 100644
--- a/src/gpu/GrClip.h
+++ b/src/gpu/GrClip.h
@@ -21,12 +21,33 @@
  */
 class GrClip {
 public:
+    enum class Effect {
+        // The clip conservatively modifies the draw's coverage but doesn't eliminate the draw
+        kClipped,
+        // The clip definitely does not modify the draw's coverage and the draw can be performed
+        // without clipping (beyond the automatic device bounds clip).
+        kUnclipped,
+        // The clip definitely eliminates all of the draw's coverage and the draw can be skipped
+        kClippedOut
+    };
+
+    struct PreClipResult {
+        Effect  fEffect;
+        SkRRect fRRect; // Ignore if 'isRRect' is false
+        GrAA    fAA;    // Ignore if 'isRRect' is false
+        bool    fIsRRect;
+
+        PreClipResult(Effect effect) : fEffect(effect), fIsRRect(false) {}
+        PreClipResult(SkRect rect, GrAA aa) : PreClipResult(SkRRect::MakeRect(rect), aa) {}
+        PreClipResult(SkRRect rrect, GrAA aa)
+                : fEffect(Effect::kClipped)
+                , fRRect(rrect)
+                , fAA(aa)
+                , fIsRRect(true) {}
+    };
+
     virtual ~GrClip() {}
 
-    virtual bool quickContains(const SkRect&) const = 0;
-    virtual bool quickContains(const SkRRect& rrect) const {
-        return this->quickContains(rrect.getBounds());
-    }
     /**
      * Compute a conservative pixel bounds restricted to the given render target dimensions.
      * The returned bounds represent the limits of pixels that can be drawn; anything outside of the
@@ -38,25 +59,34 @@
      * This computes a GrAppliedClip from the clip which in turn can be used to build a GrPipeline.
      * To determine the appropriate clipping implementation the GrClip subclass must know whether
      * the draw will enable HW AA or uses the stencil buffer. On input 'bounds' is a conservative
-     * bounds of the draw that is to be clipped. After return 'bounds' has been intersected with a
-     * conservative bounds of the clip. A return value of false indicates that the draw can be
-     * skipped as it is fully clipped out.
+     * bounds of the draw that is to be clipped. If kClipped or kUnclipped is returned, the 'bounds'
+     * will have been updated to be contained within the clip bounds (or the device's, for wide-open
+     * clips). If kNoDraw is returned, 'bounds' and the applied clip are in an undetermined state
+     * and should be ignored (and the draw should be skipped).
      */
-    virtual bool apply(GrRecordingContext*, GrRenderTargetContext*, bool useHWAA,
-                       bool hasUserStencilSettings, GrAppliedClip*, SkRect* bounds) const = 0;
+    virtual Effect apply(GrRecordingContext*, GrRenderTargetContext*, bool useHWAA,
+                         bool hasUserStencilSettings, GrAppliedClip*, SkRect* bounds) const = 0;
 
     /**
-     * This method quickly and conservatively determines whether the entire clip is equivalent to
-     * intersection with a rrect. Moreover, the returned rrect need not be contained by the render
-     * target bounds. We assume all draws will be implicitly clipped by the render target bounds.
+     * Perform preliminary, conservative analysis on the draw bounds as if it were provided to
+     * apply(). The results of this are returned the PreClipResults struct, where 'result.fEffect'
+     * corresponds to what 'apply' would return. If this value is kUnclipped or kNoDraw, then it
+     * can be assumed that apply() would also always result in the same Effect.
      *
-     * @param rrect    If return is true rrect will contain the rrect equivalent to the clip within
-     *                 rtBounds.
-     * @param aa       If return is true aa will indicate whether the rrect clip is antialiased.
-     * @return true if the clip is equivalent to a single rrect, false otherwise.
+     * If kClipped is returned, apply() may further refine the effect to kUnclipped or kNoDraw,
+     * with one exception. When 'result.fIsRRect' is true, preApply() reports the single round rect
+     * and anti-aliased state that would act as an intersection on the draw geometry. If no further
+     * action is taken to modify the draw, apply() will represent this round rect in the applied
+     * clip.
      *
+     * When set, 'result.fRRect' will intersect with the render target bounds but may extend
+     * beyond it. If the render target bounds are the only clip effect on the draw, this is reported
+     * as kUnclipped and not as a degenerate rrect that matches the bounds.
      */
-    virtual bool isRRect(SkRRect* rrect, GrAA* aa) const = 0;
+    virtual PreClipResult preApply(const SkRect& drawBounds) const {
+        bool outside = !drawBounds.intersects(SkRect::Make(this->getConservativeBounds()));
+        return outside ? Effect::kClippedOut : Effect::kClipped;
+    }
 
     /**
      * This is the maximum distance that a draw may extend beyond a clip's boundary and still count
@@ -147,11 +177,11 @@
      * return 'bounds' has been intersected with a conservative bounds of the clip. A return value
      * of false indicates that the draw can be skipped as it is fully clipped out.
      */
-    virtual bool apply(GrAppliedHardClip* out, SkRect* bounds) const = 0;
+    virtual Effect apply(GrAppliedHardClip* out, SkRect* bounds) const = 0;
 
 private:
-    bool apply(GrRecordingContext*, GrRenderTargetContext* rtc, bool useHWAA,
-               bool hasUserStencilSettings, GrAppliedClip* out, SkRect* bounds) const final {
+    Effect apply(GrRecordingContext*, GrRenderTargetContext* rtc, bool useHWAA,
+                     bool hasUserStencilSettings, GrAppliedClip* out, SkRect* bounds) const final {
         return this->apply(&out->hardClip(), bounds);
     }
 };
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index 6c5bbff..5b96643 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -34,32 +34,22 @@
 
 const char GrClipStackClip::kMaskTestTag[] = "clip_mask";
 
-bool GrClipStackClip::quickContains(const SkRect& rect) const {
-    if (!fStack || fStack->isWideOpen()) {
-        return true;
-    }
-    return fStack->quickContains(rect);
-}
-
-bool GrClipStackClip::quickContains(const SkRRect& rrect) const {
-    if (!fStack || fStack->isWideOpen()) {
-        return true;
-    }
-    return fStack->quickContains(rrect);
-}
-
-bool GrClipStackClip::isRRect(SkRRect* rr, GrAA* aa) const {
-    if (!fStack) {
-        return false;
+GrClip::PreClipResult GrClipStackClip::preApply(const SkRect& drawBounds) const {
+    SkIRect deviceRect = SkIRect::MakeSize(fDeviceSize);
+    SkRect rect = SkRect::Make(deviceRect);
+    if (!rect.intersect(drawBounds) || (fStack && fStack->isEmpty(deviceRect))) {
+        return Effect::kClippedOut;
+    } else if (!fStack || fStack->isWideOpen()) {
+        return Effect::kUnclipped;
     }
 
-    SkRect rtBounds = SkRect::MakeIWH(fDeviceSize.fWidth, fDeviceSize.fHeight);
+    PreClipResult result(Effect::kClipped);
     bool isAA;
-    if (fStack->isRRect(rtBounds, rr, &isAA)) {
-        *aa = GrAA(isAA);
-        return true;
+    if (fStack->isRRect(rect, &result.fRRect, &isAA)) {
+        result.fIsRRect = true;
+        result.fAA = GrAA(isAA);
     }
-    return false;
+    return result;
 }
 
 SkIRect GrClipStackClip::getConservativeBounds() const {
@@ -197,18 +187,19 @@
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
-bool GrClipStackClip::apply(GrRecordingContext* context, GrRenderTargetContext* renderTargetContext,
-                            bool useHWAA, bool hasUserStencilSettings, GrAppliedClip* out,
-                            SkRect* bounds) const {
+GrClip::Effect GrClipStackClip::apply(GrRecordingContext* context,
+                                          GrRenderTargetContext* renderTargetContext,
+                                          bool useHWAA, bool hasUserStencilSettings,
+                                          GrAppliedClip* out, SkRect* bounds) const {
     SkASSERT(renderTargetContext->width() == fDeviceSize.fWidth &&
              renderTargetContext->height() == fDeviceSize.fHeight);
     SkRect devBounds = SkRect::MakeIWH(fDeviceSize.fWidth, fDeviceSize.fHeight);
     if (!devBounds.intersect(*bounds)) {
-        return false;
+        return Effect::kClippedOut;
     }
 
     if (!fStack || fStack->isWideOpen()) {
-        return true;
+        return Effect::kUnclipped;
     }
 
     // An default count of 4 was chosen because of the common pattern in Blink of:
@@ -233,23 +224,27 @@
                               maxWindowRectangles, maxAnalyticFPs, ccpr ? maxAnalyticFPs : 0);
     if (InitialState::kAllOut == reducedClip.initialState() &&
         reducedClip.maskElements().isEmpty()) {
-        return false;
+        return Effect::kClippedOut;
     }
 
+    Effect effect = Effect::kUnclipped;
     if (reducedClip.hasScissor() && !GrClip::IsInsideClip(reducedClip.scissor(), devBounds)) {
         out->hardClip().addScissor(reducedClip.scissor(), bounds);
+        effect = Effect::kClipped;
     }
 
     if (!reducedClip.windowRectangles().empty()) {
         out->hardClip().addWindowRectangles(reducedClip.windowRectangles(),
                                             GrWindowRectsState::Mode::kExclusive);
+        effect = Effect::kClipped;
     }
 
     if (!reducedClip.maskElements().isEmpty()) {
         if (!this->applyClipMask(context, renderTargetContext, reducedClip, hasUserStencilSettings,
                                  out)) {
-            return false;
+            return Effect::kClippedOut;
         }
+        effect = Effect::kClipped;
     }
 
     // The opsTask ID must not be looked up until AFTER producing the clip mask (if any). That step
@@ -258,9 +253,10 @@
     if (auto clipFPs = reducedClip.finishAndDetachAnalyticFPs(context, *fMatrixProvider, ccpr,
                                                               opsTaskID)) {
         out->addCoverageFP(std::move(clipFPs));
+        effect = Effect::kClipped;
     }
 
-    return true;
+    return effect;
 }
 
 bool GrClipStackClip::applyClipMask(GrRecordingContext* context,
diff --git a/src/gpu/GrClipStackClip.h b/src/gpu/GrClipStackClip.h
index ffbd001..f1d4796 100644
--- a/src/gpu/GrClipStackClip.h
+++ b/src/gpu/GrClipStackClip.h
@@ -27,13 +27,10 @@
             , fStack(stack)
             , fMatrixProvider(matrixProvider) {}
 
-    bool quickContains(const SkRect&) const final;
-    bool quickContains(const SkRRect&) const final;
     SkIRect getConservativeBounds() const final;
-    bool apply(GrRecordingContext*, GrRenderTargetContext*, bool useHWAA,
-               bool hasUserStencilSettings, GrAppliedClip* out, SkRect* bounds) const final;
-
-    bool isRRect(SkRRect* rr, GrAA* aa) const override;
+    Effect apply(GrRecordingContext*, GrRenderTargetContext*, bool useHWAA,
+                     bool hasUserStencilSettings, GrAppliedClip* out, SkRect* bounds) const final;
+    PreClipResult preApply(const SkRect& drawBounds) const final;
 
     sk_sp<GrTextureProxy> testingOnly_createClipMask(GrContext*) const;
     static const char kMaskTestTag[];
diff --git a/src/gpu/GrFixedClip.cpp b/src/gpu/GrFixedClip.cpp
index 2f75bc9..928b680 100644
--- a/src/gpu/GrFixedClip.cpp
+++ b/src/gpu/GrFixedClip.cpp
@@ -10,42 +10,46 @@
 #include "src/gpu/GrAppliedClip.h"
 #include "src/gpu/GrRenderTargetContext.h"
 
-bool GrFixedClip::quickContains(const SkRect& rect) const {
-    if (fWindowRectsState.enabled()) {
-        return false;
-    }
-
-    return !fScissorState.enabled() || GrClip::IsInsideClip(fScissorState.rect(), rect);
-}
-
 SkIRect GrFixedClip::getConservativeBounds() const {
     return fScissorState.rect();
 }
 
-bool GrFixedClip::isRRect(SkRRect* rr, GrAA* aa) const {
-    if (fWindowRectsState.enabled()) {
-        return false;
+GrClip::PreClipResult GrFixedClip::preApply(const SkRect& drawBounds) const {
+    if (IsOutsideClip(fScissorState.rect(), drawBounds)) {
+        return Effect::kClippedOut;
     }
-    // Whether or not the scissor test is enabled, the remaining clip is a rectangle described
-    // by scissorState.rect() (either the scissor or the rt bounds).
-    rr->setRect(SkRect::Make(fScissorState.rect()));
-    *aa = GrAA::kNo;
-    return true;
-};
 
-bool GrFixedClip::apply(GrAppliedHardClip* out, SkRect* bounds) const {
-    if (IsOutsideClip(fScissorState.rect(), *bounds)) {
-        return false;
+    if (fWindowRectsState.enabled()) {
+        return Effect::kClipped;
     }
-    if (!IsInsideClip(fScissorState.rect(), *bounds)) {
+
+    if (!fScissorState.enabled() || IsInsideClip(fScissorState.rect(), drawBounds)) {
+        // Either no scissor or the scissor doesn't clip the draw
+        return Effect::kUnclipped;
+    }
+    // Report the scissor as a degenerate round rect
+    return {SkRect::Make(fScissorState.rect()), GrAA::kNo};
+}
+
+GrClip::Effect GrFixedClip::apply(GrAppliedHardClip* out, SkRect* bounds) const {
+    if (IsOutsideClip(fScissorState.rect(), *bounds)) {
+        return Effect::kClippedOut;
+    }
+
+    Effect effect = Effect::kUnclipped;
+    if (fScissorState.enabled() && !IsInsideClip(fScissorState.rect(), *bounds)) {
         SkIRect tightScissor = bounds->roundOut();
         SkAssertResult(tightScissor.intersect(fScissorState.rect()));
         out->addScissor(tightScissor, bounds);
+        effect = Effect::kClipped;
     }
 
     if (fWindowRectsState.enabled()) {
         out->addWindowRectangles(fWindowRectsState);
+        // We could iterate each window rectangle to check for intersection, but be conservative
+        // and report that it's clipped
+        effect = Effect::kClipped;
     }
 
-    return true;
+    return effect;
 }
diff --git a/src/gpu/GrFixedClip.h b/src/gpu/GrFixedClip.h
index 5abc310..383c388 100644
--- a/src/gpu/GrFixedClip.h
+++ b/src/gpu/GrFixedClip.h
@@ -46,10 +46,9 @@
         fWindowRectsState.set(windows, mode);
     }
 
-    bool quickContains(const SkRect&) const override;
-    SkIRect getConservativeBounds() const override;
-    bool isRRect(SkRRect* rr, GrAA*) const override;
-    bool apply(GrAppliedHardClip*, SkRect*) const override;
+    SkIRect getConservativeBounds() const final;
+    Effect apply(GrAppliedHardClip*, SkRect*) const final;
+    PreClipResult preApply(const SkRect& drawBounds) const final;
 
 private:
     GrScissorState       fScissorState;
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index bf6906f..4e2a438 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -682,25 +682,6 @@
     kCropped
 };
 
-static bool make_vertex_finite(float* value) {
-    if (SkScalarIsNaN(*value)) {
-        return false;
-    }
-
-    if (!SkScalarIsFinite(*value)) {
-        // +/- infinity at this point. Don't use exactly SK_ScalarMax so that we have some precision
-        // left when calculating crops.
-        static constexpr float kNearInfinity = SK_ScalarMax / 4.f;
-        *value = *value < 0.f ? -kNearInfinity : kNearInfinity;
-    }
-
-    return true;
-}
-
-static SkIRect get_clip_bounds(const GrRenderTargetContext* rtc, const GrClip* clip) {
-    return clip ? clip->getConservativeBounds() : SkIRect::MakeWH(rtc->width(), rtc->height());
-}
-
 GrRenderTargetContext::QuadOptimization GrRenderTargetContext::attemptQuadOptimization(
         const GrClip* clip, const SkPMColor4f* constColor,
         const GrUserStencilSettings* stencilSettings, GrAA* aa, DrawQuad* quad) {
@@ -721,132 +702,110 @@
     SkRect rtRect = this->asSurfaceProxy()->getBoundsRect();
 
     SkRect drawBounds = quad->fDevice.bounds();
-    if (constColor) {
-        // If the device quad is not finite, coerce into a finite quad. This is acceptable since it
-        // will be cropped to the finite 'clip' or render target and there is no local space mapping
-        if (!quad->fDevice.isFinite()) {
-            for (int i = 0; i < 4; ++i) {
-                if (!make_vertex_finite(quad->fDevice.xs() + i) ||
-                    !make_vertex_finite(quad->fDevice.ys() + i) ||
-                    !make_vertex_finite(quad->fDevice.ws() + i)) {
-                    // Discard if we see a nan
-                    return QuadOptimization::kDiscarded;
-                }
-            }
-            SkASSERT(quad->fDevice.isFinite());
-        }
-    } else {
-        // CropToRect requires the quads to be finite. If they are not finite and we have local
-        // coordinates, the mapping from local space to device space is poorly defined so drop it
-        if (!quad->fDevice.isFinite()) {
-            return QuadOptimization::kDiscarded;
-        }
-    }
-
-    // If the quad is entirely off screen, it doesn't matter what the clip does
-    if (!rtRect.intersects(drawBounds)) {
+    if (!quad->fDevice.isFinite() || drawBounds.isEmpty() ||
+        GrClip::IsOutsideClip(rtRect, drawBounds)) {
         return QuadOptimization::kDiscarded;
     }
-
-    // Check if clip can be represented as a rounded rect (initialize as if clip fully contained
-    // the render target).
-    SkRRect clipRRect = SkRRect::MakeRect(rtRect);
-    // We initialize clipAA to *aa when there are stencil settings so that we don't artificially
-    // encounter mixed-aa edges (not allowed for stencil), but we want to start as non-AA for
-    // regular draws so that if we fully cover the render target, that can stop being anti-aliased.
-    GrAA clipAA = stencilSettings ? *aa : GrAA::kNo;
-    bool axisAlignedClip = true;
-    if (clip && !clip->quickContains(rtRect)) {
-        if (!clip->isRRect(&clipRRect, &clipAA)) {
-            axisAlignedClip = false;
+    auto conservativeCrop = [&]() {
+        static constexpr int kLargeDrawLimit = 15000;
+        // Crop the quad to the render target. This doesn't change the visual results of drawing but
+        // is meant to help numerical stability for excessively large draws.
+        if (drawBounds.width() > kLargeDrawLimit || drawBounds.height() > kLargeDrawLimit) {
+            GrQuadUtils::CropToRect(rtRect, *aa, quad, /* compute local */ !constColor);
+            SkASSERT(quad->fEdgeFlags == oldFlags);
         }
-    }
+    };
 
-    // If the clip rrect is valid (i.e. axis-aligned), we can potentially combine it with the
-    // draw geometry so that no clip is needed when drawing.
-    if (axisAlignedClip && (!stencilSettings || clipAA == *aa)) {
-        // Tighten clip bounds (if clipRRect.isRect() is true, clipBounds now holds the intersection
-        // of the render target and the clip rect)
-        SkRect clipBounds = rtRect;
-        if (!clipBounds.intersect(clipRRect.rect()) || !clipBounds.intersects(drawBounds)) {
+    bool simpleColor = !stencilSettings && constColor;
+    GrClip::PreClipResult result = clip ? clip->preApply(drawBounds)
+                                        : GrClip::PreClipResult(GrClip::Effect::kUnclipped);
+    switch(result.fEffect) {
+        case GrClip::Effect::kClippedOut:
             return QuadOptimization::kDiscarded;
-        }
-
-        if (clipRRect.isRect()) {
-            // No rounded corners, so the kClear and kExplicitClip optimizations are possible
-            if (GrQuadUtils::CropToRect(clipBounds, clipAA, quad, /*compute local*/ !constColor)) {
-                if (!stencilSettings && constColor &&
-                    quad->fDevice.quadType() == GrQuad::Type::kAxisAligned) {
-                    // Clear optimization is possible
-                    drawBounds = quad->fDevice.bounds();
-                    if (drawBounds.contains(rtRect)) {
-                        // Fullscreen clear
-                        this->clear(*constColor);
-                        return QuadOptimization::kSubmitted;
-                    } else if (GrClip::IsPixelAligned(drawBounds) &&
-                               drawBounds.width() > 256 && drawBounds.height() > 256) {
-                        // Scissor + clear (round shouldn't do anything since we are pixel aligned)
-                        SkIRect scissorRect;
-                        drawBounds.round(&scissorRect);
-                        this->clear(scissorRect, *constColor);
-                        return QuadOptimization::kSubmitted;
-                    }
-                }
-
-                // Update overall AA setting.
-                if (*aa == GrAA::kNo && clipAA == GrAA::kYes &&
-                    quad->fEdgeFlags != GrQuadAAFlags::kNone) {
-                    // The clip was anti-aliased and now the draw needs to be upgraded to AA to
-                    // properly reflect the smooth edge of the clip.
-                    *aa = GrAA::kYes;
-                }
-                // We intentionally do not downgrade AA here because we don't know if we need to
-                // preserve MSAA (see GrQuadAAFlags docs). But later in the pipeline, the ops can
-                // use GrResolveAATypeForQuad() to turn off coverage AA when all flags are off.
-
-                // deviceQuad is exactly the intersection of original quad and clip, so it can be
-                // drawn with no clip (submitted by caller)
+        case GrClip::Effect::kUnclipped:
+            if (!simpleColor) {
+                conservativeCrop();
                 return QuadOptimization::kClipApplied;
             } else {
-                // The quads have been updated to better fit the clip bounds, but can't get rid of
-                // the clip entirely
-                quad->fEdgeFlags = oldFlags;
-                return QuadOptimization::kCropped;
+                // Update result to store the render target bounds in order and then fall
+                // through to attempt the draw->native clear optimization
+                result = GrClip::PreClipResult(SkRRect::MakeRect(rtRect), *aa);
             }
-        } else if (!stencilSettings && constColor) {
-            // Rounded corners and constant filled color (limit ourselves to solid colors because
-            // there is no way to use custom local coordinates with drawRRect).
-            if (GrQuadUtils::CropToRect(clipBounds, clipAA, quad, /* compute local */ false) &&
-                quad->fDevice.quadType() == GrQuad::Type::kAxisAligned &&
-                quad->fDevice.bounds().contains(clipBounds)) {
-                // Since the cropped quad became a rectangle which covered the bounds of the rrect,
-                // we can draw the rrect directly and ignore the edge flags
-                GrPaint paint;
-                clear_to_grpaint(*constColor, &paint);
-                this->drawRRect(nullptr, std::move(paint), clipAA, SkMatrix::I(),
-                                clipRRect, GrStyle::SimpleFill());
-                return QuadOptimization::kSubmitted;
-            } else {
-                // The quad has been updated to better fit clip bounds, but can't remove the clip
-                quad->fEdgeFlags = oldFlags;
+            break;
+        case GrClip::Effect::kClipped:
+            if (!result.fIsRRect || (stencilSettings && result.fAA != *aa) ||
+                (!result.fRRect.isRect() && !simpleColor)) {
+                // The clip and draw state are too complicated to try and reduce
+                conservativeCrop();
                 return QuadOptimization::kCropped;
+            } // Else fall through to attempt to combine the draw and clip geometry together
+            break;
+        default:
+            SkUNREACHABLE;
+    }
+
+    // If we reached here, we know we're an axis-aligned clip that is either a rect or a round rect,
+    // so we can potentially combine it with the draw geometry so that no clipping is needed.
+    SkASSERT(result.fEffect == GrClip::Effect::kClipped && result.fIsRRect);
+    SkRect clippedBounds = result.fRRect.getBounds();
+    clippedBounds.intersect(rtRect);
+    if (result.fRRect.isRect()) {
+        // No rounded corners, so we might be able to become a native clear or we might be able to
+        // modify geometry and edge flags to represent intersected shape of clip and draw.
+        if (GrQuadUtils::CropToRect(clippedBounds, result.fAA, quad,
+                                    /*compute local*/ !constColor)) {
+            if (simpleColor && quad->fDevice.quadType() == GrQuad::Type::kAxisAligned) {
+                // Clear optimization is possible
+                drawBounds = quad->fDevice.bounds();
+                if (drawBounds.contains(rtRect)) {
+                    // Fullscreen clear
+                    this->clear(*constColor);
+                    return QuadOptimization::kSubmitted;
+                } else if (GrClip::IsPixelAligned(drawBounds) &&
+                           drawBounds.width() > 256 && drawBounds.height() > 256) {
+                    // Scissor + clear (round shouldn't do anything since we are pixel aligned)
+                    SkIRect scissorRect;
+                    drawBounds.round(&scissorRect);
+                    this->clear(scissorRect, *constColor);
+                    return QuadOptimization::kSubmitted;
+                }
             }
+
+            // else the draw and clip were combined so just update the AA to reflect combination
+            if (*aa == GrAA::kNo && result.fAA == GrAA::kYes &&
+                quad->fEdgeFlags != GrQuadAAFlags::kNone) {
+                // The clip was anti-aliased and now the draw needs to be upgraded to AA to
+                // properly reflect the smooth edge of the clip.
+                *aa = GrAA::kYes;
+            }
+            // We intentionally do not downgrade AA here because we don't know if we need to
+            // preserve MSAA (see GrQuadAAFlags docs). But later in the pipeline, the ops can
+            // use GrResolveAATypeForQuad() to turn off coverage AA when all flags are off.
+            // deviceQuad is exactly the intersection of original quad and clip, so it can be
+            // drawn with no clip (submitted by caller)
+            return QuadOptimization::kClipApplied;
+        }
+    } else {
+        // Rounded corners and constant filled color (limit ourselves to solid colors because
+        // there is no way to use custom local coordinates with drawRRect).
+        SkASSERT(simpleColor);
+        if (GrQuadUtils::CropToRect(clippedBounds, result.fAA, quad,
+                                    /* compute local */ false) &&
+            quad->fDevice.quadType() == GrQuad::Type::kAxisAligned &&
+            quad->fDevice.bounds().contains(clippedBounds)) {
+            // Since the cropped quad became a rectangle which covered the bounds of the rrect,
+            // we can draw the rrect directly and ignore the edge flags
+            GrPaint paint;
+            clear_to_grpaint(*constColor, &paint);
+            this->drawRRect(nullptr, std::move(paint), result.fAA, SkMatrix::I(), result.fRRect,
+                            GrStyle::SimpleFill());
+            return QuadOptimization::kSubmitted;
         }
     }
 
-    // Crop the quad to the conservative bounds of the clip.
-    SkRect clipBounds = SkRect::Make(get_clip_bounds(this, clip));
-
-    // One final check for discarding, since we may have gone here directly due to a complex clip
-    if (!clipBounds.intersects(drawBounds)) {
-        return QuadOptimization::kDiscarded;
-    }
-
-    // Even if this were to return true, the crop rect does not exactly match the clip, so can not
-    // report explicit-clip. Since these edges aren't visible, don't update the final edge flags.
-    GrQuadUtils::CropToRect(clipBounds, clipAA, quad, /* compute local */ !constColor);
+    // The quads have been updated to better fit the clip bounds, but can't get rid of
+    // the clip entirely
     quad->fEdgeFlags = oldFlags;
-
     return QuadOptimization::kCropped;
 }
 
@@ -1074,7 +1033,7 @@
     GrAppliedHardClip appliedClip(fRenderTargetContext->dimensions(),
                                   fRenderTargetContext->asSurfaceProxy()->backingStoreDimensions());
 
-    if (clip && !clip->apply(&appliedClip, &bounds)) {
+    if (clip && GrClip::Effect::kClippedOut == clip->apply(&appliedClip, &bounds)) {
         return;
     }
     // else see FIXME above; we'd normally want to check path bounds with render target bounds,
@@ -1175,26 +1134,49 @@
     SkDEBUGCODE(this->validate();)
     GR_CREATE_TRACE_MARKER_CONTEXT("GrRenderTargetContext", "drawRRect", fContext);
 
+    SkASSERT(!style.pathEffect()); // this should've been devolved to a path in SkGpuDevice
+
     const SkStrokeRec& stroke = style.strokeRec();
     if (stroke.getStyle() == SkStrokeRec::kFill_Style && rrect.isEmpty()) {
        return;
     }
 
     const GrClip* clip = origClip;
-#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
-    // The Android framework frequently clips rrects to themselves where the clip is non-aa and the
-    // draw is aa. Since our lower level clip code works from op bounds, which are SkRects, it
-    // doesn't detect that the clip can be ignored (modulo antialiasing). The following test
-    // attempts to mitigate the stencil clip cost but will only help when the entire clip stack
-    // can be ignored. We'd prefer to fix this in the framework by removing the clips calls. This
-    // only works for filled rrects since the stroke width outsets beyond the rrect itself.
+    // It is not uncommon to clip to a round rect and then draw that same round rect. Since our
+    // lower level clip code works from op bounds, which are SkRects, it doesn't detect that the
+    // clip can be ignored. The following test attempts to mitigate the stencil clip cost but only
+    // works for axis-aligned round rects. This also only works for filled rrects since the stroke
+    // width outsets beyond the rrect itself.
     SkRRect devRRect;
     if (clip && stroke.getStyle() == SkStrokeRec::kFill_Style &&
-        rrect.transform(viewMatrix, &devRRect) && clip->quickContains(devRRect)) {
-        clip = nullptr;
-    }
+        rrect.transform(viewMatrix, &devRRect)) {
+        GrClip::PreClipResult result = clip->preApply(devRRect.getBounds());
+        switch(result.fEffect) {
+            case GrClip::Effect::kClippedOut:
+                return;
+            case GrClip::Effect::kUnclipped:
+                clip = nullptr;
+                break;
+            case GrClip::Effect::kClipped:
+                // Currently there's no general-purpose rrect-to-rrect contains function, and if we
+                // got here, we know the devRRect's bounds aren't fully contained by the clip.
+                // Testing for equality between the two is a reasonable stop-gap for now.
+                if (result.fIsRRect && result.fRRect == devRRect) {
+                    // NOTE: On the android framework, we allow this optimization even when the clip
+                    // is non-AA and the draw is AA.
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+                    if (result.fAA == aa || (result.fAA == GrAA::kNo && aa == GrAA::kYes)) {
+#else
+                    if (result.fAA == aa) {
 #endif
-    SkASSERT(!style.pathEffect()); // this should've been devolved to a path in SkGpuDevice
+                        clip = nullptr;
+                    }
+                }
+                break;
+            default:
+                SkUNREACHABLE;
+        }
+    }
 
     AutoCheckFlush acf(this->drawingManager());
 
@@ -1823,6 +1805,10 @@
                                      /* attempt fallback */ false);
 }
 
+static SkIRect get_clip_bounds(const GrRenderTargetContext* rtc, const GrClip* clip) {
+    return clip ? clip->getConservativeBounds() : SkIRect::MakeWH(rtc->width(), rtc->height());
+}
+
 bool GrRenderTargetContextPriv::drawAndStencilPath(const GrHardClip* clip,
                                                    const GrUserStencilSettings* ss,
                                                    SkRegion::Op op,
@@ -2059,14 +2045,11 @@
     bool skipDraw = false;
     if (clip) {
         // Have a complex clip, so defer to its early clip culling
-        if (!clip->apply(fContext, this, usesHWAA, usesUserStencilBits, &appliedClip, &bounds)) {
-            skipDraw = true;
-        }
+        skipDraw = clip->apply(fContext, this, usesHWAA, usesUserStencilBits,
+                               &appliedClip, &bounds) == GrClip::Effect::kClippedOut;
     } else {
         // No clipping, so just clip the bounds against the logical render target dimensions
-        if (!bounds.intersect(this->asSurfaceProxy()->getBoundsRect())) {
-            skipDraw = true;
-        }
+        skipDraw = !bounds.intersect(this->asSurfaceProxy()->getBoundsRect());
     }
 
     if (skipDraw) {
diff --git a/src/gpu/GrStencilClip.h b/src/gpu/GrStencilClip.h
index 4ab8a82..a55c463 100644
--- a/src/gpu/GrStencilClip.h
+++ b/src/gpu/GrStencilClip.h
@@ -32,23 +32,29 @@
     bool hasStencilClip() const { return SK_InvalidGenID != fStencilStackID; }
     void setStencilClip(uint32_t stencilStackID) { fStencilStackID = stencilStackID; }
 
-    bool quickContains(const SkRect& rect) const override {
-        return !this->hasStencilClip() && fFixedClip.quickContains(rect);
-    }
-    SkIRect getConservativeBounds() const override {
+    SkIRect getConservativeBounds() const final {
         return fFixedClip.getConservativeBounds();
     }
-    bool isRRect(SkRRect* rr, GrAA* aa) const override {
-        return !this->hasStencilClip() && fFixedClip.isRRect(rr, aa);
-    }
-    bool apply(GrAppliedHardClip* out, SkRect* bounds) const override {
-        if (!fFixedClip.apply(out, bounds)) {
-            return false;
+
+    Effect apply(GrAppliedHardClip* out, SkRect* bounds) const final {
+        Effect effect = fFixedClip.apply(out, bounds);
+        if (effect == Effect::kClippedOut) {
+            // Stencil won't bring back coverage
+            return Effect::kClippedOut;
         }
         if (this->hasStencilClip()) {
             out->addStencilClip(fStencilStackID);
+            effect = Effect::kClipped;
         }
-        return true;
+        return effect;
+    }
+
+    PreClipResult preApply(const SkRect& drawBounds) const final {
+        if (this->hasStencilClip()) {
+            return this->INHERITED::preApply(drawBounds);
+        } else {
+            return fFixedClip.preApply(drawBounds);
+        }
     }
 
 private:
diff --git a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
index fcff78c..5ea3738 100644
--- a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
@@ -125,9 +125,9 @@
 
         // fake inverse with a stencil and cover
         GrAppliedClip appliedClip(args.fRenderTargetContext->dimensions());
-        if (args.fClip && !args.fClip->apply(
+        if (args.fClip && args.fClip->apply(
                 args.fContext, args.fRenderTargetContext, doStencilMSAA, true, &appliedClip,
-                &devBounds)) {
+                &devBounds) == GrClip::Effect::kClippedOut) {
             return true;
         }
         GrStencilClip stencilClip(args.fRenderTargetContext->dimensions(),
diff --git a/src/gpu/text/GrTextBlob.cpp b/src/gpu/text/GrTextBlob.cpp
index 875d939..a390864 100644
--- a/src/gpu/text/GrTextBlob.cpp
+++ b/src/gpu/text/GrTextBlob.cpp
@@ -442,25 +442,29 @@
         bool skipClip = false;
         SkIRect clipRect = SkIRect::MakeEmpty();
         SkRect rtBounds = SkRect::MakeWH(target->width(), target->height());
-        SkRRect clipRRect = SkRRect::MakeRect(rtBounds);
-        GrAA aa;
         // We can clip geometrically if we're not using SDFs or transformed glyphs,
         // and we have an axis-aligned rectangular non-AA clip
-        if (!this->drawAsDistanceFields() &&
-            !this->needsTransform() &&
-            (!clip || (clip->isRRect(&clipRRect, &aa) &&
-                       clipRRect.isRect() && GrAA::kNo == aa))) {
+        if (!this->drawAsDistanceFields() && !this->needsTransform()) {
             // We only need to do clipping work if the subrun isn't contained by the clip
+            skipClip = true;
             SkRect subRunBounds = this->deviceRect(deviceMatrix.localToDevice(), drawOrigin);
-            if (!clipRRect.getBounds().contains(subRunBounds)) {
+            if (!clip && !rtBounds.intersects(subRunBounds)) {
                 // If the subrun is completely outside, don't add an op for it
-                if (!clipRRect.getBounds().intersects(subRunBounds)) {
+                return;
+            } else if (clip) {
+                GrClip::PreClipResult result = clip->preApply(subRunBounds);
+                if (result.fEffect == GrClip::Effect::kClipped) {
+                    if (result.fIsRRect && result.fRRect.isRect() && result.fAA == GrAA::kNo) {
+                        // Embed non-AA axis-aligned clip into the draw
+                        result.fRRect.getBounds().round(&clipRect);
+                    } else {
+                        // Can't actually skip the regular clipping
+                        skipClip = false;
+                    }
+                } else if (result.fEffect == GrClip::Effect::kClippedOut) {
                     return;
-                } else {
-                    clipRRect.getBounds().round(&clipRect);
                 }
             }
-            skipClip = true;
         }
 
         auto op = this->makeOp(deviceMatrix, drawOrigin, clipRect, paint, props, target);
diff --git a/tests/GrCCPRTest.cpp b/tests/GrCCPRTest.cpp
index 4f1b6d8..7561981 100644
--- a/tests/GrCCPRTest.cpp
+++ b/tests/GrCCPRTest.cpp
@@ -40,16 +40,15 @@
 
 private:
     SkIRect getConservativeBounds() const final { return fPath.getBounds().roundOut(); }
-    bool apply(GrRecordingContext* context, GrRenderTargetContext* rtc, bool useHWAA,
-               bool hasUserStencilSettings, GrAppliedClip* out, SkRect* bounds) const override {
+    Effect apply(GrRecordingContext* context, GrRenderTargetContext* rtc, bool useHWAA,
+                 bool hasUserStencilSettings, GrAppliedClip* out,
+                 SkRect* bounds) const override {
         out->addCoverageFP(fCCPR->makeClipProcessor(/*inputFP=*/nullptr,
                                                     rtc->priv().testingOnly_getOpsTaskID(), fPath,
                                                     SkIRect::MakeWH(rtc->width(), rtc->height()),
                                                     *context->priv().caps()));
-        return true;
+        return Effect::kClipped;
     }
-    bool quickContains(const SkRect&) const final { return false; }
-    bool isRRect(SkRRect* rr, GrAA*) const final { return false; }
 
     GrCoverageCountingPathRenderer* const fCCPR;
     const SkPath fPath;
diff --git a/tests/LazyProxyTest.cpp b/tests/LazyProxyTest.cpp
index 9bb4bff..77965a4 100644
--- a/tests/LazyProxyTest.cpp
+++ b/tests/LazyProxyTest.cpp
@@ -178,15 +178,13 @@
         SkIRect getConservativeBounds() const final {
             return SkIRect::MakeSize(fAtlas->dimensions());
         }
-
-        bool apply(GrRecordingContext* context, GrRenderTargetContext*, bool useHWAA,
-                   bool hasUserStencilSettings, GrAppliedClip* out, SkRect* bounds) const override {
+        Effect apply(GrRecordingContext* context, GrRenderTargetContext*, bool useHWAA,
+                         bool hasUserStencilSettings, GrAppliedClip* out,
+                         SkRect* bounds) const override {
             GrProxyProvider* proxyProvider = context->priv().proxyProvider();
             out->addCoverageFP(std::make_unique<ClipFP>(context, proxyProvider, fTest, fAtlas));
-            return true;
+            return Effect::kClipped;
         }
-        bool quickContains(const SkRect&) const final { return false; }
-        bool isRRect(SkRRect* rr, GrAA*) const final { return false; }
 
         LazyProxyTest* const fTest;
         GrTextureProxy* fAtlas;