Style Change: NULL->nullptr

src/pathops/SkOpAngle.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpAngle.h"
 #include "SkOpSegment.h"
 #include "SkPathOpsCurve.h"
 #include "SkTSort.h"
@@ skipping 331 matching lines @@
             }
             if (oSpan == checkEnd) {
                 continue;
             }
             if (!approximately_equal(oSpan->t(), checkEnd->t())) {
                 continue;
             }
             goto recomputeSector;
         } while (!oSpan->final() && (oSpan = oSpan->upCast()->next()));
         checkEnd = stepUp ? !checkEnd->final()
-                ? checkEnd->upCast()->next() : NULL
+                ? checkEnd->upCast()->next() : nullptr
                 : checkEnd->prev();
     } while (checkEnd);
 recomputeSector:
     SkOpSpanBase* computedEnd = stepUp ? checkEnd ? checkEnd->prev() : fEnd->segment()->head() 
             : checkEnd ? checkEnd->upCast()->next() : fEnd->segment()->tail();
     if (checkEnd == fEnd || computedEnd == fEnd || computedEnd == fStart) {
         fUnorderable = true;
         return false;
     }
     if (stepUp != (fStart->t() < computedEnd->t())) {
@@ skipping 289 matching lines @@
             }
         } else if (fNext) {
             if (!angle->merge(this)) {
                 return;
             }
         } else {
             angle->insert(this);
         }
         return;
     }
-    bool singleton = NULL == fNext;
+    bool singleton = nullptr == fNext;
     if (singleton) {
         fNext = this;
     }
     SkOpAngle* next = fNext;
     if (next->fNext == this) {
         if (singleton || angle->after(this)) {
             this->fNext = angle;
             angle->fNext = next;
         } else {
             next->fNext = angle;
@@ skipping 23 matching lines @@
                 angle->fCheckCoincidence = true;
             }
             return;
         }
     } while (true);
 }
 
 SkOpSpanBase* SkOpAngle::lastMarked() const {
     if (fLastMarked) {
         if (fLastMarked->chased()) {
-            return NULL;
+            return nullptr;
         }
         fLastMarked->setChased(true);
     }
     return fLastMarked;
 }
 
 bool SkOpAngle::loopContains(const SkOpAngle* angle) const {
     if (!fNext) {
         return false;
     }
@@ skipping 35 matching lines @@
     SkASSERT(angle->fNext);
     SkOpAngle* working = angle;
     do {
         if (this == working) {
             return false;
         }
         working = working->fNext;
     } while (working != angle);
     do {
         SkOpAngle* next = working->fNext;
-        working->fNext = NULL;
+        working->fNext = nullptr;
         insert(working);
         working = next;
     } while (working != angle);
     // it's likely that a pair of the angles are unorderable
     debugValidateNext();
     return true;
 }
 
 double SkOpAngle::midT() const {
     return (fStart->t() + fEnd->t()) / 2;
@@ skipping 97 matching lines @@
 }
 
 SkOpSegment* SkOpAngle::segment() const {
     return fStart->segment();
 }
 
 void SkOpAngle::set(SkOpSpanBase* start, SkOpSpanBase* end) {
     fStart = start;
     fComputedEnd = fEnd = end;
     SkASSERT(start != end);
-    fNext = NULL;
+    fNext = nullptr;
     fComputeSector = fComputedSector = fCheckCoincidence = false;
     setSpans();
     setSector();
     SkDEBUGCODE(fID = start ? start->globalState()->nextAngleID() : -1);
 }
 
 void SkOpAngle::setCurveHullSweep() {
     fUnorderedSweep = false;
     fSweep[0] = fCurvePart[1] - fCurvePart[0];
     const SkOpSegment* segment = fStart->segment();
@@ skipping 31 matching lines @@
     if (s3x2 * s2x1 < 0) {
         SkASSERT(s2x1 * s1x3 > 0);
         fSweep[0] = fSweep[1];
         fUnorderedSweep = true;
     }
     fSweep[1] = thirdSweep;
 }
 
 void SkOpAngle::setSpans() {
     fUnorderable = false;
-    fLastMarked = NULL;
+    fLastMarked = nullptr;
     if (!fStart) {
         fUnorderable = true;
         return;
     }
     const SkOpSegment* segment = fStart->segment();
     const SkPoint* pts = segment->pts();
     SkDEBUGCODE(fCurvePart.fVerb = SkPath::kCubic_Verb);
     SkDEBUGCODE(fCurvePart[2].fX = fCurvePart[2].fY = fCurvePart[3].fX = fCurvePart[3].fY
             = SK_ScalarNaN);
     SkDEBUGCODE(fCurvePart.fVerb = segment->verb());
@@ skipping 148 matching lines @@
         return true;
     }
     SkASSERT(s0dt0 != 0);
     double m = s0xt0 / s0dt0;
     double sDist = sweep[0].length() * m;
     double tDist = tweep[0].length() * m;
     bool useS = fabs(sDist) < fabs(tDist);
     double mFactor = fabs(useS ? this->distEndRatio(sDist) : rh->distEndRatio(tDist));
     return mFactor < 2400;  // empirically found limit
 }