fuzz wednesday

src/pathops/SkOpCoincidence.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpCoincidence_DEFINED
 #define SkOpCoincidence_DEFINED
 
 #include "SkTDArray.h"
@@ skipping 31 matching lines @@
     void debugShow() const;
 #ifdef SK_DEBUG
     void debugStartCheck(const SkOpSpanBase* outer, const SkOpSpanBase* over,
             const SkOpGlobalState* debugState) const;
 #endif
     void dump() const;
     bool expand();
     bool extend(const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd,
                 const SkOpPtT* oppPtTStart, const SkOpPtT* oppPtTEnd);
     bool flipped() const { return fOppPtTStart->fT > fOppPtTEnd->fT; }
-    void init() { sk_bzero(this, sizeof(*this)); }
+    SkDEBUGCODE(SkOpGlobalState* globalState() { return fGlobalState; })
+
+    void init(SkDEBUGCODE(SkOpGlobalState* globalState)) {
+        sk_bzero(this, sizeof(*this)); 
+        SkDEBUGCODE(fGlobalState = globalState);
+    }
+
     const SkOpPtT* oppPtTStart() const { return fOppPtTStart; }
     const SkOpPtT* oppPtTEnd() const { return fOppPtTEnd; }
     // These return non-const pointers so that, as copies, they can be added
     // to a new span pair
     SkOpPtT* oppPtTStartWritable() const { return const_cast<SkOpPtT*>(fOppPtTStart); }
     SkOpPtT* oppPtTEndWritable() const { return const_cast<SkOpPtT*>(fOppPtTEnd); }
     SkCoincidentSpans* next() { return fNext; }
     const SkCoincidentSpans* next() const { return fNext; }
     SkCoincidentSpans** nextPtr() { return &fNext; }
     int spanCount() const;
 
     void set(SkCoincidentSpans* next, const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd,
         const SkOpPtT* oppPtTStart, const SkOpPtT* oppPtTEnd
         SkDEBUGPARAMS(int id));
 
     void setCoinPtTEnd(const SkOpPtT* ptT) {
-        SkASSERT(ptT == ptT->span()->ptT())
+        SkOPASSERT(ptT == ptT->span()->ptT())
         SkASSERT(!fCoinPtTStart || ptT->fT != fCoinPtTStart->fT);
         SkASSERT(!fCoinPtTStart || fCoinPtTStart->segment() == ptT->segment());
         fCoinPtTEnd = ptT;
         ptT->setCoincident();
     }
 
     void setCoinPtTStart(const SkOpPtT* ptT) {
         SkASSERT(ptT == ptT->span()->ptT())
         SkASSERT(!fCoinPtTEnd || ptT->fT != fCoinPtTEnd->fT);
         SkASSERT(!fCoinPtTEnd || fCoinPtTEnd->segment() == ptT->segment());
         fCoinPtTStart = ptT;
         ptT->setCoincident();
     }
 
     void setEnds(const SkOpPtT* coinPtTEnd, const SkOpPtT* oppPtTEnd) {
         this->setCoinPtTEnd(coinPtTEnd);
         this->setOppPtTEnd(oppPtTEnd);
     }
 
     void setOppPtTEnd(const SkOpPtT* ptT) {
-        SkASSERT(ptT == ptT->span()->ptT())
+        SkOPASSERT(ptT == ptT->span()->ptT())
         SkASSERT(!fOppPtTStart || ptT->fT != fOppPtTStart->fT);
         SkASSERT(!fOppPtTStart || fOppPtTStart->segment() == ptT->segment());
         fOppPtTEnd = ptT;
         ptT->setCoincident();
     }
 
     void setOppPtTStart(const SkOpPtT* ptT) {
         SkASSERT(ptT == ptT->span()->ptT())
         SkASSERT(!fOppPtTEnd || ptT->fT != fOppPtTEnd->fT);
         SkASSERT(!fOppPtTEnd || fOppPtTEnd->segment() == ptT->segment());
@@ skipping 10 matching lines @@
 
     bool startEquals(const SkOpSpanBase* outer, const SkOpSpanBase* over) const {
         return fCoinPtTStart->span() == over && fOppPtTStart->span() == outer;
     }
 private:
     SkCoincidentSpans* fNext;
     const SkOpPtT* fCoinPtTStart;
     const SkOpPtT* fCoinPtTEnd;
     const SkOpPtT* fOppPtTStart;
     const SkOpPtT* fOppPtTEnd;
+    SkDEBUGCODE(SkOpGlobalState* fGlobalState);
     SkDEBUGCODE(int fID);
 };
 
 class SkOpCoincidence {
 public:
     SkOpCoincidence(SkOpGlobalState* globalState)
         : fHead(nullptr)
         , fTop(nullptr)
         , fGlobalState(globalState)
         , fContinue(false)
@@ skipping 166 matching lines @@
     SkCoincidentSpans* fTop;
     SkOpGlobalState* fGlobalState;
     bool fContinue;
     bool fSpanDeleted;
     bool fPtAllocated;
     bool fCoinExtended;
     bool fSpanMerged;
 };
 
 #endif