remove point aliases

src/pathops/SkOpCoincidence.cpp

 /*
  * Copyright 2015 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 "SkOpSegment.h"
 #include "SkPathOpsTSect.h"
 
@@ skipping 287 matching lines @@
         for (int index = 0; index < i.used(); ++index) {
             double t = i[0][index];
             if (!between(0, t, 1)) {
                 continue;
             }
             SkDPoint oppPt = i.pt(index);
             if (!oppPt.approximatelyEqual(pt)) {
                 continue;
             }
             SkOpSegment* writableSeg = const_cast<SkOpSegment*>(testSeg);
-            SkOpPtT* oppStart = writableSeg->addT(t, SkOpSegment::kAllowAliasMatch, nullptr);
+            SkOpPtT* oppStart = writableSeg->addT(t, nullptr);
             SkOpSpan* writableBase = const_cast<SkOpSpan*>(base);
             oppStart->span()->addOppAndMerge(writableBase);
             if (oppStart->deleted()) {
                 continue;
             }
             SkOpSegment* coinSeg = base->segment();
             SkOpSegment* oppSeg = oppStart->segment();
             double coinTs, coinTe, oppTs, oppTe;
             if (coinSeg < oppSeg) {
                 coinTs = base->t();
@@ skipping 365 matching lines @@
     if (osExisting && (osExisting == oe || osExisting->contains(oeExisting ? oeExisting : oe))) {
         return false;
     }
     if (oeExisting && (oeExisting == os || oeExisting->contains(osExisting ? osExisting : os))) {
         return false;
     }
     // extra line in debug code
     this->debugValidate();
     if (!cs || !os) {
         SkOpPtT* csWritable = cs ? const_cast<SkOpPtT*>(cs)
-            : coinSeg->addT(coinTs, SkOpSegment::kNoAliasMatch, nullptr);
+            : coinSeg->addT(coinTs, nullptr);
         SkOpPtT* osWritable = os ? const_cast<SkOpPtT*>(os)
-            : oppSeg->addT(oppTs, SkOpSegment::kNoAliasMatch, nullptr);
+            : oppSeg->addT(oppTs, nullptr);
         if (!csWritable || !osWritable) {
             return false;
         }
         csWritable->span()->addOppAndMerge(osWritable->span());
         cs = csWritable;
         os = osWritable;
         if ((ce && ce->deleted()) || (oe && oe->deleted())) {
             return false;
         }
     }
     if (!ce || !oe) {
         SkOpPtT* ceWritable = ce ? const_cast<SkOpPtT*>(ce)
-            : coinSeg->addT(coinTe, SkOpSegment::kNoAliasMatch, nullptr);
+            : coinSeg->addT(coinTe, nullptr);
         SkOpPtT* oeWritable = oe ? const_cast<SkOpPtT*>(oe)
-            : oppSeg->addT(oppTe, SkOpSegment::kNoAliasMatch, nullptr);
+            : oppSeg->addT(oppTe, nullptr);
         ceWritable->span()->addOppAndMerge(oeWritable->span());
         ce = ceWritable;
         oe = oeWritable;
     }
     this->debugValidate();
     if (cs->deleted() || os->deleted() || ce->deleted() || oe->deleted()) {
         return false;
     }
     if (cs->contains(ce) || os->contains(oe)) {
         return false;
@@ skipping 753 matching lines @@
             this->release(fHead, coin);
         }
     } while ((coin = coin->next()));
 }
 
 bool SkOpCoincidence::testForCoincidence(const SkCoincidentSpans* outer, const SkOpPtT* testS,
         const SkOpPtT* testE) const {
     return testS->segment()->testForCoincidence(testS, testE, testS->span(),
             testE->span(), outer->coinPtTStart()->segment());
 }