diff --git a/src/gpu/GrQuad.cpp b/src/gpu/GrQuad.cpp
index bd01a68..379d1f6 100644
--- a/src/gpu/GrQuad.cpp
+++ b/src/gpu/GrQuad.cpp
@@ -69,39 +69,10 @@
     *ys = V4f{skQuadPts[0].fY, skQuadPts[3].fY, skQuadPts[1].fY, skQuadPts[2].fY};
 }
 
-// If an SkRect is transformed by this matrix, what class of quad is required to represent it.
-static GrQuadType quad_type_for_transformed_rect(const SkMatrix& matrix) {
-    if (matrix.rectStaysRect()) {
-        return GrQuadType::kRect;
-    } else if (matrix.preservesRightAngles()) {
-        return GrQuadType::kRectilinear;
-    } else if (matrix.hasPerspective()) {
-        return GrQuadType::kPerspective;
-    } else {
-        return GrQuadType::kStandard;
-    }
-}
-
-// Perform minimal analysis of 'pts' (which are suitable for MakeFromSkQuad), and determine a
-// quad type that will be as minimally general as possible.
-static GrQuadType quad_type_for_points(const SkPoint pts[4], const SkMatrix& matrix) {
-    if (matrix.hasPerspective()) {
-        return GrQuadType::kPerspective;
-    }
-    // If 'pts' was formed by SkRect::toQuad() and not transformed further, it is safe to use the
-    // quad type derived from 'matrix'. Otherwise don't waste any more time and assume kStandard
-    // (most general 2D quad).
-    if ((pts[0].fX == pts[3].fX && pts[1].fX == pts[2].fX) &&
-        (pts[0].fY == pts[1].fY && pts[2].fY == pts[3].fY)) {
-        return quad_type_for_transformed_rect(matrix);
-    } else {
-        return GrQuadType::kStandard;
-    }
-}
-
 template <typename Q>
 void GrResolveAATypeForQuad(GrAAType requestedAAType, GrQuadAAFlags requestedEdgeFlags,
-                            const Q& quad, GrAAType* outAAType, GrQuadAAFlags* outEdgeFlags) {
+                            const Q& quad, GrQuadType knownType,
+                            GrAAType* outAAType, GrQuadAAFlags* outEdgeFlags) {
     // Most cases will keep the requested types unchanged
     *outAAType = requestedAAType;
     *outEdgeFlags = requestedEdgeFlags;
@@ -115,7 +86,7 @@
             } else {
                 // For coverage AA, if the quad is a rect and it lines up with pixel boundaries
                 // then overall aa and per-edge aa can be completely disabled
-                if (quad.quadType() == GrQuadType::kRect && !quad.aaHasEffectOnRect()) {
+                if (knownType == GrQuadType::kRect && !quad.aaHasEffectOnRect()) {
                     *outAAType = GrAAType::kNone;
                     *outEdgeFlags = GrQuadAAFlags::kNone;
                 }
@@ -136,46 +107,58 @@
 };
 
 // Instantiate GrResolve... for GrQuad and GrPerspQuad
-template void GrResolveAATypeForQuad(GrAAType, GrQuadAAFlags, const GrQuad&,
+template void GrResolveAATypeForQuad(GrAAType, GrQuadAAFlags, const GrQuad&, GrQuadType,
                                      GrAAType*, GrQuadAAFlags*);
-template void GrResolveAATypeForQuad(GrAAType, GrQuadAAFlags, const GrPerspQuad&,
+template void GrResolveAATypeForQuad(GrAAType, GrQuadAAFlags, const GrPerspQuad&, GrQuadType,
                                      GrAAType*, GrQuadAAFlags*);
 
+GrQuadType GrQuadTypeForTransformedRect(const SkMatrix& matrix) {
+    if (matrix.rectStaysRect()) {
+        return GrQuadType::kRect;
+    } else if (matrix.preservesRightAngles()) {
+        return GrQuadType::kRectilinear;
+    } else if (matrix.hasPerspective()) {
+        return GrQuadType::kPerspective;
+    } else {
+        return GrQuadType::kStandard;
+    }
+}
+
+GrQuadType GrQuadTypeForPoints(const SkPoint pts[4], const SkMatrix& matrix) {
+    if (matrix.hasPerspective()) {
+        return GrQuadType::kPerspective;
+    }
+    // If 'pts' was formed by SkRect::toQuad() and not transformed further, it is safe to use the
+    // quad type derived from 'matrix'. Otherwise don't waste any more time and assume kStandard
+    // (most general 2D quad).
+    if ((pts[0].fX == pts[3].fX && pts[1].fX == pts[2].fX) &&
+        (pts[0].fY == pts[1].fY && pts[2].fY == pts[3].fY)) {
+        return GrQuadTypeForTransformedRect(matrix);
+    } else {
+        return GrQuadType::kStandard;
+    }
+}
+
 GrQuad GrQuad::MakeFromRect(const SkRect& rect, const SkMatrix& m) {
     V4f x, y;
     SkMatrix::TypeMask tm = m.getType();
-    GrQuadType type;
     if (tm <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
         map_rect_translate_scale(rect, m, &x, &y);
-        type = GrQuadType::kRect;
     } else {
         map_rect_general(rect, m, &x, &y, nullptr);
-        type = quad_type_for_transformed_rect(m);
-        if (type == GrQuadType::kPerspective) {
-            // While the matrix created perspective, the coordinates were projected to a 2D quad
-            // in map_rect_general since no w V4f was provided.
-            type = GrQuadType::kStandard;
-        }
     }
-    return GrQuad(x, y, type);
+    return GrQuad(x, y);
 }
 
 GrQuad GrQuad::MakeFromSkQuad(const SkPoint pts[4], const SkMatrix& matrix) {
     V4f xs, ys;
     rearrange_sk_to_gr_points(pts, &xs, &ys);
-    GrQuadType type = quad_type_for_points(pts, matrix);
-    if (type == GrQuadType::kPerspective) {
-        // While the matrix created perspective, the coordinates were projected to a 2D quad
-        // in map_rect_general since no w V4f was provided.
-        type = GrQuadType::kStandard;
-    }
-
     if (matrix.isIdentity()) {
-        return GrQuad(xs, ys, type);
+        return GrQuad(xs, ys);
     } else {
         V4f mx, my;
         map_quad_general(xs, ys, matrix, &mx, &my, nullptr);
-        return GrQuad(mx, my, type);
+        return GrQuad(mx, my);
     }
 }
 
@@ -184,8 +167,7 @@
 }
 
 // Private constructor used by GrQuadList to quickly fill in a quad's values from the channel arrays
-GrPerspQuad::GrPerspQuad(const float* xs, const float* ys, const float* ws, GrQuadType type)
-        : fType(type) {
+GrPerspQuad::GrPerspQuad(const float* xs, const float* ys, const float* ws) {
     memcpy(fX, xs, 4 * sizeof(float));
     memcpy(fY, ys, 4 * sizeof(float));
     memcpy(fW, ws, 4 * sizeof(float));
@@ -194,28 +176,24 @@
 GrPerspQuad GrPerspQuad::MakeFromRect(const SkRect& rect, const SkMatrix& m) {
     V4f x, y, w;
     SkMatrix::TypeMask tm = m.getType();
-    GrQuadType type;
     if (tm <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
         map_rect_translate_scale(rect, m, &x, &y);
         w = 1.f;
-        type = GrQuadType::kRect;
     } else {
         map_rect_general(rect, m, &x, &y, &w);
-        type = quad_type_for_transformed_rect(m);
     }
-    return GrPerspQuad(x, y, w, type);
+    return GrPerspQuad(x, y, w);
 }
 
 GrPerspQuad GrPerspQuad::MakeFromSkQuad(const SkPoint pts[4], const SkMatrix& matrix) {
     V4f xs, ys;
     rearrange_sk_to_gr_points(pts, &xs, &ys);
-    GrQuadType type = quad_type_for_points(pts, matrix);
     if (matrix.isIdentity()) {
-        return GrPerspQuad(xs, ys, 1.f, type);
+        return GrPerspQuad(xs, ys, 1.f);
     } else {
         V4f mx, my, mw;
         map_quad_general(xs, ys, matrix, &mx, &my, &mw);
-        return GrPerspQuad(mx, my, mw, type);
+        return GrPerspQuad(mx, my, mw);
     }
 }
 
diff --git a/src/gpu/GrQuad.h b/src/gpu/GrQuad.h
index cb2f15d..73b7310 100644
--- a/src/gpu/GrQuad.h
+++ b/src/gpu/GrQuad.h
@@ -34,12 +34,19 @@
 };
 static const int kGrQuadTypeCount = static_cast<int>(GrQuadType::kLast) + 1;
 
+// If an SkRect is transformed by this matrix, what class of quad is required to represent it.
+GrQuadType GrQuadTypeForTransformedRect(const SkMatrix& matrix);
+// Perform minimal analysis of 'pts' (which are suitable for MakeFromSkQuad), and determine a
+// quad type that will be as minimally general as possible.
+GrQuadType GrQuadTypeForPoints(const SkPoint pts[4], const SkMatrix& matrix);
+
 // Resolve disagreements between the overall requested AA type and the per-edge quad AA flags.
 // knownQuadType must have come from GrQuadTypeForTransformedRect with the matrix that created the
 // provided quad. Both outAAType and outEdgeFlags will be updated.
 template <typename Q>
 void GrResolveAATypeForQuad(GrAAType requestedAAType, GrQuadAAFlags requestedEdgeFlags,
-                            const Q& quad, GrAAType* outAAtype, GrQuadAAFlags* outEdgeFlags);
+                            const Q& quad, GrQuadType knownQuadType,
+                            GrAAType* outAAtype, GrQuadAAFlags* outEdgeFlags);
 
 /**
  * GrQuad is a collection of 4 points which can be used to represent an arbitrary quadrilateral. The
@@ -53,15 +60,17 @@
 
     explicit GrQuad(const SkRect& rect)
             : fX{rect.fLeft, rect.fLeft, rect.fRight, rect.fRight}
-            , fY{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom}
-            , fType(GrQuadType::kRect) {}
+            , fY{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom} {}
 
-    GrQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys, GrQuadType type)
-            : fType(type) {
+    GrQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys) {
         xs.store(fX);
         ys.store(fY);
     }
 
+    explicit GrQuad(const SkPoint pts[4])
+            : fX{pts[0].fX, pts[1].fX, pts[2].fX, pts[3].fX}
+            , fY{pts[0].fY, pts[1].fY, pts[2].fY, pts[3].fY} {}
+
     /** Sets the quad to the rect as transformed by the matrix. */
     static GrQuad MakeFromRect(const SkRect&, const SkMatrix&);
 
@@ -86,8 +95,6 @@
     skvx::Vec<4, float> x4f() const { return skvx::Vec<4, float>::Load(fX); }
     skvx::Vec<4, float> y4f() const { return skvx::Vec<4, float>::Load(fY); }
 
-    GrQuadType quadType() const { return fType; }
-
     // True if anti-aliasing affects this quad. Only valid when quadType == kRect_QuadType
     bool aaHasEffectOnRect() const;
 
@@ -97,8 +104,6 @@
 
     float fX[4];
     float fY[4];
-
-    GrQuadType fType;
 };
 
 class GrPerspQuad {
@@ -108,21 +113,16 @@
     explicit GrPerspQuad(const SkRect& rect)
             : fX{rect.fLeft, rect.fLeft, rect.fRight, rect.fRight}
             , fY{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom}
-            , fW{1.f, 1.f, 1.f, 1.f}
-            , fType(GrQuadType::kRect) {}
+            , fW{1.f, 1.f, 1.f, 1.f} {}
 
-    GrPerspQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys,
-                GrQuadType type)
-            : fType(type) {
-        SkASSERT(type != GrQuadType::kPerspective);
+    GrPerspQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys) {
         xs.store(fX);
         ys.store(fY);
         fW[0] = fW[1] = fW[2] = fW[3] = 1.f;
     }
 
     GrPerspQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys,
-                const skvx::Vec<4, float>& ws, GrQuadType type)
-            : fType(type) {
+                const skvx::Vec<4, float>& ws) {
         xs.store(fX);
         ys.store(fY);
         ws.store(fW);
@@ -139,10 +139,10 @@
 
     SkPoint3 point(int i) const { return {fX[i], fY[i], fW[i]}; }
 
-    SkRect bounds() const {
+    SkRect bounds(GrQuadType type) const {
         auto x = this->x4f();
         auto y = this->y4f();
-        if (fType == GrQuadType::kPerspective) {
+        if (type == GrQuadType::kPerspective) {
             auto iw = this->iw4f();
             x *= iw;
             y *= iw;
@@ -161,9 +161,7 @@
     skvx::Vec<4, float> w4f() const { return skvx::Vec<4, float>::Load(fW); }
     skvx::Vec<4, float> iw4f() const { return 1.f / this->w4f(); }
 
-    GrQuadType quadType() const { return fType; }
-
-    bool hasPerspective() const { return fType == GrQuadType::kPerspective; }
+    bool hasPerspective() const { return any(w4f() != 1.f); }
 
     // True if anti-aliasing affects this quad. Only valid when quadType == kRect_QuadType
     bool aaHasEffectOnRect() const;
@@ -173,13 +171,11 @@
     friend class GrQuadListBase;
 
     // Copy 4 values from each of the arrays into the quad's components
-    GrPerspQuad(const float xs[4], const float ys[4], const float ws[4], GrQuadType type);
+    GrPerspQuad(const float xs[4], const float ys[4], const float ws[4]);
 
     float fX[4];
     float fY[4];
     float fW[4];
-
-    GrQuadType fType;
 };
 
 // Underlying data used by GrQuadListBase. It is defined outside of GrQuadListBase due to compiler
@@ -209,9 +205,9 @@
 
     GrQuadType quadType() const { return fType; }
 
-    void reserve(int count, bool needsPerspective) {
+    void reserve(int count, GrQuadType forType) {
         fXYs.reserve(count);
-        if (needsPerspective || fType == GrQuadType::kPerspective) {
+        if (forType == GrQuadType::kPerspective || fType == GrQuadType::kPerspective) {
             fWs.reserve(4 * count);
         }
     }
@@ -223,11 +219,11 @@
         const QuadData<T>& item = fXYs[i];
         if (fType == GrQuadType::kPerspective) {
             // Read the explicit ws
-            return GrPerspQuad(item.fX, item.fY, fWs.begin() + 4 * i, fType);
+            return GrPerspQuad(item.fX, item.fY, fWs.begin() + 4 * i);
         } else {
             // Ws are implicitly 1s.
             static constexpr float kNoPerspectiveWs[4] = {1.f, 1.f, 1.f, 1.f};
-            return GrPerspQuad(item.fX, item.fY, kNoPerspectiveWs, fType);
+            return GrPerspQuad(item.fX, item.fY, kNoPerspectiveWs);
         }
     }
 
@@ -253,8 +249,8 @@
     }
 
     // Returns the added item data so that its metadata can be initialized if T is not void
-    QuadData<T>& pushBackImpl(const GrQuad& quad) {
-        this->upgradeType(quad.quadType());
+    QuadData<T>& pushBackImpl(const GrQuad& quad, GrQuadType type) {
+        this->upgradeType(type);
         QuadData<T>& item = fXYs.push_back();
         memcpy(item.fX, quad.fX, 4 * sizeof(float));
         memcpy(item.fY, quad.fY, 4 * sizeof(float));
@@ -264,8 +260,8 @@
         return item;
     }
 
-    QuadData<T>& pushBackImpl(const GrPerspQuad& quad) {
-        this->upgradeType(quad.quadType());
+    QuadData<T>& pushBackImpl(const GrPerspQuad& quad, GrQuadType type) {
+        this->upgradeType(type);
         QuadData<T>& item = fXYs.push_back();
         memcpy(item.fX, quad.fX, 4 * sizeof(float));
         memcpy(item.fY, quad.fY, 4 * sizeof(float));
@@ -313,12 +309,12 @@
         this->concatImpl(that);
     }
 
-    void push_back(const GrQuad& quad) {
-        this->pushBackImpl(quad);
+    void push_back(const GrQuad& quad, GrQuadType type) {
+        this->pushBackImpl(quad, type);
     }
 
-    void push_back(const GrPerspQuad& quad) {
-        this->pushBackImpl(quad);
+    void push_back(const GrPerspQuad& quad, GrQuadType type) {
+        this->pushBackImpl(quad, type);
     }
 
 private:
@@ -337,13 +333,13 @@
     }
 
     // Adding to the list requires metadata
-    void push_back(const GrQuad& quad, T&& metadata) {
-        QuadData<T>& item = this->pushBackImpl(quad);
+    void push_back(const GrQuad& quad, GrQuadType type, T&& metadata) {
+        QuadData<T>& item = this->pushBackImpl(quad, type);
         item.fMetadata = std::move(metadata);
     }
 
-    void push_back(const GrPerspQuad& quad, T&& metadata) {
-        QuadData<T>& item = this->pushBackImpl(quad);
+    void push_back(const GrPerspQuad& quad, GrQuadType type, T&& metadata) {
+        QuadData<T>& item = this->pushBackImpl(quad, type);
         item.fMetadata = std::move(metadata);
     }
 
diff --git a/src/gpu/ops/GrFillRectOp.cpp b/src/gpu/ops/GrFillRectOp.cpp
index aad26c1..1889b0b 100644
--- a/src/gpu/ops/GrFillRectOp.cpp
+++ b/src/gpu/ops/GrFillRectOp.cpp
@@ -64,32 +64,35 @@
                                           GrQuadAAFlags edgeAA,
                                           const GrUserStencilSettings* stencilSettings,
                                           const GrPerspQuad& deviceQuad,
-                                          const GrPerspQuad& localQuad) {
+                                          GrQuadType deviceQuadType,
+                                          const GrPerspQuad& localQuad,
+                                          GrQuadType localQuadType) {
         // Clean up deviations between aaType and edgeAA
-        GrResolveAATypeForQuad(aaType, edgeAA, deviceQuad, &aaType, &edgeAA);
+        GrResolveAATypeForQuad(aaType, edgeAA, deviceQuad, deviceQuadType, &aaType, &edgeAA);
         return Helper::FactoryHelper<FillRectOp>(context, std::move(paint), aaType, edgeAA,
-                stencilSettings, deviceQuad, localQuad);
+                stencilSettings, deviceQuad, deviceQuadType, localQuad, localQuadType);
     }
 
     // aaType is passed to Helper in the initializer list, so incongruities between aaType and
     // edgeFlags must be resolved prior to calling this constructor.
     FillRectOp(Helper::MakeArgs args, SkPMColor4f paintColor, GrAAType aaType,
                GrQuadAAFlags edgeFlags, const GrUserStencilSettings* stencil,
-               const GrPerspQuad& deviceQuad, const GrPerspQuad& localQuad)
+               const GrPerspQuad& deviceQuad, GrQuadType deviceQuadType,
+               const GrPerspQuad& localQuad, GrQuadType localQuadType)
             : INHERITED(ClassID())
             , fHelper(args, aaType, stencil) {
         // The color stored with the quad is the clear color if a scissor-clear is decided upon
         // when executing the op.
-        fDeviceQuads.push_back(deviceQuad, { paintColor, edgeFlags });
+        fDeviceQuads.push_back(deviceQuad, deviceQuadType, { paintColor, edgeFlags });
 
         if (!fHelper.isTrivial()) {
             // Conservatively keep track of the local coordinates; it may be that the paint doesn't
             // need them after analysis is finished. If the paint is known to be solid up front they
             // can be skipped entirely.
-            fLocalQuads.push_back(localQuad);
+            fLocalQuads.push_back(localQuad, localQuadType);
         }
-        this->setBounds(deviceQuad.bounds(), HasAABloat(aaType == GrAAType::kCoverage),
-                        IsZeroArea::kNo);
+        this->setBounds(deviceQuad.bounds(deviceQuadType),
+                        HasAABloat(aaType == GrAAType::kCoverage), IsZeroArea::kNo);
     }
 
     const char* name() const override { return "FillRectOp"; }
@@ -294,7 +297,8 @@
     // 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 GrPerspQuad& deviceQuad, const GrPerspQuad& localQuad,
-                 const SkPMColor4f& color, GrQuadAAFlags edgeAA, GrAAType aaType) {
+                 GrQuadType localQuadType, 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.
@@ -310,12 +314,12 @@
 
         // Update the bounds and add the quad to this op's storage
         SkRect newBounds = this->bounds();
-        newBounds.joinPossiblyEmptyRect(deviceQuad.bounds());
+        newBounds.joinPossiblyEmptyRect(deviceQuad.bounds(fDeviceQuads.quadType()));
         this->setBounds(newBounds, HasAABloat(fHelper.aaType() == GrAAType::kCoverage),
                         IsZeroArea::kNo);
-        fDeviceQuads.push_back(deviceQuad, { color, edgeAA });
+        fDeviceQuads.push_back(deviceQuad, fDeviceQuads.quadType(), { color, edgeAA });
         if (!fHelper.isTrivial()) {
-            fLocalQuads.push_back(localQuad);
+            fLocalQuads.push_back(localQuad, localQuadType);
         }
     }
 
@@ -352,8 +356,10 @@
                                       const SkMatrix& viewMatrix,
                                       const SkRect& rect,
                                       const GrUserStencilSettings* stencilSettings) {
+    GrQuadType dstQuadType = GrQuadTypeForTransformedRect(viewMatrix);
     return FillRectOp::Make(context, std::move(paint), aaType, edgeAA, stencilSettings,
-                            GrPerspQuad::MakeFromRect(rect, viewMatrix), GrPerspQuad(rect));
+                            GrPerspQuad::MakeFromRect(rect, viewMatrix),  dstQuadType,
+                            GrPerspQuad(rect), GrQuadType::kRect);
 }
 
 std::unique_ptr<GrDrawOp> MakePerEdgeWithLocalMatrix(GrRecordingContext* context,
@@ -364,9 +370,11 @@
                                                      const SkMatrix& localMatrix,
                                                      const SkRect& rect,
                                                      const GrUserStencilSettings* stencilSettings) {
+    GrQuadType dstQuadType = GrQuadTypeForTransformedRect(viewMatrix);
+    GrQuadType localQuadType = GrQuadTypeForTransformedRect(localMatrix);
     return FillRectOp::Make(context, std::move(paint), aaType, edgeAA, stencilSettings,
-                            GrPerspQuad::MakeFromRect(rect, viewMatrix),
-                            GrPerspQuad::MakeFromRect(rect, localMatrix));
+                            GrPerspQuad::MakeFromRect(rect, viewMatrix), dstQuadType,
+                            GrPerspQuad::MakeFromRect(rect, localMatrix), localQuadType);
 }
 
 std::unique_ptr<GrDrawOp> MakePerEdgeWithLocalRect(GrRecordingContext* context,
@@ -377,8 +385,10 @@
                                                    const SkRect& rect,
                                                    const SkRect& localRect,
                                                    const GrUserStencilSettings* stencilSettings) {
+    GrQuadType dstQuadType = GrQuadTypeForTransformedRect(viewMatrix);
     return FillRectOp::Make(context, std::move(paint), aaType, edgeAA, stencilSettings,
-                            GrPerspQuad::MakeFromRect(rect, viewMatrix), GrPerspQuad(localRect));
+                            GrPerspQuad::MakeFromRect(rect, viewMatrix), dstQuadType,
+                            GrPerspQuad(localRect), GrQuadType::kRect);
 }
 
 std::unique_ptr<GrDrawOp> MakePerEdgeQuad(GrRecordingContext* context,
@@ -389,10 +399,12 @@
                                           const SkPoint quad[4],
                                           const SkPoint localQuad[4],
                                           const GrUserStencilSettings* stencilSettings) {
+    GrQuadType deviceType = GrQuadTypeForPoints(quad, viewMatrix);
+    GrQuadType localType = GrQuadTypeForPoints(localQuad ? localQuad : quad, SkMatrix::I());
     return FillRectOp::Make(context, std::move(paint), aaType, edgeAA, stencilSettings,
-                            GrPerspQuad::MakeFromSkQuad(quad, viewMatrix),
+                            GrPerspQuad::MakeFromSkQuad(quad, viewMatrix), deviceType,
                             GrPerspQuad::MakeFromSkQuad(localQuad ? localQuad : quad,
-                                                        SkMatrix::I()));
+                                                        SkMatrix::I()), localType);
 }
 
 std::unique_ptr<GrDrawOp> MakeSet(GrRecordingContext* context,
@@ -404,12 +416,14 @@
                                   const GrUserStencilSettings* stencilSettings) {
     // First make a draw op for the first quad in the set
     SkASSERT(cnt > 0);
+    GrQuadType deviceQuadType = GrQuadTypeForTransformedRect(viewMatrix);
 
     paint.setColor4f(quads[0].fColor);
     std::unique_ptr<GrDrawOp> op = FillRectOp::Make(context, std::move(paint), aaType,
             quads[0].fAAFlags, stencilSettings,
-            GrPerspQuad::MakeFromRect(quads[0].fRect, viewMatrix),
-            GrPerspQuad::MakeFromRect(quads[0].fRect, quads[0].fLocalMatrix));
+            GrPerspQuad::MakeFromRect(quads[0].fRect, viewMatrix), deviceQuadType,
+            GrPerspQuad::MakeFromRect(quads[0].fRect, quads[0].fLocalMatrix),
+            GrQuadTypeForTransformedRect(quads[0].fLocalMatrix));
     auto* fillRects = op->cast<FillRectOp>();
 
     // Accumulate remaining quads similar to onCombineIfPossible() without creating an op
@@ -418,12 +432,13 @@
 
         GrAAType resolvedAA;
         GrQuadAAFlags resolvedEdgeFlags;
-        GrResolveAATypeForQuad(aaType, quads[i].fAAFlags, deviceQuad,
+        GrResolveAATypeForQuad(aaType, quads[i].fAAFlags, deviceQuad, deviceQuadType,
                                &resolvedAA, &resolvedEdgeFlags);
 
         fillRects->addQuad(deviceQuad,
                            GrPerspQuad::MakeFromRect(quads[i].fRect, quads[i].fLocalMatrix),
-                           quads[i].fColor, resolvedEdgeFlags,resolvedAA);
+                           GrQuadTypeForTransformedRect(quads[i].fLocalMatrix), quads[i].fColor,
+                           resolvedEdgeFlags,resolvedAA);
     }
 
     return op;
diff --git a/src/gpu/ops/GrQuadPerEdgeAA.cpp b/src/gpu/ops/GrQuadPerEdgeAA.cpp
index 38c5955..62509d1 100644
--- a/src/gpu/ops/GrQuadPerEdgeAA.cpp
+++ b/src/gpu/ops/GrQuadPerEdgeAA.cpp
@@ -742,9 +742,6 @@
 void* Tessellate(void* vertices, const VertexSpec& spec, const GrPerspQuad& deviceQuad,
                  const SkPMColor4f& color4f, const GrPerspQuad& localQuad, const SkRect& domain,
                  GrQuadAAFlags aaFlags) {
-    SkASSERT(deviceQuad.quadType() <= spec.deviceQuadType());
-    SkASSERT(!spec.hasLocalCoords() || localQuad.quadType() <= spec.localQuadType());
-
     CoverageMode mode = get_mode_for_spec(spec);
 
     // Load position data into V4fs (always x, y, and load w to avoid branching down the road)
diff --git a/src/gpu/ops/GrQuadPerEdgeAA.h b/src/gpu/ops/GrQuadPerEdgeAA.h
index fb28f43..a39535a 100644
--- a/src/gpu/ops/GrQuadPerEdgeAA.h
+++ b/src/gpu/ops/GrQuadPerEdgeAA.h
@@ -91,9 +91,6 @@
     // based on the configuration in the vertex spec; if that attribute is disabled in the spec,
     // then its corresponding function argument is ignored.
     //
-    // Tessellation is based on the quad type of the vertex spec, not the provided GrPerspQuad's
-    // so that all quads in a batch are tessellated the same.
-    //
     // Returns the advanced pointer in vertices.
     void* Tessellate(void* vertices, const VertexSpec& spec, const GrPerspQuad& deviceQuad,
                      const SkPMColor4f& color, const GrPerspQuad& localQuad, const SkRect& domain,
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index 491704f..15e73a0 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -99,7 +99,7 @@
     if (origin == kBottomLeft_GrSurfaceOrigin) {
         ys = h - ys;
     }
-    return GrPerspQuad(xs, ys, GrQuadType::kStandard);
+    return GrPerspQuad(xs, ys);
 }
 
 /**
@@ -120,8 +120,9 @@
                                           const SkMatrix& viewMatrix,
                                           sk_sp<GrColorSpaceXform> textureColorSpaceXform) {
         GrPerspQuad dstQuad = GrPerspQuad::MakeFromRect(dstRect, viewMatrix);
+        GrQuadType dstQuadType = GrQuadTypeForTransformedRect(viewMatrix);
 
-        if (dstQuad.quadType() == GrQuadType::kRect) {
+        if (dstQuadType == GrQuadType::kRect) {
             // Disable filtering if possible (note AA optimizations for rects are automatically
             // handled above in GrResolveAATypeForQuad).
             if (filter != GrSamplerState::Filter::kNearest &&
@@ -133,8 +134,8 @@
         GrOpMemoryPool* pool = context->priv().opMemoryPool();
         // srcRect provides both local coords and domain (if needed), so use nullptr for srcQuad
         return pool->allocate<TextureOp>(
-                std::move(proxy), filter, color, dstQuad, srcRect, constraint,
-                nullptr, aaType, aaFlags, std::move(textureColorSpaceXform));
+                std::move(proxy), filter, color, dstQuad, dstQuadType, srcRect, constraint,
+                nullptr, GrQuadType::kRect, aaType, aaFlags, std::move(textureColorSpaceXform));
     }
     static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
                                           sk_sp<GrTextureProxy> proxy,
@@ -148,7 +149,9 @@
                                           const SkMatrix& viewMatrix,
                                           sk_sp<GrColorSpaceXform> textureColorSpaceXform) {
         GrPerspQuad grDstQuad = GrPerspQuad::MakeFromSkQuad(dstQuad, viewMatrix);
+        GrQuadType dstQuadType = GrQuadTypeForPoints(dstQuad, viewMatrix);
         GrPerspQuad grSrcQuad = GrPerspQuad::MakeFromSkQuad(srcQuad, SkMatrix::I());
+        GrQuadType srcQuadType = GrQuadTypeForPoints(srcQuad, SkMatrix::I());
 
         // If constraint remains fast, the value in srcRect will be ignored since srcQuads provides
         // the local coordinates and a domain won't be used.
@@ -162,8 +165,9 @@
         GrOpMemoryPool* pool = context->priv().opMemoryPool();
         // Pass domain as srcRect if provided, but send srcQuad as a GrPerspQuad for local coords
         return pool->allocate<TextureOp>(
-                std::move(proxy), filter, color, grDstQuad, srcRect, constraint, &grSrcQuad,
-                aaType, aaFlags, std::move(textureColorSpaceXform));
+                std::move(proxy), filter, color, grDstQuad, dstQuadType, srcRect, constraint,
+                &grSrcQuad, srcQuadType, aaType, aaFlags,
+                std::move(textureColorSpaceXform));
     }
     static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
                                           const GrRenderTargetContext::TextureSetEntry set[],
@@ -255,8 +259,9 @@
     // If srcQuad is provided, it will be used for the local coords instead of srcRect, although
     // srcRect will still specify the domain constraint if needed.
     TextureOp(sk_sp<GrTextureProxy> proxy, GrSamplerState::Filter filter, const SkPMColor4f& color,
-              const GrPerspQuad& dstQuad, const SkRect& srcRect,
-              SkCanvas::SrcRectConstraint constraint, const GrPerspQuad* srcQuad, GrAAType aaType,
+              const GrPerspQuad& dstQuad, GrQuadType dstQuadType,
+              const SkRect& srcRect, SkCanvas::SrcRectConstraint constraint,
+              const GrPerspQuad* srcQuad, GrQuadType srcQuadType, GrAAType aaType,
               GrQuadAAFlags aaFlags, sk_sp<GrColorSpaceXform> textureColorSpaceXform)
             : INHERITED(ClassID())
             , fTextureColorSpaceXform(std::move(textureColorSpaceXform))
@@ -264,7 +269,7 @@
             , fFinalized(0) {
         // Clean up disparities between the overall aa type and edge configuration and apply
         // optimizations based on the rect and matrix when appropriate
-        GrResolveAATypeForQuad(aaType, aaFlags, dstQuad, &aaType, &aaFlags);
+        GrResolveAATypeForQuad(aaType, aaFlags, dstQuad, dstQuadType, &aaType, &aaFlags);
         fAAType = static_cast<unsigned>(aaType);
 
         // We expect our caller to have already caught this optimization.
@@ -283,14 +288,14 @@
         Domain domain = constraint == SkCanvas::kStrict_SrcRectConstraint ? Domain::kYes
                                                                           : Domain::kNo;
         // Initially, if srcQuad is provided it will always be at index 0 of fSrcQuads
-        fQuads.push_back(dstQuad, {color, srcRect, srcQuad ? 0 : -1, domain, aaFlags});
+        fQuads.push_back(dstQuad, dstQuadType, {color, srcRect, srcQuad ? 0 : -1, domain, aaFlags});
         if (srcQuad) {
-            fSrcQuads.push_back(*srcQuad);
+            fSrcQuads.push_back(*srcQuad, srcQuadType);
         }
         fProxyCnt = 1;
         fProxies[0] = {proxy.release(), 1};
-        this->setBounds(dstQuad.bounds(), HasAABloat(aaType == GrAAType::kCoverage),
-                        IsZeroArea::kNo);
+        auto bounds = dstQuad.bounds(dstQuadType);
+        this->setBounds(bounds, HasAABloat(aaType == GrAAType::kCoverage), IsZeroArea::kNo);
         fDomain = static_cast<unsigned>(domain);
     }
     TextureOp(const GrRenderTargetContext::TextureSetEntry set[], int cnt,
@@ -308,7 +313,7 @@
         // Most dst rects are transformed by the same view matrix, so their quad types start
         // identical, unless an entry provides a dstClip or additional transform that changes it.
         // The quad list will automatically adapt to that.
-        fQuads.reserve(cnt, viewMatrix.hasPerspective());
+        fQuads.reserve(cnt, GrQuadTypeForTransformedRect(viewMatrix));
         bool allOpaque = true;
         Domain netDomain = Domain::kNo;
         for (unsigned p = 0; p < fProxyCnt; ++p) {
@@ -326,19 +331,22 @@
             auto quad = set[p].fDstClipQuad == nullptr ?
                     GrPerspQuad::MakeFromRect(set[p].fDstRect, ctm) :
                     GrPerspQuad::MakeFromSkQuad(set[p].fDstClipQuad, ctm);
+            GrQuadType quadType =
+                    set[p].fDstClipQuad ? GrQuadTypeForPoints(set[p].fDstClipQuad, ctm)
+                                        : GrQuadTypeForTransformedRect(ctm);
 
-            bounds.joinPossiblyEmptyRect(quad.bounds());
+            bounds.joinPossiblyEmptyRect(quad.bounds(quadType));
             GrQuadAAFlags aaFlags;
             // Don't update the overall aaType, might be inappropriate for some of the quads
             GrAAType aaForQuad;
-            GrResolveAATypeForQuad(aaType, set[p].fAAFlags, quad, &aaForQuad, &aaFlags);
+            GrResolveAATypeForQuad(aaType, set[p].fAAFlags, quad, quadType, &aaForQuad, &aaFlags);
             // Resolve sets aaForQuad to aaType or None, there is never a change between aa methods
             SkASSERT(aaForQuad == GrAAType::kNone || aaForQuad == aaType);
             if (overallAAType == GrAAType::kNone && aaForQuad != GrAAType::kNone) {
                 overallAAType = aaType;
             }
             if (!mustFilter && this->filter() != GrSamplerState::Filter::kNearest) {
-                mustFilter = quad.quadType() != GrQuadType::kRect ||
+                mustFilter = quadType != GrQuadType::kRect ||
                              GrTextureOp::GetFilterHasEffect(ctm, set[p].fSrcRect,
                                                              set[p].fDstRect);
             }
@@ -362,10 +370,12 @@
                 // but with respect to srcRect
                 SkPoint srcQuad[4];
                 GrMapRectPoints(set[p].fDstRect, set[p].fSrcRect, set[p].fDstClipQuad, srcQuad, 4);
-                fSrcQuads.push_back(GrPerspQuad::MakeFromSkQuad(srcQuad, SkMatrix::I()));
+                fSrcQuads.push_back(GrPerspQuad::MakeFromSkQuad(srcQuad, SkMatrix::I()),
+                                    GrQuadTypeForPoints(srcQuad, SkMatrix::I()));
                 srcQuadIndex = fSrcQuads.count() - 1;
             }
-            fQuads.push_back(quad, {color, set[p].fSrcRect, srcQuadIndex, domainForQuad, aaFlags});
+            fQuads.push_back(quad, quadType,
+                             {color, set[p].fSrcRect, srcQuadIndex, domainForQuad, aaFlags});
         }
         fAAType = static_cast<unsigned>(overallAAType);
         if (!mustFilter) {
diff --git a/tests/GrQuadListTest.cpp b/tests/GrQuadListTest.cpp
index 3100c37..a9cd9b3 100644
--- a/tests/GrQuadListTest.cpp
+++ b/tests/GrQuadListTest.cpp
@@ -55,8 +55,8 @@
     GrQuadList list2D;
     // Add a plain quad, a 2D persp quad, and then a 3D persp quad, then read back and make sure
     // the coordinates make sense (including that the type was lifted to perspective).
-    list2D.push_back(make_2d_quad());
-    list2D.push_back(make_2d_persp_quad());
+    list2D.push_back(make_2d_quad(), GrQuadType::kRect);
+    list2D.push_back(make_2d_persp_quad(), GrQuadType::kRect);
 
     // Check 2D state of the list
     ASSERTF(list2D.count() == 2, "Unexpected count: %d", list2D.count());
@@ -66,7 +66,7 @@
     ASSERTF(is_2d_persp_quad(list2D[1]), "Incorrect quad at i=1");
 
     // Force the 2D quads to be updated to store ws by adding a perspective quad
-    list2D.push_back(make_3d_persp_quad());
+    list2D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective);
     ASSERTF(list2D.quadType() == GrQuadType::kPerspective,
             "Expected 2D list to be upgraded to perspective");
 
@@ -81,9 +81,9 @@
     // Now make a list that starts with a 3D persp quad, then has conventional quads added to it
     // and make sure its state is correct
     GrQuadList list3D;
-    list3D.push_back(make_3d_persp_quad());
-    list3D.push_back(make_2d_persp_quad());
-    list3D.push_back(make_2d_quad());
+    list3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective);
+    list3D.push_back(make_2d_persp_quad(), GrQuadType::kRect);
+    list3D.push_back(make_2d_quad(), GrQuadType::kRect);
 
     ASSERTF(list3D.count() == 3, "Unexpected count: %d", list3D.count());
     ASSERTF(is_3d_persp_quad(list3D[0]), "Incorrect quad at i=0");
@@ -96,8 +96,8 @@
     GrTQuadList<TestData> list2D;
     // Add a plain quad, a 2D persp quad, and then a 3D persp quad, then read back and make sure
     // the coordinates make sense (including that the type was lifted to perspective).
-    list2D.push_back(make_2d_quad(), {1, 1.f});
-    list2D.push_back(make_2d_persp_quad(), {2, 2.f});
+    list2D.push_back(make_2d_quad(), GrQuadType::kRect, {1, 1.f});
+    list2D.push_back(make_2d_persp_quad(), GrQuadType::kRect, {2, 2.f});
 
     // Check 2D state of the list
     ASSERTF(list2D.count() == 2, "Unexpected count: %d", list2D.count());
@@ -111,7 +111,7 @@
             "Incorrect metadata at i=1");
 
     // Force the 2D quads to be updated to store ws by adding a perspective quad
-    list2D.push_back(make_3d_persp_quad(), {3, 3.f});
+    list2D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective, {3, 3.f});
     ASSERTF(list2D.quadType() == GrQuadType::kPerspective,
             "Expected 2D list to be upgraded to perspective");
 
@@ -132,9 +132,9 @@
     // Now make a list that starts with a 3D persp quad, then has conventional quads added to it
     // and make sure its state is correct
     GrTQuadList<TestData> list3D;
-    list3D.push_back(make_3d_persp_quad(), {3, 3.f});
-    list3D.push_back(make_2d_persp_quad(), {2, 2.f});
-    list3D.push_back(make_2d_quad(), {1, 1.f});
+    list3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective, {3, 3.f});
+    list3D.push_back(make_2d_persp_quad(), GrQuadType::kRect, {2, 2.f});
+    list3D.push_back(make_2d_quad(), GrQuadType::kRect, {1, 1.f});
 
     ASSERTF(list3D.count() == 3, "Unexpected count: %d", list3D.count());
     ASSERTF(is_3d_persp_quad(list3D[0]), "Incorrect quad at i=0");
@@ -150,9 +150,9 @@
 
 TEST(Concat2DWith2D) {
     GrQuadList a2D;
-    a2D.push_back(make_2d_quad());
+    a2D.push_back(make_2d_quad(), GrQuadType::kRect);
     GrQuadList b2D;
-    b2D.push_back(make_2d_persp_quad());
+    b2D.push_back(make_2d_persp_quad(), GrQuadType::kRect);
 
     a2D.concat(b2D);
 
@@ -163,9 +163,9 @@
 
 TEST(Concat2DWith3D) {
     GrQuadList a2D;
-    a2D.push_back(make_2d_quad());
+    a2D.push_back(make_2d_quad(), GrQuadType::kRect);
     GrQuadList b3D;
-    b3D.push_back(make_3d_persp_quad());
+    b3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective);
 
     a2D.concat(b3D);
 
@@ -176,9 +176,9 @@
 
 TEST(Concat3DWith2D) {
     GrQuadList a3D;
-    a3D.push_back(make_3d_persp_quad());
+    a3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective);
     GrQuadList b2D;
-    b2D.push_back(make_2d_quad());
+    b2D.push_back(make_2d_quad(), GrQuadType::kRect);
 
     a3D.concat(b2D);
 
@@ -189,9 +189,9 @@
 
 TEST(Concat3DWith3D) {
     GrQuadList a3D;
-    a3D.push_back(make_3d_persp_quad());
+    a3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective);
     GrQuadList b3D;
-    b3D.push_back(make_3d_persp_quad());
+    b3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective);
 
     a3D.concat(b3D);
 
@@ -202,9 +202,9 @@
 
 TEST(Concat2DWith2DMetadata) {
     GrTQuadList<TestData> a2D;
-    a2D.push_back(make_2d_quad(), {1, 1.f});
+    a2D.push_back(make_2d_quad(), GrQuadType::kRect, {1, 1.f});
     GrTQuadList<TestData> b2D;
-    b2D.push_back(make_2d_persp_quad(), {2, 2.f});
+    b2D.push_back(make_2d_persp_quad(), GrQuadType::kRect, {2, 2.f});
 
     a2D.concat(b2D);
 
@@ -219,9 +219,9 @@
 
 TEST(Concat2DWith3DMetadata) {
     GrTQuadList<TestData> a2D;
-    a2D.push_back(make_2d_quad(), {1, 1.f});
+    a2D.push_back(make_2d_quad(), GrQuadType::kRect, {1, 1.f});
     GrTQuadList<TestData> b3D;
-    b3D.push_back(make_3d_persp_quad(), {2, 2.f});
+    b3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective, {2, 2.f});
 
     a2D.concat(b3D);
 
@@ -236,9 +236,9 @@
 
 TEST(Concat3DWith2DMetadata) {
     GrTQuadList<TestData> a3D;
-    a3D.push_back(make_3d_persp_quad(), {1, 1.f});
+    a3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective, {1, 1.f});
     GrTQuadList<TestData> b2D;
-    b2D.push_back(make_2d_quad(), {2, 2.f});
+    b2D.push_back(make_2d_quad(), GrQuadType::kRect, {2, 2.f});
 
     a3D.concat(b2D);
 
@@ -253,9 +253,9 @@
 
 TEST(Concat3DWith3DMetadata) {
     GrTQuadList<TestData> a3D;
-    a3D.push_back(make_3d_persp_quad(), {1, 1.f});
+    a3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective, {1, 1.f});
     GrTQuadList<TestData> b3D;
-    b3D.push_back(make_3d_persp_quad(), {2, 2.f});
+    b3D.push_back(make_3d_persp_quad(), GrQuadType::kPerspective, {2, 2.f});
 
     a3D.concat(b3D);
 
@@ -270,7 +270,7 @@
 
 TEST(WriteMetadata) {
     GrTQuadList<TestData> list;
-    list.push_back(make_2d_quad(), {1, 1.f});
+    list.push_back(make_2d_quad(), GrQuadType::kRect, {1, 1.f});
     ASSERTF(list.metadata(0).fItem1 == 1 && list.metadata(0).fItem2 == 1.f,
             "Incorrect metadata at i=0"); // Sanity check