Reland of Better encapsulate oval/rrect batchs.

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 506 matching lines @@
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DIEllipseGeometryProcessor);
 
 sk_sp<GrGeometryProcessor> DIEllipseGeometryProcessor::TestCreate(GrProcessorTestData* d) {
     return sk_sp<GrGeometryProcessor>(
         new DIEllipseGeometryProcessor(GrTest::TestMatrix(d->fRandom),
                                        (DIEllipseStyle)(d->fRandom->nextRangeU(0,2))));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrDrawBatch* GrOvalRenderer::CreateOvalBatch(GrColor color,
-                                             const SkMatrix& viewMatrix,
-                                             const SkRect& oval,
-                                             const SkStrokeRec& stroke,
-                                             GrShaderCaps* shaderCaps) {
-    // we can draw circles
-    if (SkScalarNearlyEqual(oval.width(), oval.height()) && circle_stays_circle(viewMatrix)) {
-        return CreateCircleBatch(color, viewMatrix, oval, stroke);
-    }
-
-    // if we have shader derivative support, render as device-independent
-    if (shaderCaps->shaderDerivativeSupport()) {
-        return CreateDIEllipseBatch(color, viewMatrix, oval, stroke);
-    }
-
-    // otherwise axis-aligned ellipses only
-    if (viewMatrix.rectStaysRect()) {
-        return CreateEllipseBatch(color, viewMatrix, oval, stroke);
-    }
-
-    return nullptr;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 class CircleBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
-    struct Geometry {
-        SkRect fDevBounds;
-        SkScalar fInnerRadius;
-        SkScalar fOuterRadius;
-        GrColor fColor;
-    };
+    CircleBatch(GrColor color, const SkMatrix& viewMatrix, const SkRect& circle,
+                const SkStrokeRec& stroke)
+            : INHERITED(ClassID())
+            , fViewMatrixIfUsingLocalCoords(viewMatrix) {
+        SkPoint center = SkPoint::Make(circle.centerX(), circle.centerY());
+        viewMatrix.mapPoints(&center, 1);
+        SkScalar radius = viewMatrix.mapRadius(SkScalarHalf(circle.width()));
+        SkScalar strokeWidth = viewMatrix.mapRadius(stroke.getWidth());
 
-    CircleBatch(const Geometry& geometry, const SkMatrix& viewMatrix, bool stroked)
-        : INHERITED(ClassID())
-        , fStroked(stroked)
-        , fViewMatrixIfUsingLocalCoords(viewMatrix) {
-        fGeoData.push_back(geometry);
-        this->setBounds(geometry.fDevBounds);
+        SkStrokeRec::Style style = stroke.getStyle();
+        bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
+                            SkStrokeRec::kHairline_Style == style;
+        bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
+
+        SkScalar innerRadius = 0.0f;
+        SkScalar outerRadius = radius;
+        SkScalar halfWidth = 0;
+        if (hasStroke) {
+            if (SkScalarNearlyZero(strokeWidth)) {
+                halfWidth = SK_ScalarHalf;
+            } else {
+                halfWidth = SkScalarHalf(strokeWidth);
+            }
+
+            outerRadius += halfWidth;
+            if (isStrokeOnly) {
+                innerRadius = radius - halfWidth;
+            }
+        }
+
+        // The radii are outset for two reasons. First, it allows the shader to simply perform
+        // simpler computation because the computed alpha is zero, rather than 50%, at the radius.
+        // Second, the outer radius is used to compute the verts of the bounding box that is
+        // rendered and the outset ensures the box will cover all partially covered by the circle.
+        outerRadius += SK_ScalarHalf;
+        innerRadius -= SK_ScalarHalf;
+
+        fGeoData.emplace_back(Geometry {
+            color,
+            innerRadius,
+            outerRadius,
+            SkRect::MakeLTRB(center.fX - outerRadius, center.fY - outerRadius,
+                             center.fX + outerRadius, center.fY + outerRadius)
+        });
+        this->setBounds(fGeoData.back().fDevBounds);
+        fStroked = isStrokeOnly && innerRadius > 0;
     }
+
     const char* name() const override { return "CircleBatch"; }
 
     SkString dumpInfo() const override {
         SkString string;
         for (int i = 0; i < fGeoData.count(); ++i) {
             string.appendf("Color: 0x%08x Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f],"
                            "InnerRad: %.2f, OuterRad: %.2f\n",
                            fGeoData[i].fColor,
                            fGeoData[i].fDevBounds.fLeft, fGeoData[i].fDevBounds.fTop,
                            fGeoData[i].fDevBounds.fRight, fGeoData[i].fDevBounds.fBottom,
@@ skipping 93 matching lines @@
 
         if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
+    struct Geometry {
+        GrColor fColor;
+        SkScalar fInnerRadius;
+        SkScalar fOuterRadius;
+        SkRect fDevBounds;
+    };
+
     bool                         fStroked;
     SkMatrix                     fViewMatrixIfUsingLocalCoords;
     SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
-static GrDrawBatch* create_circle_batch(GrColor color,
-                                        const SkMatrix& viewMatrix,
-                                        const SkRect& circle,
-                                        const SkStrokeRec& stroke) {
-    SkPoint center = SkPoint::Make(circle.centerX(), circle.centerY());
-    viewMatrix.mapPoints(&center, 1);
-    SkScalar radius = viewMatrix.mapRadius(SkScalarHalf(circle.width()));
-    SkScalar strokeWidth = viewMatrix.mapRadius(stroke.getWidth());
-
-    SkStrokeRec::Style style = stroke.getStyle();
-    bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
-                        SkStrokeRec::kHairline_Style == style;
-    bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
-
-    SkScalar innerRadius = 0.0f;
-    SkScalar outerRadius = radius;
-    SkScalar halfWidth = 0;
-    if (hasStroke) {
-        if (SkScalarNearlyZero(strokeWidth)) {
-            halfWidth = SK_ScalarHalf;
-        } else {
-            halfWidth = SkScalarHalf(strokeWidth);
-        }
-
-        outerRadius += halfWidth;
-        if (isStrokeOnly) {
-            innerRadius = radius - halfWidth;
-        }
-    }
-
-    // The radii are outset for two reasons. First, it allows the shader to simply perform simpler
-    // computation because the computed alpha is zero, rather than 50%, at the radius.
-    // Second, the outer radius is used to compute the verts of the bounding box that is rendered
-    // and the outset ensures the box will cover all partially covered by the circle.
-    outerRadius += SK_ScalarHalf;
-    innerRadius -= SK_ScalarHalf;
-
-    CircleBatch::Geometry geometry;
-    geometry.fColor = color;
-    geometry.fInnerRadius = innerRadius;
-    geometry.fOuterRadius = outerRadius;
-    geometry.fDevBounds = SkRect::MakeLTRB(center.fX - outerRadius, center.fY - outerRadius,
-                                           center.fX + outerRadius, center.fY + outerRadius);
-
-    return new CircleBatch(geometry, viewMatrix, isStrokeOnly && innerRadius > 0);
-}
-
-GrDrawBatch* GrOvalRenderer::CreateCircleBatch(GrColor color,
-                                               const SkMatrix& viewMatrix,
-                                               const SkRect& circle,
-                                               const SkStrokeRec& stroke) {
-    return create_circle_batch(color, viewMatrix, circle, stroke);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 class EllipseBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
+    static GrDrawBatch* Create(GrColor color, const SkMatrix& viewMatrix, const SkRect& ellipse,
+                               const SkStrokeRec& stroke) {
+        SkASSERT(viewMatrix.rectStaysRect());
 
-    struct Geometry {
-        SkRect fDevBounds;
-        SkScalar fXRadius;
-        SkScalar fYRadius;
-        SkScalar fInnerXRadius;
-        SkScalar fInnerYRadius;
-        GrColor fColor;
-    };
+        // do any matrix crunching before we reset the draw state for device coords
+        SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
+        viewMatrix.mapPoints(&center, 1);
+        SkScalar ellipseXRadius = SkScalarHalf(ellipse.width());
+        SkScalar ellipseYRadius = SkScalarHalf(ellipse.height());
+        SkScalar xRadius = SkScalarAbs(viewMatrix[SkMatrix::kMScaleX]*ellipseXRadius +
+                                       viewMatrix[SkMatrix::kMSkewY]*ellipseYRadius);
+        SkScalar yRadius = SkScalarAbs(viewMatrix[SkMatrix::kMSkewX]*ellipseXRadius +
+                                       viewMatrix[SkMatrix::kMScaleY]*ellipseYRadius);
 
-    EllipseBatch(const Geometry& geometry, const SkMatrix& viewMatrix, bool stroked)
-        : INHERITED(ClassID())
-        , fStroked(stroked)
-        , fViewMatrixIfUsingLocalCoords(viewMatrix) {
-        fGeoData.push_back(geometry);
-        this->setBounds(geometry.fDevBounds);
+        // do (potentially) anisotropic mapping of stroke
+        SkVector scaledStroke;
+        SkScalar strokeWidth = stroke.getWidth();
+        scaledStroke.fX = SkScalarAbs(strokeWidth*(viewMatrix[SkMatrix::kMScaleX] +
+                                                   viewMatrix[SkMatrix::kMSkewY]));
+        scaledStroke.fY = SkScalarAbs(strokeWidth*(viewMatrix[SkMatrix::kMSkewX] +
+                                                   viewMatrix[SkMatrix::kMScaleY]));
+
+        SkStrokeRec::Style style = stroke.getStyle();
+        bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
+                            SkStrokeRec::kHairline_Style == style;
+        bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
+
+        SkScalar innerXRadius = 0;
+        SkScalar innerYRadius = 0;
+        if (hasStroke) {
+            if (SkScalarNearlyZero(scaledStroke.length())) {
+                scaledStroke.set(SK_ScalarHalf, SK_ScalarHalf);
+            } else {
+                scaledStroke.scale(SK_ScalarHalf);
+            }
+
+            // we only handle thick strokes for near-circular ellipses
+            if (scaledStroke.length() > SK_ScalarHalf &&
+                (SK_ScalarHalf*xRadius > yRadius || SK_ScalarHalf*yRadius > xRadius)) {
+                return nullptr;
+            }
+
+            // we don't handle it if curvature of the stroke is less than curvature of the ellipse
+            if (scaledStroke.fX*(yRadius*yRadius) < (scaledStroke.fY*scaledStroke.fY)*xRadius ||
+                scaledStroke.fY*(xRadius*xRadius) < (scaledStroke.fX*scaledStroke.fX)*yRadius) {
+                return nullptr;
+            }
+
+            // this is legit only if scale & translation (which should be the case at the moment)
+            if (isStrokeOnly) {
+                innerXRadius = xRadius - scaledStroke.fX;
+                innerYRadius = yRadius - scaledStroke.fY;
+            }
+
+            xRadius += scaledStroke.fX;
+            yRadius += scaledStroke.fY;
+        }
+
+        EllipseBatch* batch = new EllipseBatch();
+        batch->fGeoData.emplace_back(Geometry {
+            color,
+            xRadius,
+            yRadius,
+            innerXRadius,
+            innerYRadius,
+            SkRect::MakeLTRB(center.fX - xRadius, center.fY - yRadius,
+                             center.fX + xRadius, center.fY + yRadius)
+        });
+
+        // Outset bounds to include half-pixel width antialiasing.
+        batch->fGeoData[0].fDevBounds.outset(SK_ScalarHalf, SK_ScalarHalf);
+
+        batch->fStroked = isStrokeOnly && innerXRadius > 0 && innerYRadius > 0;
+        batch->fViewMatrixIfUsingLocalCoords = viewMatrix;
+        batch->setBounds(batch->fGeoData.back().fDevBounds);
+        return batch;
     }
 
     const char* name() const override { return "EllipseBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
     }
 
 private:
+    EllipseBatch() : INHERITED(ClassID()) {}
+
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle any overrides that affect our GP.
         if (!overrides.readsCoverage()) {
             fGeoData[0].fColor = GrColor_ILLEGAL;
         }
         if (!overrides.readsLocalCoords()) {
             fViewMatrixIfUsingLocalCoords.reset();
         }
     }
 
@@ skipping 79 matching lines @@
 
         if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
+    struct Geometry {
+        GrColor fColor;
+        SkScalar fXRadius;
+        SkScalar fYRadius;
+        SkScalar fInnerXRadius;
+        SkScalar fInnerYRadius;
+        SkRect fDevBounds;
+    };
 
     bool                         fStroked;
     SkMatrix                     fViewMatrixIfUsingLocalCoords;
     SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
-static GrDrawBatch* create_ellipse_batch(GrColor color,
-                                         const SkMatrix& viewMatrix,
-                                         const SkRect& ellipse,
-                                         const SkStrokeRec& stroke) {
-    SkASSERT(viewMatrix.rectStaysRect());
-
-    // do any matrix crunching before we reset the draw state for device coords
-    SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
-    viewMatrix.mapPoints(&center, 1);
-    SkScalar ellipseXRadius = SkScalarHalf(ellipse.width());
-    SkScalar ellipseYRadius = SkScalarHalf(ellipse.height());
-    SkScalar xRadius = SkScalarAbs(viewMatrix[SkMatrix::kMScaleX]*ellipseXRadius +
-                                   viewMatrix[SkMatrix::kMSkewY]*ellipseYRadius);
-    SkScalar yRadius = SkScalarAbs(viewMatrix[SkMatrix::kMSkewX]*ellipseXRadius +
-                                   viewMatrix[SkMatrix::kMScaleY]*ellipseYRadius);
-
-    // do (potentially) anisotropic mapping of stroke
-    SkVector scaledStroke;
-    SkScalar strokeWidth = stroke.getWidth();
-    scaledStroke.fX = SkScalarAbs(strokeWidth*(viewMatrix[SkMatrix::kMScaleX] +
-                                               viewMatrix[SkMatrix::kMSkewY]));
-    scaledStroke.fY = SkScalarAbs(strokeWidth*(viewMatrix[SkMatrix::kMSkewX] +
-                                               viewMatrix[SkMatrix::kMScaleY]));
-
-    SkStrokeRec::Style style = stroke.getStyle();
-    bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
-                        SkStrokeRec::kHairline_Style == style;
-    bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
-
-    SkScalar innerXRadius = 0;
-    SkScalar innerYRadius = 0;
-    if (hasStroke) {
-        if (SkScalarNearlyZero(scaledStroke.length())) {
-            scaledStroke.set(SK_ScalarHalf, SK_ScalarHalf);
-        } else {
-            scaledStroke.scale(SK_ScalarHalf);
-        }
-
-        // we only handle thick strokes for near-circular ellipses
-        if (scaledStroke.length() > SK_ScalarHalf &&
-            (SK_ScalarHalf*xRadius > yRadius || SK_ScalarHalf*yRadius > xRadius)) {
-            return nullptr;
-        }
-
-        // we don't handle it if curvature of the stroke is less than curvature of the ellipse
-        if (scaledStroke.fX*(yRadius*yRadius) < (scaledStroke.fY*scaledStroke.fY)*xRadius ||
-            scaledStroke.fY*(xRadius*xRadius) < (scaledStroke.fX*scaledStroke.fX)*yRadius) {
-            return nullptr;
-        }
-
-        // this is legit only if scale & translation (which should be the case at the moment)
-        if (isStrokeOnly) {
-            innerXRadius = xRadius - scaledStroke.fX;
-            innerYRadius = yRadius - scaledStroke.fY;
-        }
-
-        xRadius += scaledStroke.fX;
-        yRadius += scaledStroke.fY;
-    }
-
-    EllipseBatch::Geometry geometry;
-    geometry.fColor = color;
-    geometry.fXRadius = xRadius;
-    geometry.fYRadius = yRadius;
-    geometry.fInnerXRadius = innerXRadius;
-    geometry.fInnerYRadius = innerYRadius;
-    geometry.fDevBounds = SkRect::MakeLTRB(center.fX - xRadius, center.fY - yRadius,
-                                           center.fX + xRadius, center.fY + yRadius);
-
-    // outset bounds to include half-pixel width antialiasing. 
-    geometry.fDevBounds.outset(SK_ScalarHalf, SK_ScalarHalf);
-
-    return new EllipseBatch(geometry, viewMatrix,
-                            isStrokeOnly && innerXRadius > 0 && innerYRadius > 0);
-}
-
-GrDrawBatch* GrOvalRenderer::CreateEllipseBatch(GrColor color,
-                                                const SkMatrix& viewMatrix,
-                                                const SkRect& ellipse,
-                                                const SkStrokeRec& stroke) {
-    return create_ellipse_batch(color, viewMatrix, ellipse, stroke);
-}
-
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 class DIEllipseBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
-    struct Geometry {
-        SkMatrix fViewMatrix;
-        SkRect fBounds;
-        SkScalar fXRadius;
-        SkScalar fYRadius;
-        SkScalar fInnerXRadius;
-        SkScalar fInnerYRadius;
-        SkScalar fGeoDx;
-        SkScalar fGeoDy;
-        GrColor fColor;
-        DIEllipseStyle fStyle;
-    };
+    static GrDrawBatch* Create(GrColor color,
+                               const SkMatrix& viewMatrix,
+                               const SkRect& ellipse,
+                               const SkStrokeRec& stroke) {
+        SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
+        SkScalar xRadius = SkScalarHalf(ellipse.width());
+        SkScalar yRadius = SkScalarHalf(ellipse.height());
 
-    static GrDrawBatch* Create(const Geometry& geometry, const SkRect& bounds) {
-        return new DIEllipseBatch(geometry, bounds);
+        SkStrokeRec::Style style = stroke.getStyle();
+        DIEllipseStyle dieStyle = (SkStrokeRec::kStroke_Style == style) ?
+                                  DIEllipseStyle::kStroke :
+                                  (SkStrokeRec::kHairline_Style == style) ?
+                                  DIEllipseStyle::kHairline : DIEllipseStyle::kFill;
+
+        SkScalar innerXRadius = 0;
+        SkScalar innerYRadius = 0;
+        if (SkStrokeRec::kFill_Style != style && SkStrokeRec::kHairline_Style != style) {
+            SkScalar strokeWidth = stroke.getWidth();
+
+            if (SkScalarNearlyZero(strokeWidth)) {
+                strokeWidth = SK_ScalarHalf;
+            } else {
+                strokeWidth *= SK_ScalarHalf;
+            }
+
+            // we only handle thick strokes for near-circular ellipses
+            if (strokeWidth > SK_ScalarHalf &&
+                (SK_ScalarHalf*xRadius > yRadius || SK_ScalarHalf*yRadius > xRadius)) {
+                return nullptr;
+            }
+
+            // we don't handle it if curvature of the stroke is less than curvature of the ellipse
+            if (strokeWidth*(yRadius*yRadius) < (strokeWidth*strokeWidth)*xRadius ||
+                strokeWidth*(xRadius*xRadius) < (strokeWidth*strokeWidth)*yRadius) {
+                return nullptr;
+            }
+
+            // set inner radius (if needed)
+            if (SkStrokeRec::kStroke_Style == style) {
+                innerXRadius = xRadius - strokeWidth;
+                innerYRadius = yRadius - strokeWidth;
+            }
+
+            xRadius += strokeWidth;
+            yRadius += strokeWidth;
+        }
+        if (DIEllipseStyle::kStroke == dieStyle) {
+            dieStyle = (innerXRadius > 0 && innerYRadius > 0) ? DIEllipseStyle ::kStroke :
+                       DIEllipseStyle ::kFill;
+        }
+
+        // This expands the outer rect so that after CTM we end up with a half-pixel border
+        SkScalar a = viewMatrix[SkMatrix::kMScaleX];
+        SkScalar b = viewMatrix[SkMatrix::kMSkewX];
+        SkScalar c = viewMatrix[SkMatrix::kMSkewY];
+        SkScalar d = viewMatrix[SkMatrix::kMScaleY];
+        SkScalar geoDx = SK_ScalarHalf / SkScalarSqrt(a*a + c*c);
+        SkScalar geoDy = SK_ScalarHalf / SkScalarSqrt(b*b + d*d);
+
+        DIEllipseBatch* batch = new DIEllipseBatch();
+        batch->fGeoData.emplace_back(Geometry {
+            viewMatrix,
+            color,
+            xRadius,
+            yRadius,
+            innerXRadius,
+            innerYRadius,
+            geoDx,
+            geoDy,
+            dieStyle,
+            SkRect::MakeLTRB(center.fX - xRadius - geoDx, center.fY - yRadius - geoDy,
+                             center.fX + xRadius + geoDx, center.fY + yRadius + geoDy)
+        });
+        SkRect devBounds = batch->fGeoData.back().fBounds;
+        viewMatrix.mapRect(&devBounds);
+        batch->setBounds(devBounds);
+        return batch;
     }
 
     const char* name() const override { return "DIEllipseBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
     }
 
 private:
 
+    DIEllipseBatch() : INHERITED(ClassID()) {}
+
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle any overrides that affect our GP.
         overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
         fUsesLocalCoords = overrides.readsLocalCoords();
     }
 
     void onPrepareDraws(Target* target) const override {
         // Setup geometry processor
         SkAutoTUnref<GrGeometryProcessor> gp(new DIEllipseGeometryProcessor(this->viewMatrix(),
                                                                             this->style()));
@@ skipping 42 matching lines @@
             verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
             verts[3].fColor = color;
             verts[3].fOuterOffset = SkPoint::Make(1.0f + offsetDx, -1.0f - offsetDy);
             verts[3].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, -innerRatioY - offsetDy);
 
             verts += kVerticesPerQuad;
         }
         helper.recordDraw(target, gp);
     }
 
-    DIEllipseBatch(const Geometry& geometry, const SkRect& bounds) : INHERITED(ClassID()) {
-        fGeoData.push_back(geometry);
-
-        this->setBounds(bounds);
-    }
-
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         DIEllipseBatch* that = t->cast<DIEllipseBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                     that->bounds(), caps)) {
             return false;
         }
 
         if (this->style() != that->style()) {
             return false;
         }
 
         // TODO rewrite to allow positioning on CPU
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     DIEllipseStyle style() const { return fGeoData[0].fStyle; }
 
+    struct Geometry {
+        SkMatrix fViewMatrix;
+        GrColor fColor;
+        SkScalar fXRadius;
+        SkScalar fYRadius;
+        SkScalar fInnerXRadius;
+        SkScalar fInnerYRadius;
+        SkScalar fGeoDx;
+        SkScalar fGeoDy;
+        DIEllipseStyle fStyle;
+        SkRect fBounds;
+    };
+
     bool                         fUsesLocalCoords;
     SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
-static GrDrawBatch* create_diellipse_batch(GrColor color,
-                                           const SkMatrix& viewMatrix,
-                                           const SkRect& ellipse,
-                                           const SkStrokeRec& stroke) {
-    SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
-    SkScalar xRadius = SkScalarHalf(ellipse.width());
-    SkScalar yRadius = SkScalarHalf(ellipse.height());
-
-    SkStrokeRec::Style style = stroke.getStyle();
-    DIEllipseStyle dieStyle = (SkStrokeRec::kStroke_Style == style) ?
-                                DIEllipseStyle::kStroke :
-                                (SkStrokeRec::kHairline_Style == style) ?
-                                        DIEllipseStyle::kHairline : DIEllipseStyle::kFill;
-
-    SkScalar innerXRadius = 0;
-    SkScalar innerYRadius = 0;
-    if (SkStrokeRec::kFill_Style != style && SkStrokeRec::kHairline_Style != style) {
-        SkScalar strokeWidth = stroke.getWidth();
-
-        if (SkScalarNearlyZero(strokeWidth)) {
-            strokeWidth = SK_ScalarHalf;
-        } else {
-            strokeWidth *= SK_ScalarHalf;
-        }
-
-        // we only handle thick strokes for near-circular ellipses
-        if (strokeWidth > SK_ScalarHalf &&
-            (SK_ScalarHalf*xRadius > yRadius || SK_ScalarHalf*yRadius > xRadius)) {
-            return nullptr;
-        }
-
-        // we don't handle it if curvature of the stroke is less than curvature of the ellipse
-        if (strokeWidth*(yRadius*yRadius) < (strokeWidth*strokeWidth)*xRadius ||
-            strokeWidth*(xRadius*xRadius) < (strokeWidth*strokeWidth)*yRadius) {
-            return nullptr;
-        }
-
-        // set inner radius (if needed)
-        if (SkStrokeRec::kStroke_Style == style) {
-            innerXRadius = xRadius - strokeWidth;
-            innerYRadius = yRadius - strokeWidth;
-        }
-
-        xRadius += strokeWidth;
-        yRadius += strokeWidth;
-    }
-    if (DIEllipseStyle::kStroke == dieStyle) {
-        dieStyle = (innerXRadius > 0 && innerYRadius > 0) ? DIEllipseStyle ::kStroke :
-                                                            DIEllipseStyle ::kFill;
-    }
-
-    // This expands the outer rect so that after CTM we end up with a half-pixel border
-    SkScalar a = viewMatrix[SkMatrix::kMScaleX];
-    SkScalar b = viewMatrix[SkMatrix::kMSkewX];
-    SkScalar c = viewMatrix[SkMatrix::kMSkewY];
-    SkScalar d = viewMatrix[SkMatrix::kMScaleY];
-    SkScalar geoDx = SK_ScalarHalf / SkScalarSqrt(a*a + c*c);
-    SkScalar geoDy = SK_ScalarHalf / SkScalarSqrt(b*b + d*d);
-
-    DIEllipseBatch::Geometry geometry;
-    geometry.fViewMatrix = viewMatrix;
-    geometry.fColor = color;
-    geometry.fXRadius = xRadius;
-    geometry.fYRadius = yRadius;
-    geometry.fInnerXRadius = innerXRadius;
-    geometry.fInnerYRadius = innerYRadius;
-    geometry.fGeoDx = geoDx;
-    geometry.fGeoDy = geoDy;
-    geometry.fStyle = dieStyle;
-    geometry.fBounds = SkRect::MakeLTRB(center.fX - xRadius - geoDx, center.fY - yRadius - geoDy,
-                                        center.fX + xRadius + geoDx, center.fY + yRadius + geoDy);
-
-    SkRect devBounds = geometry.fBounds;
-    viewMatrix.mapRect(&devBounds);
-    return DIEllipseBatch::Create(geometry, devBounds);
-}
-
-GrDrawBatch* GrOvalRenderer::CreateDIEllipseBatch(GrColor color,
-                                                  const SkMatrix& viewMatrix,
-                                                  const SkRect& ellipse,
-                                                  const SkStrokeRec& stroke) {
-    return create_diellipse_batch(color, viewMatrix, ellipse, stroke);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 static const uint16_t gRRectIndices[] = {
     // corners
     0, 1, 5, 0, 5, 4,
     2, 3, 7, 2, 7, 6,
     8, 9, 13, 8, 13, 12,
     10, 11, 15, 10, 15, 14,
 
     // edges
@@ skipping 29 matching lines @@
 
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class RRectCircleRendererBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
-    struct Geometry {
-        SkRect fDevBounds;
-        SkScalar fInnerRadius;
-        SkScalar fOuterRadius;
-        GrColor  fColor;
-    };
+    // A devStrokeWidth <= 0 indicates a fill only. If devStrokeWidth > 0 then strokeOnly indicates
+    // whether the rrect is only stroked or stroked and filled.
+    RRectCircleRendererBatch(GrColor color, const SkMatrix& viewMatrix, const SkRect& devRect,
+                             float devRadius, float devStrokeWidth, bool strokeOnly)
+            : INHERITED(ClassID())
+            , fViewMatrixIfUsingLocalCoords(viewMatrix) {
+        SkRect bounds = devRect;
+        SkASSERT(!(devStrokeWidth <= 0 && strokeOnly));
+        SkScalar innerRadius = 0.0f;
+        SkScalar outerRadius = devRadius;
+        SkScalar halfWidth = 0;
+        fStroked = false;
+        if (devStrokeWidth > 0) {
+            if (SkScalarNearlyZero(devStrokeWidth)) {
+                halfWidth = SK_ScalarHalf;
+            } else {
+                halfWidth = SkScalarHalf(devStrokeWidth);
+            }
 
-    RRectCircleRendererBatch(const Geometry& geometry, const SkMatrix& viewMatrix, bool stroked)
-        : INHERITED(ClassID())
-        , fStroked(stroked)
-        , fViewMatrixIfUsingLocalCoords(viewMatrix) {
-        fGeoData.push_back(geometry);
+            if (strokeOnly) {
+                innerRadius = devRadius - halfWidth;
+                fStroked = innerRadius >= 0;
+            }
+            outerRadius += halfWidth;
+            bounds.outset(halfWidth, halfWidth);
+        }
 
-        this->setBounds(geometry.fDevBounds);
+        // The radii are outset for two reasons. First, it allows the shader to simply perform
+        // simpler computation because the computed alpha is zero, rather than 50%, at the radius.
+        // Second, the outer radius is used to compute the verts of the bounding box that is
+        // rendered and the outset ensures the box will cover all partially covered by the rrect
+        // corners.
+        outerRadius += SK_ScalarHalf;
+        innerRadius -= SK_ScalarHalf;
+
+        // Expand the rect so all the pixels will be captured.
+        bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
+
+        fGeoData.emplace_back(Geometry { color, innerRadius, outerRadius, bounds });
+        this->setBounds(bounds);
     }
 
     const char* name() const override { return "RRectCircleBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
@@ skipping 101 matching lines @@
 
         if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
+    struct Geometry {
+        GrColor  fColor;
+        SkScalar fInnerRadius;
+        SkScalar fOuterRadius;
+        SkRect fDevBounds;
+    };
+
     bool                         fStroked;
     SkMatrix                     fViewMatrixIfUsingLocalCoords;
     SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
 class RRectEllipseRendererBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
-    struct Geometry {
-        SkRect fDevBounds;
-        SkScalar fXRadius;
-        SkScalar fYRadius;
-        SkScalar fInnerXRadius;
-        SkScalar fInnerYRadius;
-        GrColor fColor;
-    };
+    // If devStrokeWidths values are <= 0 indicates then fill only. Otherwise, strokeOnly indicates
+    // whether the rrect is only stroked or stroked and filled.
+    static GrDrawBatch* Create(GrColor color, const SkMatrix& viewMatrix, const SkRect& devRect,
+                               float devXRadius, float devYRadius, SkVector devStrokeWidths,
+                               bool strokeOnly) {
+        SkASSERT(devXRadius > 0.5);
+        SkASSERT(devYRadius > 0.5);
+        SkASSERT((devStrokeWidths.fX > 0) == (devStrokeWidths.fY > 0));
+        SkASSERT(!(strokeOnly && devStrokeWidths.fX <= 0));
+        SkScalar innerXRadius = 0.0f;
+        SkScalar innerYRadius = 0.0f;
+        SkRect bounds = devRect;
+        bool stroked = false;
+        if (devStrokeWidths.fX > 0) {
+            if (SkScalarNearlyZero(devStrokeWidths.length())) {
+                devStrokeWidths.set(SK_ScalarHalf, SK_ScalarHalf);
+            } else {
+                devStrokeWidths.scale(SK_ScalarHalf);
+            }
 
-    RRectEllipseRendererBatch(const Geometry& geometry, const SkMatrix& viewMatrix, bool stroked)
-        : INHERITED(ClassID())
-        , fStroked(stroked)
-        , fViewMatrixIfUsingLocalCoords(viewMatrix) {
-        fGeoData.push_back(geometry);
-        this->setBounds(geometry.fDevBounds);
+            // we only handle thick strokes for near-circular ellipses
+            if (devStrokeWidths.length() > SK_ScalarHalf &&
+                (SK_ScalarHalf*devXRadius > devYRadius || SK_ScalarHalf*devYRadius > devXRadius)) {
+                return nullptr;
+            }
+
+            // we don't handle it if curvature of the stroke is less than curvature of the ellipse
+            if (devStrokeWidths.fX*(devYRadius*devYRadius) <
+                (devStrokeWidths.fY*devStrokeWidths.fY)*devXRadius) {
+                return nullptr;
+            }
+            if (devStrokeWidths.fY*(devXRadius*devXRadius) <
+                (devStrokeWidths.fX*devStrokeWidths.fX)*devYRadius) {
+                return nullptr;
+            }
+
+            // this is legit only if scale & translation (which should be the case at the moment)
+            if (strokeOnly) {
+                innerXRadius = devXRadius - devStrokeWidths.fX;
+                innerYRadius = devYRadius - devStrokeWidths.fY;
+                stroked = (innerXRadius >= 0 && innerYRadius >= 0);
+            }
+
+            devXRadius += devStrokeWidths.fX;
+            devYRadius += devStrokeWidths.fY;
+            bounds.outset(devStrokeWidths.fX, devStrokeWidths.fY);
+        }
+
+        // Expand the rect so all the pixels will be captured.
+        bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
+
+        RRectEllipseRendererBatch* batch = new RRectEllipseRendererBatch();
+        batch->fStroked = stroked;
+        batch->fViewMatrixIfUsingLocalCoords = viewMatrix;
+        batch->fGeoData.emplace_back(
+            Geometry {color, devXRadius, devYRadius, innerXRadius, innerYRadius, bounds});
+        batch->setBounds(bounds);
+        return batch;
     }
 
     const char* name() const override { return "RRectEllipseRendererBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
     }
 
 private:
+    RRectEllipseRendererBatch() : INHERITED(ClassID()) {}
+
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle overrides that affect our GP.
         overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
         if (!overrides.readsLocalCoords()) {
             fViewMatrixIfUsingLocalCoords.reset();
         }
     }
 
     void onPrepareDraws(Target* target) const override {
         SkMatrix localMatrix;
@@ skipping 99 matching lines @@
 
         if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
+    struct Geometry {
+        GrColor fColor;
+        SkScalar fXRadius;
+        SkScalar fYRadius;
+        SkScalar fInnerXRadius;
+        SkScalar fInnerYRadius;
+        SkRect fDevBounds;
+    };
+
     bool                            fStroked;
     SkMatrix                        fViewMatrixIfUsingLocalCoords;
     SkSTArray<1, Geometry, true>    fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
 static GrDrawBatch* create_rrect_batch(GrColor color,
                                        const SkMatrix& viewMatrix,
                                        const SkRRect& rrect,
                                        const SkStrokeRec& stroke) {
     SkASSERT(viewMatrix.rectStaysRect());
     SkASSERT(rrect.isSimple());
     SkASSERT(!rrect.isOval());
 
     // RRect batchs only handle simple, but not too simple, rrects
     // do any matrix crunching before we reset the draw state for device coords
     const SkRect& rrectBounds = rrect.getBounds();
     SkRect bounds;
     viewMatrix.mapRect(&bounds, rrectBounds);
 
     SkVector radii = rrect.getSimpleRadii();
     SkScalar xRadius = SkScalarAbs(viewMatrix[SkMatrix::kMScaleX]*radii.fX +
                                    viewMatrix[SkMatrix::kMSkewY]*radii.fY);
     SkScalar yRadius = SkScalarAbs(viewMatrix[SkMatrix::kMSkewX]*radii.fX +
                                    viewMatrix[SkMatrix::kMScaleY]*radii.fY);
 
     SkStrokeRec::Style style = stroke.getStyle();
 
-    // do (potentially) anisotropic mapping of stroke
-    SkVector scaledStroke;
+    // Do (potentially) anisotropic mapping of stroke. Use -1s to indicate fill-only draws.
+    SkVector scaledStroke = {-1, -1};
     SkScalar strokeWidth = stroke.getWidth();
 
     bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
                         SkStrokeRec::kHairline_Style == style;
     bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
 
     if (hasStroke) {
         if (SkStrokeRec::kHairline_Style == style) {
             scaledStroke.set(1, 1);
         } else {
@@ skipping 13 matching lines @@
     // the interior of the rrect if the radii are >= 0.5. Otherwise, the inner rect of the nine-
     // patch will have fractional coverage. This only matters when the interior is actually filled.
     // We could consider falling back to rect rendering here, since a tiny radius is
     // indistinguishable from a square corner.
     if (!isStrokeOnly && (SK_ScalarHalf > xRadius || SK_ScalarHalf > yRadius)) {
         return nullptr;
     }
 
     // if the corners are circles, use the circle renderer
     if ((!hasStroke || scaledStroke.fX == scaledStroke.fY) && xRadius == yRadius) {
-        SkScalar innerRadius = 0.0f;
-        SkScalar outerRadius = xRadius;
-        SkScalar halfWidth = 0;
-        if (hasStroke) {
-            if (SkScalarNearlyZero(scaledStroke.fX)) {
-                halfWidth = SK_ScalarHalf;
-            } else {
-                halfWidth = SkScalarHalf(scaledStroke.fX);
-            }
-
-            if (isStrokeOnly) {
-                innerRadius = xRadius - halfWidth;
-            }
-            outerRadius += halfWidth;
-            bounds.outset(halfWidth, halfWidth);
-        }
-
-        isStrokeOnly = (isStrokeOnly && innerRadius >= 0);
-
-        // The radii are outset for two reasons. First, it allows the shader to simply perform
-        // simpler computation because the computed alpha is zero, rather than 50%, at the radius.
-        // Second, the outer radius is used to compute the verts of the bounding box that is
-        // rendered and the outset ensures the box will cover all partially covered by the rrect
-        // corners.
-        outerRadius += SK_ScalarHalf;
-        innerRadius -= SK_ScalarHalf;
-
-        // Expand the rect so all the pixels will be captured.
-        bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
-
-        RRectCircleRendererBatch::Geometry geometry;
-        geometry.fColor = color;
-        geometry.fInnerRadius = innerRadius;
-        geometry.fOuterRadius = outerRadius;
-        geometry.fDevBounds = bounds;
-
-        return new RRectCircleRendererBatch(geometry, viewMatrix, isStrokeOnly);
+        return new RRectCircleRendererBatch(color, viewMatrix, bounds, xRadius, scaledStroke.fX,
+                                            isStrokeOnly);
     // otherwise we use the ellipse renderer
     } else {
-        SkScalar innerXRadius = 0.0f;
-        SkScalar innerYRadius = 0.0f;
-        if (hasStroke) {
-            if (SkScalarNearlyZero(scaledStroke.length())) {
-                scaledStroke.set(SK_ScalarHalf, SK_ScalarHalf);
-            } else {
-                scaledStroke.scale(SK_ScalarHalf);
-            }
+        return RRectEllipseRendererBatch::Create(color, viewMatrix, bounds, xRadius, yRadius,
+                                                 scaledStroke, isStrokeOnly);
 
-            // we only handle thick strokes for near-circular ellipses
-            if (scaledStroke.length() > SK_ScalarHalf &&
-                (SK_ScalarHalf*xRadius > yRadius || SK_ScalarHalf*yRadius > xRadius)) {
-                return nullptr;
-            }
-
-            // we don't handle it if curvature of the stroke is less than curvature of the ellipse
-            if (scaledStroke.fX*(yRadius*yRadius) < (scaledStroke.fY*scaledStroke.fY)*xRadius ||
-                scaledStroke.fY*(xRadius*xRadius) < (scaledStroke.fX*scaledStroke.fX)*yRadius) {
-                return nullptr;
-            }
-
-            // this is legit only if scale & translation (which should be the case at the moment)
-            if (isStrokeOnly) {
-                innerXRadius = xRadius - scaledStroke.fX;
-                innerYRadius = yRadius - scaledStroke.fY;
-            }
-
-            xRadius += scaledStroke.fX;
-            yRadius += scaledStroke.fY;
-            bounds.outset(scaledStroke.fX, scaledStroke.fY);
-        }
-
-        isStrokeOnly = (isStrokeOnly && innerXRadius >= 0 && innerYRadius >= 0);
-
-        // Expand the rect so all the pixels will be captured.
-        bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
-
-        RRectEllipseRendererBatch::Geometry geometry;
-        geometry.fColor = color;
-        geometry.fXRadius = xRadius;
-        geometry.fYRadius = yRadius;
-        geometry.fInnerXRadius = innerXRadius;
-        geometry.fInnerYRadius = innerYRadius;
-        geometry.fDevBounds = bounds;
-
-        return new RRectEllipseRendererBatch(geometry, viewMatrix, isStrokeOnly);
     }
 }
 
 GrDrawBatch* GrOvalRenderer::CreateRRectBatch(GrColor color,
                                               const SkMatrix& viewMatrix,
                                               const SkRRect& rrect,
                                               const SkStrokeRec& stroke,
                                               GrShaderCaps* shaderCaps) {
     if (rrect.isOval()) {
         return CreateOvalBatch(color, viewMatrix, rrect.getBounds(), stroke, shaderCaps);
     }
 
     if (!viewMatrix.rectStaysRect() || !rrect.isSimple()) {
         return nullptr;
     }
 
     return create_rrect_batch(color, viewMatrix, rrect, stroke);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+GrDrawBatch* GrOvalRenderer::CreateOvalBatch(GrColor color,
+                                             const SkMatrix& viewMatrix,
+                                             const SkRect& oval,
+                                             const SkStrokeRec& stroke,
+                                             GrShaderCaps* shaderCaps) {
+    // we can draw circles
+    if (SkScalarNearlyEqual(oval.width(), oval.height()) && circle_stays_circle(viewMatrix)) {
+        return new CircleBatch(color, viewMatrix, oval, stroke);
+    }
+
+    // if we have shader derivative support, render as device-independent
+    if (shaderCaps->shaderDerivativeSupport()) {
+        return DIEllipseBatch::Create(color, viewMatrix, oval, stroke);
+    }
+
+    // otherwise axis-aligned ellipses only
+    if (viewMatrix.rectStaysRect()) {
+        return EllipseBatch::Create(color, viewMatrix, oval, stroke);
+    }
+
+    return nullptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 DRAW_BATCH_TEST_DEFINE(CircleBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
     SkRect circle = GrTest::TestSquare(random);
-    return create_circle_batch(color, viewMatrix, circle, GrTest::TestStrokeRec(random));
+    return new CircleBatch(color, viewMatrix, circle, GrTest::TestStrokeRec(random));
 }
 
 DRAW_BATCH_TEST_DEFINE(EllipseBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
     GrColor color = GrRandomColor(random);
     SkRect ellipse = GrTest::TestSquare(random);
-    return create_ellipse_batch(color, viewMatrix, ellipse, GrTest::TestStrokeRec(random));
+    return EllipseBatch::Create(color, viewMatrix, ellipse, GrTest::TestStrokeRec(random));
 }
 
 DRAW_BATCH_TEST_DEFINE(DIEllipseBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
     SkRect ellipse = GrTest::TestSquare(random);
-    return create_diellipse_batch(color, viewMatrix, ellipse, GrTest::TestStrokeRec(random));
+    return DIEllipseBatch::Create(color, viewMatrix, ellipse, GrTest::TestStrokeRec(random));
 }
 
 DRAW_BATCH_TEST_DEFINE(RRectBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
     GrColor color = GrRandomColor(random);
     const SkRRect& rrect = GrTest::TestRRectSimple(random);
     return create_rrect_batch(color, viewMatrix, rrect, GrTest::TestStrokeRec(random));
 }
 
 #endif