Revert of faster edge re-sort, drop trailing edges

src/core/SkEdgeBuilder.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkEdgeBuilder.h"
 #include "SkPath.h"
 #include "SkEdge.h"
@@ skipping 61 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void setShiftedClip(SkRect* dst, const SkIRect& src, int shift) {
     dst->set(SkIntToScalar(src.fLeft >> shift),
              SkIntToScalar(src.fTop >> shift),
              SkIntToScalar(src.fRight >> shift),
              SkIntToScalar(src.fBottom >> shift));
 }
 
-int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip, int shiftUp,
-                             bool clipToTheRight) {
+int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip,
+                             int shiftUp) {
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
     SkPath::Verb    verb;
 
     int maxEdgeCount = path.countPoints();
     if (iclip) {
         // clipping can turn 1 line into (up to) kMaxClippedLineSegments, since
         // we turn portions that are clipped out on the left/right into vertical
         // segments.
         maxEdgeCount *= SkLineClipper::kMaxClippedLineSegments;
@@ skipping 14 matching lines @@
 
         while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
             switch (verb) {
                 case SkPath::kMove_Verb:
                 case SkPath::kClose_Verb:
                     // we ignore these, and just get the whole segment from
                     // the corresponding line/quad/cubic verbs
                     break;
                 case SkPath::kLine_Verb: {
                     SkPoint lines[SkLineClipper::kMaxPoints];
-                    int lineCount = SkLineClipper::ClipLine(pts, clip, lines, clipToTheRight);
+                    int lineCount = SkLineClipper::ClipLine(pts, clip, lines);
                     SkASSERT(lineCount <= SkLineClipper::kMaxClippedLineSegments);
                     for (int i = 0; i < lineCount; i++) {
                         if (edge->setLine(lines[i], lines[i + 1], shiftUp)) {
                             *edgePtr++ = edge++;
                         }
                     }
                     break;
                 }
                 default:
                     SkDEBUGFAIL("unexpected verb");
@@ skipping 25 matching lines @@
 }
 
 static void handle_quad(SkEdgeBuilder* builder, const SkPoint pts[3]) {
     SkPoint monoX[5];
     int n = SkChopQuadAtYExtrema(pts, monoX);
     for (int i = 0; i <= n; i++) {
         builder->addQuad(&monoX[i * 2]);
     }
 }
 
-int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, int shiftUp,
-                         bool clipToTheRight) {
+int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip,
+                         int shiftUp) {
     fAlloc.reset();
     fList.reset();
     fShiftUp = shiftUp;
 
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks()) {
-        return this->buildPoly(path, iclip, shiftUp, clipToTheRight);
+        return this->buildPoly(path, iclip, shiftUp);
     }
 
     SkAutoConicToQuads quadder;
     const SkScalar conicTol = SK_Scalar1 / 4;
 
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
     SkPath::Verb    verb;
 
     if (iclip) {
         SkRect clip;
         setShiftedClip(&clip, *iclip, shiftUp);
         SkEdgeClipper clipper;
 
         while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
             switch (verb) {
                 case SkPath::kMove_Verb:
                 case SkPath::kClose_Verb:
                     // we ignore these, and just get the whole segment from
                     // the corresponding line/quad/cubic verbs
                     break;
                 case SkPath::kLine_Verb: {
                     SkPoint lines[SkLineClipper::kMaxPoints];
-                    int lineCount = SkLineClipper::ClipLine(pts, clip, lines, clipToTheRight);
+                    int lineCount = SkLineClipper::ClipLine(pts, clip, lines);
                     for (int i = 0; i < lineCount; i++) {
                         this->addLine(&lines[i]);
                     }
                     break;
                 }
                 case SkPath::kQuad_Verb:
                     if (clipper.clipQuad(pts, clip)) {
                         this->addClipper(&clipper);
                     }
                     break;
@@ skipping 50 matching lines @@
                 }
                 default:
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
         }
     }
     fEdgeList = fList.begin();
     return fList.count();
 }