Style Change: NULL->nullptr

src/core/SkPath.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBuffer.h"
 #include "SkErrorInternals.h"
 #include "SkGeometry.h"
@@ skipping 119 matching lines @@
 }
 
 void SkPath::resetFields() {
     //fPathRef is assumed to have been emptied by the caller.
     fLastMoveToIndex = INITIAL_LASTMOVETOINDEX_VALUE;
     fFillType = kWinding_FillType;
     fConvexity = kUnknown_Convexity;
     fFirstDirection = SkPathPriv::kUnknown_FirstDirection;
 
     // We don't touch Android's fSourcePath.  It's used to track texture garbage collection, so we
-    // don't want to muck with it if it's been set to something non-NULL.
+    // don't want to muck with it if it's been set to something non-nullptr.
 }
 
 SkPath::SkPath(const SkPath& that)
     : fPathRef(SkRef(that.fPathRef.get())) {
     this->copyFields(that);
     SkDEBUGCODE(that.validate();)
 }
 
 SkPath::~SkPath() {
     SkDEBUGCODE(this->validate();)
@@ skipping 227 matching lines @@
 
  */
 static int rect_make_dir(SkScalar dx, SkScalar dy) {
     return ((0 != dx) << 0) | ((dx > 0 || dy > 0) << 1);
 }
 bool SkPath::isRectContour(bool allowPartial, int* currVerb, const SkPoint** ptsPtr,
         bool* isClosed, Direction* direction) const {
     int corners = 0;
     SkPoint first, last;
     const SkPoint* pts = *ptsPtr;
-    const SkPoint* savePts = NULL;
+    const SkPoint* savePts = nullptr;
     first.set(0, 0);
     last.set(0, 0);
     int firstDirection = 0;
     int lastDirection = 0;
     int nextDirection = 0;
     bool closedOrMoved = false;
     bool autoClose = false;
     bool insertClose = false;
     int verbCnt = fPathRef->countVerbs();
     while (*currVerb < verbCnt && (!allowPartial || !autoClose)) {
@@ skipping 125 matching lines @@
     }
     return true;
 }
 
 bool SkPath::isNestedFillRects(SkRect rects[2], Direction dirs[2]) const {
     SkDEBUGCODE(this->validate();)
     int currVerb = 0;
     const SkPoint* pts = fPathRef->points();
     const SkPoint* first = pts;
     Direction testDirs[2];
-    if (!isRectContour(true, &currVerb, &pts, NULL, &testDirs[0])) {
+    if (!isRectContour(true, &currVerb, &pts, nullptr, &testDirs[0])) {
         return false;
     }
     const SkPoint* last = pts;
     SkRect testRects[2];
     bool isClosed;
     if (isRectContour(false, &currVerb, &pts, &isClosed, &testDirs[1])) {
         testRects[0].set(first, SkToS32(last - first));
         if (!isClosed) {
             pts = fPathRef->points() + fPathRef->countPoints();
         }
@@ skipping 882 matching lines @@
         SkChopCubicAtHalf(pts, tmp);
         subdivide_cubic_to(path, &tmp[0], level);
         subdivide_cubic_to(path, &tmp[3], level);
     } else {
         path->cubicTo(pts[1], pts[2], pts[3]);
     }
 }
 
 void SkPath::transform(const SkMatrix& matrix, SkPath* dst) const {
     SkDEBUGCODE(this->validate();)
-    if (dst == NULL) {
+    if (dst == nullptr) {
         dst = (SkPath*)this;
     }
 
     if (matrix.hasPerspective()) {
         SkPath  tmp;
         tmp.fFillType = fFillType;
 
         SkPath::Iter    iter(*this, false);
         SkPoint         pts[4];
         SkPath::Verb    verb;
@@ skipping 67 matching lines @@
     kEmptyContour_SegmentState,   // The current contour is empty. We may be
                                   // starting processing or we may have just
                                   // closed a contour.
     kAfterMove_SegmentState,      // We have seen a move, but nothing else.
     kAfterPrimitive_SegmentState  // We have seen a primitive but not yet
                                   // closed the path. Also the initial state.
 };
 
 SkPath::Iter::Iter() {
 #ifdef SK_DEBUG
-    fPts = NULL;
-    fConicWeights = NULL;
+    fPts = nullptr;
+    fConicWeights = nullptr;
     fMoveTo.fX = fMoveTo.fY = fLastPt.fX = fLastPt.fY = 0;
     fForceClose = fCloseLine = false;
     fSegmentState = kEmptyContour_SegmentState;
 #endif
     // need to init enough to make next() harmlessly return kDone_Verb
-    fVerbs = NULL;
-    fVerbStop = NULL;
+    fVerbs = nullptr;
+    fVerbStop = nullptr;
     fNeedClose = false;
 }
 
 SkPath::Iter::Iter(const SkPath& path, bool forceClose) {
     this->setPath(path, forceClose);
 }
 
 void SkPath::Iter::setPath(const SkPath& path, bool forceClose) {
     fPts = path.fPathRef->points();
     fVerbs = path.fPathRef->verbs();
     fVerbStop = path.fPathRef->verbsMemBegin();
     fConicWeights = path.fPathRef->conicWeights() - 1; // begin one behind
     fLastPt.fX = fLastPt.fY = 0;
     fMoveTo.fX = fMoveTo.fY = 0;
     fForceClose = SkToU8(forceClose);
     fNeedClose = false;
     fSegmentState = kEmptyContour_SegmentState;
 }
 
 bool SkPath::Iter::isClosedContour() const {
-    if (fVerbs == NULL || fVerbs == fVerbStop) {
+    if (fVerbs == nullptr || fVerbs == fVerbStop) {
         return false;
     }
     if (fForceClose) {
         return true;
     }
 
     const uint8_t* verbs = fVerbs;
     const uint8_t* stop = fVerbStop;
 
     if (kMove_Verb == *(verbs - 1)) {
@@ skipping 45 matching lines @@
          // Set the first return pt to the last pt of the previous primitive.
         return fPts[-1];
     }
 }
 
 void SkPath::Iter::consumeDegenerateSegments(bool exact) {
     // We need to step over anything that will not move the current draw point
     // forward before the next move is seen
     const uint8_t* lastMoveVerb = 0;
     const SkPoint* lastMovePt = 0;
-    const SkScalar* lastMoveWeight = NULL;
+    const SkScalar* lastMoveWeight = nullptr;
     SkPoint lastPt = fLastPt;
     while (fVerbs != fVerbStop) {
         unsigned verb = *(fVerbs - 1); // fVerbs is one beyond the current verb
         switch (verb) {
             case kMove_Verb:
                 // Keep a record of this most recent move
                 lastMoveVerb = fVerbs;
                 lastMovePt = fPts;
                 lastMoveWeight = fConicWeights;
                 lastPt = fPts[0];
@@ skipping 138 matching lines @@
             break;
     }
     fPts = srcPts;
     return (Verb)verb;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPath::RawIter::RawIter() {
 #ifdef SK_DEBUG
-    fPts = NULL;
-    fConicWeights = NULL;
+    fPts = nullptr;
+    fConicWeights = nullptr;
 #endif
     // need to init enough to make next() harmlessly return kDone_Verb
-    fVerbs = NULL;
-    fVerbStop = NULL;
+    fVerbs = nullptr;
+    fVerbStop = nullptr;
 }
 
 SkPath::RawIter::RawIter(const SkPath& path) {
     this->setPath(path);
 }
 
 void SkPath::RawIter::setPath(const SkPath& path) {
     fPts = path.fPathRef->points();
     fVerbs = path.fPathRef->verbs();
     fVerbStop = path.fPathRef->verbsMemBegin();
@@ skipping 48 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /*
     Format in compressed buffer: [ptCount, verbCount, pts[], verbs[]]
 */
 
 size_t SkPath::writeToMemory(void* storage) const {
     SkDEBUGCODE(this->validate();)
 
-    if (NULL == storage) {
+    if (nullptr == storage) {
         const int byteCount = sizeof(int32_t) + fPathRef->writeSize();
         return SkAlign4(byteCount);
     }
 
     SkWBuffer   buffer(storage);
 
     int32_t packed = (fConvexity << kConvexity_SerializationShift) |
                      (fFillType << kFillType_SerializationShift) |
                      (fFirstDirection << kDirection_SerializationShift) |
                      (fIsVolatile << kIsVolatile_SerializationShift) |
@@ skipping 42 matching lines @@
         fFirstDirection = dir;
     }
 
     size_t sizeRead = 0;
     if (buffer.isValid()) {
         fPathRef.reset(pathRef);
         SkDEBUGCODE(this->validate();)
         buffer.skipToAlign4();
         sizeRead = buffer.pos();
     } else if (pathRef) {
-        // If the buffer is not valid, pathRef should be NULL
+        // If the buffer is not valid, pathRef should be nullptr
         sk_throw();
     }
     return sizeRead;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStringUtils.h"
 #include "SkStream.h"
 
@@ skipping 72 matching lines @@
             SkDebugf("%s", builder.c_str());
             builder.reset();
         }
     }
     if (wStream) {
         wStream->writeText(builder.c_str());
     }
 }
 
 void SkPath::dump() const {
-    this->dump(NULL, false, false);
+    this->dump(nullptr, false, false);
 }
 
 void SkPath::dumpHex() const {
-    this->dump(NULL, false, true);
+    this->dump(nullptr, false, true);
 }
 
 #ifdef SK_DEBUG
 void SkPath::validate() const {
     SkASSERT((fFillType & ~3) == 0);
 
 #ifdef SK_DEBUG_PATH
     if (!fBoundsIsDirty) {
         SkRect bounds;
 
@@ skipping 784 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }