Style Change: NULL->nullptr

src/pathops/SkPathOpsCommon.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 "SkAddIntersections.h"
 #include "SkOpCoincidence.h"
 #include "SkOpEdgeBuilder.h"
 #include "SkPathOpsCommon.h"
 #include "SkPathWriter.h"
 #include "SkTSort.h"
 
 const SkOpAngle* AngleWinding(SkOpSpanBase* start, SkOpSpanBase* end, int* windingPtr,
         bool* sortablePtr) {
     // find first angle, initialize winding to computed fWindSum
     SkOpSegment* segment = start->segment();
     const SkOpAngle* angle = segment->spanToAngle(start, end);
     if (!angle) {
         *windingPtr = SK_MinS32;
-        return NULL;
+        return nullptr;
     }
     bool computeWinding = false;
     const SkOpAngle* firstAngle = angle;
     bool loop = false;
     bool unorderable = false;
     int winding = SK_MinS32;
     do {
         angle = angle->next();
         unorderable |= angle->unorderable();
         if ((computeWinding = unorderable || (angle == firstAngle && loop))) {
@@ skipping 31 matching lines @@
 SkOpSegment* FindUndone(SkOpContourHead* contourList, SkOpSpanBase** startPtr,
          SkOpSpanBase** endPtr) {
     SkOpSegment* result;
     SkOpContour* contour = contourList;
     do {
         result = contour->undoneSegment(startPtr, endPtr);
         if (result) {
             return result;
         }
     } while ((contour = contour->next()));
-    return NULL;
+    return nullptr;
 }
 
 SkOpSegment* FindChase(SkTDArray<SkOpSpanBase*>* chase, SkOpSpanBase** startPtr,
         SkOpSpanBase** endPtr) {
     while (chase->count()) {
         SkOpSpanBase* span;
         chase->pop(&span);
         SkOpSegment* segment = span->segment();
         *startPtr = span->ptT()->next()->span();
         bool done = true;
-        *endPtr = NULL;
+        *endPtr = nullptr;
         if (SkOpAngle* last = segment->activeAngle(*startPtr, startPtr, endPtr, &done)) {
             *startPtr = last->start();
             *endPtr = last->end();
     #if TRY_ROTATE
             *chase->insert(0) = span;
     #else
             *chase->append() = span;
     #endif
             return last->segment();
         }
         if (done) {
             continue;
         }
         // find first angle, initialize winding to computed wind sum
         int winding;
         bool sortable;
         const SkOpAngle* angle = AngleWinding(*startPtr, *endPtr, &winding, &sortable);
         if (winding == SK_MinS32) {
             continue;
         }
         int sumWinding SK_INIT_TO_AVOID_WARNING;
         if (sortable) {
             segment = angle->segment();
             sumWinding = segment->updateWindingReverse(angle);
         }
-        SkOpSegment* first = NULL;
+        SkOpSegment* first = nullptr;
         const SkOpAngle* firstAngle = angle;
         while ((angle = angle->next()) != firstAngle) {
             segment = angle->segment();
             SkOpSpanBase* start = angle->start();
             SkOpSpanBase* end = angle->end();
             int maxWinding;
             if (sortable) {
                 segment->setUpWinding(start, end, &maxWinding, &sumWinding);
             }
             if (!segment->done(angle)) {
@@ skipping 10 matching lines @@
         }
         if (first) {
        #if TRY_ROTATE
             *chase->insert(0) = span;
        #else
             *chase->append() = span;
        #endif
             return first;
         }
     }
-    return NULL;
+    return nullptr;
 }
 
 #if DEBUG_ACTIVE_SPANS
 void DebugShowActiveSpans(SkOpContourHead* contourList) {
     SkOpContour* contour = contourList;
     do {
         contour->debugShowActiveSpans();
     } while ((contour = contour->next()));
 }
 #endif
@@ skipping 16 matching lines @@
     }
     contour = list[0];
     SkOpContourHead* contourHead = static_cast<SkOpContourHead*>(contour);
     contour->globalState()->setContourHead(contourHead);
     *contourList = contourHead;
     for (int index = 1; index < count; ++index) {
         SkOpContour* next = list[index];
         contour->setNext(next);
         contour = next;
     }
-    contour->setNext(NULL);
+    contour->setNext(nullptr);
     return true;
 }
 
 class DistanceLessThan {
 public:
     DistanceLessThan(double* distances) : fDistances(distances) { }
     double* fDistances;
     bool operator()(const int one, const int two) {
         return fDistances[one] < fDistances[two];
     }
 };
 
     /*
         check start and end of each contour
         if not the same, record them
         match them up
         connect closest
         reassemble contour pieces into new path
     */
 void Assemble(const SkPathWriter& path, SkPathWriter* simple) {
     SkChunkAlloc allocator(4096);  // FIXME: constant-ize, tune
     SkOpContourHead contour;
-    SkOpGlobalState globalState(NULL, &contour  SkDEBUGPARAMS(NULL));
+    SkOpGlobalState globalState(nullptr, &contour  SkDEBUGPARAMS(nullptr));
 #if DEBUG_SHOW_TEST_NAME
     SkDebugf("</div>\n");
 #endif
 #if DEBUG_PATH_CONSTRUCTION
     SkDebugf("%s\n", __FUNCTION__);
 #endif
     SkOpEdgeBuilder builder(path, &contour, &allocator, &globalState);
     builder.finish(&allocator);
     SkTDArray<const SkOpContour* > runs;  // indices of partial contours
     const SkOpContour* eContour = builder.head();
@@ skipping 282 matching lines @@
         if (!coincidence->apply()) {
             return false;
         }
     }
 #if DEBUG_ACTIVE_SPANS
     coincidence->debugShowCoincidence();
     DebugShowActiveSpans(contourList);
 #endif
     return true;
 }