remove point aliases

src/pathops/SkOpSegment.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpSegment_DEFINE
 #define SkOpSegment_DEFINE
 
 #include "SkOpAngle.h"
 #include "SkOpSpan.h"
 #include "SkOpTAllocator.h"
 #include "SkPathOpsBounds.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsCurve.h"
 
 struct SkDCurve;
 class SkOpCoincidence;
 class SkOpContour;
 enum class SkOpRayDir;
 struct SkOpRayHit;
 class SkPathWriter;
 
 class SkOpSegment {
 public:
-    enum AliasMatch {
-        kNoAliasMatch,
-        kAllowAliasMatch,
-    };
-
     bool operator<(const SkOpSegment& rh) const {
         return fBounds.fTop < rh.fBounds.fTop;
     }
 
     SkOpAngle* activeAngle(SkOpSpanBase* start, SkOpSpanBase** startPtr, SkOpSpanBase** endPtr,
                             bool* done);
     SkOpAngle* activeAngleInner(SkOpSpanBase* start, SkOpSpanBase** startPtr,
                                        SkOpSpanBase** endPtr, bool* done);
     SkOpAngle* activeAngleOther(SkOpSpanBase* start, SkOpSpanBase** startPtr,
                                        SkOpSpanBase** endPtr, bool* done);
@@ skipping 49 matching lines @@
     }
 
     SkOpSegment* addQuad(SkPoint pts[3], SkOpContour* parent) {
         init(pts, 1, parent, SkPath::kQuad_Verb);
         SkDCurve curve;
         curve.fQuad.set(pts);
         curve.setQuadBounds(pts, 1, 0, 1, &fBounds);
         return this;
     }
 
-    SkOpPtT* addT(double t, AliasMatch, bool* allocated);
+    SkOpPtT* addT(double t, bool* allocated);
 
     template<typename T> T* allocateArray(int count) {
         return SkOpTAllocator<T>::AllocateArray(this->globalState()->allocator(), count);
     }
 
     const SkPathOpsBounds& bounds() const {
         return fBounds;
     }
 
     void bumpCount() {
@@ skipping 15 matching lines @@
 
     SkOpContour* contour() const {
         return fContour;
     }
 
     int count() const {
         return fCount;
     }
 
     void debugAddAngle(double startT, double endT);
-    const SkOpPtT* debugAddT(double t, AliasMatch , bool* allocated) const;
+    const SkOpPtT* debugAddT(double t, bool* allocated) const;
     const SkOpAngle* debugAngle(int id) const;
 #if DEBUG_ANGLE
     void debugCheckAngleCoin() const;
 #endif
 #if DEBUG_COINCIDENCE_VERBOSE
     void debugCheckHealth(const char* id, SkPathOpsDebug::GlitchLog* ) const;
     void debugClearAll(const char* id, SkPathOpsDebug::GlitchLog* glitches) const;
     void debugClearOne(const SkOpSpan* span, const char* id, SkPathOpsDebug::GlitchLog* glitches) const;
 #endif
     const SkOpCoincidence* debugCoincidence() const;
@@ skipping 125 matching lines @@
     bool markAndChaseWinding(SkOpSpanBase* start, SkOpSpanBase* end, int winding,
             SkOpSpanBase** lastPtr);
     bool markAndChaseWinding(SkOpSpanBase* start, SkOpSpanBase* end, int winding,
             int oppWinding, SkOpSpanBase** lastPtr);
     SkOpSpanBase* markAngle(int maxWinding, int sumWinding, const SkOpAngle* angle);
     SkOpSpanBase* markAngle(int maxWinding, int sumWinding, int oppMaxWinding, int oppSumWinding,
                          const SkOpAngle* angle);
     void markDone(SkOpSpan* );
     bool markWinding(SkOpSpan* , int winding);
     bool markWinding(SkOpSpan* , int winding, int oppWinding);
-    bool match(const SkOpPtT* span, const SkOpSegment* parent, double t, const SkPoint& pt,
-               AliasMatch ) const;
+    bool match(const SkOpPtT* span, const SkOpSegment* parent, double t, const SkPoint& pt) const;
     bool missingCoincidence();
     bool moveMultiples();
     void moveNearby();
 
     SkOpSegment* next() const {
         return fNext;
     }
 
     SkOpSegment* nextChase(SkOpSpanBase** , int* step, SkOpSpan** , SkOpSpanBase** last) const;
     bool operand() const;
@@ skipping 96 matching lines @@
     }
 
     SkOpSpanBase* tail() {
         return &fTail;
     }
 
     bool testForCoincidence(const SkOpPtT* priorPtT, const SkOpPtT* ptT, const SkOpSpanBase* prior,
             const SkOpSpanBase* spanBase, const SkOpSegment* opp) const;
 
     void undoneSpan(SkOpSpanBase** start, SkOpSpanBase** end);
-    bool uniqueT(double t, AliasMatch allowAlias) const;
     int updateOppWinding(const SkOpSpanBase* start, const SkOpSpanBase* end) const;
     int updateOppWinding(const SkOpAngle* angle) const;
     int updateOppWindingReverse(const SkOpAngle* angle) const;
     int updateWinding(SkOpSpanBase* start, SkOpSpanBase* end);
     int updateWinding(SkOpAngle* angle);
     int updateWindingReverse(const SkOpAngle* angle);
 
     static bool UseInnerWinding(int outerWinding, int innerWinding);
 
     SkPath::Verb verb() const {
@@ skipping 29 matching lines @@
     int fDoneCount;  // number of processed spans (zero initially)
     SkPath::Verb fVerb;
     bool fVisited;  // used by missing coincidence check
 #if DEBUG_COINCIDENCE
     mutable bool fDebugVisited;  // used by debug missing coincidence check
 #endif
     SkDEBUGCODE(int fID);
 };
 
 #endif