serious SkEdgeBuilder refactoring

This splits the three logical types of SkEdgeBuilders
into distinct C++ types, with some shared logic.

Looks like this cuts another 10K off Flutter,
including that 8K table.

Change-Id: I0c901de8b0bb70b9a9dce07683110177a287b0ee
Reviewed-on: https://skia-review.googlesource.com/c/164626
Commit-Queue: Mike Reed <reed@google.com>
Auto-Submit: Mike Klein <mtklein@google.com>
Reviewed-by: Mike Reed <reed@google.com>

src/core/SkEdgeBuilder.cpp

@@ -5,10 +5,9 @@
  * found in the LICENSE file.
  */
 
-#include "SkEdgeBuilder.h"
-
 #include "SkAnalyticEdge.h"
 #include "SkEdge.h"
+#include "SkEdgeBuilder.h"
 #include "SkEdgeClipper.h"
 #include "SkGeometry.h"
 #include "SkLineClipper.h"
@@ -17,15 +16,7 @@
 #include "SkSafeMath.h"
 #include "SkTo.h"
 
-///////////////////////////////////////////////////////////////////////////////
+SkEdgeBuilder::Combine SkBasicEdgeBuilder::combineVertical(const SkEdge* edge, SkEdge* last) {
-
-SkEdgeBuilder::SkEdgeBuilder(EdgeType type, int shiftEdgesUp)
-    : fEdgeList(nullptr)
-    , fEdgeType(type)
-    , fShiftUp(shiftEdgesUp)
-    , fIsFinite(true) {}
-
-SkEdgeBuilder::Combine SkEdgeBuilder::combineVertical(const SkEdge* edge, SkEdge* last) {
     if (last->fCurveCount || last->fDX || edge->fX != last->fX) {
         return kNo_Combine;
     }
@@ -66,13 +57,12 @@ SkEdgeBuilder::Combine SkEdgeBuilder::combineVertical(const SkEdge* edge, SkEdge
     return kNo_Combine;
 }
 
-static inline bool approximately_equal(SkFixed a, SkFixed b) {
+SkEdgeBuilder::Combine SkAnalyticEdgeBuilder::combineVertical(const SkAnalyticEdge* edge,
+                                                              SkAnalyticEdge* last) {
+    auto approximately_equal = [](SkFixed a, SkFixed b) {
         return SkAbs32(a - b) < 0x100;
-}
+    };
 
-SkEdgeBuilder::Combine SkEdgeBuilder::combineVertical(
-        const SkAnalyticEdge* edge, SkAnalyticEdge* last) {
-    SkASSERT(fEdgeType == kAnalyticEdge);
     if (last->fCurveCount || last->fDX || edge->fX != last->fX) {
         return kNo_Combine;
     }
@@ -117,180 +107,152 @@ SkEdgeBuilder::Combine SkEdgeBuilder::combineVertical(
     return kNo_Combine;
 }
 
-bool SkEdgeBuilder::verticalLine(const SkEdge* edge) {
+template <typename Edge>
-    return !edge->fDX && !edge->fCurveCount;
+static bool is_vertical(const Edge* edge) {
+    return edge->fDX         == 0
+        && edge->fCurveCount == 0;
 }
 
-bool SkEdgeBuilder::verticalLine(const SkAnalyticEdge* edge) {
+// TODO: we can deallocate the edge if edge->setFoo() fails
-    SkASSERT(fEdgeType == kAnalyticEdge);
+// or when we don't use it (kPartial_Combine or kTotal_Combine).
-    return !edge->fDX && !edge->fCurveCount;
-}
 
-void SkEdgeBuilder::addLine(const SkPoint pts[]) {
+void SkBasicEdgeBuilder::addLine(const SkPoint pts[]) {
-    if (fEdgeType == kBezier) {
+    SkEdge* edge = fAlloc.make<SkEdge>();
+    if (edge->setLine(pts[0], pts[1], fClipShift)) {
+        Combine combine = is_vertical(edge) && !fList.empty()
+            ? this->combineVertical(edge, (SkEdge*)fList.top())
+            : kNo_Combine;
+
+        switch (combine) {
+            case kTotal_Combine:    fList.pop();           break;
+            case kPartial_Combine:                         break;
+            case kNo_Combine:       fList.push_back(edge); break;
+        }
+    }
+}
+void SkAnalyticEdgeBuilder::addLine(const SkPoint pts[]) {
+    SkAnalyticEdge* edge = fAlloc.make<SkAnalyticEdge>();
+    if (edge->setLine(pts[0], pts[1])) {
+
+        Combine combine = is_vertical(edge) && !fList.empty()
+            ? this->combineVertical(edge, (SkAnalyticEdge*)fList.top())
+            : kNo_Combine;
+
+        switch (combine) {
+            case kTotal_Combine:    fList.pop();           break;
+            case kPartial_Combine:                         break;
+            case kNo_Combine:       fList.push_back(edge); break;
+        }
+    }
+}
+void SkBezierEdgeBuilder::addLine(const SkPoint pts[]) {
     SkLine* line = fAlloc.make<SkLine>();
     if (line->set(pts)) {
         fList.push_back(line);
     }
-    } else if (fEdgeType == kAnalyticEdge) {
-        SkAnalyticEdge* edge = fAlloc.make<SkAnalyticEdge>();
-        if (edge->setLine(pts[0], pts[1])) {
-            if (this->verticalLine(edge) && fList.count()) {
-                Combine combine = this->combineVertical(edge, (SkAnalyticEdge*)*(fList.end() - 1));
-                if (kNo_Combine != combine) {
-                    if (kTotal_Combine == combine) {
-                        fList.pop();
-                    }
-                    goto unallocate_analytic_edge;
-                }
-            }
-            fList.push_back(edge);
-        } else {
-unallocate_analytic_edge:
-            ;
-            // TODO: unallocate edge from storage...
-        }
-    } else {
-        SkEdge* edge = fAlloc.make<SkEdge>();
-        if (edge->setLine(pts[0], pts[1], fShiftUp)) {
-            if (this->verticalLine(edge) && fList.count()) {
-                Combine combine = this->combineVertical(edge, (SkEdge*)*(fList.end() - 1));
-                if (kNo_Combine != combine) {
-                    if (kTotal_Combine == combine) {
-                        fList.pop();
-                    }
-                    goto unallocate_edge;
-                }
-            }
-            fList.push_back(edge);
-        } else {
-unallocate_edge:
-            ;
-            // TODO: unallocate edge from storage...
-        }
-    }
-}
-void SkEdgeBuilder::addPolyLine(SkPoint pts[],
-                                char* &edge,
-                                size_t edgeSize,
-                                char** &edgePtr) {
-    if (fEdgeType == kBezier) {
-        if (((SkLine*)edge)->set(pts)) {
-            *edgePtr++ = edge;
-            edge += edgeSize;
-        }
-        return;
-    }
-    bool analyticAA = fEdgeType == kAnalyticEdge;
-    bool setLineResult = analyticAA ?
-            ((SkAnalyticEdge*)edge)->setLine(pts[0], pts[1]) :
-            ((SkEdge*)edge)->setLine(pts[0], pts[1], fShiftUp);
-    if (setLineResult) {
-        Combine combine = analyticAA ?
-                checkVertical((SkAnalyticEdge*)edge, (SkAnalyticEdge**)edgePtr) :
-                checkVertical((SkEdge*)edge, (SkEdge**)edgePtr);
-        if (kNo_Combine == combine) {
-            *edgePtr++ = edge;
-            edge += edgeSize;
-        } else if (kTotal_Combine == combine) {
-            --edgePtr;
-        }
-    }
 }
 
-void SkEdgeBuilder::addQuad(const SkPoint pts[]) {
+void SkBasicEdgeBuilder::addQuad(const SkPoint pts[]) {
-    if (fEdgeType == kBezier) {
+    SkQuadraticEdge* edge = fAlloc.make<SkQuadraticEdge>();
+    if (edge->setQuadratic(pts, fClipShift)) {
+        fList.push_back(edge);
+    }
+}
+void SkAnalyticEdgeBuilder::addQuad(const SkPoint pts[]) {
+    SkAnalyticQuadraticEdge* edge = fAlloc.make<SkAnalyticQuadraticEdge>();
+    if (edge->setQuadratic(pts)) {
+        fList.push_back(edge);
+    }
+}
+void SkBezierEdgeBuilder::addQuad(const SkPoint pts[]) {
     SkQuad* quad = fAlloc.make<SkQuad>();
     if (quad->set(pts)) {
         fList.push_back(quad);
     }
-    } else if (fEdgeType == kAnalyticEdge) {
-        SkAnalyticQuadraticEdge* edge = fAlloc.make<SkAnalyticQuadraticEdge>();
-        if (edge->setQuadratic(pts)) {
-            fList.push_back(edge);
-        } else {
-            // TODO: unallocate edge from storage...
-        }
-    } else {
-        SkQuadraticEdge* edge = fAlloc.make<SkQuadraticEdge>();
-        if (edge->setQuadratic(pts, fShiftUp)) {
-            fList.push_back(edge);
-        } else {
-            // TODO: unallocate edge from storage...
-        }
-    }
 }
 
-void SkEdgeBuilder::addCubic(const SkPoint pts[]) {
+void SkBasicEdgeBuilder::addCubic(const SkPoint pts[]) {
-    if (fEdgeType == kBezier) {
+    SkCubicEdge* edge = fAlloc.make<SkCubicEdge>();
+    if (edge->setCubic(pts, fClipShift)) {
+        fList.push_back(edge);
+    }
+}
+void SkAnalyticEdgeBuilder::addCubic(const SkPoint pts[]) {
+    SkAnalyticCubicEdge* edge = fAlloc.make<SkAnalyticCubicEdge>();
+    if (edge->setCubic(pts)) {
+        fList.push_back(edge);
+    }
+}
+void SkBezierEdgeBuilder::addCubic(const SkPoint pts[]) {
     SkCubic* cubic = fAlloc.make<SkCubic>();
     if (cubic->set(pts)) {
         fList.push_back(cubic);
     }
-    } else if (fEdgeType == kAnalyticEdge) {
-        SkAnalyticCubicEdge* edge = fAlloc.make<SkAnalyticCubicEdge>();
-        if (edge->setCubic(pts)) {
-            fList.push_back(edge);
-        } else {
-            // TODO: unallocate edge from storage...
-        }
-    } else {
-        SkCubicEdge* edge = fAlloc.make<SkCubicEdge>();
-        if (edge->setCubic(pts, fShiftUp)) {
-            fList.push_back(edge);
-        } else {
-            // TODO: unallocate edge from storage...
-        }
-    }
 }
 
-void SkEdgeBuilder::addClipper(SkEdgeClipper* clipper) {
+// TODO: merge addLine() and addPolyLine()?
-    SkPoint      pts[4];
-    SkPath::Verb verb;
 
-    while ((verb = clipper->next(pts)) != SkPath::kDone_Verb) {
+SkEdgeBuilder::Combine SkBasicEdgeBuilder::addPolyLine(SkPoint pts[],
-        const int count = SkPathPriv::PtsInIter(verb);
+                                                       char* arg_edge, char** arg_edgePtr) {
-        if (!SkScalarsAreFinite(&pts[0].fX, count*2)) {
+    auto edge    = (SkEdge*) arg_edge;
-            fIsFinite = false;
+    auto edgePtr = (SkEdge**)arg_edgePtr;
-            return;
+
+    if (edge->setLine(pts[0], pts[1], fClipShift)) {
+        return is_vertical(edge) && edgePtr > (SkEdge**)fEdgeList
+            ? this->combineVertical(edge, edgePtr[-1])
+            : kNo_Combine;
     }
-        switch (verb) {
+    return SkEdgeBuilder::kPartial_Combine;  // A convenient lie.  Same do-nothing behavior.
-            case SkPath::kLine_Verb:
+}
-                this->addLine(pts);
+SkEdgeBuilder::Combine SkAnalyticEdgeBuilder::addPolyLine(SkPoint pts[],
-                break;
+                                                          char* arg_edge, char** arg_edgePtr) {
-            case SkPath::kQuad_Verb:
+    auto edge    = (SkAnalyticEdge*) arg_edge;
-                this->addQuad(pts);
+    auto edgePtr = (SkAnalyticEdge**)arg_edgePtr;
-                break;
+
-            case SkPath::kCubic_Verb:
+    if (edge->setLine(pts[0], pts[1])) {
-                this->addCubic(pts);
+        return is_vertical(edge) && edgePtr > (SkAnalyticEdge**)fEdgeList
-                break;
+            ? this->combineVertical(edge, edgePtr[-1])
-            default:
+            : kNo_Combine;
-                break;
     }
+    return SkEdgeBuilder::kPartial_Combine;  // As above.
+}
+SkEdgeBuilder::Combine SkBezierEdgeBuilder::addPolyLine(SkPoint pts[],
+                                                        char* arg_edge, char** arg_edgePtr) {
+    auto edge = (SkLine*)arg_edge;
+
+    if (edge->set(pts)) {
+        return kNo_Combine;
     }
+    return SkEdgeBuilder::kPartial_Combine;  // As above.
 }
 
-///////////////////////////////////////////////////////////////////////////////
+SkRect SkBasicEdgeBuilder::recoverClip(const SkIRect& src) const {
-
+    return { SkIntToScalar(src.fLeft   >> fClipShift),
-static void set_shifted_clip(SkRect* dst, const SkIRect& src, int shift) {
+             SkIntToScalar(src.fTop    >> fClipShift),
-    dst->set(SkIntToScalar(src.fLeft >> shift),
+             SkIntToScalar(src.fRight  >> fClipShift),
-             SkIntToScalar(src.fTop >> shift),
+             SkIntToScalar(src.fBottom >> fClipShift), };
-             SkIntToScalar(src.fRight >> shift),
+}
-             SkIntToScalar(src.fBottom >> shift));
+SkRect SkAnalyticEdgeBuilder::recoverClip(const SkIRect& src) const {
+    return SkRect::Make(src);
+}
+SkRect SkBezierEdgeBuilder::recoverClip(const SkIRect& src) const {
+    return SkRect::Make(src);
 }
 
-SkEdgeBuilder::Combine SkEdgeBuilder::checkVertical(const SkEdge* edge, SkEdge** edgePtr) {
+char* SkBasicEdgeBuilder::allocEdges(size_t n, size_t* size) {
-    return !this->verticalLine(edge) || edgePtr <= (SkEdge**)fEdgeList ? kNo_Combine :
+    *size = sizeof(SkEdge);
-            this->combineVertical(edge, edgePtr[-1]);
+    return (char*)fAlloc.makeArrayDefault<SkEdge>(n);
-}
+}
-
+char* SkAnalyticEdgeBuilder::allocEdges(size_t n, size_t* size) {
-SkEdgeBuilder::Combine SkEdgeBuilder::checkVertical(const SkAnalyticEdge* edge,
+    *size = sizeof(SkAnalyticEdge);
-        SkAnalyticEdge** edgePtr) {
+    return (char*)fAlloc.makeArrayDefault<SkAnalyticEdge>(n);
-    SkASSERT(fEdgeType == kAnalyticEdge);
+}
-    return !this->verticalLine(edge) || edgePtr <= (SkAnalyticEdge**)fEdgeList ? kNo_Combine :
+char* SkBezierEdgeBuilder::allocEdges(size_t n, size_t* size) {
-            this->combineVertical(edge, edgePtr[-1]);
+    *size = sizeof(SkLine);
+    return (char*)fAlloc.makeArrayDefault<SkLine>(n);
 }
 
+// TODO: maybe get rid of buildPoly() entirely?
 int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip, bool canCullToTheRight) {
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
@@ -309,29 +271,14 @@ int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip, bool canC
     }
 
     size_t edgeSize;
-    char* edge;
+    char* edge = this->allocEdges(maxEdgeCount, &edgeSize);
-    switch (fEdgeType) {
-        case kEdge:
-            edgeSize = sizeof(SkEdge);
-            edge = (char*)fAlloc.makeArrayDefault<SkEdge>(maxEdgeCount);
-            break;
-        case kAnalyticEdge:
-            edgeSize = sizeof(SkAnalyticEdge);
-            edge = (char*)fAlloc.makeArrayDefault<SkAnalyticEdge>(maxEdgeCount);
-            break;
-        case kBezier:
-            edgeSize = sizeof(SkLine);
-            edge = (char*)fAlloc.makeArrayDefault<SkLine>(maxEdgeCount);
-            break;
-    }
 
     SkDEBUGCODE(char* edgeStart = edge);
     char** edgePtr = fAlloc.makeArrayDefault<char*>(maxEdgeCount);
     fEdgeList = (void**)edgePtr;
 
     if (iclip) {
-        SkRect clip;
+        SkRect clip = this->recoverClip(*iclip);
-        set_shifted_clip(&clip, *iclip, fShiftUp);
 
         while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
             switch (verb) {
@@ -345,7 +292,12 @@ int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip, bool canC
                     int lineCount = SkLineClipper::ClipLine(pts, clip, lines, canCullToTheRight);
                     SkASSERT(lineCount <= SkLineClipper::kMaxClippedLineSegments);
                     for (int i = 0; i < lineCount; i++) {
-                        this->addPolyLine(lines + i, edge, edgeSize, edgePtr);
+                        switch( this->addPolyLine(lines + i, edge, edgePtr) ) {
+                            case kTotal_Combine:   edgePtr--; break;
+                            case kPartial_Combine:            break;
+                            case kNo_Combine: *edgePtr++ = edge;
+                                               edge += edgeSize;
+                        }
                     }
                     break;
                 }
@@ -363,7 +315,12 @@ int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip, bool canC
                     // the corresponding line/quad/cubic verbs
                     break;
                 case SkPath::kLine_Verb: {
-                    this->addPolyLine(pts, edge, edgeSize, edgePtr);
+                    switch( this->addPolyLine(pts, edge, edgePtr) ) {
+                        case kTotal_Combine:   edgePtr--; break;
+                        case kPartial_Combine:            break;
+                        case kNo_Combine: *edgePtr++ = edge;
+                                           edge += edgeSize;
+                    }
                     break;
                 }
                 default:
@@ -374,17 +331,10 @@ int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip, bool canC
     }
     SkASSERT((size_t)(edge - edgeStart) <= maxEdgeCount * edgeSize);
     SkASSERT((size_t)(edgePtr - (char**)fEdgeList) <= maxEdgeCount);
-    return fIsFinite ? SkToInt(edgePtr - (char**)fEdgeList) : 0;
+    return SkToInt(edgePtr - (char**)fEdgeList);
 }
 
 int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, bool canCullToTheRight) {
-    fAlloc.reset();
-    fList.reset();
-
-    if (SkPath::kLine_SegmentMask == path.getSegmentMasks()) {
-        return this->buildPoly(path, iclip, canCullToTheRight);
-    }
-
     SkAutoConicToQuads quadder;
     const SkScalar conicTol = SK_Scalar1 / 4;
 
@@ -392,11 +342,31 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, bool canCullT
     SkPoint         pts[4];
     SkPath::Verb    verb;
 
+    bool is_finite = true;
+
     if (iclip) {
-        SkRect clip;
+        SkRect clip = this->recoverClip(*iclip);
-        set_shifted_clip(&clip, *iclip, fShiftUp);
         SkEdgeClipper clipper(canCullToTheRight);
 
+        auto apply_clipper = [this, &clipper, &is_finite] {
+            SkPoint      pts[4];
+            SkPath::Verb verb;
+
+            while ((verb = clipper.next(pts)) != SkPath::kDone_Verb) {
+                const int count = SkPathPriv::PtsInIter(verb);
+                if (!SkScalarsAreFinite(&pts[0].fX, count*2)) {
+                    is_finite = false;
+                    return;
+                }
+                switch (verb) {
+                    case SkPath::kLine_Verb:  this->addLine (pts); break;
+                    case SkPath::kQuad_Verb:  this->addQuad (pts); break;
+                    case SkPath::kCubic_Verb: this->addCubic(pts); break;
+                    default: break;
+                }
+            }
+        };
+
         while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
             switch (verb) {
                 case SkPath::kMove_Verb:
@@ -406,12 +376,12 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, bool canCullT
                     break;
                 case SkPath::kLine_Verb:
                     if (clipper.clipLine(pts[0], pts[1], clip)) {
-                        this->addClipper(&clipper);
+                        apply_clipper();
                     }
                     break;
                 case SkPath::kQuad_Verb:
                     if (clipper.clipQuad(pts, clip)) {
-                        this->addClipper(&clipper);
+                        apply_clipper();
                     }
                     break;
                 case SkPath::kConic_Verb: {
@@ -419,14 +389,14 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, bool canCullT
                                           pts, iter.conicWeight(), conicTol);
                     for (int i = 0; i < quadder.countQuads(); ++i) {
                         if (clipper.clipQuad(quadPts, clip)) {
-                            this->addClipper(&clipper);
+                            apply_clipper();
                         }
                         quadPts += 2;
                     }
                 } break;
                 case SkPath::kCubic_Verb:
                     if (clipper.clipCubic(pts, clip)) {
-                        this->addClipper(&clipper);
+                        apply_clipper();
                     }
                     break;
                 default:
@@ -466,7 +436,7 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, bool canCullT
                     }
                 } break;
                 case SkPath::kCubic_Verb: {
-                    if (fEdgeType == kBezier) {
+                    if (!this->chopCubics()) {
                         this->addCubic(pts);
                         break;
                     }
@@ -484,23 +454,28 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, bool canCullT
         }
     }
     fEdgeList = fList.begin();
-    return fIsFinite ? fList.count() : 0;
+    return is_finite ? fList.count() : 0;
 }
 
 int SkEdgeBuilder::buildEdges(const SkPath& path,
-                              const SkIRect* shiftedClip,
+                              const SkIRect* shiftedClip) {
-                              bool pathContainedInClip) {
+    // If we're convex, then we need both edges, even if the right edge is past the clip.
-    // If we're convex, then we need both edges, even the right edge is past the clip
     const bool canCullToTheRight = !path.isConvex();
 
-    const SkIRect* builderClip = pathContainedInClip ? nullptr : shiftedClip;
+    // We can use our buildPoly() optimization if all the segments are lines.
-    int count = this->build(path, builderClip, canCullToTheRight);
+    // (Edges are homogenous and stored contiguously in memory, no need for indirection.)
+    const int count = SkPath::kLine_SegmentMask == path.getSegmentMasks()
+        ? this->buildPoly(path, shiftedClip, canCullToTheRight)
+        : this->build    (path, shiftedClip, canCullToTheRight);
+
     SkASSERT(count >= 0);
 
-    // canCullToRight == false should imply count != 1 if fEdgeType != kBezier.
+    // If we can't cull to the right, we should have count > 1 (or 0),
-    // If fEdgeType == kBezier (DAA), we don't chop edges at y extrema so count == 1 is valid.
+    // unless we're in DAA which doesn't need to chop edges at y extrema.
     // For example, a single cubic edge with a valley shape \_/ is fine for DAA.
-    SkASSERT(fEdgeType == kBezier || canCullToTheRight || count != 1);
+    if (!canCullToTheRight && count == 1) {
+        SkASSERT(!this->chopCubics());
+    }
 
-    return fIsFinite ? count : 0;
+    return count;
 }

src/core/SkEdgeBuilder.h

@@ -7,80 +7,104 @@
 #ifndef SkEdgeBuilder_DEFINED
 #define SkEdgeBuilder_DEFINED
 
+#include "SkAnalyticEdge.h"
 #include "SkArenaAlloc.h"
+#include "SkEdge.h"
 #include "SkRect.h"
 #include "SkTDArray.h"
-#include "SkEdge.h"
-#include "SkAnalyticEdge.h"
 
-struct SkEdge;
-struct SkAnalyticEdge;
-class SkEdgeClipper;
 class SkPath;
 
 class SkEdgeBuilder {
 public:
-    enum EdgeType {
-        // Used in supersampling or non-AA scan coverter; it stores only integral y coordinates.
-        kEdge,
-
-        // Used in Analytic AA scan converter; it uses SkFixed to store fractional y.
-        kAnalyticEdge,
-
-        // Used in Delta AA scan converter; it's a super-light wrapper of SkPoint, which can then be
-        // used to construct SkAnalyticEdge (kAnalyticEdge) later. We use kBezier to save the memory
-        // allocation time (a SkBezier is much lighter than SkAnalyticEdge or SkEdge). Note that
-        // Delta AA only has to deal with one SkAnalyticEdge at a time (whereas Analytic AA has to
-        // deal with all SkAnalyticEdges at the same time). Thus for Delta AA, we only need to
-        // allocate memory for n SkBeziers and 1 SkAnalyticEdge. (Analytic AA need to allocate
-        // memory for n SkAnalyticEdges.)
-        kBezier
-    };
-
-    SkEdgeBuilder(EdgeType, int shiftEdgesUp);
-
     int buildEdges(const SkPath& path,
-                   const SkIRect* shiftedClip,
+                   const SkIRect* shiftedClip);
-                   bool pathContainedInClip);
 
-    SkEdge**                 edgeList() { return         (SkEdge**)fEdgeList; }
+protected:
-    SkAnalyticEdge** analyticEdgeList() { return (SkAnalyticEdge**)fEdgeList; }
+    SkEdgeBuilder() = default;
-    SkBezier**             bezierList() { return       (SkBezier**)fEdgeList; }
+    virtual ~SkEdgeBuilder() = default;
+
+    // In general mode we allocate pointers in fList and fEdgeList points to its head.
+    // In polygon mode we preallocated edges contiguously in fAlloc and fEdgeList points there.
+    void**              fEdgeList = nullptr;
+    SkTDArray<void*>    fList;
+    SkSTArenaAlloc<512> fAlloc;
 
-private:
     enum Combine {
         kNo_Combine,
         kPartial_Combine,
         kTotal_Combine
     };
 
+private:
     int build    (const SkPath& path, const SkIRect* clip, bool clipToTheRight);
     int buildPoly(const SkPath& path, const SkIRect* clip, bool clipToTheRight);
 
+    virtual char* allocEdges(size_t n, size_t* sizeof_edge) = 0;
+    virtual SkRect recoverClip(const SkIRect&) const = 0;
+    virtual bool chopCubics() const = 0;
+
+    virtual void addLine (const SkPoint pts[]) = 0;
+    virtual void addQuad (const SkPoint pts[]) = 0;
+    virtual void addCubic(const SkPoint pts[]) = 0;
+    virtual Combine addPolyLine(SkPoint pts[], char* edge, char** edgePtr) = 0;
+};
+
+class SkBasicEdgeBuilder final : public SkEdgeBuilder {
+public:
+    explicit SkBasicEdgeBuilder(int clipShift) : fClipShift(clipShift) {}
+
+    SkEdge** edgeList() { return (SkEdge**)fEdgeList; }
+
+private:
     Combine combineVertical(const SkEdge* edge, SkEdge* last);
-    Combine   checkVertical(const SkEdge* edge, SkEdge** edgePtr);
-    bool       verticalLine(const SkEdge* edge);
 
+    char* allocEdges(size_t, size_t*) override;
+    SkRect recoverClip(const SkIRect&) const override;
+    bool chopCubics() const override { return true; }
+
+    void addLine (const SkPoint pts[]) override;
+    void addQuad (const SkPoint pts[]) override;
+    void addCubic(const SkPoint pts[]) override;
+    Combine addPolyLine(SkPoint pts[], char* edge, char** edgePtr) override;
+
+    const int fClipShift;
+};
+
+class SkAnalyticEdgeBuilder final : public SkEdgeBuilder {
+public:
+    SkAnalyticEdgeBuilder() {}
+
+    SkAnalyticEdge** analyticEdgeList() { return (SkAnalyticEdge**)fEdgeList; }
+
+private:
     Combine combineVertical(const SkAnalyticEdge* edge, SkAnalyticEdge* last);
-    Combine   checkVertical(const SkAnalyticEdge* edge, SkAnalyticEdge** edgePtr);
-    bool       verticalLine(const SkAnalyticEdge* edge);
 
-    void addLine(const SkPoint pts[]);
+    char* allocEdges(size_t, size_t*) override;
-    void addQuad(const SkPoint pts[]);
+    SkRect recoverClip(const SkIRect&) const override;
-    void addCubic(const SkPoint pts[]);
+    bool chopCubics() const override { return true; }
-    void addClipper(SkEdgeClipper*);
-    void addPolyLine(SkPoint pts[], char* &edge, size_t edgeSize, char** &edgePtr);
 
+    void addLine (const SkPoint pts[]) override;
+    void addQuad (const SkPoint pts[]) override;
+    void addCubic(const SkPoint pts[]) override;
+    Combine addPolyLine(SkPoint pts[], char* edge, char** edgePtr) override;
+};
 
-    // In general mode we allocate pointers in fList and this points to its head.
+class SkBezierEdgeBuilder final : public SkEdgeBuilder {
-    // In polygon mode we preallocated pointers in fAlloc and this points there.
+public:
-    void**              fEdgeList;
+    SkBezierEdgeBuilder() {}
-    SkSTArenaAlloc<512> fAlloc;
-    SkTDArray<void*>    fList;
 
-    const EdgeType    fEdgeType;
+    SkBezier** bezierList() { return (SkBezier**)fEdgeList; }
-    const int         fShiftUp;
+
-    bool              fIsFinite;
+private:
+    char* allocEdges(size_t, size_t*) override;
+    SkRect recoverClip(const SkIRect&) const override;
+    bool chopCubics() const override { return false; }
+
+    void addLine (const SkPoint pts[]) override;
+    void addQuad (const SkPoint pts[]) override;
+    void addCubic(const SkPoint pts[]) override;
+    Combine addPolyLine(SkPoint pts[], char* edge, char** edgePtr) override;
 };
 
 #endif

src/core/SkScan_AAAPath.cpp

@@ -1594,8 +1594,8 @@ static SK_ALWAYS_INLINE void aaa_fill_path(const SkPath& path, const SkIRect& cl
         bool isUsingMask, bool forceRLE) { // forceRLE implies that SkAAClip is calling us
     SkASSERT(blitter);
 
-    SkEdgeBuilder builder(SkEdgeBuilder::kAnalyticEdge, 0);
+    SkAnalyticEdgeBuilder builder;
-    int count = builder.buildEdges(path, &clipRect, pathContainedInClip);
+    int count = builder.buildEdges(path, pathContainedInClip ? nullptr : &clipRect);
     SkAnalyticEdge** list = builder.analyticEdgeList();
 
     SkIRect rect = clipRect;

src/core/SkScan_DAAPath.cpp

@@ -160,10 +160,10 @@ template<class Deltas> static SK_ALWAYS_INLINE
 void gen_alpha_deltas(const SkPath& path, const SkIRect& clippedIR, const SkIRect& clipBounds,
         Deltas& result, SkBlitter* blitter, bool skipRect, bool pathContainedInClip) {
     // 1. Build edges
-    SkEdgeBuilder builder(SkEdgeBuilder::kBezier, 0);
+    SkBezierEdgeBuilder builder;
     // We have to use clipBounds instead of clippedIR to build edges because of "canCullToTheRight":
     // if the builder finds a right edge past the right clip, it won't build that right edge.
-    int  count = builder.buildEdges(path, &clipBounds, pathContainedInClip);
+    int  count = builder.buildEdges(path, pathContainedInClip ? nullptr : &clipBounds);
 
     if (count == 0) {
         return;

src/core/SkScan_Path.cpp

@@ -406,8 +406,8 @@ void sk_fill_path(const SkPath& path, const SkIRect& clipRect, SkBlitter* blitte
     shiftedClip.fTop = SkLeftShift(shiftedClip.fTop, shiftEdgesUp);
     shiftedClip.fBottom = SkLeftShift(shiftedClip.fBottom, shiftEdgesUp);
 
-    SkEdgeBuilder builder(SkEdgeBuilder::kEdge, shiftEdgesUp);
+    SkBasicEdgeBuilder builder(shiftEdgesUp);
-    int count = builder.buildEdges(path, &shiftedClip, pathContainedInClip);
+    int count = builder.buildEdges(path, pathContainedInClip ? nullptr : &shiftedClip);
     SkEdge** list = builder.edgeList();
 
     if (0 == count) {