Style Change: NULL->nullptr

src/pathops/SkPathOpsOp.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"
 
 static SkOpSegment* findChaseOp(SkTDArray<SkOpSpanBase*>& chase, SkOpSpanBase** startPtr,
         SkOpSpanBase** endPtr) {
     while (chase.count()) {
         SkOpSpanBase* span;
         chase.pop(&span);
         // OPTIMIZE: prev makes this compatible with old code -- but is it necessary?
         *startPtr = span->ptT()->prev()->span();
         SkOpSegment* segment = (*startPtr)->segment();
         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;
         }
         int winding;
         bool sortable;
         const SkOpAngle* angle = AngleWinding(*startPtr, *endPtr, &winding, &sortable);
         if (winding == SK_MinS32) {
             continue;
         }
         int sumMiWinding, sumSuWinding;
         if (sortable) {
             segment = angle->segment();
             sumMiWinding = segment->updateWindingReverse(angle);
             sumSuWinding = segment->updateOppWindingReverse(angle);
             if (segment->operand()) {
                 SkTSwap<int>(sumMiWinding, sumSuWinding);
             }
         }
-        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, sumWinding, oppMaxWinding, oppSumWinding;
             if (sortable) {
                 segment->setUpWindings(start, end, &sumMiWinding, &sumSuWinding,
                         &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
             }
@@ skipping 12 matching lines @@
         }
         if (first) {
        #if TRY_ROTATE
             *chase.insert(0) = span;
        #else
             *chase.append() = span;
        #endif
             return first;
         }
     }
-    return NULL;
+    return nullptr;
 }
 
 static bool bridgeOp(SkOpContourHead* contourList, const SkPathOp op,
         const int xorMask, const int xorOpMask, SkPathWriter* simple, SkChunkAlloc* allocator) {
     bool unsortable = false;
     do {
         SkOpSpan* span = FindSortableTop(contourList);
         if (!span) {
             break;
         }
@@ skipping 202 matching lines @@
         temp.setFillType(fillType);
         SkPathWriter assembled(temp);
         Assemble(wrapper, &assembled);
         *result = *assembled.nativePath();
         result->setFillType(fillType);
     }
     return true;
 }
 
 bool Op(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result) {
-    return OpDebug(one, two, op, result, true  SkDEBUGPARAMS(NULL));
+    return OpDebug(one, two, op, result, true  SkDEBUGPARAMS(nullptr));
 }