remove point aliases

src/pathops/SkOpSegment.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpCoincidence.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 211 matching lines @@
 
 const SkOpPtT* SkOpSegment::existing(double t, const SkOpSegment* opp) const {
     const SkOpSpanBase* test = &fHead;
     const SkOpPtT* testPtT;
     SkPoint pt = this->ptAtT(t);
     do {
         testPtT = test->ptT();
         if (testPtT->fT == t) {
             break;
         }
-        if (!this->match(testPtT, this, t, pt, opp ? kAllowAliasMatch : kNoAliasMatch)) {
+        if (!this->match(testPtT, this, t, pt)) {
             if (t < testPtT->fT) {
                 return nullptr;
             }
             continue;
         }
         if (!opp) {
             return testPtT;
         }
         const SkOpPtT* loop = testPtT->next();
         while (loop != testPtT) {
             if (loop->segment() == this && loop->fT == t && loop->fPt == pt) {
                 goto foundMatch;
             }
             loop = loop->next();
         }
         return nullptr;
     } while ((test = test->upCast()->next()));
 foundMatch:
     return opp && !test->contains(opp) ? nullptr : testPtT;
 }
 
 // break the span so that the coincident part does not change the angle of the remainder
 bool SkOpSegment::addExpanded(double newT, const SkOpSpanBase* test, bool* startOver) {
     if (this->contains(newT)) {
         return true;
     }
-    SkOpPtT* newPtT = this->addT(newT, kAllowAliasMatch, startOver);
+    SkOpPtT* newPtT = this->addT(newT, startOver);
     if (!newPtT) {
         return false;
     }
     newPtT->fPt = this->ptAtT(newT);
     // const cast away to change linked list; pt/t values stays unchanged
     SkOpSpanBase* writableTest = const_cast<SkOpSpanBase*>(test);
     if (writableTest->ptT()->addOpp(newPtT)) {
         writableTest->checkForCollapsedCoincidence();
     }
     return true;
 }
 
 // Please keep this in sync with debugAddT()
-SkOpPtT* SkOpSegment::addT(double t, AliasMatch allowAlias, bool* allocated) {
+SkOpPtT* SkOpSegment::addT(double t, bool* allocated) {
     debugValidate();
     SkPoint pt = this->ptAtT(t);
     SkOpSpanBase* span = &fHead;
     do {
         SkOpPtT* result = span->ptT();
         SkOpPtT* loop;
         bool duplicatePt;
         if (t == result->fT) {
             goto bumpSpan;
         }
-        if (this->match(result, this, t, pt, allowAlias)) {
+        if (this->match(result, this, t, pt)) {
             // see if any existing alias matches segment, pt, and t
             loop = result->next();
             duplicatePt = false;
             while (loop != result) {
                 bool ptMatch = loop->fPt == pt;
                 if (loop->segment() == this && loop->fT == t && ptMatch) {
                     goto bumpSpan;
                 }
                 duplicatePt |= ptMatch;
                 loop = loop->next();
             }
-            if (kNoAliasMatch == allowAlias) {
     bumpSpan:
-                span->bumpSpanAdds();
-                return result;
-            }
-            SkOpPtT* alias = SkOpTAllocator<SkOpPtT>::Allocate(this->globalState()->allocator());
-            alias->init(result->span(), t, pt, duplicatePt);
-            result->insert(alias);
-            result->span()->unaligned();
-            this->debugValidate();
-#if DEBUG_ADD_T
-            SkDebugf("%s alias t=%1.9g segID=%d spanID=%d\n",  __FUNCTION__, t,
-                    alias->segment()->debugID(), alias->span()->debugID());
-#endif
             span->bumpSpanAdds();
-            if (allocated) {
-                *allocated = true;
-            }
-            return alias;
+            return result;
         }
         if (t < result->fT) {
             SkOpSpan* prev = result->span()->prev();
             if (!prev) {
                 return nullptr;
             }
             SkOpSpan* span = insert(prev);
             span->init(this, prev, t, pt);
             this->debugValidate();
 #if DEBUG_ADD_T
@@ skipping 719 matching lines @@
 #if DEBUG_MARK_DONE
     debugShowNewWinding(__FUNCTION__, span, winding, oppWinding);
 #endif
     span->setWindSum(winding);
     span->setOppSum(oppWinding);
     debugValidate();
     return true;
 }
 
 bool SkOpSegment::match(const SkOpPtT* base, const SkOpSegment* testParent, double testT,
-        const SkPoint& testPt, AliasMatch aliasMatch) const {
+        const SkPoint& testPt) const {
     SkASSERT(this == base->segment());
     if (this == testParent) {
         if (precisely_equal(base->fT, testT)) {
             return true;
         }
     }
     if (!SkDPoint::ApproximatelyEqual(testPt, base->fPt)) {
         return false;
     }
     return this != testParent || !this->ptsDisjoint(base->fT, base->fPt, testT, testPt);
@@ skipping 349 matching lines @@
                 distSqBest = distSq;
                 refBest = ref;
                 checkBest = check;
             }
         } while ((check = check->next()) != checkHead);
 nextRef:
         ;
    } while ((ref = ref->next()) != refHead);
 doneCheckingDistance:
     return checkBest && refBest->segment()->match(refBest, checkBest->segment(), checkBest->fT,
-            checkBest->fPt, kAllowAliasMatch);
+            checkBest->fPt);
 }
 
 // Please keep this function in sync with debugMoveNearby()
 // Move nearby t values and pts so they all hang off the same span. Alignment happens later.
 void SkOpSegment::moveNearby() {
     debugValidate();
     // release undeleted spans pointing to this seg that are linked to the primary span
     SkOpSpanBase* spanBase = &fHead;
     do {
         SkOpPtT* ptT = spanBase->ptT();
@@ skipping 371 matching lines @@
     int absOut = SkTAbs(outerWinding);
     int absIn = SkTAbs(innerWinding);
     bool result = absOut == absIn ? outerWinding < 0 : absOut < absIn;
     return result;
 }
 
 int SkOpSegment::windSum(const SkOpAngle* angle) const {
     const SkOpSpan* minSpan = angle->start()->starter(angle->end());
     return minSpan->windSum();
 }