Style Change: NULL->nullptr

src/core/SkRegion_path.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 "SkRegionPriv.h"
 #include "SkBlitter.h"
 #include "SkScan.h"
@@ skipping 14 matching lines @@
 
 class SkRgnBuilder : public SkBlitter {
 public:
     SkRgnBuilder();
     virtual ~SkRgnBuilder();
 
     // returns true if it could allocate the working storage needed
     bool init(int maxHeight, int maxTransitions, bool pathIsInverse);
 
     void done() {
-        if (fCurrScanline != NULL) {
+        if (fCurrScanline != nullptr) {
             fCurrScanline->fXCount = (SkRegion::RunType)((int)(fCurrXPtr - fCurrScanline->firstX()));
             if (!this->collapsWithPrev()) { // flush the last line
                 fCurrScanline = fCurrScanline->nextScanline();
             }
         }
     }
 
     int     computeRunCount() const;
     void    copyToRect(SkIRect*) const;
     void    copyToRgn(SkRegion::RunType runs[]) const;
@@ skipping 41 matching lines @@
     SkRegion::RunType*  fStorage;
     Scanline*           fCurrScanline;
     Scanline*           fPrevScanline;
     //  points at next avialable x[] in fCurrScanline
     SkRegion::RunType*  fCurrXPtr;
     SkRegion::RunType   fTop;           // first Y value
 
     int fStorageCount;
 
     bool collapsWithPrev() {
-        if (fPrevScanline != NULL &&
+        if (fPrevScanline != nullptr &&
             fPrevScanline->fLastY + 1 == fCurrScanline->fLastY &&
             fPrevScanline->fXCount == fCurrScanline->fXCount &&
             sk_memeq32(fPrevScanline->firstX(), fCurrScanline->firstX(), fCurrScanline->fXCount))
         {
             // update the height of fPrevScanline
             fPrevScanline->fLastY = fCurrScanline->fLastY;
             return true;
         }
         return false;
     }
 };
 
 SkRgnBuilder::SkRgnBuilder()
-    : fStorage(NULL) {
+    : fStorage(nullptr) {
 }
 
 SkRgnBuilder::~SkRgnBuilder() {
     sk_free(fStorage);
 }
 
 bool SkRgnBuilder::init(int maxHeight, int maxTransitions, bool pathIsInverse) {
     if ((maxHeight | maxTransitions) < 0) {
         return false;
     }
@@ skipping 18 matching lines @@
         return false;
     }
     fStorageCount = sk_64_asS32(count);
 
     int64_t size = sk_64_mul(fStorageCount, sizeof(SkRegion::RunType));
     if (size < 0 || !sk_64_isS32(size)) {
         return false;
     }
 
     fStorage = (SkRegion::RunType*)sk_malloc_flags(sk_64_asS32(size), 0);
-    if (NULL == fStorage) {
+    if (nullptr == fStorage) {
         return false;
     }
 
-    fCurrScanline = NULL;    // signal empty collection
-    fPrevScanline = NULL;    // signal first scanline
+    fCurrScanline = nullptr;    // signal empty collection
+    fPrevScanline = nullptr;    // signal first scanline
     return true;
 }
 
 void SkRgnBuilder::blitH(int x, int y, int width) {
-    if (fCurrScanline == NULL) {  // first time
+    if (fCurrScanline == nullptr) {  // first time
         fTop = (SkRegion::RunType)(y);
         fCurrScanline = (Scanline*)fStorage;
         fCurrScanline->fLastY = (SkRegion::RunType)(y);
         fCurrXPtr = fCurrScanline->firstX();
     } else {
         SkASSERT(y >= fCurrScanline->fLastY);
 
         if (y > fCurrScanline->fLastY) {
             // if we get here, we're done with fCurrScanline
             fCurrScanline->fXCount = (SkRegion::RunType)((int)(fCurrXPtr - fCurrScanline->firstX()));
@@ skipping 19 matching lines @@
         fCurrXPtr[-1] = (SkRegion::RunType)(x + width);
     } else {
         fCurrXPtr[0] = (SkRegion::RunType)(x);
         fCurrXPtr[1] = (SkRegion::RunType)(x + width);
         fCurrXPtr += 2;
     }
     SkASSERT(fCurrXPtr - fStorage < fStorageCount);
 }
 
 int SkRgnBuilder::computeRunCount() const {
-    if (fCurrScanline == NULL) {
+    if (fCurrScanline == nullptr) {
         return 0;
     }
 
     const SkRegion::RunType*  line = fStorage;
     const SkRegion::RunType*  stop = (const SkRegion::RunType*)fCurrScanline;
 
     return 2 + (int)(stop - line);
 }
 
 void SkRgnBuilder::copyToRect(SkIRect* r) const {
-    SkASSERT(fCurrScanline != NULL);
+    SkASSERT(fCurrScanline != nullptr);
     // A rect's scanline is [bottom intervals left right sentinel] == 5
     SkASSERT((const SkRegion::RunType*)fCurrScanline - fStorage == 5);
 
     const Scanline* line = (const Scanline*)fStorage;
     SkASSERT(line->fXCount == 2);
 
     r->set(line->firstX()[0], fTop, line->firstX()[1], line->fLastY + 1);
 }
 
 void SkRgnBuilder::copyToRgn(SkRegion::RunType runs[]) const {
-    SkASSERT(fCurrScanline != NULL);
+    SkASSERT(fCurrScanline != nullptr);
     SkASSERT((const SkRegion::RunType*)fCurrScanline - fStorage > 4);
 
     const Scanline* line = (const Scanline*)fStorage;
     const Scanline* stop = fCurrScanline;
 
     *runs++ = fTop;
     do {
         *runs++ = (SkRegion::RunType)(line->fLastY + 1);
         int count = line->fXCount;
         *runs++ = count >> 1;   // intervalCount
@@ skipping 157 matching lines @@
     uint8_t fFlags;
     Edge*   fNext;
 
     void set(int x, int y0, int y1) {
         SkASSERT(y0 != y1);
 
         fX = (SkRegion::RunType)(x);
         fY0 = (SkRegion::RunType)(y0);
         fY1 = (SkRegion::RunType)(y1);
         fFlags = 0;
-        SkDEBUGCODE(fNext = NULL;)
+        SkDEBUGCODE(fNext = nullptr;)
     }
 
     int top() const {
         return SkFastMin32(fY0, fY1);
     }
 };
 
 static void find_link(Edge* base, Edge* stop) {
     SkASSERT(base < stop);
 
     if (base->fFlags == Edge::kCompleteLink) {
         SkASSERT(base->fNext);
         return;
     }
 
     SkASSERT(base + 1 < stop);
 
     int y0 = base->fY0;
     int y1 = base->fY1;
 
     Edge* e = base;
     if ((base->fFlags & Edge::kY0Link) == 0) {
         for (;;) {
             e += 1;
             if ((e->fFlags & Edge::kY1Link) == 0 && y0 == e->fY1) {
-                SkASSERT(NULL == e->fNext);
+                SkASSERT(nullptr == e->fNext);
                 e->fNext = base;
                 e->fFlags = SkToU8(e->fFlags | Edge::kY1Link);
                 break;
             }
         }
     }
 
     e = base;
     if ((base->fFlags & Edge::kY1Link) == 0) {
         for (;;) {
             e += 1;
             if ((e->fFlags & Edge::kY0Link) == 0 && y1 == e->fY0) {
-                SkASSERT(NULL == base->fNext);
+                SkASSERT(nullptr == base->fNext);
                 base->fNext = e;
                 e->fFlags = SkToU8(e->fFlags | Edge::kY0Link);
                 break;
             }
         }
     }
 
     base->fFlags = Edge::kCompleteLink;
 }
 
@@ skipping 27 matching lines @@
     return count;
 }
 
 struct EdgeLT {
     bool operator()(const Edge& a, const Edge& b) const {
         return (a.fX == b.fX) ? a.top() < b.top() : a.fX < b.fX;
     }
 };
 
 bool SkRegion::getBoundaryPath(SkPath* path) const {
-    // path could safely be NULL if we're empty, but the caller shouldn't
+    // path could safely be nullptr if we're empty, but the caller shouldn't
     // *know* that
     SkASSERT(path);
 
     if (this->isEmpty()) {
         return false;
     }
 
     const SkIRect& bounds = this->getBounds();
 
     if (this->isRect()) {
@@ skipping 17 matching lines @@
     Edge* stop = start + count;
     SkTQSort<Edge>(start, stop - 1, EdgeLT());
 
     Edge* e;
     for (e = start; e != stop; e++) {
         find_link(e, stop);
     }
 
 #ifdef SK_DEBUG
     for (e = start; e != stop; e++) {
-        SkASSERT(e->fNext != NULL);
+        SkASSERT(e->fNext != nullptr);
         SkASSERT(e->fFlags == Edge::kCompleteLink);
     }
 #endif
 
     path->incReserve(count << 1);
     do {
         SkASSERT(count > 1);
         count -= extract_path(start, stop, path);
     } while (count > 0);
 
     return true;
 }