Style Change: NULL->nullptr

src/core/SkPathRef.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBuffer.h"
 #include "SkLazyPtr.h"
 #include "SkPath.h"
@@ skipping 17 matching lines @@
     SkDEBUGCODE(sk_atomic_inc(&fPathRef->fEditorsAttached);)
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 SkPathRef::~SkPathRef() {
     this->callGenIDChangeListeners();
     SkDEBUGCODE(this->validate();)
     sk_free(fPoints);
 
-    SkDEBUGCODE(fPoints = NULL;)
-    SkDEBUGCODE(fVerbs = NULL;)
+    SkDEBUGCODE(fPoints = nullptr;)
+    SkDEBUGCODE(fVerbs = nullptr;)
     SkDEBUGCODE(fVerbCnt = 0x9999999;)
     SkDEBUGCODE(fPointCnt = 0xAAAAAAA;)
     SkDEBUGCODE(fPointCnt = 0xBBBBBBB;)
     SkDEBUGCODE(fGenerationID = 0xEEEEEEEE;)
     SkDEBUGCODE(fEditorsAttached = 0x7777777;)
 }
 
 // As a template argument, this must have external linkage.
 SkPathRef* sk_create_empty_pathref() {
     SkPathRef* empty = new SkPathRef;
@@ skipping 73 matching lines @@
 }
 
 SkPathRef* SkPathRef::CreateFromBuffer(SkRBuffer* buffer) {
     SkPathRef* ref = new SkPathRef;
     bool isOval;
     uint8_t segmentMask;
 
     int32_t packed;
     if (!buffer->readS32(&packed)) {
         delete ref;
-        return NULL;
+        return nullptr;
     }
 
     ref->fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
     segmentMask = (packed >> kSegmentMask_SerializationShift) & 0xF;
     isOval  = (packed >> kIsOval_SerializationShift) & 1;
 
     int32_t verbCount, pointCount, conicCount;
     if (!buffer->readU32(&(ref->fGenerationID)) ||
         !buffer->readS32(&verbCount) ||
         !buffer->readS32(&pointCount) ||
         !buffer->readS32(&conicCount)) {
         delete ref;
-        return NULL;
+        return nullptr;
     }
 
     ref->resetToSize(verbCount, pointCount, conicCount);
     SkASSERT(verbCount == ref->countVerbs());
     SkASSERT(pointCount == ref->countPoints());
     SkASSERT(conicCount == ref->fConicWeights.count());
 
     if (!buffer->read(ref->verbsMemWritable(), verbCount * sizeof(uint8_t)) ||
         !buffer->read(ref->fPoints, pointCount * sizeof(SkPoint)) ||
         !buffer->read(ref->fConicWeights.begin(), conicCount * sizeof(SkScalar)) ||
         !buffer->read(&ref->fBounds, sizeof(SkRect))) {
         delete ref;
-        return NULL;
+        return nullptr;
     }
     ref->fBoundsIsDirty = false;
 
     // resetToSize clears fSegmentMask and fIsOval
     ref->fSegmentMask = segmentMask;
     ref->fIsOval = isOval;
     return ref;
 }
 
 void SkPathRef::Rewind(SkAutoTUnref<SkPathRef>* pathRef) {
@@ skipping 266 matching lines @@
             // empty ID
             do {
                 fGenerationID = (sk_atomic_inc(&gPathRefGenerationID) + 1) & kMask;
             } while (fGenerationID <= kEmptyGenID);
         }
     }
     return fGenerationID;
 }
 
 void SkPathRef::addGenIDChangeListener(GenIDChangeListener* listener) {
-    if (NULL == listener || this == empty.get()) {
+    if (nullptr == listener || this == empty.get()) {
         delete listener;
         return;
     }
     *fGenIDChangeListeners.append() = listener;
 }
 
 // we need to be called *before* the genID gets changed or zerod
 void SkPathRef::callGenIDChangeListeners() {
     for (int i = 0; i < fGenIDChangeListeners.count(); i++) {
         fGenIDChangeListeners[i]->onChange();
     }
 
     // Listeners get at most one shot, so whether these triggered or not, blow them away.
     fGenIDChangeListeners.deleteAll();
 }
 
 #ifdef SK_DEBUG
 void SkPathRef::validate() const {
     this->INHERITED::validate();
     SkASSERT(static_cast<ptrdiff_t>(fFreeSpace) >= 0);
     SkASSERT(reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints) >= 0);
-    SkASSERT((NULL == fPoints) == (NULL == fVerbs));
-    SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
-    SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
-    SkASSERT(!(NULL == fPoints && fPointCnt));
-    SkASSERT(!(NULL == fVerbs && fVerbCnt));
+    SkASSERT((nullptr == fPoints) == (nullptr == fVerbs));
+    SkASSERT(!(nullptr == fPoints && 0 != fFreeSpace));
+    SkASSERT(!(nullptr == fPoints && 0 != fFreeSpace));
+    SkASSERT(!(nullptr == fPoints && fPointCnt));
+    SkASSERT(!(nullptr == fVerbs && fVerbCnt));
     SkASSERT(this->currSize() ==
                 fFreeSpace + sizeof(SkPoint) * fPointCnt + sizeof(uint8_t) * fVerbCnt);
 
     if (!fBoundsIsDirty && !fBounds.isEmpty()) {
         bool isFinite = true;
         for (int i = 0; i < fPointCnt; ++i) {
 #ifdef SK_DEBUG
             if (fPoints[i].isFinite() &&
                 (fPoints[i].fX < fBounds.fLeft || fPoints[i].fX > fBounds.fRight ||
                  fPoints[i].fY < fBounds.fTop || fPoints[i].fY > fBounds.fBottom)) {
@@ skipping 43 matching lines @@
                 break;
             default:
                 SkDEBUGFAIL("Unknown Verb");
                 break;
         }
     }
     SkASSERT(mask == fSegmentMask);
 #endif // SK_DEBUG_PATH
 }
 #endif