diff --git a/gm/compositor_quads.cpp b/gm/compositor_quads.cpp
index 90672e5..02fe08d 100644
--- a/gm/compositor_quads.cpp
+++ b/gm/compositor_quads.cpp
@@ -9,11 +9,10 @@
 
 #if SK_SUPPORT_GPU
 
+#include "GrClip.h"
+#include "GrRect.h"
 #include "GrRenderTargetContextPriv.h"
 
-#include "ops/GrFillRectOp.h"
-#include "ops/GrTextureOp.h"
-
 #include "Resources.h"
 #include "SkFont.h"
 #include "SkGr.h"
@@ -188,7 +187,7 @@
 
     virtual void drawBanner(SkCanvas* canvas) = 0;
 
-    void drawTiles(SkCanvas* canvas, GrContext* context, GrRenderTargetContext* rtc) {
+    virtual void drawTiles(SkCanvas* canvas, GrContext* context, GrRenderTargetContext* rtc) {
         // TODO (michaelludwig) - once the quad APIs are in SkCanvas, drop these
         // cached fields, which drawTile() needs
         fContext = context;
@@ -236,12 +235,6 @@
         return flags;
     }
 
-    // NOTE: This will go away when the quad APIs exist on the RTC and we don't have to add
-    // draw ops manually.
-    GrAAType getDefaultAAType(GrAA aa = GrAA::kYes) const {
-        return GrChooseAAType(aa, fRTC->fsaaType(), GrAllowMixedSamples::kNo, *fRTC->caps());
-    }
-
     // Recursively splits the quadrilateral against the segments stored in 'lines', which must be
     // 2 * lineCount long. Increments 'quadCount' for each split quadrilateral, and invokes the
     // drawTile at leaves.
@@ -566,16 +559,13 @@
         paint.setColor4f(c);
 
         GrQuadAAFlags aaFlags = fEnableAAOverride ? fAAOverride : this->maskToFlags(edgeAA);
-        std::unique_ptr<GrDrawOp> op;
         if (clip) {
-            op = GrFillRectOp::MakePerEdgeQuad(fContext, std::move(paint), this->getDefaultAAType(),
-                                               aaFlags, canvas->getTotalMatrix(), clip, nullptr);
+            fRTC->fillQuadWithEdgeAA(GrNoClip(), std::move(paint), GrAA::kYes, aaFlags,
+                                     canvas->getTotalMatrix(), clip, nullptr);
         } else {
-            op = GrFillRectOp::MakePerEdge(fContext, std::move(paint), this->getDefaultAAType(),
-                                           aaFlags, canvas->getTotalMatrix(), rect);
+            fRTC->fillRectWithEdgeAA(GrNoClip(), std::move(paint), GrAA::kYes, aaFlags,
+                                     canvas->getTotalMatrix(), rect);
         }
-
-        fRTC->priv().testingOnly_addDrawOp(std::move(op));
     }
 
     void drawBanner(SkCanvas* canvas) override {
@@ -623,18 +613,13 @@
         GrPaint paint;
         paint.setColor4f(fColor);
 
-        std::unique_ptr<GrDrawOp> op;
         if (clip) {
-            op = GrFillRectOp::MakePerEdgeQuad(fContext, std::move(paint), this->getDefaultAAType(),
-                                               this->maskToFlags(edgeAA), canvas->getTotalMatrix(),
-                                               clip, nullptr);
+            fRTC->fillQuadWithEdgeAA(GrNoClip(), std::move(paint), GrAA::kYes,
+                    this->maskToFlags(edgeAA), canvas->getTotalMatrix(), clip, nullptr);
         } else {
-            op = GrFillRectOp::MakePerEdge(fContext, std::move(paint), this->getDefaultAAType(),
-                                           this->maskToFlags(edgeAA), canvas->getTotalMatrix(),
-                                           rect);
+            fRTC->fillRectWithEdgeAA(GrNoClip(), std::move(paint), GrAA::kYes,
+                    this->maskToFlags(edgeAA), canvas->getTotalMatrix(), rect);
         }
-
-        fRTC->priv().testingOnly_addDrawOp(std::move(op));
     }
 
     void drawBanner(SkCanvas* canvas) override {
@@ -666,38 +651,21 @@
         SkPaintToGrPaint(fContext, fRTC->colorSpaceInfo(), fGradient, canvas->getTotalMatrix(),
                          &paint);
 
-        std::unique_ptr<GrDrawOp> op;
-        if (fLocal) {
-            SkRect localRect = SkRect::MakeWH(kTileWidth, kTileHeight);
-            if (clip) {
-                SkMatrix toLocal = SkMatrix::MakeRectToRect(rect, localRect,
-                                                            SkMatrix::kFill_ScaleToFit);
-                SkPoint localQuad[4];
-                toLocal.mapPoints(localQuad, clip, 4);
-
-                op = GrFillRectOp::MakePerEdgeQuad(
-                        fContext, std::move(paint), this->getDefaultAAType(),
-                        this->maskToFlags(edgeAA), canvas->getTotalMatrix(),
-                        clip, localQuad);
-            } else {
-                op = GrFillRectOp::MakePerEdgeWithLocalRect(
-                        fContext, std::move(paint), this->getDefaultAAType(),
-                        this->maskToFlags(edgeAA), canvas->getTotalMatrix(), rect, localRect);
-            }
-        } else {
-            if (clip) {
-                op = GrFillRectOp::MakePerEdgeQuad(
-                        fContext, std::move(paint), this->getDefaultAAType(),
-                        this->maskToFlags(edgeAA), canvas->getTotalMatrix(),
-                        clip, nullptr);
-            } else {
-                op = GrFillRectOp::MakePerEdge(
-                        fContext, std::move(paint), this->getDefaultAAType(),
-                        this->maskToFlags(edgeAA), canvas->getTotalMatrix(), rect);
-            }
+        SkRect localRect = SkRect::MakeWH(kTileWidth, kTileHeight);
+        SkPoint localQuad[4];
+        if (fLocal && clip) {
+            GrMapRectPoints(rect, localRect, clip, localQuad, 4);
         }
 
-        fRTC->priv().testingOnly_addDrawOp(std::move(op));
+        if (clip) {
+            fRTC->fillQuadWithEdgeAA(GrNoClip(), std::move(paint), GrAA::kYes,
+                    this->maskToFlags(edgeAA), canvas->getTotalMatrix(), clip,
+                    fLocal ? localQuad : nullptr);
+        } else {
+            fRTC->fillRectWithEdgeAA(GrNoClip(), std::move(paint), GrAA::kYes,
+                    this->maskToFlags(edgeAA), canvas->getTotalMatrix(), rect,
+                    fLocal ? &localRect : nullptr);
+        }
     }
 
     void drawBanner(SkCanvas* canvas) override {
@@ -727,6 +695,17 @@
     typedef TileRenderer INHERITED;
 };
 
+static SkRect get_image_local_rect(const sk_sp<SkImage> image, const SkRect& rect) {
+    // This acts like the whole image is rendered over the entire tile grid, so derive local
+    // coordinates from 'rect', based on the grid to image transform.
+    SkMatrix gridToImage = SkMatrix::MakeRectToRect(SkRect::MakeWH(kColCount * kTileWidth,
+                                                                   kRowCount * kTileHeight),
+                                                    SkRect::MakeWH(image->width(),
+                                                                   image->height()),
+                                                    SkMatrix::kFill_ScaleToFit);
+    return gridToImage.mapRect(rect);
+}
+
 class TextureRenderer : public TileRenderer {
 public:
 
@@ -736,37 +715,24 @@
 
     void drawTile(SkCanvas* canvas, const SkRect& rect, const SkPoint clip[4], const bool edgeAA[4],
                   int tileID, int quadID) override {
-        // This acts like the whole image is rendered over the entire tile grid, so derive local
-        // coordinates from 'rect', based on the grid to image transform.
-        SkMatrix gridToImage = SkMatrix::MakeRectToRect(SkRect::MakeWH(kColCount * kTileWidth,
-                                                                       kRowCount * kTileHeight),
-                                                        SkRect::MakeWH(fImage->width(),
-                                                                       fImage->height()),
-                                                        SkMatrix::kFill_ScaleToFit);
-        SkRect localRect = gridToImage.mapRect(rect);
-
         SkPMColor4f color = {1.f, 1.f, 1.f, 1.f};
+        SkRect localRect = get_image_local_rect(fImage, rect);
+
         fImage = fImage->makeTextureImage(fContext, nullptr);
         sk_sp<GrTextureProxy> proxy = as_IB(fImage)->asTextureProxyRef();
         SkASSERT(proxy);
-
-        std::unique_ptr<GrDrawOp> op;
         if (clip) {
-            SkMatrix toLocal = SkMatrix::MakeRectToRect(rect, localRect,
-                                                        SkMatrix::kFill_ScaleToFit);
             SkPoint localQuad[4];
-            toLocal.mapPoints(localQuad, clip, 4);
-
-            op = GrTextureOp::MakeQuad(fContext, std::move(proxy), GrSamplerState::Filter::kBilerp,
-                    color, localQuad, clip, this->getDefaultAAType(), this->maskToFlags(edgeAA),
-                    nullptr, canvas->getTotalMatrix(), nullptr);
+            GrMapRectPoints(rect, localRect, clip, localQuad, 4);
+            fRTC->drawTextureQuad(GrNoClip(), std::move(proxy), GrSamplerState::Filter::kBilerp,
+                    SkBlendMode::kSrcOver, color, localQuad, clip, GrAA::kYes,
+                    this->maskToFlags(edgeAA), nullptr, canvas->getTotalMatrix(), nullptr);
         } else {
-            op = GrTextureOp::Make(fContext, std::move(proxy), GrSamplerState::Filter::kBilerp,
-                    color, localRect, rect, this->getDefaultAAType(), this->maskToFlags(edgeAA),
-                    SkCanvas::kFast_SrcRectConstraint, canvas->getTotalMatrix(), nullptr);
+            fRTC->drawTexture(GrNoClip(), std::move(proxy), GrSamplerState::Filter::kBilerp,
+                    SkBlendMode::kSrcOver, color, localRect, rect, GrAA::kYes,
+                    this->maskToFlags(edgeAA), SkCanvas::kFast_SrcRectConstraint,
+                    canvas->getTotalMatrix(), nullptr);
         }
-
-        fRTC->priv().testingOnly_addDrawOp(std::move(op));
     }
 
     void drawBanner(SkCanvas* canvas) override {
@@ -782,6 +748,101 @@
     typedef TileRenderer INHERITED;
 };
 
+// Looks like TextureRenderer, but bundles tiles into drawTextureSet calls
+class TextureSetRenderer : public TileRenderer {
+public:
+
+    static sk_sp<TileRenderer> Make(sk_sp<SkImage> image) {
+        return sk_sp<TileRenderer>(new TextureSetRenderer(image));
+    }
+
+    void drawTiles(SkCanvas* canvas, GrContext* ctx, GrRenderTargetContext* rtc) override {
+        this->INHERITED::drawTiles(canvas, ctx, rtc);
+        // Push the last tile set
+        this->drawAndReset(canvas);
+    }
+
+    void drawTile(SkCanvas* canvas, const SkRect& rect, const SkPoint clip[4], const bool edgeAA[4],
+                  int tileID, int quadID) override {
+        // Submit the last batch if we've moved on to a new tile
+        if (tileID != fCurrentTileID) {
+            this->drawAndReset(canvas);
+        }
+        SkASSERT((fCurrentTileID < 0 && fDstClips.count() == 0 && fDstClipIndices.count() == 0 &&
+                  fSetEntries.count() == 0) ||
+                 (fCurrentTileID == tileID && fSetEntries.count() > 0));
+
+        // Now don't actually draw the tile, accumulate it in the growing entry set
+        fCurrentTileID = tileID;
+
+        int clipIndex = -1;
+        if (clip) {
+            // Record the four points into fDstClips and get the pointer to the first in the array
+            clipIndex = fDstClips.count();
+            fDstClips.push_back_n(4, clip);
+        }
+
+        SkRect localRect = get_image_local_rect(fImage, rect);
+
+        fImage = fImage->makeTextureImage(fContext, nullptr);
+        sk_sp<GrTextureProxy> proxy = as_IB(fImage)->asTextureProxyRef();
+        // drawTextureSet automatically derives appropriate local quad from localRect if clipPtr
+        // is not null.
+        fSetEntries.push_back({proxy, localRect, rect, nullptr, 1.f, this->maskToFlags(edgeAA)});
+        fDstClipIndices.push_back(clipIndex);
+    }
+
+    void drawBanner(SkCanvas* canvas) override {
+        draw_text(canvas, "Texture Set");
+    }
+
+private:
+    sk_sp<SkImage> fImage;
+
+    SkTArray<SkPoint> fDstClips;
+    // Since fDstClips will reallocate as needed, can't get the final pointer for the entries'
+    // fDstClip values until submitting the entire set
+    SkTArray<int> fDstClipIndices;
+    SkTArray<GrRenderTargetContext::TextureSetEntry> fSetEntries;
+    int fCurrentTileID;
+
+    TextureSetRenderer(sk_sp<SkImage> image)
+            : fImage(image)
+            , fCurrentTileID(-1) {}
+
+    void drawAndReset(SkCanvas* canvas) {
+        // Early out if there's nothing to draw
+        if (fSetEntries.count() == 0) {
+            SkASSERT(fCurrentTileID < 0 && fDstClips.count() == 0 && fDstClipIndices.count() == 0);
+            return;
+        }
+
+        // Fill in fDstClip in the entries now that fDstClips' storage won't change until after the
+        // draw is finished.
+        // NOTE: The eventual API in SkGpuDevice will make easier to collect
+        // SkCanvas::ImageSetEntries and dst clips without this extra work, but also internally maps
+        // very cleanly on to the TextureSetEntry fDstClip approach.
+        SkASSERT(fDstClipIndices.count() == fSetEntries.count());
+        for (int i = 0; i < fSetEntries.count(); ++i) {
+            if (fDstClipIndices[i] >= 0) {
+                fSetEntries[i].fDstClip = &fDstClips[fDstClipIndices[i]];
+            }
+        }
+
+        // Send to GPU
+        fRTC->drawTextureSet(GrNoClip(), fSetEntries.begin(), fSetEntries.count(),
+                             GrSamplerState::Filter::kBilerp, SkBlendMode::kSrcOver, GrAA::kYes,
+                             canvas->getTotalMatrix(), nullptr);
+        // Reset for next tile
+        fCurrentTileID = -1;
+        fDstClips.reset();
+        fDstClipIndices.reset();
+        fSetEntries.reset();
+    }
+
+    typedef TileRenderer INHERITED;
+};
+
 DEF_GM(return new CompositorGM("debug",
         DebugTileRenderer::Make(), DebugTileRenderer::MakeAA(),
         DebugTileRenderer::MakeNonAA());)
@@ -789,6 +850,7 @@
 DEF_GM(return new CompositorGM("shader",
         GradientRenderer::MakeSeamless(), GradientRenderer::MakeLocal()));
 DEF_GM(return new CompositorGM("image",
-        TextureRenderer::Make(GetResourceAsImage("images/mandrill_512.png"))));
+        TextureRenderer::Make(GetResourceAsImage("images/mandrill_512.png")),
+        TextureSetRenderer::Make(GetResourceAsImage("images/mandrill_512.png"))));
 
 #endif // SK_SUPPORT_GPU
diff --git a/src/gpu/GrRect.h b/src/gpu/GrRect.h
index 8c44ed7..aa00534 100644
--- a/src/gpu/GrRect.h
+++ b/src/gpu/GrRect.h
@@ -72,4 +72,14 @@
     SkASSERT(!b.isFinite() || (b.fLeft <= b.fRight && b.fTop <= b.fBottom));
     return a.fRight >= b.fLeft && a.fBottom >= b.fTop && b.fRight >= a.fLeft && b.fBottom >= a.fTop;
 }
+
+/**
+ * Apply the transform from 'inRect' to 'outRect' to each point in 'inPts', storing the mapped point
+ * into the parallel index of 'outPts'.
+ */
+static inline void GrMapRectPoints(const SkRect& inRect, const SkRect& outRect,
+                                   const SkPoint inPts[], SkPoint outPts[], int ptCount) {
+    SkMatrix rectTransform = SkMatrix::MakeRectToRect(inRect, outRect, SkMatrix::kFill_ScaleToFit);
+    rectTransform.mapPoints(outPts, inPts, ptCount);
+}
 #endif
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index c870ef1..910fcdb 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -928,6 +928,22 @@
     this->addDrawOp(clip, std::move(op));
 }
 
+void GrRenderTargetContext::fillQuadWithEdgeAA(const GrClip& clip, GrPaint&& paint, GrAA aa,
+                                               GrQuadAAFlags edgeAA, const SkMatrix& viewMatrix,
+                                               const SkPoint quad[4], const SkPoint localQuad[4]) {
+    ASSERT_SINGLE_OWNER
+    RETURN_IF_ABANDONED
+    SkDEBUGCODE(this->validate();)
+    GR_CREATE_TRACE_MARKER_CONTEXT("GrRenderTargetContext", "fillQuadWithEdgeAA", fContext);
+
+    GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
+
+    AutoCheckFlush acf(this->drawingManager());
+    // MakePerEdgeQuad automatically does the right thing if localQuad is null or not
+    this->addDrawOp(clip, GrFillRectOp::MakePerEdgeQuad(fContext, std::move(paint), aaType, edgeAA,
+                                                        viewMatrix, quad, localQuad));
+}
+
 // Creates a paint for GrFillRectOp that matches behavior of GrTextureOp
 static void draw_texture_to_grpaint(sk_sp<GrTextureProxy> proxy, const SkRect* domain,
                                     GrSamplerState::Filter filter, SkBlendMode mode,
@@ -938,7 +954,12 @@
 
     std::unique_ptr<GrFragmentProcessor> fp;
     if (domain) {
-        fp = GrTextureDomainEffect::Make(std::move(proxy), SkMatrix::I(), *domain,
+        SkRect correctedDomain = *domain;
+        if (filter == GrSamplerState::Filter::kBilerp) {
+            // Inset by 1/2 pixel, which GrTextureOp and GrTextureAdjuster handle automatically
+            correctedDomain.inset(0.5f, 0.5f);
+        }
+        fp = GrTextureDomainEffect::Make(std::move(proxy), SkMatrix::I(), correctedDomain,
                                          GrTextureDomain::kClamp_Mode, filter);
     } else {
         fp = GrSimpleTextureEffect::Make(std::move(proxy), SkMatrix::I(), filter);
@@ -982,16 +1003,9 @@
             filter = GrSamplerState::Filter::kNearest;
         }
 
-        SkRect domain = srcRect;
-        if (constraint == SkCanvas::kStrict_SrcRectConstraint &&
-            filter == GrSamplerState::Filter::kBilerp) {
-            // Inset by 1/2 pixel, which GrTextureOp and GrTextureAdjuster handle automatically
-            domain.inset(0.5f, 0.5f);
-        }
-
         GrPaint paint;
         draw_texture_to_grpaint(std::move(proxy),
-                constraint == SkCanvas::kStrict_SrcRectConstraint ? &domain : nullptr,
+                constraint == SkCanvas::kStrict_SrcRectConstraint ? &srcRect : nullptr,
                 filter, mode, color, std::move(textureColorSpaceXform), &paint);
         op = GrFillRectOp::MakePerEdgeWithLocalRect(fContext, std::move(paint), aaType, aaFlags,
                                                     viewMatrix, clippedDstRect, clippedSrcRect);
@@ -1005,6 +1019,44 @@
     this->addDrawOp(clip, std::move(op));
 }
 
+void GrRenderTargetContext::drawTextureQuad(const GrClip& clip, sk_sp<GrTextureProxy> proxy,
+                                            GrSamplerState::Filter filter, SkBlendMode mode,
+                                            const SkPMColor4f& color, const SkPoint srcQuad[4],
+                                            const SkPoint dstQuad[4], GrAA aa,
+                                            GrQuadAAFlags aaFlags, const SkRect* domain,
+                                            const SkMatrix& viewMatrix,
+                                            sk_sp<GrColorSpaceXform> texXform) {
+    ASSERT_SINGLE_OWNER
+    RETURN_IF_ABANDONED
+    SkDEBUGCODE(this->validate();)
+    GR_CREATE_TRACE_MARKER_CONTEXT("GrRenderTargetContext", "drawTextureQuad", fContext);
+    if (domain && domain->contains(proxy->getWorstCaseBoundsRect())) {
+        domain = nullptr;
+    }
+
+    GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
+
+    // Unlike drawTexture(), don't bother cropping or optimizing the filter type since we're
+    // sampling an arbitrary quad of the texture.
+    AutoCheckFlush acf(this->drawingManager());
+    std::unique_ptr<GrDrawOp> op;
+    if (mode != SkBlendMode::kSrcOver) {
+        // Emulation mode, but don't bother converting to kNearest filter since it's an arbitrary
+        // quad that is being drawn, which makes the tests too expensive here
+        GrPaint paint;
+        draw_texture_to_grpaint(
+                std::move(proxy), domain, filter, mode, color, std::move(texXform), &paint);
+        op = GrFillRectOp::MakePerEdgeQuad(fContext, std::move(paint), aaType, aaFlags, viewMatrix,
+                                           dstQuad, srcQuad);
+    } else {
+        // Use lighter weight GrTextureOp
+        op = GrTextureOp::MakeQuad(fContext, std::move(proxy), filter, color, srcQuad, dstQuad,
+                                   aaType, aaFlags, domain, viewMatrix, std::move(texXform));
+    }
+
+    this->addDrawOp(clip, std::move(op));
+}
+
 void GrRenderTargetContext::drawTextureSet(const GrClip& clip, const TextureSetEntry set[], int cnt,
                                            GrSamplerState::Filter filter, SkBlendMode mode,
                                            GrAA aa, const SkMatrix& viewMatrix,
@@ -1019,9 +1071,23 @@
         // Draw one at a time with GrFillRectOp and a GrPaint that emulates what GrTextureOp does
         for (int i = 0; i < cnt; ++i) {
             float alpha = set[i].fAlpha;
-            this->drawTexture(clip, set[i].fProxy, filter, mode, {alpha, alpha, alpha, alpha},
-                              set[i].fSrcRect, set[i].fDstRect, aa, set[i].fAAFlags,
-                              SkCanvas::kFast_SrcRectConstraint, viewMatrix, texXform);
+            if (set[i].fDstClip == nullptr) {
+                // Stick with original rectangles, which allows the ops to know more about what's
+                // being drawn.
+                this->drawTexture(clip, set[i].fProxy, filter, mode, {alpha, alpha, alpha, alpha},
+                                  set[i].fSrcRect, set[i].fDstRect, aa, set[i].fAAFlags,
+                                  SkCanvas::kFast_SrcRectConstraint, viewMatrix, texXform);
+            } else {
+                // Generate interpolated texture coordinates to match the dst clip
+                SkPoint srcQuad[4];
+                GrMapRectPoints(set[i].fDstRect, set[i].fSrcRect, set[i].fDstClip, srcQuad, 4);
+                // Don't send srcRect as the domain, since the normal case doesn't use a constraint
+                // with the entire srcRect, so sampling into dstRect outside of dstClip will just
+                // keep seams look more correct.
+                this->drawTextureQuad(clip, set[i].fProxy, filter, mode,
+                                      {alpha, alpha, alpha, alpha}, srcQuad, set[i].fDstClip,
+                                      aa, set[i].fAAFlags, nullptr, viewMatrix, texXform);
+            }
         }
     } else {
         // Can use a single op, avoiding GrPaint creation, and can batch across proxies
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index 443a03e..d21af5a 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -132,11 +132,30 @@
 
     /**
      * Creates an op that draws a fill rect with per-edge control over anti-aliasing.
+     *
+     * This is a specialized version of fillQuadWithEdgeAA, but is kept separate since knowing
+     * the geometry is a rectangle affords more optimizations.
      */
     void fillRectWithEdgeAA(const GrClip& clip, GrPaint&& paint, GrAA aa, GrQuadAAFlags edgeAA,
                             const SkMatrix& viewMatrix, const SkRect& rect,
                             const SkRect* optionalLocalRect = nullptr);
 
+    /**
+     * Similar to fillRectWithEdgeAA but draws an arbitrary 2D convex quadrilateral transformed
+     * by 'viewMatrix', with per-edge control over anti-aliasing. The quad should follow the
+     * ordering used by SkRect::toQuad(), which determines how the edge AA is applied:
+     *  - "top" = points [0] and [1]
+     *  - "right" = points[1] and [2]
+     *  - "bottom" = points[2] and [3]
+     *  - "left" = points[3] and [0]
+     *
+     * The last argument, 'optionalLocalQuad', can be null if no separate local coordinates are
+     * necessary.
+     */
+    void fillQuadWithEdgeAA(const GrClip& clip, GrPaint&& paint, GrAA aa, GrQuadAAFlags edgeAA,
+                            const SkMatrix& viewMatrix, const SkPoint quad[4],
+                            const SkPoint optionalLocalQuad[4]);
+
     /** Used with drawQuadSet */
     struct QuadSetEntry {
         SkRect fRect;
@@ -160,17 +179,32 @@
                      const SkRect& dstRect, GrAA, GrQuadAAFlags, SkCanvas::SrcRectConstraint,
                      const SkMatrix& viewMatrix, sk_sp<GrColorSpaceXform> texXform);
 
+    /**
+     * Variant of drawTexture that instead draws the texture applied to 'dstQuad' transformed by
+     * 'viewMatrix', using the 'srcQuad' texture coordinates clamped to the optional 'domain'. If
+     * 'domain' is null, it's equivalent to using the fast src rect constraint. If 'domain' is
+     * provided, the strict src rect constraint is applied using 'domain'.
+     */
+    void drawTextureQuad(const GrClip& clip, sk_sp<GrTextureProxy>, GrSamplerState::Filter,
+                         SkBlendMode mode, const SkPMColor4f&, const SkPoint srcQuad[4],
+                         const SkPoint dstQuad[4], GrAA, GrQuadAAFlags, const SkRect* domain,
+                         const SkMatrix& viewMatrix, sk_sp<GrColorSpaceXform> texXform);
+
     /** Used with drawTextureSet */
     struct TextureSetEntry {
         sk_sp<GrTextureProxy> fProxy;
         SkRect fSrcRect;
         SkRect fDstRect;
+        SkPoint* fDstClip; // Must be null, or point to an array of 4 points
         float fAlpha;
         GrQuadAAFlags fAAFlags;
     };
     /**
      * Draws a set of textures with a shared filter, color, view matrix, color xform, and
      * texture color xform. The textures must all have the same GrTextureType and GrConfig.
+     *
+     * If any entries provide a non-null fDstClip array, it will be read from immediately based on
+     * fDstClipCount, so the pointer can become invalid after this returns.
      */
     void drawTextureSet(const GrClip&, const TextureSetEntry[], int cnt, GrSamplerState::Filter,
                         SkBlendMode mode, GrAA aa, const SkMatrix& viewMatrix,
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index ba4a48f..cb5c3dc 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1468,6 +1468,7 @@
         }
         textures[i].fSrcRect = set[i].fSrcRect;
         textures[i].fDstRect = set[i].fDstRect;
+        textures[i].fDstClip = nullptr; // TODO(michaelludwig) Not exposed in SkGpuDevice API yet
         textures[i].fAlpha = set[i].fAlpha;
         textures[i].fAAFlags = SkToGrQuadAAFlags(set[i].fAAFlags);
         if (n > 0 &&
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index cb97b9b..5cf35ec 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -307,9 +307,10 @@
         GrAAType overallAAType = GrAAType::kNone; // aa type maximally compatible with all dst rects
         bool mustFilter = false;
         fCanSkipAllocatorGather = static_cast<unsigned>(true);
-        // All dst rects are transformed by the same view matrix, so their quad types are identical
-        GrQuadType quadType = GrQuadTypeForTransformedRect(viewMatrix);
-        fQuads.reserve(cnt, quadType);
+        // All dst rects are transformed by the same view matrix, so their quad types are identical,
+        // unless an entry provides a dstClip that forces quad type to be at least standard.
+        GrQuadType baseQuadType = GrQuadTypeForTransformedRect(viewMatrix);
+        fQuads.reserve(cnt, baseQuadType);
 
         for (unsigned p = 0; p < fProxyCnt; ++p) {
             fProxies[p].fProxy = SkRef(set[p].fProxy.get());
@@ -319,7 +320,16 @@
             if (!fProxies[p].fProxy->canSkipResourceAllocator()) {
                 fCanSkipAllocatorGather = static_cast<unsigned>(false);
             }
-            auto quad = GrPerspQuad::MakeFromRect(set[p].fDstRect, viewMatrix);
+
+            // Use dstRect unless dstClip is provided, which is assumed to be a quad
+            auto quad = set[p].fDstClip == nullptr ?
+                    GrPerspQuad::MakeFromRect(set[p].fDstRect, viewMatrix) :
+                    GrPerspQuad::MakeFromSkQuad(set[p].fDstClip, viewMatrix);
+            GrQuadType quadType = baseQuadType;
+            if (set[p].fDstClip && baseQuadType != GrQuadType::kPerspective) {
+                quadType = GrQuadType::kStandard;
+            }
+
             bounds.joinPossiblyEmptyRect(quad.bounds(quadType));
             GrQuadAAFlags aaFlags;
             // Don't update the overall aaType, might be inappropriate for some of the quads
@@ -337,9 +347,18 @@
             }
             float alpha = SkTPin(set[p].fAlpha, 0.f, 1.f);
             SkPMColor4f color{alpha, alpha, alpha, alpha};
-            // TODO(michaelludwig) - Once TextureSetEntry is updated to include a dstClip, fSrcQuads
-            // will need to be used similarly to the single-image ctor.
-            fQuads.push_back(quad, quadType, {color, set[p].fSrcRect, -1, Domain::kNo, aaFlags});
+            int srcQuadIndex = -1;
+            if (set[p].fDstClip) {
+                // Derive new source coordinates that match dstClip's relative locations in dstRect,
+                // but with respect to srcRect
+                SkPoint srcQuad[4];
+                GrMapRectPoints(set[p].fDstRect, set[p].fSrcRect, set[p].fDstClip, srcQuad, 4);
+                fSrcQuads.push_back(GrPerspQuad::MakeFromSkQuad(srcQuad, SkMatrix::I()),
+                                    GrQuadType::kStandard);
+                srcQuadIndex = fSrcQuads.count() - 1;
+            }
+            fQuads.push_back(quad, quadType,
+                             {color, set[p].fSrcRect, srcQuadIndex, Domain::kNo, aaFlags});
         }
         fAAType = static_cast<unsigned>(overallAAType);
         if (!mustFilter) {