diff --git a/gn/tests.gni b/gn/tests.gni
index b893768..c823ac2 100644
--- a/gn/tests.gni
+++ b/gn/tests.gni
@@ -24,6 +24,7 @@
   "$_tests/BlendTest.cpp",
   "$_tests/BlitMaskClip.cpp",
   "$_tests/BlurTest.cpp",
+  "$_tests/BulkFillRectTest.cpp",
   "$_tests/CTest.cpp",
   "$_tests/CachedDataTest.cpp",
   "$_tests/CachedDecodingPixelRefTest.cpp",
diff --git a/src/gpu/GrOpsTask.h b/src/gpu/GrOpsTask.h
index 1a4c517..fd69509 100644
--- a/src/gpu/GrOpsTask.h
+++ b/src/gpu/GrOpsTask.h
@@ -106,6 +106,11 @@
     SkDEBUGCODE(int numClips() const override { return fNumClips; })
     SkDEBUGCODE(void visitProxies_debugOnly(const VisitSurfaceProxyFunc&) const override;)
 
+#if GR_TEST_UTILS
+    int numOpChains() const { return fOpChains.count(); }
+    const GrOp* getChain(int index) const { return fOpChains[index].head(); }
+#endif
+
 private:
     bool isNoOp() const {
         // TODO: GrLoadOp::kDiscard (i.e., storing a discard) should also be grounds for skipping
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 1e0cc19..06147d9 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -733,8 +733,9 @@
                                         const SkMatrix& viewMatrix, const QuadSetEntry quads[],
                                         int cnt) {
     GrAAType aaType = this->chooseAAType(aa);
-    this->addDrawOp(clip, GrFillRectOp::MakeSet(fContext, std::move(paint), aaType, viewMatrix,
-                                                quads, cnt));
+
+    GrFillRectOp::AddFillRectOps(this, clip, fContext, std::move(paint), aaType, viewMatrix,
+                                 quads, cnt);
 }
 
 int GrRenderTargetContextPriv::maxWindowRectangles() const {
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index eacff51..89fd20c 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -549,12 +549,16 @@
     friend class GrTessellatingPathRenderer;         // for access to add[Mesh]DrawOp
     friend class GrCCPerFlushResources;              // for access to addDrawOp
     friend class GrCoverageCountingPathRenderer;     // for access to addDrawOp
+    friend class GrFillRectOp;                       // for access to addDrawOp
+
+#if GR_TEST_UTILS
     // for a unit test
     friend void test_draw_op(GrContext*,
                              GrRenderTargetContext*,
                              std::unique_ptr<GrFragmentProcessor>,
                              sk_sp<GrTextureProxy>,
                              GrColorType);
+#endif
 
     GrRenderTargetContext(GrRecordingContext*, sk_sp<GrRenderTargetProxy>, GrColorType,
                           GrSurfaceOrigin, GrSwizzle texSwizzle, GrSwizzle outSwizzle,
diff --git a/src/gpu/ops/GrDrawOp.h b/src/gpu/ops/GrDrawOp.h
index a9e9752..3385b64 100644
--- a/src/gpu/ops/GrDrawOp.h
+++ b/src/gpu/ops/GrDrawOp.h
@@ -54,6 +54,11 @@
     }
 #endif
 
+#if GR_TEST_UTILS
+    // This is really only intended for GrTextureOp and GrFillRectOp to override
+    virtual int numQuads() const { return -1; }
+#endif
+
 private:
     typedef GrOp INHERITED;
 };
diff --git a/src/gpu/ops/GrFillRectOp.cpp b/src/gpu/ops/GrFillRectOp.cpp
index ec6fa0b..2ee183a 100644
--- a/src/gpu/ops/GrFillRectOp.cpp
+++ b/src/gpu/ops/GrFillRectOp.cpp
@@ -178,13 +178,11 @@
     DEFINE_OP_CLASS_ID
 
 private:
-    // For GrFillRectOp::MakeSet's use of addQuad
-    friend std::unique_ptr<GrDrawOp> GrFillRectOp::MakeSet(
-            GrRecordingContext*,
-            GrPaint&&,
-            GrAAType, const SkMatrix& viewMatrix,
-            const GrRenderTargetContext::QuadSetEntry quads[], int quadCount,
-            const GrUserStencilSettings*);
+    friend class ::GrFillRectOp; // for access to addQuad
+
+#if GR_TEST_UTILS
+    int numQuads() const final { return fQuads.count(); }
+#endif
 
     void onPrepareDraws(Target* target) override {
         TRACE_EVENT0("skia.gpu", TRACE_FUNC);
@@ -297,19 +295,29 @@
     // But since it's avoiding the op list management, it must update the op's bounds. This is only
     // used with quad sets, which uses the same view matrix for each quad so this assumes that the
     // device quad type of the new quad is the same as the op's.
-    void addQuad(const GrQuad& deviceQuad, const GrQuad& localQuad,
+    bool addQuad(const GrQuad& deviceQuad, const GrQuad& localQuad,
                  const SkPMColor4f& color, GrQuadAAFlags edgeAA, GrAAType aaType) {
         // The new quad's aa type should be the same as the first quad's or none, except when the
         // first quad's aa type was already downgraded to none, in which case the stored type must
         // be lifted to back to the requested type.
-        if (aaType != fHelper.aaType()) {
-            if (aaType != GrAAType::kNone) {
-                // Original quad was downgraded to non-aa, lift back up to this quad's required type
-                SkASSERT(fHelper.aaType() == GrAAType::kNone);
-                fHelper.setAAType(aaType);
+        if (aaType != fHelper.aaType() && aaType != GrAAType::kNone) {
+            auto indexBufferOption = GrQuadPerEdgeAA::CalcIndexBufferOption(aaType,
+                                                                            fQuads.count()+1);
+            if (fQuads.count()+1 > GrQuadPerEdgeAA::QuadLimit(indexBufferOption)) {
+                // Promoting to the new aaType would've caused an overflow of the indexBuffer
+                // limit
+                return false;
             }
-            // else the new quad could have been downgraded but the other quads can't be, so don't
-            // reset the op's accumulated aa type.
+
+            // Original quad was downgraded to non-aa, lift back up to this quad's required type
+            SkASSERT(fHelper.aaType() == GrAAType::kNone);
+            fHelper.setAAType(aaType);
+        } else {
+            auto indexBufferOption = GrQuadPerEdgeAA::CalcIndexBufferOption(fHelper.aaType(),
+                                                                            fQuads.count()+1);
+            if (fQuads.count()+1 > GrQuadPerEdgeAA::QuadLimit(indexBufferOption)) {
+                return false; // This op can't grow any more
+            }
         }
 
         // Update the bounds and add the quad to this op's storage
@@ -318,6 +326,7 @@
         this->setBounds(newBounds, HasAABloat(fHelper.aaType() == GrAAType::kCoverage),
                         IsHairline::kNo);
         fQuads.append(deviceQuad, { color, edgeAA }, fHelper.isTrivial() ? nullptr : &localQuad);
+        return true;
     }
 
     struct ColorAndAA {
@@ -335,45 +344,46 @@
 
 } // anonymous namespace
 
-namespace GrFillRectOp {
-
-std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
-                               GrPaint&& paint,
-                               GrAAType aaType,
-                               GrQuadAAFlags aaFlags,
-                               const GrQuad& deviceQuad,
-                               const GrQuad& localQuad,
-                               const GrUserStencilSettings* stencil) {
+std::unique_ptr<GrDrawOp> GrFillRectOp::Make(GrRecordingContext* context,
+                                             GrPaint&& paint,
+                                             GrAAType aaType,
+                                             GrQuadAAFlags aaFlags,
+                                             const GrQuad& deviceQuad,
+                                             const GrQuad& localQuad,
+                                             const GrUserStencilSettings* stencil) {
     return FillRectOp::Make(context, std::move(paint), aaType, aaFlags, stencil,
                             deviceQuad, localQuad);
 }
 
-std::unique_ptr<GrDrawOp> MakeNonAARect(GrRecordingContext* context,
-                                        GrPaint&& paint,
-                                        const SkMatrix& view,
-                                        const SkRect& rect,
-                                        const GrUserStencilSettings* stencil) {
+std::unique_ptr<GrDrawOp> GrFillRectOp::MakeNonAARect(GrRecordingContext* context,
+                                                      GrPaint&& paint,
+                                                      const SkMatrix& view,
+                                                      const SkRect& rect,
+                                                      const GrUserStencilSettings* stencil) {
     return FillRectOp::Make(context, std::move(paint), GrAAType::kNone, GrQuadAAFlags::kNone,
                             stencil, GrQuad::MakeFromRect(rect, view), GrQuad(rect));
 }
 
-std::unique_ptr<GrDrawOp> MakeSet(GrRecordingContext* context,
-                                  GrPaint&& paint,
-                                  GrAAType aaType,
-                                  const SkMatrix& viewMatrix,
-                                  const GrRenderTargetContext::QuadSetEntry quads[],
-                                  int cnt,
-                                  const GrUserStencilSettings* stencilSettings) {
+std::unique_ptr<GrDrawOp> GrFillRectOp::MakeOp(GrRecordingContext* context,
+                                               GrPaint&& paint,
+                                               GrAAType aaType,
+                                               const SkMatrix& viewMatrix,
+                                               const GrRenderTargetContext::QuadSetEntry quads[],
+                                               int cnt,
+                                               const GrUserStencilSettings* stencilSettings,
+                                               int* numConsumed) {
     // First make a draw op for the first quad in the set
     SkASSERT(cnt > 0);
 
     paint.setColor4f(quads[0].fColor);
-    std::unique_ptr<GrDrawOp> op = FillRectOp::Make(context, std::move(paint), aaType,
+    std::unique_ptr<GrDrawOp> op = FillRectOp::Make(
+            context, std::move(paint), aaType,
             quads[0].fAAFlags, stencilSettings,
             GrQuad::MakeFromRect(quads[0].fRect, viewMatrix),
             GrQuad::MakeFromRect(quads[0].fRect, quads[0].fLocalMatrix));
-    auto* fillRects = op->cast<FillRectOp>();
+    FillRectOp* fillRects = op->cast<FillRectOp>();
 
+    *numConsumed = 1;
     // Accumulate remaining quads similar to onCombineIfPossible() without creating an op
     for (int i = 1; i < cnt; ++i) {
         GrQuad deviceQuad = GrQuad::MakeFromRect(quads[i].fRect, viewMatrix);
@@ -383,18 +393,52 @@
         GrQuadUtils::ResolveAAType(aaType, quads[i].fAAFlags, deviceQuad,
                                    &resolvedAA, &resolvedEdgeFlags);
 
-        fillRects->addQuad(deviceQuad,
-                           GrQuad::MakeFromRect(quads[i].fRect, quads[i].fLocalMatrix),
-                           quads[i].fColor, resolvedEdgeFlags,resolvedAA);
+        if (!fillRects->addQuad(deviceQuad,
+                                GrQuad::MakeFromRect(quads[i].fRect, quads[i].fLocalMatrix),
+                                quads[i].fColor, resolvedEdgeFlags, resolvedAA)) {
+            break;
+        }
+
+        (*numConsumed)++;
     }
 
     return op;
 }
 
-} // namespace GrFillRectOp
+void GrFillRectOp::AddFillRectOps(GrRenderTargetContext* rtc,
+                                  const GrClip& clip,
+                                  GrRecordingContext* context,
+                                  GrPaint&& paint,
+                                  GrAAType aaType,
+                                  const SkMatrix& viewMatrix,
+                                  const GrRenderTargetContext::QuadSetEntry quads[],
+                                  int cnt,
+                                  const GrUserStencilSettings* stencilSettings) {
+
+    int offset = 0;
+    int numLeft = cnt;
+    while (numLeft) {
+        int numConsumed = 0;
+
+        std::unique_ptr<GrDrawOp> op = MakeOp(context, GrPaint::Clone(paint), aaType, viewMatrix,
+                                              &quads[offset], numLeft, stencilSettings,
+                                              &numConsumed);
+
+        offset += numConsumed;
+        numLeft -= numConsumed;
+
+        rtc->addDrawOp(clip, std::move(op));
+    }
+
+    SkASSERT(offset == cnt);
+}
 
 #if GR_TEST_UTILS
 
+uint32_t GrFillRectOp::ClassID() {
+    return FillRectOp::ClassID();
+}
+
 #include "src/gpu/GrDrawOpTest.h"
 #include "src/gpu/SkGr.h"
 
@@ -417,35 +461,11 @@
 
     if (random->nextBool()) {
         if (random->nextBool()) {
-            if (random->nextBool()) {
-                // Local matrix with a set op
-                uint32_t extraQuadCt = random->nextRangeU(1, 4);
-                SkTArray<GrRenderTargetContext::QuadSetEntry> quads(extraQuadCt + 1);
-                quads.push_back(
-                        {rect, SkPMColor4f::FromBytes_RGBA(SkColorToPremulGrColor(random->nextU())),
-                         GrTest::TestMatrixInvertible(random), aaFlags});
-                for (uint32_t i = 0; i < extraQuadCt; ++i) {
-                    GrQuadAAFlags aaFlags = GrQuadAAFlags::kNone;
-                    aaFlags |= random->nextBool() ? GrQuadAAFlags::kLeft : GrQuadAAFlags::kNone;
-                    aaFlags |= random->nextBool() ? GrQuadAAFlags::kTop : GrQuadAAFlags::kNone;
-                    aaFlags |= random->nextBool() ? GrQuadAAFlags::kRight : GrQuadAAFlags::kNone;
-                    aaFlags |= random->nextBool() ? GrQuadAAFlags::kBottom : GrQuadAAFlags::kNone;
-
-                    quads.push_back(
-                        {GrTest::TestRect(random),
-                         SkPMColor4f::FromBytes_RGBA(SkColorToPremulGrColor(random->nextU())),
-                         GrTest::TestMatrixInvertible(random), aaFlags});
-                }
-
-                return GrFillRectOp::MakeSet(context, std::move(paint), aaType, viewMatrix,
-                                             quads.begin(), quads.count(), stencil);
-            } else {
-                // Single local matrix
-                SkMatrix localMatrix = GrTest::TestMatrixInvertible(random);
-                return GrFillRectOp::Make(context, std::move(paint), aaType, aaFlags,
-                                          GrQuad::MakeFromRect(rect, viewMatrix),
-                                          GrQuad::MakeFromRect(rect, localMatrix), stencil);
-            }
+            // Single local matrix
+            SkMatrix localMatrix = GrTest::TestMatrixInvertible(random);
+            return GrFillRectOp::Make(context, std::move(paint), aaType, aaFlags,
+                                      GrQuad::MakeFromRect(rect, viewMatrix),
+                                      GrQuad::MakeFromRect(rect, localMatrix), stencil);
         } else {
             // Pass local rect directly
             SkRect localRect = GrTest::TestRect(random);
diff --git a/src/gpu/ops/GrFillRectOp.h b/src/gpu/ops/GrFillRectOp.h
index 768ed8b..600e87b 100644
--- a/src/gpu/ops/GrFillRectOp.h
+++ b/src/gpu/ops/GrFillRectOp.h
@@ -25,34 +25,53 @@
  * the GrPaint is only consumed by these methods if a valid op is returned. If null is returned then
  * the paint is unmodified and may still be used.
  */
-namespace GrFillRectOp {
+class GrFillRectOp {
+public:
 
-std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
-                               GrPaint&& paint,
-                               GrAAType aaType,
-                               GrQuadAAFlags aaFlags,
-                               const GrQuad& deviceQuad,
-                               const GrQuad& localQuad,
-                               const GrUserStencilSettings* stencil = nullptr);
+    static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
+                                          GrPaint&& paint,
+                                          GrAAType aaType,
+                                          GrQuadAAFlags aaFlags,
+                                          const GrQuad& deviceQuad,
+                                          const GrQuad& localQuad,
+                                          const GrUserStencilSettings* stencil = nullptr);
 
-// Utility function to create a non-AA rect transformed by view. This is used commonly enough in
-// testing and GMs that manage ops without going through GrRTC that it's worth the convenience.
-std::unique_ptr<GrDrawOp> MakeNonAARect(GrRecordingContext* context,
-                                        GrPaint&& paint,
-                                        const SkMatrix& view,
-                                        const SkRect& rect,
-                                        const GrUserStencilSettings* stencil = nullptr);
+    // Utility function to create a non-AA rect transformed by view. This is used commonly enough
+    // in testing and GMs that manage ops without going through GrRTC that it's worth the
+    // convenience.
+    static std::unique_ptr<GrDrawOp> MakeNonAARect(GrRecordingContext* context,
+                                                   GrPaint&& paint,
+                                                   const SkMatrix& view,
+                                                   const SkRect& rect,
+                                                   const GrUserStencilSettings* stencil = nullptr);
 
-// Bulk API for drawing quads with a single op
-// TODO(michaelludwig) - remove if the bulk API is not useful for SkiaRenderer
-std::unique_ptr<GrDrawOp> MakeSet(GrRecordingContext* context,
-                                  GrPaint&& paint,
-                                  GrAAType aaType,
-                                  const SkMatrix& viewMatrix,
-                                  const GrRenderTargetContext::QuadSetEntry quads[],
-                                  int quadCount,
-                                  const GrUserStencilSettings* stencil = nullptr);
+    // Bulk API for drawing quads with a single op
+    // TODO(michaelludwig) - remove if the bulk API is not useful for SkiaRenderer
+    static void AddFillRectOps(GrRenderTargetContext*,
+                               const GrClip& clip,
+                               GrRecordingContext*,
+                               GrPaint&&,
+                               GrAAType,
+                               const SkMatrix& viewMatrix,
+                               const GrRenderTargetContext::QuadSetEntry quads[],
+                               int quadCount,
+                               const GrUserStencilSettings* = nullptr);
 
-} // namespace GrFillRectOp
+#if GR_TEST_UTILS
+    static uint32_t ClassID();
+#endif
+
+private:
+    // Create a GrFillRectOp that uses as many quads as possible from 'quads' w/o exceeding
+    // any index buffer size limits.
+    static std::unique_ptr<GrDrawOp> MakeOp(GrRecordingContext*,
+                                            GrPaint&&,
+                                            GrAAType,
+                                            const SkMatrix& viewMatrix,
+                                            const GrRenderTargetContext::QuadSetEntry quads[],
+                                            int quadCount,
+                                            const GrUserStencilSettings*,
+                                            int* numConsumed);
+};
 
 #endif // GrFillRectOp_DEFINED
diff --git a/src/gpu/ops/GrQuadPerEdgeAA.cpp b/src/gpu/ops/GrQuadPerEdgeAA.cpp
index 86fe00f..687d3a5 100644
--- a/src/gpu/ops/GrQuadPerEdgeAA.cpp
+++ b/src/gpu/ops/GrQuadPerEdgeAA.cpp
@@ -166,6 +166,15 @@
     }
 }
 
+int QuadLimit(IndexBufferOption option) {
+    switch (option) {
+        case IndexBufferOption::kPictureFramed: return GrResourceProvider::MaxNumAAQuads();
+        case IndexBufferOption::kIndexedRects:  return GrResourceProvider::MaxNumNonAAQuads();
+        case IndexBufferOption::kTriStrips:     return SK_MaxS32; // not limited by an indexBuffer
+    }
+
+    SkUNREACHABLE;
+}
 
 void ConfigureMesh(GrMesh* mesh, const VertexSpec& spec,
                    int runningQuadCount, int quadsInDraw, int maxVerts,
diff --git a/src/gpu/ops/GrQuadPerEdgeAA.h b/src/gpu/ops/GrQuadPerEdgeAA.h
index ae245ea..1e5675b 100644
--- a/src/gpu/ops/GrQuadPerEdgeAA.h
+++ b/src/gpu/ops/GrQuadPerEdgeAA.h
@@ -151,6 +151,9 @@
     // It will, correctly, return nullptr if the indexBufferOption is kTriStrips.
     sk_sp<const GrBuffer> GetIndexBuffer(GrMeshDrawOp::Target*, IndexBufferOption);
 
+    // What is the maximum number of quads allowed for the specified indexBuffer option?
+    int QuadLimit(IndexBufferOption);
+
     // This method will configure the vertex and index data of the provided 'mesh' to comply
     // with the indexing method specified in the vertexSpec. It is up to the calling code
     // to allocate and fill in the vertex data and acquire the correct indexBuffer if it is needed.
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
index acf28b4..f184769 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
@@ -119,7 +119,7 @@
     GrAAType aaType() const { return static_cast<GrAAType>(fAAType); }
 
     void setAAType(GrAAType aaType) {
-      fAAType = static_cast<unsigned>(aaType);
+        fAAType = static_cast<unsigned>(aaType);
     }
 
     void executeDrawsAndUploads(const GrOp*, GrOpFlushState*, const SkRect& chainBounds);
diff --git a/tests/BulkFillRectTest.cpp b/tests/BulkFillRectTest.cpp
new file mode 100644
index 0000000..f80a360
--- /dev/null
+++ b/tests/BulkFillRectTest.cpp
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/GrClip.h"
+#include "src/gpu/GrContextPriv.h"
+#include "src/gpu/GrRenderTargetContext.h"
+#include "src/gpu/ops/GrFillRectOp.h"
+#include "tests/Test.h"
+
+static std::unique_ptr<GrRenderTargetContext> new_RTC(GrContext* context) {
+    return context->priv().makeDeferredRenderTargetContext(SkBackingFit::kExact, 128, 128,
+                                                           GrColorType::kRGBA_8888, nullptr);
+}
+
+typedef GrQuadAAFlags (*PerQuadAAFunc)(int i);
+
+static void bulk_fill_rect_create_test(skiatest::Reporter* reporter, GrContext* context,
+                                       PerQuadAAFunc perQuadAA, GrAAType overallAA,
+                                       int requestedTotNumQuads, int expectedNumOps) {
+
+    std::unique_ptr<GrRenderTargetContext> rtc = new_RTC(context);
+
+    auto quads = new GrRenderTargetContext::QuadSetEntry[requestedTotNumQuads];
+
+    for (int i = 0; i < requestedTotNumQuads; ++i) {
+        quads[i].fRect = SkRect::MakeWH(100.5f, 100.5f); // prevent the int non-AA optimization
+        quads[i].fColor = SK_PMColor4fWHITE;
+        quads[i].fLocalMatrix = SkMatrix::I();
+        quads[i].fAAFlags = perQuadAA(i);
+    }
+
+    GrPaint paint;
+
+    GrFillRectOp::AddFillRectOps(rtc.get(), GrNoClip(), context, std::move(paint), overallAA,
+                                 SkMatrix::I(), quads, requestedTotNumQuads);
+
+    GrOpsTask* opsTask = rtc->testingOnly_PeekLastOpsTask();
+    int actualNumOps = opsTask->numOpChains();
+
+    int actualTotNumQuads = 0;
+
+    for (int i = 0; i < actualNumOps; ++i) {
+        const GrOp* tmp = opsTask->getChain(i);
+        REPORTER_ASSERT(reporter, tmp->classID() == GrFillRectOp::ClassID());
+        REPORTER_ASSERT(reporter, tmp->isChainTail());
+        actualTotNumQuads += ((GrDrawOp*) tmp)->numQuads();
+    }
+
+    REPORTER_ASSERT(reporter, expectedNumOps == actualNumOps);
+    REPORTER_ASSERT(reporter, requestedTotNumQuads == actualTotNumQuads);
+
+    context->flush();
+
+    delete[] quads;
+}
+
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(BulkFillRectTest, reporter, ctxInfo) {
+    GrContext* context = ctxInfo.grContext();
+
+    if (!context->priv().caps()->dynamicStateArrayGeometryProcessorTextureSupport()) {
+        return;
+    }
+
+    // This is the simple case where there is no AA at all. We expect 2 non-AA clumps of quads.
+    {
+        auto noAA = [](int i) -> GrQuadAAFlags {
+            return GrQuadAAFlags::kNone;
+        };
+
+        static const int kNumExpectedOps = 2;
+
+        bulk_fill_rect_create_test(reporter, context, noAA, GrAAType::kNone,
+                                   2*GrResourceProvider::MaxNumNonAAQuads(), kNumExpectedOps);
+    }
+
+    // This is the same as the above case except the overall AA is kCoverage. However, since
+    // the per-quad AA is still none, all the quads should be downgraded to non-AA.
+    {
+        auto noAA = [](int i) -> GrQuadAAFlags {
+            return GrQuadAAFlags::kNone;
+        };
+
+        static const int kNumExpectedOps = 2;
+
+        bulk_fill_rect_create_test(reporter, context, noAA, GrAAType::kCoverage,
+                                   2*GrResourceProvider::MaxNumNonAAQuads(), kNumExpectedOps);
+    }
+
+    // This case has an overall AA of kCoverage but the per-quad AA alternates.
+    // We should end up with several aa-sized clumps
+    {
+        auto alternateAA = [](int i) -> GrQuadAAFlags {
+            return (i % 2) ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone;
+        };
+
+        int numExpectedOps = 2*GrResourceProvider::MaxNumNonAAQuads() /
+                                                 GrResourceProvider::MaxNumAAQuads();
+
+        bulk_fill_rect_create_test(reporter, context, alternateAA, GrAAType::kCoverage,
+                                   2*GrResourceProvider::MaxNumNonAAQuads(), numExpectedOps);
+    }
+
+    // In this case we have a run of MaxNumAAQuads non-AA quads and then AA quads. This
+    // exercises the case where we have a clump of quads that can't be upgraded to AA bc of
+    // its size. We expect one clump of non-AA quads followed by one clump of AA quads.
+    {
+        auto runOfNonAA = [](int i) -> GrQuadAAFlags {
+            return (i < GrResourceProvider::MaxNumAAQuads()) ? GrQuadAAFlags::kNone
+                                                             : GrQuadAAFlags::kAll;
+        };
+
+        static const int kNumExpectedOps = 2;
+
+        bulk_fill_rect_create_test(reporter, context, runOfNonAA, GrAAType::kCoverage,
+                                   2*GrResourceProvider::MaxNumAAQuads(), kNumExpectedOps);
+    }
+}