Style Change: NULL->nullptr

src/core/SkAAClip.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAAClip.h"
 #include "SkAtomics.h"
@@ skipping 118 matching lines @@
     const uint8_t* fData;
 
     int fTop, fBottom;
     bool fDone;
 };
 
 SkAAClip::Iter::Iter(const SkAAClip& clip) {
     if (clip.isEmpty()) {
         fDone = true;
         fTop = fBottom = clip.fBounds.fBottom;
-        fData = NULL;
-        fCurrYOff = NULL;
-        fStopYOff = NULL;
+        fData = nullptr;
+        fCurrYOff = nullptr;
+        fStopYOff = nullptr;
         return;
     }
 
     const RunHead* head = clip.fRunHead;
     fCurrYOff = head->yoffsets();
     fStopYOff = fCurrYOff + head->fRowCount;
     fData     = head->data() + fCurrYOff->fOffset;
 
     // setup first value
     fTop = clip.fBounds.fTop;
     fBottom = clip.fBounds.fTop + fCurrYOff->fY + 1;
     fDone = false;
 }
 
 void SkAAClip::Iter::next() {
     if (!fDone) {
         const YOffset* prev = fCurrYOff;
         const YOffset* curr = prev + 1;
         SkASSERT(curr <= fStopYOff);
 
         fTop = fBottom;
         if (curr >= fStopYOff) {
             fDone = true;
             fBottom = kMaxInt32;
-            fData = NULL;
+            fData = nullptr;
         } else {
             fBottom += curr->fY - prev->fY;
             fData += curr->fOffset - prev->fOffset;
             fCurrYOff = curr;
         }
     }
 }
 
 #ifdef SK_DEBUG
 // assert we're exactly width-wide, and then return the number of bytes used
 static size_t compute_row_length(const uint8_t row[], int width) {
     const uint8_t* origRow = row;
     while (width > 0) {
         int n = row[0];
         SkASSERT(n > 0);
         SkASSERT(n <= width);
         row += 2;
         width -= n;
     }
     SkASSERT(0 == width);
     return row - origRow;
 }
 
 void SkAAClip::validate() const {
-    if (NULL == fRunHead) {
+    if (nullptr == fRunHead) {
         SkASSERT(fBounds.isEmpty());
         return;
     }
 
     const RunHead* head = fRunHead;
     SkASSERT(head->fRefCnt > 0);
     SkASSERT(head->fRowCount > 0);
 
     const YOffset* yoff = head->yoffsets();
     const YOffset* ystop = yoff + head->fRowCount;
@@ skipping 416 matching lines @@
     if (fRunHead) {
         SkASSERT(fRunHead->fRefCnt >= 1);
         if (1 == sk_atomic_dec(&fRunHead->fRefCnt)) {
             sk_free(fRunHead);
         }
     }
 }
 
 SkAAClip::SkAAClip() {
     fBounds.setEmpty();
-    fRunHead = NULL;
+    fRunHead = nullptr;
 }
 
 SkAAClip::SkAAClip(const SkAAClip& src) {
     SkDEBUGCODE(fBounds.setEmpty();)    // need this for validate
-    fRunHead = NULL;
+    fRunHead = nullptr;
     *this = src;
 }
 
 SkAAClip::~SkAAClip() {
     this->freeRuns();
 }
 
 SkAAClip& SkAAClip::operator=(const SkAAClip& src) {
     AUTO_AACLIP_VALIDATE(*this);
     src.validate();
@@ skipping 47 matching lines @@
 }
 
 bool SkAAClip::set(const SkAAClip& src) {
     *this = src;
     return !this->isEmpty();
 }
 
 bool SkAAClip::setEmpty() {
     this->freeRuns();
     fBounds.setEmpty();
-    fRunHead = NULL;
+    fRunHead = nullptr;
     return false;
 }
 
 bool SkAAClip::setRect(const SkIRect& bounds) {
     if (bounds.isEmpty()) {
         return this->setEmpty();
     }
 
     AUTO_AACLIP_VALIDATE(*this);
 
@@ skipping 44 matching lines @@
     if (r.isEmpty()) {
         return this->setEmpty();
     }
 
     AUTO_AACLIP_VALIDATE(*this);
 
     // TODO: special case this
 
     SkPath path;
     path.addRect(r);
-    return this->setPath(path, NULL, doAA);
+    return this->setPath(path, nullptr, doAA);
 }
 
 static void append_run(SkTDArray<uint8_t>& array, uint8_t value, int count) {
     SkASSERT(count >= 0);
     while (count > 0) {
         int n = count;
         if (n > 255) {
             n = 255;
         }
         uint8_t* data = array.append(2);
@@ skipping 26 matching lines @@
 
     SkTDArray<YOffset> yArray;
     SkTDArray<uint8_t> xArray;
 
     yArray.setReserve(SkMin32(bounds.height(), 1024));
     xArray.setReserve(SkMin32(bounds.width() * 128, 64 * 1024));
 
     SkRegion::Iterator iter(rgn);
     int prevRight = 0;
     int prevBot = 0;
-    YOffset* currY = NULL;
+    YOffset* currY = nullptr;
 
     for (; !iter.done(); iter.next()) {
         const SkIRect& r = iter.rect();
         SkASSERT(bounds.contains(r));
 
         int bot = r.fBottom - offsetY;
         SkASSERT(bot >= prevBot);
         if (bot > prevBot) {
             if (currY) {
                 // flush current row
@@ skipping 38 matching lines @@
     return true;
 #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 const uint8_t* SkAAClip::findRow(int y, int* lastYForRow) const {
     SkASSERT(fRunHead);
 
     if (!y_in_rect(y, fBounds)) {
-        return NULL;
+        return nullptr;
     }
     y -= fBounds.y();  // our yoffs values are relative to the top
 
     const YOffset* yoff = fRunHead->yoffsets();
     while (yoff->fY < y) {
         yoff += 1;
         SkASSERT(yoff - fRunHead->yoffsets() < fRunHead->fRowCount);
     }
 
     if (lastYForRow) {
@@ skipping 70 matching lines @@
     SkTDArray<Row>  fRows;
     Row* fCurrRow;
     int fPrevY;
     int fWidth;
     int fMinY;
 
 public:
     Builder(const SkIRect& bounds) : fBounds(bounds) {
         fPrevY = -1;
         fWidth = bounds.width();
-        fCurrRow = NULL;
+        fCurrRow = nullptr;
         fMinY = bounds.fTop;
     }
 
     ~Builder() {
         Row* row = fRows.begin();
         Row* stop = fRows.end();
         while (row < stop) {
             delete row->fData;
             row += 1;
         }
@@ skipping 200 matching lines @@
 private:
     void flushRowH(Row* row) {
         // flush current row if needed
         if (row->fWidth < fWidth) {
             AppendRun(*row->fData, 0, fWidth - row->fWidth);
             row->fWidth = fWidth;
         }
     }
 
     Row* flushRow(bool readyForAnother) {
-        Row* next = NULL;
+        Row* next = nullptr;
         int count = fRows.count();
         if (count > 0) {
             this->flushRowH(&fRows[count - 1]);
         }
         if (count > 1) {
             // are our last two runs the same?
             Row* prev = &fRows[count - 2];
             Row* curr = &fRows[count - 1];
             SkASSERT(prev->fWidth == fWidth);
             SkASSERT(curr->fWidth == fWidth);
@@ skipping 96 matching lines @@
         this->recordMinY(y);
         this->checkForYGap(y);
         fBuilder->addAntiRectRun(x, y, width, height, leftAlpha, rightAlpha);
         fLastY = y + height - 1;
     }
 
     void blitMask(const SkMask&, const SkIRect& clip) override
         { unexpected(); }
 
     const SkPixmap* justAnOpaqueColor(uint32_t*) override {
-        return NULL;
+        return nullptr;
     }
 
     void blitH(int x, int y, int width) override {
         this->recordMinY(y);
         this->checkForYGap(y);
         fBuilder->addRun(x, y, 0xFF, width);
     }
 
     virtual void blitAntiH(int x, int y, const SkAlpha alpha[],
                            const int16_t runs[]) override {
@@ skipping 62 matching lines @@
     AUTO_AACLIP_VALIDATE(*this);
 
     if (clip && clip->isEmpty()) {
         return this->setEmpty();
     }
 
     SkIRect ibounds;
     path.getBounds().roundOut(&ibounds);
 
     SkRegion tmpClip;
-    if (NULL == clip) {
+    if (nullptr == clip) {
         tmpClip.setRect(ibounds);
         clip = &tmpClip;
     }
 
     if (path.isInverseFillType()) {
         ibounds = clip->getBounds();
     } else {
         if (ibounds.isEmpty() || !ibounds.intersect(clip->getBounds())) {
             return this->setEmpty();
         }
@@ skipping 206 matching lines @@
     SkAAClip::Iter iterB(B);
 
     SkASSERT(!iterA.done());
     int topA = iterA.top();
     int botA = iterA.bottom();
     SkASSERT(!iterB.done());
     int topB = iterB.top();
     int botB = iterB.bottom();
 
     do {
-        const uint8_t* rowA = NULL;
-        const uint8_t* rowB = NULL;
+        const uint8_t* rowA = nullptr;
+        const uint8_t* rowB = nullptr;
         int top, bot;
 
         if (topA < topB) {
             top = topA;
             rowA = iterA.data();
             if (botA <= topB) {
                 bot = botA;
             } else {
                 bot = topA = topB;
             }
@@ skipping 173 matching lines @@
     return this->op(*this, clip, op);
 }
 
 bool SkAAClip::op(const SkAAClip& clip, SkRegion::Op op) {
     return this->op(*this, clip, op);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkAAClip::translate(int dx, int dy, SkAAClip* dst) const {
-    if (NULL == dst) {
+    if (nullptr == dst) {
         return !this->isEmpty();
     }
 
     if (this->isEmpty()) {
         return dst->setEmpty();
     }
 
     if (this != dst) {
         sk_atomic_inc(&fRunHead->fRefCnt);
         dst->freeRuns();
@@ skipping 15 matching lines @@
         row += 2;
         width -= n;
     }
     SkASSERT(0 == width);
 }
 
 void SkAAClip::copyToMask(SkMask* mask) const {
     mask->fFormat = SkMask::kA8_Format;
     if (this->isEmpty()) {
         mask->fBounds.setEmpty();
-        mask->fImage = NULL;
+        mask->fImage = nullptr;
         mask->fRowBytes = 0;
         return;
     }
 
     mask->fBounds = fBounds;
     mask->fRowBytes = fBounds.width();
     size_t size = mask->computeImageSize();
     mask->fImage = SkMask::AllocImage(size);
 
     Iter iter(*this);
@@ skipping 38 matching lines @@
         n = data[0];
     }
     runs[0] = 0;    // sentinel
 }
 
 SkAAClipBlitter::~SkAAClipBlitter() {
     sk_free(fScanlineScratch);
 }
 
 void SkAAClipBlitter::ensureRunsAndAA() {
-    if (NULL == fScanlineScratch) {
+    if (nullptr == fScanlineScratch) {
         // add 1 so we can store the terminating run count of 0
         int count = fAAClipBounds.width() + 1;
         // we use this either for fRuns + fAA, or a scaline of a mask
         // which may be as deep as 32bits
         fScanlineScratch = sk_malloc_throw(count * sizeof(SkPMColor));
         fRuns = (int16_t*)fScanlineScratch;
         fAA = (SkAlpha*)(fRuns + count);
     }
 }
 
@@ skipping 173 matching lines @@
         SkASSERT(rowN == n);
         row += 2;
         rowN = row[0];
     }
 }
 
 static MergeAAProc find_merge_aa_proc(SkMask::Format format) {
     switch (format) {
         case SkMask::kBW_Format:
             SkDEBUGFAIL("unsupported");
-            return NULL;
+            return nullptr;
         case SkMask::kA8_Format:
         case SkMask::k3D_Format: {
             void (*proc8)(const uint8_t*, int, const uint8_t*, int, uint8_t*) = mergeT;
             return (MergeAAProc)proc8;
         }
         case SkMask::kLCD16_Format: {
             void (*proc16)(const uint16_t*, int, const uint8_t*, int, uint16_t*) = mergeT;
             return (MergeAAProc)proc16;
         }
         default:
             SkDEBUGFAIL("unsupported");
-            return NULL;
+            return nullptr;
     }
 }
 
 static U8CPU bit2byte(int bitInAByte) {
     SkASSERT(bitInAByte <= 0xFF);
     // negation turns any non-zero into 0xFFFFFF??, so we just shift down
     // some value >= 8 to get a full FF value
     return -bitInAByte >> 8;
 }
 
@@ skipping 43 matching lines @@
 
     if (fAAClip->quickContains(clip)) {
         fBlitter->blitMask(origMask, clip);
         return;
     }
 
     const SkMask* mask = &origMask;
 
     // if we're BW, we need to upscale to A8 (ugh)
     SkMask  grayMask;
-    grayMask.fImage = NULL;
+    grayMask.fImage = nullptr;
     if (SkMask::kBW_Format == origMask.fFormat) {
         grayMask.fFormat = SkMask::kA8_Format;
         grayMask.fBounds = origMask.fBounds;
         grayMask.fRowBytes = origMask.fBounds.width();
         size_t size = grayMask.computeImageSize();
         grayMask.fImage = (uint8_t*)fGrayMaskScratch.reset(size,
                                                SkAutoMalloc::kReuse_OnShrink);
 
         upscaleBW2A8(&grayMask, origMask);
         mask = &grayMask;
@@ skipping 31 matching lines @@
             mergeProc(src, width, row, initialCount, rowMask.fImage);
             rowMask.fBounds.fTop = y;
             rowMask.fBounds.fBottom = y + 1;
             fBlitter->blitMask(rowMask, rowMask.fBounds);
             src = (const void*)((const char*)src + srcRB);
         } while (++y < localStopY);
     } while (y < stopY);
 }
 
 const SkPixmap* SkAAClipBlitter::justAnOpaqueColor(uint32_t* value) {
-    return NULL;
+    return nullptr;
 }