Style Change: NULL->nullptr

src/pathops/SkOpSpan.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 SkOpSpan_DEFINED
 #define SkOpSpan_DEFINED
 
 #include "SkPathOpsDebug.h"
@@ skipping 87 matching lines @@
         return fNext;
     }
 
     bool onEnd() const;
 
     static bool Overlaps(SkOpPtT* s1, SkOpPtT* e1, SkOpPtT* s2, SkOpPtT* e2,
             SkOpPtT** sOut, SkOpPtT** eOut) {
         SkOpPtT* start1 = s1->fT < e1->fT ? s1 : e1;
         SkOpPtT* start2 = s2->fT < e2->fT ? s2 : e2;
         *sOut = between(s1->fT, start2->fT, e1->fT) ? start2
-                : between(s2->fT, start1->fT, e2->fT) ? start1 : NULL;
+                : between(s2->fT, start1->fT, e2->fT) ? start1 : nullptr;
         SkOpPtT* end1 = s1->fT < e1->fT ? e1 : s1;
         SkOpPtT* end2 = s2->fT < e2->fT ? e2 : s2;
         *eOut = between(s1->fT, end2->fT, e1->fT) ? end2
-                : between(s2->fT, end1->fT, e2->fT) ? end1 : NULL;
+                : between(s2->fT, end1->fT, e2->fT) ? end1 : nullptr;
         if (*sOut == *eOut) {
             SkASSERT(start1->fT >= end2->fT || start2->fT >= end1->fT);
             return false;
         }
         SkASSERT(!*sOut || *sOut != *eOut);
         return *sOut && *eOut;
     }
 
     SkOpPtT* prev();
     SkOpPtT* remove();
@@ skipping 211 matching lines @@
         SkASSERT(!final());
         return (SkOpSpan*) this;
     }
 
     const SkOpSpan* upCast() const {
         SkASSERT(!final());
         return (const SkOpSpan*) this;
     }
 
     SkOpSpan* upCastable() {
-        return final() ? NULL : upCast();
+        return final() ? nullptr : upCast();
     }
 
     const SkOpSpan* upCastable() const {
-        return final() ? NULL : upCast();
+        return final() ? nullptr : upCast();
     }
 
 private:
     void alignInner();
 
 protected:  // no direct access to internals to avoid treating a span base as a span
     SkOpPtT fPtT;  // list of points and t values associated with the start of this span
     SkOpSegment* fSegment;  // segment that contains this span
     SkOpSpanBase* fCoinEnd;  // linked list of coincident spans that end here (may point to itself)
     SkOpAngle* fFromAngle;  // points to next angle from span start to end
@@ skipping 137 matching lines @@
     SkOpSpanBase* fNext;  // next intersection point
     int fWindSum;  // accumulated from contours surrounding this one.
     int fOppSum;  // for binary operators: the opposite winding sum
     int fWindValue;  // 0 == canceled; 1 == normal; >1 == coincident
     int fOppValue;  // normally 0 -- when binary coincident edges combine, opp value goes here
     int fTopTTry; // specifies direction and t value to try next
     bool fDone;  // if set, this span to next higher T has been processed
 };
 
 #endif