diff --git a/src/gpu/GrQuad.cpp b/src/gpu/GrQuad.cpp
index 379d1f6..bd01a68 100644
--- a/src/gpu/GrQuad.cpp
+++ b/src/gpu/GrQuad.cpp
@@ -69,10 +69,39 @@
     *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, GrQuadType knownType,
-                            GrAAType* outAAType, GrQuadAAFlags* outEdgeFlags) {
+                            const Q& quad, GrAAType* outAAType, GrQuadAAFlags* outEdgeFlags) {
     // Most cases will keep the requested types unchanged
     *outAAType = requestedAAType;
     *outEdgeFlags = requestedEdgeFlags;
@@ -86,7 +115,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 (knownType == GrQuadType::kRect && !quad.aaHasEffectOnRect()) {
+                if (quad.quadType() == GrQuadType::kRect && !quad.aaHasEffectOnRect()) {
                     *outAAType = GrAAType::kNone;
                     *outEdgeFlags = GrQuadAAFlags::kNone;
                 }
@@ -107,58 +136,46 @@
 };
 
 // Instantiate GrResolve... for GrQuad and GrPerspQuad
-template void GrResolveAATypeForQuad(GrAAType, GrQuadAAFlags, const GrQuad&, GrQuadType,
+template void GrResolveAATypeForQuad(GrAAType, GrQuadAAFlags, const GrQuad&,
                                      GrAAType*, GrQuadAAFlags*);
-template void GrResolveAATypeForQuad(GrAAType, GrQuadAAFlags, const GrPerspQuad&, GrQuadType,
+template void GrResolveAATypeForQuad(GrAAType, GrQuadAAFlags, const GrPerspQuad&,
                                      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);
+    return GrQuad(x, y, type);
 }
 
 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);
+        return GrQuad(xs, ys, type);
     } else {
         V4f mx, my;
         map_quad_general(xs, ys, matrix, &mx, &my, nullptr);
-        return GrQuad(mx, my);
+        return GrQuad(mx, my, type);
     }
 }
 
@@ -167,7 +184,8 @@
 }
 
 // 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) {
+GrPerspQuad::GrPerspQuad(const float* xs, const float* ys, const float* ws, GrQuadType type)
+        : fType(type) {
     memcpy(fX, xs, 4 * sizeof(float));
     memcpy(fY, ys, 4 * sizeof(float));
     memcpy(fW, ws, 4 * sizeof(float));
@@ -176,24 +194,28 @@
 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);
+    return GrPerspQuad(x, y, w, type);
 }
 
 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);
+        return GrPerspQuad(xs, ys, 1.f, type);
     } else {
         V4f mx, my, mw;
         map_quad_general(xs, ys, matrix, &mx, &my, &mw);
-        return GrPerspQuad(mx, my, mw);
+        return GrPerspQuad(mx, my, mw, type);
     }
 }
 
diff --git a/src/gpu/GrQuad.h b/src/gpu/GrQuad.h
index 73b7310..cb2f15d 100644
--- a/src/gpu/GrQuad.h
+++ b/src/gpu/GrQuad.h
@@ -34,19 +34,12 @@
 };
 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, GrQuadType knownQuadType,
-                            GrAAType* outAAtype, GrQuadAAFlags* outEdgeFlags);
+                            const Q& quad, GrAAType* outAAtype, GrQuadAAFlags* outEdgeFlags);
 
 /**
  * GrQuad is a collection of 4 points which can be used to represent an arbitrary quadrilateral. The
@@ -60,17 +53,15 @@
 
     explicit GrQuad(const SkRect& rect)
             : fX{rect.fLeft, rect.fLeft, rect.fRight, rect.fRight}
-            , fY{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom} {}
+            , fY{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom}
+            , fType(GrQuadType::kRect) {}
 
-    GrQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys) {
+    GrQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys, GrQuadType type)
+            : fType(type) {
         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&);
 
@@ -95,6 +86,8 @@
     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;
 
@@ -104,6 +97,8 @@
 
     float fX[4];
     float fY[4];
+
+    GrQuadType fType;
 };
 
 class GrPerspQuad {
@@ -113,16 +108,21 @@
     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} {}
+            , fW{1.f, 1.f, 1.f, 1.f}
+            , fType(GrQuadType::kRect) {}
 
-    GrPerspQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys) {
+    GrPerspQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys,
+                GrQuadType type)
+            : fType(type) {
+        SkASSERT(type != GrQuadType::kPerspective);
         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) {
+                const skvx::Vec<4, float>& ws, GrQuadType type)
+            : fType(type) {
         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(GrQuadType type) const {
+    SkRect bounds() const {
         auto x = this->x4f();
         auto y = this->y4f();
-        if (type == GrQuadType::kPerspective) {
+        if (fType == GrQuadType::kPerspective) {
             auto iw = this->iw4f();
             x *= iw;
             y *= iw;
@@ -161,7 +161,9 @@
     skvx::Vec<4, float> w4f() const { return skvx::Vec<4, float>::Load(fW); }
     skvx::Vec<4, float> iw4f() const { return 1.f / this->w4f(); }
 
-    bool hasPerspective() const { return any(w4f() != 1.f); }
+    GrQuadType quadType() const { return fType; }
+
+    bool hasPerspective() const { return fType == GrQuadType::kPerspective; }
 
     // True if anti-aliasing affects this quad. Only valid when quadType == kRect_QuadType
     bool aaHasEffectOnRect() const;
@@ -171,11 +173,13 @@
     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]);
+    GrPerspQuad(const float xs[4], const float ys[4], const float ws[4], GrQuadType type);
 
     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
@@ -205,9 +209,9 @@
 
     GrQuadType quadType() const { return fType; }
 
-    void reserve(int count, GrQuadType forType) {
+    void reserve(int count, bool needsPerspective) {
         fXYs.reserve(count);
-        if (forType == GrQuadType::kPerspective || fType == GrQuadType::kPerspective) {
+        if (needsPerspective || fType == GrQuadType::kPerspective) {
             fWs.reserve(4 * count);
         }
     }
@@ -219,11 +223,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);
+            return GrPerspQuad(item.fX, item.fY, fWs.begin() + 4 * i, fType);
         } 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);
+            return GrPerspQuad(item.fX, item.fY, kNoPerspectiveWs, fType);
         }
     }
 
@@ -249,8 +253,8 @@
     }
 
     // Returns the added item data so that its metadata can be initialized if T is not void
-    QuadData<T>& pushBackImpl(const GrQuad& quad, GrQuadType type) {
-        this->upgradeType(type);
+    QuadData<T>& pushBackImpl(const GrQuad& quad) {
+        this->upgradeType(quad.quadType());
         QuadData<T>& item = fXYs.push_back();
         memcpy(item.fX, quad.fX, 4 * sizeof(float));
         memcpy(item.fY, quad.fY, 4 * sizeof(float));
@@ -260,8 +264,8 @@
         return item;
     }
 
-    QuadData<T>& pushBackImpl(const GrPerspQuad& quad, GrQuadType type) {
-        this->upgradeType(type);
+    QuadData<T>& pushBackImpl(const GrPerspQuad& quad) {
+        this->upgradeType(quad.quadType());
         QuadData<T>& item = fXYs.push_back();
         memcpy(item.fX, quad.fX, 4 * sizeof(float));
         memcpy(item.fY, quad.fY, 4 * sizeof(float));
@@ -309,12 +313,12 @@
         this->concatImpl(that);
     }
 
-    void push_back(const GrQuad& quad, GrQuadType type) {
-        this->pushBackImpl(quad, type);
+    void push_back(const GrQuad& quad) {
+        this->pushBackImpl(quad);
     }
 
-    void push_back(const GrPerspQuad& quad, GrQuadType type) {
-        this->pushBackImpl(quad, type);
+    void push_back(const GrPerspQuad& quad) {
+        this->pushBackImpl(quad);
     }
 
 private:
@@ -333,13 +337,13 @@
     }
 
     // Adding to the list requires metadata
-    void push_back(const GrQuad& quad, GrQuadType type, T&& metadata) {
-        QuadData<T>& item = this->pushBackImpl(quad, type);
+    void push_back(const GrQuad& quad, T&& metadata) {
+        QuadData<T>& item = this->pushBackImpl(quad);
         item.fMetadata = std::move(metadata);
     }
 
-    void push_back(const GrPerspQuad& quad, GrQuadType type, T&& metadata) {
-        QuadData<T>& item = this->pushBackImpl(quad, type);
+    void push_back(const GrPerspQuad& quad, T&& metadata) {
+        QuadData<T>& item = this->pushBackImpl(quad);
         item.fMetadata = std::move(metadata);
     }
 
diff --git a/src/gpu/ops/GrFillRectOp.cpp b/src/gpu/ops/GrFillRectOp.cpp
index 1889b0b..aad26c1 100644
--- a/src/gpu/ops/GrFillRectOp.cpp
+++ b/src/gpu/ops/GrFillRectOp.cpp
@@ -64,35 +64,32 @@
                                           GrQuadAAFlags edgeAA,
                                           const GrUserStencilSettings* stencilSettings,
                                           const GrPerspQuad& deviceQuad,
-                                          GrQuadType deviceQuadType,
-                                          const GrPerspQuad& localQuad,
-                                          GrQuadType localQuadType) {
+                                          const GrPerspQuad& localQuad) {
         // Clean up deviations between aaType and edgeAA
-        GrResolveAATypeForQuad(aaType, edgeAA, deviceQuad, deviceQuadType, &aaType, &edgeAA);
+        GrResolveAATypeForQuad(aaType, edgeAA, deviceQuad, &aaType, &edgeAA);
         return Helper::FactoryHelper<FillRectOp>(context, std::move(paint), aaType, edgeAA,
-                stencilSettings, deviceQuad, deviceQuadType, localQuad, localQuadType);
+                stencilSettings, deviceQuad, localQuad);
     }
 
     // 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, GrQuadType deviceQuadType,
-               const GrPerspQuad& localQuad, GrQuadType localQuadType)
+               const GrPerspQuad& deviceQuad, const GrPerspQuad& localQuad)
             : 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, deviceQuadType, { paintColor, edgeFlags });
+        fDeviceQuads.push_back(deviceQuad, { 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, localQuadType);
+            fLocalQuads.push_back(localQuad);
         }
-        this->setBounds(deviceQuad.bounds(deviceQuadType),
-                        HasAABloat(aaType == GrAAType::kCoverage), IsZeroArea::kNo);
+        this->setBounds(deviceQuad.bounds(), HasAABloat(aaType == GrAAType::kCoverage),
+                        IsZeroArea::kNo);
     }
 
     const char* name() const override { return "FillRectOp"; }
@@ -297,8 +294,7 @@
     // 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,
-                 GrQuadType localQuadType, const SkPMColor4f& color, GrQuadAAFlags edgeAA,
-                 GrAAType aaType) {
+                 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.
@@ -314,12 +310,12 @@
 
         // Update the bounds and add the quad to this op's storage
         SkRect newBounds = this->bounds();
-        newBounds.joinPossiblyEmptyRect(deviceQuad.bounds(fDeviceQuads.quadType()));
+        newBounds.joinPossiblyEmptyRect(deviceQuad.bounds());
         this->setBounds(newBounds, HasAABloat(fHelper.aaType() == GrAAType::kCoverage),
                         IsZeroArea::kNo);
-        fDeviceQuads.push_back(deviceQuad, fDeviceQuads.quadType(), { color, edgeAA });
+        fDeviceQuads.push_back(deviceQuad, { color, edgeAA });
         if (!fHelper.isTrivial()) {
-            fLocalQuads.push_back(localQuad, localQuadType);
+            fLocalQuads.push_back(localQuad);
         }
     }
 
@@ -356,10 +352,8 @@
                                       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),  dstQuadType,
-                            GrPerspQuad(rect), GrQuadType::kRect);
+                            GrPerspQuad::MakeFromRect(rect, viewMatrix), GrPerspQuad(rect));
 }
 
 std::unique_ptr<GrDrawOp> MakePerEdgeWithLocalMatrix(GrRecordingContext* context,
@@ -370,11 +364,9 @@
                                                      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), dstQuadType,
-                            GrPerspQuad::MakeFromRect(rect, localMatrix), localQuadType);
+                            GrPerspQuad::MakeFromRect(rect, viewMatrix),
+                            GrPerspQuad::MakeFromRect(rect, localMatrix));
 }
 
 std::unique_ptr<GrDrawOp> MakePerEdgeWithLocalRect(GrRecordingContext* context,
@@ -385,10 +377,8 @@
                                                    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), dstQuadType,
-                            GrPerspQuad(localRect), GrQuadType::kRect);
+                            GrPerspQuad::MakeFromRect(rect, viewMatrix), GrPerspQuad(localRect));
 }
 
 std::unique_ptr<GrDrawOp> MakePerEdgeQuad(GrRecordingContext* context,
@@ -399,12 +389,10 @@
                                           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), deviceType,
+                            GrPerspQuad::MakeFromSkQuad(quad, viewMatrix),
                             GrPerspQuad::MakeFromSkQuad(localQuad ? localQuad : quad,
-                                                        SkMatrix::I()), localType);
+                                                        SkMatrix::I()));
 }
 
 std::unique_ptr<GrDrawOp> MakeSet(GrRecordingContext* context,
@@ -416,14 +404,12 @@
                                   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), deviceQuadType,
-            GrPerspQuad::MakeFromRect(quads[0].fRect, quads[0].fLocalMatrix),
-            GrQuadTypeForTransformedRect(quads[0].fLocalMatrix));
+            GrPerspQuad::MakeFromRect(quads[0].fRect, viewMatrix),
+            GrPerspQuad::MakeFromRect(quads[0].fRect, quads[0].fLocalMatrix));
     auto* fillRects = op->cast<FillRectOp>();
 
     // Accumulate remaining quads similar to onCombineIfPossible() without creating an op
@@ -432,13 +418,12 @@
 
         GrAAType resolvedAA;
         GrQuadAAFlags resolvedEdgeFlags;
-        GrResolveAATypeForQuad(aaType, quads[i].fAAFlags, deviceQuad, deviceQuadType,
+        GrResolveAATypeForQuad(aaType, quads[i].fAAFlags, deviceQuad,
                                &resolvedAA, &resolvedEdgeFlags);
 
         fillRects->addQuad(deviceQuad,
                            GrPerspQuad::MakeFromRect(quads[i].fRect, quads[i].fLocalMatrix),
-                           GrQuadTypeForTransformedRect(quads[i].fLocalMatrix), quads[i].fColor,
-                           resolvedEdgeFlags,resolvedAA);
+                           quads[i].fColor, resolvedEdgeFlags,resolvedAA);
     }
 
     return op;
diff --git a/src/gpu/ops/GrQuadPerEdgeAA.cpp b/src/gpu/ops/GrQuadPerEdgeAA.cpp
index 62509d1..38c5955 100644
--- a/src/gpu/ops/GrQuadPerEdgeAA.cpp
+++ b/src/gpu/ops/GrQuadPerEdgeAA.cpp
@@ -742,6 +742,9 @@
 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 a39535a..fb28f43 100644
--- a/src/gpu/ops/GrQuadPerEdgeAA.h
+++ b/src/gpu/ops/GrQuadPerEdgeAA.h
@@ -91,6 +91,9 @@
     // 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 15e73a0..11ee9e2 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);
+    return GrPerspQuad(xs, ys, srcQuad.quadType());
 }
 
 /**
@@ -120,9 +120,8 @@
                                           const SkMatrix& viewMatrix,
                                           sk_sp<GrColorSpaceXform> textureColorSpaceXform) {
         GrPerspQuad dstQuad = GrPerspQuad::MakeFromRect(dstRect, viewMatrix);
-        GrQuadType dstQuadType = GrQuadTypeForTransformedRect(viewMatrix);
 
-        if (dstQuadType == GrQuadType::kRect) {
+        if (dstQuad.quadType() == GrQuadType::kRect) {
             // Disable filtering if possible (note AA optimizations for rects are automatically
             // handled above in GrResolveAATypeForQuad).
             if (filter != GrSamplerState::Filter::kNearest &&
@@ -134,8 +133,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, dstQuadType, srcRect, constraint,
-                nullptr, GrQuadType::kRect, aaType, aaFlags, std::move(textureColorSpaceXform));
+                std::move(proxy), filter, color, dstQuad, srcRect, constraint,
+                nullptr, aaType, aaFlags, std::move(textureColorSpaceXform));
     }
     static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
                                           sk_sp<GrTextureProxy> proxy,
@@ -149,9 +148,7 @@
                                           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.
@@ -165,9 +162,8 @@
         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, dstQuadType, srcRect, constraint,
-                &grSrcQuad, srcQuadType, aaType, aaFlags,
-                std::move(textureColorSpaceXform));
+                std::move(proxy), filter, color, grDstQuad, srcRect, constraint, &grSrcQuad,
+                aaType, aaFlags, std::move(textureColorSpaceXform));
     }
     static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
                                           const GrRenderTargetContext::TextureSetEntry set[],
@@ -259,9 +255,8 @@
     // 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, GrQuadType dstQuadType,
-              const SkRect& srcRect, SkCanvas::SrcRectConstraint constraint,
-              const GrPerspQuad* srcQuad, GrQuadType srcQuadType, GrAAType aaType,
+              const GrPerspQuad& dstQuad, const SkRect& srcRect,
+              SkCanvas::SrcRectConstraint constraint, const GrPerspQuad* srcQuad, GrAAType aaType,
               GrQuadAAFlags aaFlags, sk_sp<GrColorSpaceXform> textureColorSpaceXform)
             : INHERITED(ClassID())
             , fTextureColorSpaceXform(std::move(textureColorSpaceXform))
@@ -269,7 +264,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, dstQuadType, &aaType, &aaFlags);
+        GrResolveAATypeForQuad(aaType, aaFlags, dstQuad, &aaType, &aaFlags);
         fAAType = static_cast<unsigned>(aaType);
 
         // We expect our caller to have already caught this optimization.
@@ -288,14 +283,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, dstQuadType, {color, srcRect, srcQuad ? 0 : -1, domain, aaFlags});
+        fQuads.push_back(dstQuad, {color, srcRect, srcQuad ? 0 : -1, domain, aaFlags});
         if (srcQuad) {
-            fSrcQuads.push_back(*srcQuad, srcQuadType);
+            fSrcQuads.push_back(*srcQuad);
         }
         fProxyCnt = 1;
         fProxies[0] = {proxy.release(), 1};
-        auto bounds = dstQuad.bounds(dstQuadType);
-        this->setBounds(bounds, HasAABloat(aaType == GrAAType::kCoverage), IsZeroArea::kNo);
+        this->setBounds(dstQuad.bounds(), HasAABloat(aaType == GrAAType::kCoverage),
+                        IsZeroArea::kNo);
         fDomain = static_cast<unsigned>(domain);
     }
     TextureOp(const GrRenderTargetContext::TextureSetEntry set[], int cnt,
@@ -313,7 +308,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, GrQuadTypeForTransformedRect(viewMatrix));
+        fQuads.reserve(cnt, viewMatrix.hasPerspective());
         bool allOpaque = true;
         Domain netDomain = Domain::kNo;
         for (unsigned p = 0; p < fProxyCnt; ++p) {
@@ -331,22 +326,19 @@
             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(quadType));
+            bounds.joinPossiblyEmptyRect(quad.bounds());
             GrQuadAAFlags aaFlags;
             // Don't update the overall aaType, might be inappropriate for some of the quads
             GrAAType aaForQuad;
-            GrResolveAATypeForQuad(aaType, set[p].fAAFlags, quad, quadType, &aaForQuad, &aaFlags);
+            GrResolveAATypeForQuad(aaType, set[p].fAAFlags, quad, &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 = quadType != GrQuadType::kRect ||
+                mustFilter = quad.quadType() != GrQuadType::kRect ||
                              GrTextureOp::GetFilterHasEffect(ctm, set[p].fSrcRect,
                                                              set[p].fDstRect);
             }
@@ -370,12 +362,10 @@
                 // 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()),
-                                    GrQuadTypeForPoints(srcQuad, SkMatrix::I()));
+                fSrcQuads.push_back(GrPerspQuad::MakeFromSkQuad(srcQuad, SkMatrix::I()));
                 srcQuadIndex = fSrcQuads.count() - 1;
             }
-            fQuads.push_back(quad, quadType,
-                             {color, set[p].fSrcRect, srcQuadIndex, domainForQuad, aaFlags});
+            fQuads.push_back(quad, {color, set[p].fSrcRect, srcQuadIndex, domainForQuad, aaFlags});
         }
         fAAType = static_cast<unsigned>(overallAAType);
         if (!mustFilter) {