Style Change: NULL->nullptr

src/pathops/SkPathOpsWinding.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.
  */
 
 // given a prospective edge, compute its initial winding by projecting a ray
 // if the ray hits another edge
     // if the edge doesn't have a winding yet, hop up to that edge and start over
@@ skipping 64 matching lines @@
 }
 
 static bool ccw_dxdy(const SkDVector& v, SkOpRayDir dir) {
     bool vPartPos = pt_dydx(v, dir) > 0;
     bool leftBottom = ((static_cast<int>(dir) + 1) & 2) != 0;
     return vPartPos == leftBottom;
 }
 
 struct SkOpRayHit {
     SkOpRayDir makeTestBase(SkOpSpan* span, double t) {
-        fNext = NULL;
+        fNext = nullptr;
         fSpan = span;
         fT = span->t() * (1 - t) + span->next()->t() * t;
         SkOpSegment* segment = span->segment();
         fSlope = segment->dSlopeAtT(fT);
         fPt = segment->ptAtT(fT);
         fValid = true;
         return fabs(fSlope.fX) < fabs(fSlope.fY) ? SkOpRayDir::kLeft : SkOpRayDir::kTop;
     }
 
     SkOpRayHit* fNext;
@@ skipping 88 matching lines @@
         *hits = newHit;
     }
 }
 
 SkOpSpan* SkOpSegment::windingSpanAtT(double tHit) {
     SkOpSpan* span = &fHead;
     SkOpSpanBase* next;
     do {
         next = span->next();
         if (approximately_equal(tHit, next->t())) {
-            return NULL;
+            return nullptr;
         } 
         if (tHit < next->t()) {
             return span;
         }
     } while (!next->final() && (span = next->upCast()));
-    return NULL;
+    return nullptr;
 }
 
 static bool hit_compare_x(const SkOpRayHit* a, const SkOpRayHit* b) {
     return a->fPt.fX < b->fPt.fX;
 }
 
 static bool reverse_hit_compare_x(const SkOpRayHit* a, const SkOpRayHit* b) {
     return b->fPt.fX  < a->fPt.fX;
 }
 
@@ skipping 48 matching lines @@
             ? less_than(dir) ? hit_compare_y : reverse_hit_compare_y 
             : less_than(dir) ? hit_compare_x : reverse_hit_compare_x);
     // verify windings
 #if DEBUG_WINDING
     SkDebugf("%s dir=%s seg=%d t=%1.9g pt=(%1.9g,%1.9g)\n", __FUNCTION__, 
             gDebugRayDirName[static_cast<int>(dir)], hitBase.fSpan->segment()->debugID(),
             hitBase.fT, hitBase.fPt.fX, hitBase.fPt.fY);
     for (int index = 0; index < count; ++index) {
         hit = sorted[index];
         SkOpSpan* span = hit->fSpan;
-        SkOpSegment* hitSegment = span ? span->segment() : NULL;
+        SkOpSegment* hitSegment = span ? span->segment() : nullptr;
         bool operand = span ? hitSegment->operand() : false;
         bool ccw = ccw_dxdy(hit->fSlope, dir);
         SkDebugf("%s [%d] valid=%d operand=%d span=%d ccw=%d ", __FUNCTION__, index,
                 hit->fValid, operand, span ? span->debugID() : -1, ccw);
         if (span) {
             hitSegment->dumpPtsInner();
         }
         SkDebugf(" t=%1.9g pt=(%1.9g,%1.9g) slope=(%1.9g,%1.9g)\n", hit->fT,
                 hit->fPt.fX, hit->fPt.fY, hit->fSlope.fX, hit->fSlope.fY);
     }
 #endif
-    const SkPoint* last = NULL;
+    const SkPoint* last = nullptr;
     int wind = 0;
     int oppWind = 0;
     for (int index = 0; index < count; ++index) {
         hit = sorted[index];
         if (!hit->fValid) {
             return false;
         }
         bool ccw = ccw_dxdy(hit->fSlope, dir);
         SkASSERT(!approximately_zero(hit->fT) || !hit->fValid);
         SkOpSpan* span = hit->fSpan;
@@ skipping 46 matching lines @@
 #if 0
             SkASSERT(hitSegment->oppXor() ? (oppSum & 1) == (oSpanSum & 1) : oppSum == oSpanSum
                     || (abs(oppWind) == abs(lastOpp)
                     && (oppSum ^ oppWind ^ lastOpp) == oSpanSum));
 #endif
         }
         if (sumSet) {
             if (this->globalState()->phase() == SkOpGlobalState::kFixWinding) {
                 hitSegment->contour()->setCcw(ccw);
             } else {
-                (void) hitSegment->markAndChaseWinding(span, span->next(), windSum, oppSum, NULL);
-                (void) hitSegment->markAndChaseWinding(span->next(), span, windSum, oppSum, NULL);
+                (void) hitSegment->markAndChaseWinding(span, span->next(), windSum, oppSum, nullptr);
+                (void) hitSegment->markAndChaseWinding(span->next(), span, windSum, oppSum, nullptr);
             }
         }
         if (operand) {
             SkTSwap(wind, oppWind);
         }
         last = &hit->fPt;
         this->globalState()->bumpNested();
     }
     return true;
 }
 
 SkOpSpan* SkOpSegment::findSortableTop(SkOpContour* contourHead) {
     SkOpSpan* span = &fHead;
     SkOpSpanBase* next;
     do {
         next = span->next();
         if (span->done()) {
             continue;
         }
         if (span->windSum() != SK_MinS32) {
             return span;
         }
         if (span->sortableTop(contourHead)) {
             return span;
         }
     } while (!next->final() && (span = next->upCast()));
-    return NULL;
+    return nullptr;
 }
 
 SkOpSpan* SkOpContour::findSortableTop(SkOpContour* contourHead) {
     SkOpSegment* testSegment = &fHead;
     do {
         if (testSegment->done()) {
             continue;
         }
         SkOpSpan* result = testSegment->findSortableTop(contourHead);
         if (result) {
             return result;
         }
     } while ((testSegment = testSegment->next()));
-    return NULL;
+    return nullptr;
 }
 
 SkOpSpan* FindSortableTop(SkOpContourHead* contourHead) {
     for (int index = 0; index < SkOpGlobalState::kMaxWindingTries; ++index) {
         SkOpContour* contour = contourHead;
         do {
             if (contour->done()) {
                 continue;
             }
             SkOpSpan* result = contour->findSortableTop(contourHead);
             if (result) {
                 return result;
             }
         } while ((contour = contour->next()));
     }
-    return NULL;
+    return nullptr;
 }