diff --git a/src/gpu/geometry/GrQuad.h b/src/gpu/geometry/GrQuad.h
index 9f4f974..9a080f3 100644
--- a/src/gpu/geometry/GrQuad.h
+++ b/src/gpu/geometry/GrQuad.h
@@ -117,6 +117,15 @@
     // True if anti-aliasing affects this quad. Only valid when quadType == kAxisAligned
     bool aaHasEffectOnRect() const;
 
+    // The non-const pointers are provided to support modifying a GrQuad in-place, but care must be
+    // taken to keep its quad type aligned with the geometric nature of the new coordinates. This is
+    // no different than using the constructors that accept a quad type.
+
+    float* xs() { return fX; }
+    float* ys() { return fY; }
+    float* ws() { return fW; }
+
+    void setQuadType(Type newType) { fType = newType; }
 private:
     template<typename T>
     friend class GrQuadListBase; // for access to fX, fY, fW
diff --git a/src/gpu/geometry/GrQuadUtils.cpp b/src/gpu/geometry/GrQuadUtils.cpp
index ba109cf..fce38d2 100644
--- a/src/gpu/geometry/GrQuadUtils.cpp
+++ b/src/gpu/geometry/GrQuadUtils.cpp
@@ -7,9 +7,158 @@
 
 #include "src/gpu/geometry/GrQuadUtils.h"
 
+#include "include/core/SkRect.h"
 #include "include/private/GrTypesPriv.h"
+#include "include/private/SkVx.h"
 #include "src/gpu/geometry/GrQuad.h"
 
+using V4f = skvx::Vec<4, float>;
+using M4f = skvx::Vec<4, int32_t>;
+
+// Since the local quad may not be type kRect, this uses the opposites for each vertex when
+// interpolating, and calculates new ws in addition to new xs, ys.
+static void interpolate_local(float alpha, int v0, int v1, int v2, int v3,
+                              float lx[4], float ly[4], float lw[4]) {
+    SkASSERT(v0 >= 0 && v0 < 4);
+    SkASSERT(v1 >= 0 && v1 < 4);
+    SkASSERT(v2 >= 0 && v2 < 4);
+    SkASSERT(v3 >= 0 && v3 < 4);
+
+    float beta = 1.f - alpha;
+    lx[v0] = alpha * lx[v0] + beta * lx[v2];
+    ly[v0] = alpha * ly[v0] + beta * ly[v2];
+    lw[v0] = alpha * lw[v0] + beta * lw[v2];
+
+    lx[v1] = alpha * lx[v1] + beta * lx[v3];
+    ly[v1] = alpha * ly[v1] + beta * ly[v3];
+    lw[v1] = alpha * lw[v1] + beta * lw[v3];
+}
+
+// Crops v0 to v1 based on the clipDevRect. v2 is opposite of v0, v3 is opposite of v1.
+// It is written to not modify coordinates if there's no intersection along the edge.
+// Ideally this would have been detected earlier and the entire draw is skipped.
+static bool crop_rect_edge(const SkRect& clipDevRect, int v0, int v1, int v2, int v3,
+                           float x[4], float y[4], float lx[4], float ly[4], float lw[4]) {
+    SkASSERT(v0 >= 0 && v0 < 4);
+    SkASSERT(v1 >= 0 && v1 < 4);
+    SkASSERT(v2 >= 0 && v2 < 4);
+    SkASSERT(v3 >= 0 && v3 < 4);
+
+    if (SkScalarNearlyEqual(x[v0], x[v1])) {
+        // A vertical edge
+        if (x[v0] < clipDevRect.fLeft && x[v2] >= clipDevRect.fLeft) {
+            // Overlapping with left edge of clipDevRect
+            if (lx) {
+                float alpha = (x[v2] - clipDevRect.fLeft) / (x[v2] - x[v0]);
+                interpolate_local(alpha, v0, v1, v2, v3, lx, ly, lw);
+            }
+            x[v0] = clipDevRect.fLeft;
+            x[v1] = clipDevRect.fLeft;
+            return true;
+        } else if (x[v0] > clipDevRect.fRight && x[v2] <= clipDevRect.fRight) {
+            // Overlapping with right edge of clipDevRect
+            if (lx) {
+                float alpha = (clipDevRect.fRight - x[v2]) / (x[v0] - x[v2]);
+                interpolate_local(alpha, v0, v1, v2, v3, lx, ly, lw);
+            }
+            x[v0] = clipDevRect.fRight;
+            x[v1] = clipDevRect.fRight;
+            return true;
+        }
+    } else {
+        // A horizontal edge
+        SkASSERT(SkScalarNearlyEqual(y[v0], y[v1]));
+        if (y[v0] < clipDevRect.fTop && y[v2] >= clipDevRect.fTop) {
+            // Overlapping with top edge of clipDevRect
+            if (lx) {
+                float alpha = (y[v2] - clipDevRect.fTop) / (y[v2] - y[v0]);
+                interpolate_local(alpha, v0, v1, v2, v3, lx, ly, lw);
+            }
+            y[v0] = clipDevRect.fTop;
+            y[v1] = clipDevRect.fTop;
+            return true;
+        } else if (y[v0] > clipDevRect.fBottom && y[v2] <= clipDevRect.fBottom) {
+            // Overlapping with bottom edge of clipDevRect
+            if (lx) {
+                float alpha = (clipDevRect.fBottom - y[v2]) / (y[v0] - y[v2]);
+                interpolate_local(alpha, v0, v1, v2, v3, lx, ly, lw);
+            }
+            y[v0] = clipDevRect.fBottom;
+            y[v1] = clipDevRect.fBottom;
+            return true;
+        }
+    }
+
+    // No overlap so don't crop it
+    return false;
+}
+
+// Updates x and y to intersect with clipDevRect, and applies clipAA policy to edgeFlags for each
+// intersected edge. lx, ly, and lw are updated appropriately and may be null to skip calculations.
+static void crop_rect(const SkRect& clipDevRect, GrAA clipAA, GrQuadAAFlags* edgeFlags,
+                      float x[4], float y[4], float lx[4], float ly[4], float lw[4]) {
+    // Filled in as if clipAA were true, will be inverted at the end if needed.
+    GrQuadAAFlags clipEdgeFlags = GrQuadAAFlags::kNone;
+
+    // However, the quad's left edge may not align with the SkRect notion of left due to 90 degree
+    // rotations or mirrors. So, this processes the logical edges of the quad and clamps it to the 4
+    // sides of clipDevRect.
+
+    // Quad's left is v0 to v1 (op. v2 and v3)
+    if (crop_rect_edge(clipDevRect, 0, 1, 2, 3, x, y, lx, ly, lw)) {
+        clipEdgeFlags |= GrQuadAAFlags::kLeft;
+    }
+    // Quad's top edge is v0 to v2 (op. v1 and v3)
+    if (crop_rect_edge(clipDevRect, 0, 2, 1, 3, x, y, lx, ly, lw)) {
+        clipEdgeFlags |= GrQuadAAFlags::kTop;
+    }
+    // Quad's right edge is v2 to v3 (op. v0 and v1)
+    if (crop_rect_edge(clipDevRect, 2, 3, 0, 1, x, y, lx, ly, lw)) {
+        clipEdgeFlags |= GrQuadAAFlags::kRight;
+    }
+    // Quad's bottom edge is v1 to v3 (op. v0 and v2)
+    if (crop_rect_edge(clipDevRect, 1, 3, 0, 2, x, y, lx, ly, lw)) {
+        clipEdgeFlags |= GrQuadAAFlags::kBottom;
+    }
+
+    if (clipAA == GrAA::kYes) {
+        // Turn on all edges that were clipped
+        *edgeFlags |= clipEdgeFlags;
+    } else {
+        // Turn off all edges that were clipped
+        *edgeFlags &= ~clipEdgeFlags;
+    }
+}
+
+// Calculates barycentric coordinates for each point in (testX, testY) in the triangle formed by
+// (x0,y0) - (x1,y1) - (x2, y2) and stores them in u, v, w.
+static void barycentric_coords(float x0, float y0, float x1, float y1, float x2, float y2,
+                               const V4f& testX, const V4f& testY,
+                               V4f* u, V4f* v, V4f* w) {
+    // Modeled after SkPathOpsQuad::pointInTriangle() but uses float instead of double, is
+    // vectorized and outputs normalized barycentric coordinates instead of inside/outside test
+    float v0x = x2 - x0;
+    float v0y = y2 - y0;
+    float v1x = x1 - x0;
+    float v1y = y1 - y0;
+    V4f v2x = testX - x0;
+    V4f v2y = testY - y0;
+
+    float dot00 = v0x * v0x + v0y * v0y;
+    float dot01 = v0x * v1x + v0y * v1y;
+    V4f   dot02 = v0x * v2x + v0y * v2y;
+    float dot11 = v1x * v1x + v1y * v1y;
+    V4f   dot12 = v1x * v2x + v1y * v2y;
+    float invDenom = sk_ieee_float_divide(1.f, dot00 * dot11 - dot01 * dot01);
+    *u = (dot11 * dot02 - dot01 * dot12) * invDenom;
+    *v = (dot00 * dot12 - dot01 * dot02) * invDenom;
+    *w = 1.f - *u - *v;
+}
+
+static M4f inside_triangle(const V4f& u, const V4f& v, const V4f& w) {
+    return ((u >= 0.f) & (u <= 1.f)) & ((v >= 0.f) & (v <= 1.f)) & ((w >= 0.f) & (w <= 1.f));
+}
+
 namespace GrQuadUtils {
 
 void ResolveAAType(GrAAType requestedAAType, GrQuadAAFlags requestedEdgeFlags, const GrQuad& quad,
@@ -45,6 +194,79 @@
             SK_ABORT("Should not use mixed sample AA with edge AA flags");
             break;
     }
-};
+}
+
+bool CropToRect(const SkRect& cropRect, GrAA cropAA, GrQuadAAFlags* edgeFlags, GrQuad* quad,
+                GrQuad* local) {
+    if (quad->quadType() == GrQuad::Type::kAxisAligned) {
+        // crop_rect keeps the rectangles as rectangles, so there's no need to modify types
+        if (local) {
+            crop_rect(cropRect, cropAA, edgeFlags, quad->xs(), quad->ys(),
+                      local->xs(), local->ys(), local->ws());
+        } else {
+            crop_rect(cropRect, cropAA, edgeFlags, quad->xs(), quad->ys(),
+                      nullptr, nullptr, nullptr);
+        }
+        return true;
+    }
+
+    if (local) {
+        // FIXME (michaelludwig) Calculate cropped local coordinates when not kAxisAligned
+        return false;
+    }
+
+    V4f devX = quad->x4f();
+    V4f devY = quad->y4f();
+    V4f devIW = quad->iw4f();
+    // Project the 3D coordinates to 2D
+    if (quad->quadType() == GrQuad::Type::kPerspective) {
+        devX *= devIW;
+        devY *= devIW;
+    }
+
+    V4f clipX = {cropRect.fLeft, cropRect.fLeft, cropRect.fRight, cropRect.fRight};
+    V4f clipY = {cropRect.fTop, cropRect.fBottom, cropRect.fTop, cropRect.fBottom};
+
+    // Calculate barycentric coordinates for the 4 rect corners in the 2 triangles that the quad
+    // is tessellated into when drawn.
+    V4f u1, v1, w1;
+    barycentric_coords(devX[0], devY[0], devX[1], devY[1], devX[2], devY[2], clipX, clipY,
+                       &u1, &v1, &w1);
+    V4f u2, v2, w2;
+    barycentric_coords(devX[1], devY[1], devX[3], devY[3], devX[2], devY[2], clipX, clipY,
+                       &u2, &v2, &w2);
+
+    // clipDevRect is completely inside this quad if each corner is in at least one of two triangles
+    M4f inTri1 = inside_triangle(u1, v1, w1);
+    M4f inTri2 = inside_triangle(u2, v2, w2);
+    if (all(inTri1 | inTri2)) {
+        // We can crop to exactly the clipDevRect.
+        // FIXME (michaelludwig) - there are other ways to have determined quad covering the clip
+        // rect, but the barycentric coords will be useful to derive local coordinates in the future
+
+        // Since we are cropped to exactly clipDevRect, we have discarded any perspective and the
+        // type becomes kRect. If updated locals were requested, they will incorporate perspective.
+        // FIXME (michaelludwig) - once we have local coordinates handled, it may be desirable to
+        // keep the draw as perspective so that the hardware does perspective interpolation instead
+        // of pushing it into a local coord w and having the shader do an extra divide.
+        clipX.store(quad->xs());
+        clipY.store(quad->ys());
+        quad->ws()[0] = 1.f;
+        quad->ws()[1] = 1.f;
+        quad->ws()[2] = 1.f;
+        quad->ws()[3] = 1.f;
+        quad->setQuadType(GrQuad::Type::kAxisAligned);
+
+        // Update the edge flags to match the clip setting since all 4 edges have been clipped
+        *edgeFlags = cropAA == GrAA::kYes ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone;
+
+        return true;
+    }
+
+    // FIXME (michaelludwig) - use the GrQuadPerEdgeAA tessellation inset/outset math to move
+    // edges to the closest clip corner they are outside of
+
+    return false;
+}
 
 }; // namespace GrQuadUtils
diff --git a/src/gpu/geometry/GrQuadUtils.h b/src/gpu/geometry/GrQuadUtils.h
index 29feeeb..5f6d283 100644
--- a/src/gpu/geometry/GrQuadUtils.h
+++ b/src/gpu/geometry/GrQuadUtils.h
@@ -9,8 +9,10 @@
 #define GrQuadUtils_DEFINED
 
 enum class GrQuadAAFlags;
+enum class GrAA : bool;
 enum class GrAAType : unsigned;
 class GrQuad;
+struct SkRect;
 
 namespace GrQuadUtils {
 
@@ -19,6 +21,23 @@
     void ResolveAAType(GrAAType requestedAAType, GrQuadAAFlags requestedEdgeFlags,
                        const GrQuad& quad, GrAAType* outAAtype, GrQuadAAFlags* outEdgeFlags);
 
+    /**
+     * Crops quad to the provided device-space axis-aligned rectangle. If the intersection of this
+     * quad (projected) and cropRect results in a quadrilateral, this returns true. If not, this
+     * quad may be updated to be a smaller quad of the same type such that its intersection with
+     * cropRect is visually the same.
+     *
+     * The provided edge flags are updated to reflect edges clipped by cropRect (toggling on or off
+     * based on cropAA policy). If provided, the local coordinates will be updated to reflect the
+     * updated device coordinates of this quad.
+     *
+     * 'local' may be null, in which case the new local coordinates will not be calculated. This is
+     * useful when it's known a paint does not require local coordinates. However, neither
+     * 'edgeFlags' nore 'quad' can be null.
+     */
+    bool CropToRect(const SkRect& cropRect, GrAA cropAA, GrQuadAAFlags* edgeFlags, GrQuad* quad,
+                    GrQuad* local=nullptr);
+
 }; // namespace GrQuadUtils
 
 #endif