Style Change: NULL->nullptr
DOCS_PREVIEW= https://skia.org/?cl=1316233002
Review URL: https://codereview.chromium.org/1316233002
diff --git a/src/core/SkAAClip.cpp b/src/core/SkAAClip.cpp
index 902b87a..bbd1f55 100644
--- a/src/core/SkAAClip.cpp
+++ b/src/core/SkAAClip.cpp
@@ -136,9 +136,9 @@
if (clip.isEmpty()) {
fDone = true;
fTop = fBottom = clip.fBounds.fBottom;
- fData = NULL;
- fCurrYOff = NULL;
- fStopYOff = NULL;
+ fData = nullptr;
+ fCurrYOff = nullptr;
+ fStopYOff = nullptr;
return;
}
@@ -163,7 +163,7 @@
if (curr >= fStopYOff) {
fDone = true;
fBottom = kMaxInt32;
- fData = NULL;
+ fData = nullptr;
} else {
fBottom += curr->fY - prev->fY;
fData += curr->fOffset - prev->fOffset;
@@ -188,7 +188,7 @@
}
void SkAAClip::validate() const {
- if (NULL == fRunHead) {
+ if (nullptr == fRunHead) {
SkASSERT(fBounds.isEmpty());
return;
}
@@ -625,12 +625,12 @@
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;
}
@@ -698,7 +698,7 @@
bool SkAAClip::setEmpty() {
this->freeRuns();
fBounds.setEmpty();
- fRunHead = NULL;
+ fRunHead = nullptr;
return false;
}
@@ -763,7 +763,7 @@
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) {
@@ -810,7 +810,7 @@
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();
@@ -869,7 +869,7 @@
SkASSERT(fRunHead);
if (!y_in_rect(y, fBounds)) {
- return NULL;
+ return nullptr;
}
y -= fBounds.y(); // our yoffs values are relative to the top
@@ -960,7 +960,7 @@
Builder(const SkIRect& bounds) : fBounds(bounds) {
fPrevY = -1;
fWidth = bounds.width();
- fCurrRow = NULL;
+ fCurrRow = nullptr;
fMinY = bounds.fTop;
}
@@ -1181,7 +1181,7 @@
}
Row* flushRow(bool readyForAnother) {
- Row* next = NULL;
+ Row* next = nullptr;
int count = fRows.count();
if (count > 0) {
this->flushRowH(&fRows[count - 1]);
@@ -1298,7 +1298,7 @@
{ unexpected(); }
const SkPixmap* justAnOpaqueColor(uint32_t*) override {
- return NULL;
+ return nullptr;
}
void blitH(int x, int y, int width) override {
@@ -1381,7 +1381,7 @@
path.getBounds().roundOut(&ibounds);
SkRegion tmpClip;
- if (NULL == clip) {
+ if (nullptr == clip) {
tmpClip.setRect(ibounds);
clip = &tmpClip;
}
@@ -1608,8 +1608,8 @@
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) {
@@ -1803,7 +1803,7 @@
///////////////////////////////////////////////////////////////////////////////
bool SkAAClip::translate(int dx, int dy, SkAAClip* dst) const {
- if (NULL == dst) {
+ if (nullptr == dst) {
return !this->isEmpty();
}
@@ -1839,7 +1839,7 @@
mask->fFormat = SkMask::kA8_Format;
if (this->isEmpty()) {
mask->fBounds.setEmpty();
- mask->fImage = NULL;
+ mask->fImage = nullptr;
mask->fRowBytes = 0;
return;
}
@@ -1898,7 +1898,7 @@
}
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
@@ -2092,7 +2092,7 @@
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;
@@ -2104,7 +2104,7 @@
}
default:
SkDEBUGFAIL("unsupported");
- return NULL;
+ return nullptr;
}
}
@@ -2168,7 +2168,7 @@
// 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;
@@ -2220,5 +2220,5 @@
}
const SkPixmap* SkAAClipBlitter::justAnOpaqueColor(uint32_t* value) {
- return NULL;
+ return nullptr;
}
diff --git a/src/core/SkAAClip.h b/src/core/SkAAClip.h
index 9f6a3d6..0207233 100644
--- a/src/core/SkAAClip.h
+++ b/src/core/SkAAClip.h
@@ -26,7 +26,7 @@
void swap(SkAAClip&);
- bool isEmpty() const { return NULL == fRunHead; }
+ bool isEmpty() const { return nullptr == fRunHead; }
const SkIRect& getBounds() const { return fBounds; }
// Returns true iff the clip is not empty, and is just a hard-edged rect (no partial alpha).
@@ -36,7 +36,7 @@
bool setEmpty();
bool setRect(const SkIRect&);
bool setRect(const SkRect&, bool doAA = true);
- bool setPath(const SkPath&, const SkRegion* clip = NULL, bool doAA = true);
+ bool setPath(const SkPath&, const SkRegion* clip = nullptr, bool doAA = true);
bool setRegion(const SkRegion&);
bool set(const SkAAClip&);
@@ -65,8 +65,8 @@
return this->quickContains(r.fLeft, r.fTop, r.fRight, r.fBottom);
}
- const uint8_t* findRow(int y, int* lastYForRow = NULL) const;
- const uint8_t* findX(const uint8_t data[], int x, int* initialCount = NULL) const;
+ const uint8_t* findRow(int y, int* lastYForRow = nullptr) const;
+ const uint8_t* findX(const uint8_t data[], int x, int* initialCount = nullptr) const;
class Iter;
struct RunHead;
@@ -99,7 +99,7 @@
class SkAAClipBlitter : public SkBlitter {
public:
- SkAAClipBlitter() : fScanlineScratch(NULL) {}
+ SkAAClipBlitter() : fScanlineScratch(nullptr) {}
virtual ~SkAAClipBlitter();
void init(SkBlitter* blitter, const SkAAClip* aaclip) {
diff --git a/src/core/SkAdvancedTypefaceMetrics.cpp b/src/core/SkAdvancedTypefaceMetrics.cpp
index 81e98f3..56a557c 100644
--- a/src/core/SkAdvancedTypefaceMetrics.cpp
+++ b/src/core/SkAdvancedTypefaceMetrics.cpp
@@ -148,7 +148,7 @@
SkAutoTDelete<SkAdvancedTypefaceMetrics::AdvanceMetric<Data> > result;
SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* curRange;
- SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* prevRange = NULL;
+ SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* prevRange = nullptr;
Data lastAdvance = kInvalidAdvance;
int repeatedAdvances = 0;
int wildCardsInRun = 0;
@@ -168,7 +168,7 @@
for (int gId = firstIndex; gId <= lastIndex; gId++) {
Data advance = kInvalidAdvance;
if (gId < lastIndex) {
- // Get glyph id only when subset is NULL, or the id is in subset.
+ // Get glyph id only when subset is nullptr, or the id is in subset.
SkASSERT(!subsetGlyphIDs || (subsetIndex < subsetGlyphIDsLength &&
static_cast<uint32_t>(gId) <= subsetGlyphIDs[subsetIndex]));
if (!subsetGlyphIDs ||
diff --git a/src/core/SkAdvancedTypefaceMetrics.h b/src/core/SkAdvancedTypefaceMetrics.h
index 44a6854..b2c9ac3 100644
--- a/src/core/SkAdvancedTypefaceMetrics.h
+++ b/src/core/SkAdvancedTypefaceMetrics.h
@@ -147,9 +147,9 @@
@param num_glyphs Total number of glyphs in the given font.
@param glyphIDs For per-glyph info, specify subset of the font by
giving glyph ids. Each integer represents a glyph
- id. Passing NULL means all glyphs in the font.
+ id. Passing nullptr means all glyphs in the font.
@param glyphIDsCount Number of elements in subsetGlyphIds. Ignored if
- glyphIDs is NULL.
+ glyphIDs is nullptr.
*/
template <typename Data, typename FontHandle>
SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* getAdvanceData(
diff --git a/src/core/SkAnnotation.cpp b/src/core/SkAnnotation.cpp
index aa7a02a..84d41fc 100644
--- a/src/core/SkAnnotation.cpp
+++ b/src/core/SkAnnotation.cpp
@@ -13,7 +13,7 @@
#include "SkWriteBuffer.h"
SkAnnotation::SkAnnotation(const char key[], SkData* value) : fKey(key) {
- if (NULL == value) {
+ if (nullptr == value) {
value = SkData::NewEmpty();
} else {
value->ref();
@@ -26,7 +26,7 @@
}
SkData* SkAnnotation::find(const char key[]) const {
- return fKey.equals(key) ? fData : NULL;
+ return fKey.equals(key) ? fData : nullptr;
}
SkAnnotation::SkAnnotation(SkReadBuffer& buffer) {
@@ -60,7 +60,7 @@
}
void SkAnnotateRectWithURL(SkCanvas* canvas, const SkRect& rect, SkData* value) {
- if (NULL == value) {
+ if (nullptr == value) {
return;
}
SkPaint paint;
@@ -69,7 +69,7 @@
}
void SkAnnotateNamedDestination(SkCanvas* canvas, const SkPoint& point, SkData* name) {
- if (NULL == name) {
+ if (nullptr == name) {
return;
}
SkPaint paint;
@@ -78,7 +78,7 @@
}
void SkAnnotateLinkToDestination(SkCanvas* canvas, const SkRect& rect, SkData* name) {
- if (NULL == name) {
+ if (nullptr == name) {
return;
}
SkPaint paint;
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 03d1f42..7cc7344 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -56,8 +56,8 @@
if (fPixelRef) {
// ignore the values from the memcpy
- fPixels = NULL;
- fColorTable = NULL;
+ fPixels = nullptr;
+ fColorTable = nullptr;
// Note that what to for genID is somewhat arbitrary. We have no
// way to track changes to raw pixels across multiple SkBitmaps.
// Would benefit from an SkRawPixelRef type created by
@@ -165,8 +165,8 @@
fColorTable = fPixelRef->colorTable();
} else {
SkASSERT(0 == fPixelLockCount);
- fPixels = NULL;
- fColorTable = NULL;
+ fPixels = nullptr;
+ fColorTable = nullptr;
}
}
}
@@ -207,7 +207,7 @@
if (fPixelRef != pr) {
this->freePixels();
- SkASSERT(NULL == fPixelRef);
+ SkASSERT(nullptr == fPixelRef);
SkSafeRef(pr);
fPixelRef = pr;
@@ -227,7 +227,7 @@
}
void SkBitmap::unlockPixels() const {
- SkASSERT(NULL == fPixelRef || fPixelLockCount > 0);
+ SkASSERT(nullptr == fPixelRef || fPixelLockCount > 0);
if (fPixelRef && 1 == sk_atomic_dec(&fPixelLockCount)) {
fPixelRef->unlockPixels();
@@ -241,19 +241,19 @@
}
void SkBitmap::setPixels(void* p, SkColorTable* ctable) {
- if (NULL == p) {
- this->setPixelRef(NULL);
+ if (nullptr == p) {
+ this->setPixelRef(nullptr);
return;
}
if (kUnknown_SkColorType == fInfo.colorType()) {
- this->setPixelRef(NULL);
+ this->setPixelRef(nullptr);
return;
}
SkPixelRef* pr = SkMallocPixelRef::NewDirect(fInfo, p, fRowBytes, ctable);
- if (NULL == pr) {
- this->setPixelRef(NULL);
+ if (nullptr == pr) {
+ this->setPixelRef(nullptr);
return;
}
@@ -267,7 +267,7 @@
bool SkBitmap::tryAllocPixels(Allocator* allocator, SkColorTable* ctable) {
HeapAllocator stdalloc;
- if (NULL == allocator) {
+ if (nullptr == allocator) {
allocator = &stdalloc;
}
return allocator->allocPixelRef(this, ctable);
@@ -290,15 +290,15 @@
SkMallocPixelRef::PRFactory defaultFactory;
- SkPixelRef* pr = defaultFactory.create(correctedInfo, rowBytes, NULL);
- if (NULL == pr) {
+ SkPixelRef* pr = defaultFactory.create(correctedInfo, rowBytes, nullptr);
+ if (nullptr == pr) {
return reset_return_false(this);
}
this->setPixelRef(pr)->unref();
- // TODO: lockPixels could/should return bool or void*/NULL
+ // TODO: lockPixels could/should return bool or void*/nullptr
this->lockPixels();
- if (NULL == this->getPixels()) {
+ if (nullptr == this->getPixels()) {
return reset_return_false(this);
}
return true;
@@ -306,7 +306,7 @@
bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, SkPixelRefFactory* factory,
SkColorTable* ctable) {
- if (kIndex_8_SkColorType == requestedInfo.colorType() && NULL == ctable) {
+ if (kIndex_8_SkColorType == requestedInfo.colorType() && nullptr == ctable) {
return reset_return_false(this);
}
if (!this->setInfo(requestedInfo)) {
@@ -317,19 +317,19 @@
const SkImageInfo& correctedInfo = this->info();
SkMallocPixelRef::PRFactory defaultFactory;
- if (NULL == factory) {
+ if (nullptr == factory) {
factory = &defaultFactory;
}
SkPixelRef* pr = factory->create(correctedInfo, correctedInfo.minRowBytes(), ctable);
- if (NULL == pr) {
+ if (nullptr == pr) {
return reset_return_false(this);
}
this->setPixelRef(pr)->unref();
- // TODO: lockPixels could/should return bool or void*/NULL
+ // TODO: lockPixels could/should return bool or void*/nullptr
this->lockPixels();
- if (NULL == this->getPixels()) {
+ if (nullptr == this->getPixels()) {
return reset_return_false(this);
}
return true;
@@ -349,7 +349,7 @@
this->reset();
return false;
}
- if (NULL == pixels) {
+ if (nullptr == pixels) {
invoke_release_proc(releaseProc, pixels, context);
return true; // we behaved as if they called setInfo()
}
@@ -390,12 +390,12 @@
fPixelRef->unlockPixels();
}
fPixelRef->unref();
- fPixelRef = NULL;
+ fPixelRef = nullptr;
fPixelRefOrigin.setZero();
}
fPixelLockCount = 0;
- fPixels = NULL;
- fColorTable = NULL;
+ fPixels = nullptr;
+ fColorTable = nullptr;
}
uint32_t SkBitmap::getGenerationID() const {
@@ -410,7 +410,7 @@
}
GrTexture* SkBitmap::getTexture() const {
- return fPixelRef ? fPixelRef->getTexture() : NULL;
+ return fPixelRef ? fPixelRef->getTexture() : nullptr;
}
///////////////////////////////////////////////////////////////////////////////
@@ -427,7 +427,7 @@
}
SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, dst->rowBytes(), ctable);
- if (NULL == pr) {
+ if (nullptr == pr) {
return false;
}
@@ -482,7 +482,7 @@
}
bool SkBitmap::copyPixelsTo(void* dst, size_t dstSize, size_t dstRB, bool preserveDstPad) const {
- if (NULL == dst) {
+ if (nullptr == dst) {
return false;
}
SkAutoPixmapUnlock result;
@@ -539,7 +539,7 @@
break;
default:
SkDEBUGFAIL("Can't return addr for config");
- base = NULL;
+ base = nullptr;
break;
}
}
@@ -605,7 +605,7 @@
} break;
case kIndex_8_SkColorType: {
const SkColorTable* ctable = pmap.ctable();
- if (NULL == ctable) {
+ if (nullptr == ctable) {
return false;
}
const SkPMColor* table = ctable->readColors();
@@ -696,7 +696,7 @@
bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const {
SkDEBUGCODE(this->validate();)
- if (NULL == result || NULL == fPixelRef) {
+ if (nullptr == result || nullptr == fPixelRef) {
return false; // no src pixels
}
@@ -706,10 +706,10 @@
return false; // r is empty (i.e. no intersection)
}
- if (fPixelRef->getTexture() != NULL) {
+ if (fPixelRef->getTexture() != nullptr) {
// Do a deep copy
SkPixelRef* pixelRef = fPixelRef->deepCopy(this->colorType(), this->profileType(), &subset);
- if (pixelRef != NULL) {
+ if (pixelRef != nullptr) {
SkBitmap dst;
dst.setInfo(SkImageInfo::Make(subset.width(), subset.height(),
this->colorType(), this->alphaType()));
@@ -816,7 +816,7 @@
SkASSERT(tmpSrc.height() == this->height());
// did we get lucky and we can just return tmpSrc?
- if (tmpSrc.colorType() == dstColorType && NULL == alloc) {
+ if (tmpSrc.colorType() == dstColorType && nullptr == alloc) {
dst->swap(tmpSrc);
// If the result is an exact copy, clone the gen ID.
if (dst->pixelRef() && dst->pixelRef()->info() == fPixelRef->info()) {
@@ -888,7 +888,7 @@
// If we have a PixelRef, and it supports deep copy, use it.
// Currently supported only by texture-backed bitmaps.
if (fPixelRef) {
- SkPixelRef* pixelRef = fPixelRef->deepCopy(dstCT, dstPT, NULL);
+ SkPixelRef* pixelRef = fPixelRef->deepCopy(dstCT, dstPT, nullptr);
if (pixelRef) {
uint32_t rowBytes;
if (this->colorType() == dstCT && this->profileType() == dstPT) {
@@ -915,7 +915,7 @@
if (this->getTexture()) {
return false;
} else {
- return this->copyTo(dst, dstCT, NULL);
+ return this->copyTo(dst, dstCT, nullptr);
}
}
@@ -978,7 +978,7 @@
}
static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha, int alphaRowBytes) {
- SkASSERT(alpha != NULL);
+ SkASSERT(alpha != nullptr);
SkASSERT(alphaRowBytes >= src.width());
SkAutoPixmapUnlock apl;
@@ -1006,20 +1006,20 @@
srcM.fRowBytes = SkAlign4(this->width());
srcM.fFormat = SkMask::kA8_Format;
- SkMaskFilter* filter = paint ? paint->getMaskFilter() : NULL;
+ SkMaskFilter* filter = paint ? paint->getMaskFilter() : nullptr;
// compute our (larger?) dst bounds if we have a filter
if (filter) {
identity.reset();
- srcM.fImage = NULL;
- if (!filter->filterMask(&dstM, srcM, identity, NULL)) {
+ srcM.fImage = nullptr;
+ if (!filter->filterMask(&dstM, srcM, identity, nullptr)) {
goto NO_FILTER_CASE;
}
dstM.fRowBytes = SkAlign4(dstM.fBounds.width());
} else {
NO_FILTER_CASE:
tmpBitmap.setInfo(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
- if (!tmpBitmap.tryAllocPixels(allocator, NULL)) {
+ if (!tmpBitmap.tryAllocPixels(allocator, nullptr)) {
// Allocation of pixels for alpha bitmap failed.
SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
tmpBitmap.width(), tmpBitmap.height());
@@ -1036,14 +1036,14 @@
SkAutoMaskFreeImage srcCleanup(srcM.fImage);
GetBitmapAlpha(*this, srcM.fImage, srcM.fRowBytes);
- if (!filter->filterMask(&dstM, srcM, identity, NULL)) {
+ if (!filter->filterMask(&dstM, srcM, identity, nullptr)) {
goto NO_FILTER_CASE;
}
SkAutoMaskFreeImage dstCleanup(dstM.fImage);
tmpBitmap.setInfo(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
dstM.fRowBytes);
- if (!tmpBitmap.tryAllocPixels(allocator, NULL)) {
+ if (!tmpBitmap.tryAllocPixels(allocator, nullptr)) {
// Allocation of pixels for alpha bitmap failed.
SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
tmpBitmap.width(), tmpBitmap.height());
@@ -1091,7 +1091,7 @@
void SkBitmap::WriteRawPixels(SkWriteBuffer* buffer, const SkBitmap& bitmap) {
const SkImageInfo info = bitmap.info();
- if (0 == info.width() || 0 == info.height() || NULL == bitmap.pixelRef()) {
+ if (0 == info.width() || 0 == info.height() || nullptr == bitmap.pixelRef()) {
buffer->writeUInt(0); // instead of snugRB, signaling no pixels
return;
}
@@ -1210,7 +1210,7 @@
SkASSERT(fPixelRef->info().height() >= (int)this->height() + fPixelRefOrigin.fY);
SkASSERT(fPixelRef->rowBytes() >= fInfo.minRowBytes());
} else {
- SkASSERT(NULL == fColorTable);
+ SkASSERT(nullptr == fColorTable);
}
}
#endif
@@ -1240,7 +1240,7 @@
str->append(")");
SkPixelRef* pr = this->pixelRef();
- if (NULL == pr) {
+ if (nullptr == pr) {
// show null or the explicit pixel address (rare)
str->appendf(" pixels:%p", this->getPixels());
} else {
@@ -1262,7 +1262,7 @@
SkASSERT(result);
SkPixelRef* pr = fPixelRef;
- if (NULL == pr) {
+ if (nullptr == pr) {
return false;
}
diff --git a/src/core/SkBitmapCache.cpp b/src/core/SkBitmapCache.cpp
index 66075d4..2b11b81 100644
--- a/src/core/SkBitmapCache.cpp
+++ b/src/core/SkBitmapCache.cpp
@@ -202,7 +202,7 @@
const SkMipMap* mm = SkRef(rec.fMipMap);
// the call to ref() above triggers a "lock" in the case of discardable memory,
// which means we can now check for null (in case the lock failed).
- if (NULL == mm->data()) {
+ if (nullptr == mm->data()) {
mm->unref(); // balance our call to ref()
return false;
}
@@ -222,7 +222,7 @@
const SkMipMap* result;
if (!CHECK_LOCAL(localCache, find, Find, key, MipMapRec::Finder, &result)) {
- result = NULL;
+ result = nullptr;
}
return result;
}
diff --git a/src/core/SkBitmapCache.h b/src/core/SkBitmapCache.h
index c758942..3e541ee 100644
--- a/src/core/SkBitmapCache.h
+++ b/src/core/SkBitmapCache.h
@@ -22,7 +22,7 @@
public:
/**
* Use this allocator for bitmaps, so they can use ashmem when available.
- * Returns NULL if the ResourceCache has not been initialized with a DiscardableFactory.
+ * Returns nullptr if the ResourceCache has not been initialized with a DiscardableFactory.
*/
static SkBitmap::Allocator* GetAllocator();
@@ -31,37 +31,37 @@
* result will be set to the matching bitmap with its pixels already locked.
*/
static bool Find(const SkBitmap& src, SkScalar invScaleX, SkScalar invScaleY, SkBitmap* result,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
/*
* result must be marked isImmutable()
*/
static void Add(const SkBitmap& src, SkScalar invScaleX, SkScalar invScaleY,
- const SkBitmap& result, SkResourceCache* localCache = NULL);
+ const SkBitmap& result, SkResourceCache* localCache = nullptr);
/**
* Search based on the bitmap's genID and subset. If found, returns true and
* result will be set to the matching bitmap with its pixels already locked.
*/
static bool Find(uint32_t genID, const SkIRect& subset, SkBitmap* result,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
/**
* The width and the height of the provided subset must be the same as the result bitmap ones.
* result must be marked isImmutable()
*/
static bool Add(SkPixelRef*, const SkIRect& subset, const SkBitmap& result,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
- static bool Find(uint32_t genID, SkBitmap* result, SkResourceCache* localCache = NULL);
+ static bool Find(uint32_t genID, SkBitmap* result, SkResourceCache* localCache = nullptr);
// todo: eliminate the need to specify ID, since it should == the bitmap's
- static void Add(uint32_t genID, const SkBitmap&, SkResourceCache* localCache = NULL);
+ static void Add(uint32_t genID, const SkBitmap&, SkResourceCache* localCache = nullptr);
};
class SkMipMapCache {
public:
- static const SkMipMap* FindAndRef(const SkBitmap& src, SkResourceCache* localCache = NULL);
- static const SkMipMap* AddAndRef(const SkBitmap& src, SkResourceCache* localCache = NULL);
+ static const SkMipMap* FindAndRef(const SkBitmap& src, SkResourceCache* localCache = nullptr);
+ static const SkMipMap* AddAndRef(const SkBitmap& src, SkResourceCache* localCache = nullptr);
};
#endif
diff --git a/src/core/SkBitmapController.cpp b/src/core/SkBitmapController.cpp
index fb54388..e4b4199 100644
--- a/src/core/SkBitmapController.cpp
+++ b/src/core/SkBitmapController.cpp
@@ -16,7 +16,7 @@
if (0 == bm.width() || 0 == bm.height()) {
return false; // nothing to draw
}
- if (NULL == bm.pixelRef()) {
+ if (nullptr == bm.pixelRef()) {
return false; // no pixels to read
}
if (bm.getTexture()) {
@@ -38,14 +38,14 @@
void* storage, size_t storageSize) {
if (!valid_for_drawing(bm)) {
- return NULL;
+ return nullptr;
}
State* state = this->onRequestBitmap(bm, inv, quality, storage, storageSize);
if (state) {
- if (NULL == state->fPixmap.addr()) {
+ if (nullptr == state->fPixmap.addr()) {
SkInPlaceDeleteCheck(state, storage);
- state = NULL;
+ state = nullptr;
}
}
return state;
@@ -161,21 +161,21 @@
fQuality = kLow_SkFilterQuality;
SkSize invScaleSize;
- if (!fInvMatrix.decomposeScale(&invScaleSize, NULL)) {
+ if (!fInvMatrix.decomposeScale(&invScaleSize, nullptr)) {
return false;
}
SkScalar invScale = SkScalarSqrt(invScaleSize.width() * invScaleSize.height());
if (invScale > SK_Scalar1) {
fCurrMip.reset(SkMipMapCache::FindAndRef(origBitmap));
- if (NULL == fCurrMip.get()) {
+ if (nullptr == fCurrMip.get()) {
fCurrMip.reset(SkMipMapCache::AddAndRef(origBitmap));
- if (NULL == fCurrMip.get()) {
+ if (nullptr == fCurrMip.get()) {
return false;
}
}
// diagnostic for a crasher...
- if (NULL == fCurrMip->data()) {
+ if (nullptr == fCurrMip->data()) {
sk_throw();
}
@@ -191,7 +191,7 @@
return fResultBitmap.installPixels(info, level.fPixels, level.fRowBytes);
} else {
// failed to extract, so release the mipmap
- fCurrMip.reset(NULL);
+ fCurrMip.reset(nullptr);
}
}
return false;
@@ -213,7 +213,7 @@
SkASSERT(fQuality <= kLow_SkFilterQuality);
// fResultBitmap.getPixels() may be null, but our caller knows to check fPixmap.addr()
- // and will destroy us if it is NULL.
+ // and will destroy us if it is nullptr.
fPixmap.reset(fResultBitmap.info(), fResultBitmap.getPixels(), fResultBitmap.rowBytes(),
fResultBitmap.getColorTable());
}
diff --git a/src/core/SkBitmapController.h b/src/core/SkBitmapController.h
index ead4b78..aa663e8 100644
--- a/src/core/SkBitmapController.h
+++ b/src/core/SkBitmapController.h
@@ -40,7 +40,7 @@
void* storage, size_t storageSize);
State* requestBitmap(const SkBitmap& bm, const SkMatrix& inverse, SkFilterQuality quality) {
- return this->requestBitmap(bm, inverse, quality, NULL, 0);
+ return this->requestBitmap(bm, inverse, quality, nullptr, 0);
}
protected:
diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index d4445fa..b7df9a4 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -67,7 +67,7 @@
SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap)
: INHERITED(SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType))
, fBitmap(bitmap) {
- SkASSERT(valid_for_bitmap_device(bitmap.info(), NULL));
+ SkASSERT(valid_for_bitmap_device(bitmap.info(), nullptr));
}
SkBitmapDevice* SkBitmapDevice::Create(const SkImageInfo& info) {
@@ -77,14 +77,14 @@
SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap, const SkSurfaceProps& surfaceProps)
: INHERITED(surfaceProps)
, fBitmap(bitmap) {
- SkASSERT(valid_for_bitmap_device(bitmap.info(), NULL));
+ SkASSERT(valid_for_bitmap_device(bitmap.info(), nullptr));
}
SkBitmapDevice* SkBitmapDevice::Create(const SkImageInfo& origInfo,
const SkSurfaceProps& surfaceProps) {
SkAlphaType newAT = origInfo.alphaType();
if (!valid_for_bitmap_device(origInfo, &newAT)) {
- return NULL;
+ return nullptr;
}
const SkImageInfo info = origInfo.makeAlphaType(newAT);
@@ -92,11 +92,11 @@
if (kUnknown_SkColorType == info.colorType()) {
if (!bitmap.setInfo(info)) {
- return NULL;
+ return nullptr;
}
} else {
if (!bitmap.tryAllocPixels(info)) {
- return NULL;
+ return nullptr;
}
if (!bitmap.info().isOpaque()) {
bitmap.eraseColor(SK_ColorTRANSPARENT);
@@ -142,7 +142,7 @@
bool SkBitmapDevice::onPeekPixels(SkPixmap* pmap) {
const SkImageInfo info = fBitmap.info();
if (fBitmap.getPixels() && (kUnknown_SkColorType != info.colorType())) {
- SkColorTable* ctable = NULL;
+ SkColorTable* ctable = nullptr;
pmap->reset(fBitmap.info(), fBitmap.getPixels(), fBitmap.rowBytes(), ctable);
return true;
}
@@ -152,7 +152,7 @@
bool SkBitmapDevice::onWritePixels(const SkImageInfo& srcInfo, const void* srcPixels,
size_t srcRowBytes, int x, int y) {
// since we don't stop creating un-pixeled devices yet, check for no pixels here
- if (NULL == fBitmap.getPixels()) {
+ if (nullptr == fBitmap.getPixels()) {
return false;
}
@@ -211,7 +211,7 @@
path.addOval(oval);
// call the VIRTUAL version, so any subclasses who do handle drawPath aren't
// required to override drawOval.
- this->drawPath(draw, path, paint, NULL, true);
+ this->drawPath(draw, path, paint, nullptr, true);
}
void SkBitmapDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPaint& paint) {
@@ -223,7 +223,7 @@
path.addRRect(rrect);
// call the VIRTUAL version, so any subclasses who do handle drawPath aren't
// required to override drawRRect.
- this->drawPath(draw, path, paint, NULL, true);
+ this->drawPath(draw, path, paint, nullptr, true);
#else
draw.drawRRect(rrect, paint);
#endif
@@ -238,7 +238,7 @@
void SkBitmapDevice::drawBitmap(const SkDraw& draw, const SkBitmap& bitmap,
const SkMatrix& matrix, const SkPaint& paint) {
- draw.drawBitmap(bitmap, matrix, NULL, paint);
+ draw.drawBitmap(bitmap, matrix, nullptr, paint);
}
void SkBitmapDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
@@ -319,7 +319,7 @@
SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode,
&matrix);
- if (NULL == s) {
+ if (nullptr == s) {
return;
}
diff --git a/src/core/SkBitmapFilter.cpp b/src/core/SkBitmapFilter.cpp
index 4c1e9c6..55a7092 100644
--- a/src/core/SkBitmapFilter.cpp
+++ b/src/core/SkBitmapFilter.cpp
@@ -35,6 +35,6 @@
SkDEBUGFAIL("Unknown filter type");
}
- return NULL;
+ return nullptr;
}
diff --git a/src/core/SkBitmapHeap.cpp b/src/core/SkBitmapHeap.cpp
index 5b16d21..c65a704 100644
--- a/src/core/SkBitmapHeap.cpp
+++ b/src/core/SkBitmapHeap.cpp
@@ -65,9 +65,9 @@
SkBitmapHeap::SkBitmapHeap(int32_t preferredSize, int32_t ownerCount)
: INHERITED()
- , fExternalStorage(NULL)
- , fMostRecentlyUsed(NULL)
- , fLeastRecentlyUsed(NULL)
+ , fExternalStorage(nullptr)
+ , fMostRecentlyUsed(nullptr)
+ , fLeastRecentlyUsed(nullptr)
, fPreferredCount(preferredSize)
, fOwnerCount(ownerCount)
, fBytesAllocated(0)
@@ -77,8 +77,8 @@
SkBitmapHeap::SkBitmapHeap(ExternalStorage* storage, int32_t preferredSize)
: INHERITED()
, fExternalStorage(storage)
- , fMostRecentlyUsed(NULL)
- , fLeastRecentlyUsed(NULL)
+ , fMostRecentlyUsed(nullptr)
+ , fLeastRecentlyUsed(nullptr)
, fPreferredCount(preferredSize)
, fOwnerCount(IGNORE_OWNERS)
, fBytesAllocated(0)
@@ -111,39 +111,39 @@
void SkBitmapHeap::removeFromLRU(SkBitmapHeap::LookupEntry* entry) {
if (fMostRecentlyUsed == entry) {
fMostRecentlyUsed = entry->fLessRecentlyUsed;
- if (NULL == fMostRecentlyUsed) {
+ if (nullptr == fMostRecentlyUsed) {
SkASSERT(fLeastRecentlyUsed == entry);
- fLeastRecentlyUsed = NULL;
+ fLeastRecentlyUsed = nullptr;
} else {
- fMostRecentlyUsed->fMoreRecentlyUsed = NULL;
+ fMostRecentlyUsed->fMoreRecentlyUsed = nullptr;
}
} else {
// Remove entry from its prior place, and make sure to cover the hole.
if (fLeastRecentlyUsed == entry) {
- SkASSERT(entry->fMoreRecentlyUsed != NULL);
+ SkASSERT(entry->fMoreRecentlyUsed != nullptr);
fLeastRecentlyUsed = entry->fMoreRecentlyUsed;
}
// Since we have already considered the case where entry is the most recently used, it must
// have a more recently used at this point.
- SkASSERT(entry->fMoreRecentlyUsed != NULL);
+ SkASSERT(entry->fMoreRecentlyUsed != nullptr);
entry->fMoreRecentlyUsed->fLessRecentlyUsed = entry->fLessRecentlyUsed;
- if (entry->fLessRecentlyUsed != NULL) {
+ if (entry->fLessRecentlyUsed != nullptr) {
SkASSERT(fLeastRecentlyUsed != entry);
entry->fLessRecentlyUsed->fMoreRecentlyUsed = entry->fMoreRecentlyUsed;
}
}
- entry->fMoreRecentlyUsed = NULL;
+ entry->fMoreRecentlyUsed = nullptr;
}
void SkBitmapHeap::appendToLRU(SkBitmapHeap::LookupEntry* entry) {
- if (fMostRecentlyUsed != NULL) {
- SkASSERT(NULL == fMostRecentlyUsed->fMoreRecentlyUsed);
+ if (fMostRecentlyUsed != nullptr) {
+ SkASSERT(nullptr == fMostRecentlyUsed->fMoreRecentlyUsed);
fMostRecentlyUsed->fMoreRecentlyUsed = entry;
entry->fLessRecentlyUsed = fMostRecentlyUsed;
}
fMostRecentlyUsed = entry;
- if (NULL == fLeastRecentlyUsed) {
+ if (nullptr == fLeastRecentlyUsed) {
fLeastRecentlyUsed = entry;
}
}
@@ -154,13 +154,13 @@
SkASSERT(fStorage.count() >= fPreferredCount);
SkBitmapHeap::LookupEntry* iter = fLeastRecentlyUsed;
- while (iter != NULL) {
+ while (iter != nullptr) {
SkBitmapHeapEntry* heapEntry = fStorage[iter->fStorageSlot];
if (heapEntry->fRefCount > 0) {
// If the least recently used bitmap has not been unreferenced
// by its owner, then according to our LRU specifications a more
// recently used one can not have used all its references yet either.
- return NULL;
+ return nullptr;
}
if (replacement.getGenerationID() == iter->fGenerationId) {
// Do not replace a bitmap with a new one using the same
@@ -171,7 +171,7 @@
return iter;
}
}
- return NULL;
+ return nullptr;
}
size_t SkBitmapHeap::freeMemoryIfPossible(size_t bytesToFree) {
@@ -182,7 +182,7 @@
size_t origBytesAllocated = fBytesAllocated;
// Purge starting from LRU until a non-evictable bitmap is found or until
// everything is evicted.
- while (iter != NULL) {
+ while (iter != nullptr) {
SkBitmapHeapEntry* heapEntry = fStorage[iter->fStorageSlot];
if (heapEntry->fRefCount > 0) {
break;
@@ -203,15 +203,15 @@
if (fLeastRecentlyUsed != iter) {
// There was at least one eviction.
fLeastRecentlyUsed = iter;
- if (NULL == fLeastRecentlyUsed) {
+ if (nullptr == fLeastRecentlyUsed) {
// Everything was evicted
- fMostRecentlyUsed = NULL;
+ fMostRecentlyUsed = nullptr;
fBytesAllocated -= (fStorage.count() * sizeof(SkBitmapHeapEntry));
fStorage.deleteAll();
fUnusedSlots.reset();
SkASSERT(0 == fBytesAllocated);
} else {
- fLeastRecentlyUsed->fLessRecentlyUsed = NULL;
+ fLeastRecentlyUsed->fLessRecentlyUsed = nullptr;
}
}
@@ -228,7 +228,7 @@
// insert ourselves into the bitmapIndex
index = ~index;
*fLookupTable.insert(index) = new LookupEntry(indexEntry);
- } else if (entry != NULL) {
+ } else if (entry != nullptr) {
// populate the entry if needed
*entry = fStorage[fLookupTable[index]->fStorageSlot];
}
@@ -244,7 +244,7 @@
if (originalBitmap.isImmutable()) {
copiedBitmap = originalBitmap;
// TODO if we have the pixel ref in the heap we could pass it here to avoid a potential deep copy
-// else if (sharedPixelRef != NULL) {
+// else if (sharedPixelRef != nullptr) {
// copiedBitmap = orig;
// copiedBitmap.setPixelRef(sharedPixelRef, originalBitmap.pixelRefOffset());
} else if (originalBitmap.empty()) {
@@ -259,7 +259,7 @@
int SkBitmapHeap::removeEntryFromLookupTable(LookupEntry* entry) {
// remove the bitmap index for the deleted entry
SkDEBUGCODE(int count = fLookupTable.count();)
- int index = this->findInLookupTable(*entry, NULL);
+ int index = this->findInLookupTable(*entry, nullptr);
// Verify that findInLookupTable found an existing entry rather than adding
// a new entry to the lookup table.
SkASSERT(count == fLookupTable.count());
@@ -270,7 +270,7 @@
}
int32_t SkBitmapHeap::insert(const SkBitmap& originalBitmap) {
- SkBitmapHeapEntry* entry = NULL;
+ SkBitmapHeapEntry* entry = nullptr;
int searchIndex = this->findInLookupTable(LookupEntry(originalBitmap), &entry);
if (entry) {
@@ -296,7 +296,7 @@
if (fPreferredCount != UNLIMITED_SIZE && fStorage.count() >= fPreferredCount) {
// iterate through our LRU cache and try to find an entry to evict
LookupEntry* lookupEntry = this->findEntryToReplace(originalBitmap);
- if (lookupEntry != NULL) {
+ if (lookupEntry != nullptr) {
// we found an entry to evict
entry = fStorage[lookupEntry->fStorageSlot];
// Remove it from the LRU. The new entry will be added to the LRU later.
@@ -383,7 +383,7 @@
for (int i = 0; i < fDeferredEntries.count(); i++) {
SkASSERT(fOwnerCount != IGNORE_OWNERS);
SkBitmapHeapEntry* heapEntry = this->getEntry(fDeferredEntries[i]);
- SkASSERT(heapEntry != NULL);
+ SkASSERT(heapEntry != nullptr);
heapEntry->addReferences(fOwnerCount);
}
}
diff --git a/src/core/SkBitmapHeap.h b/src/core/SkBitmapHeap.h
index 1e1979f..22c31a0 100644
--- a/src/core/SkBitmapHeap.h
+++ b/src/core/SkBitmapHeap.h
@@ -116,24 +116,24 @@
/**
* Retrieves the bitmap from the specified slot in the heap
*
- * @return The bitmap located at that slot or NULL if external storage is being used.
+ * @return The bitmap located at that slot or nullptr if external storage is being used.
*/
SkBitmap* getBitmap(int32_t slot) const override {
- SkASSERT(fExternalStorage == NULL);
+ SkASSERT(fExternalStorage == nullptr);
SkBitmapHeapEntry* entry = getEntry(slot);
if (entry) {
return &entry->fBitmap;
}
- return NULL;
+ return nullptr;
}
/**
* Retrieves the bitmap from the specified slot in the heap
*
- * @return The bitmap located at that slot or NULL if external storage is being used.
+ * @return The bitmap located at that slot or nullptr if external storage is being used.
*/
void releaseRef(int32_t slot) override {
- SkASSERT(fExternalStorage == NULL);
+ SkASSERT(fExternalStorage == nullptr);
if (fOwnerCount != IGNORE_OWNERS) {
SkBitmapHeapEntry* entry = getEntry(slot);
if (entry) {
@@ -158,12 +158,12 @@
* Retrieves an entry from the heap at a given slot.
*
* @param slot the slot in the heap where a bitmap was stored.
- * @return a SkBitmapHeapEntry that wraps the bitmap or NULL if external storage is used.
+ * @return a SkBitmapHeapEntry that wraps the bitmap or nullptr if external storage is used.
*/
SkBitmapHeapEntry* getEntry(int32_t slot) const {
SkASSERT(slot <= fStorage.count());
- if (fExternalStorage != NULL) {
- return NULL;
+ if (fExternalStorage != nullptr) {
+ return nullptr;
}
return fStorage[slot];
}
@@ -172,7 +172,7 @@
* Returns a count of the number of items currently in the heap
*/
int count() const {
- SkASSERT(fExternalStorage != NULL ||
+ SkASSERT(fExternalStorage != nullptr ||
fStorage.count() - fUnusedSlots.count() == fLookupTable.count());
return fLookupTable.count();
}
@@ -215,8 +215,8 @@
, fPixelOrigin(bm.pixelRefOrigin())
, fWidth(bm.width())
, fHeight(bm.height())
- , fMoreRecentlyUsed(NULL)
- , fLessRecentlyUsed(NULL){}
+ , fMoreRecentlyUsed(nullptr)
+ , fLessRecentlyUsed(nullptr){}
const uint32_t fGenerationId; // SkPixelRef GenerationID.
const SkIPoint fPixelOrigin;
@@ -260,7 +260,7 @@
/**
* Remove a LookupEntry from the LRU, in preparation for either deleting or appending as most
* recent. Points the LookupEntry's old neighbors at each other, and sets fLeastRecentlyUsed
- * (if there is still an entry left). Sets LookupEntry's fMoreRecentlyUsed to NULL and leaves
+ * (if there is still an entry left). Sets LookupEntry's fMoreRecentlyUsed to nullptr and leaves
* its fLessRecentlyUsed unmodified.
*/
void removeFromLRU(LookupEntry* entry);
diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp
index ef9cfd4..e382d09 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -47,7 +47,7 @@
buffer.readMatrix(&lm);
SkBitmap bm;
if (!buffer.readBitmap(&bm)) {
- return NULL;
+ return nullptr;
}
bm.setImmutable();
TileMode mx = (TileMode)buffer.readUInt();
@@ -75,7 +75,7 @@
SkMatrix totalInverse;
// Do this first, so we know the matrix can be inverted.
if (!this->computeTotalInverse(rec, &totalInverse)) {
- return NULL;
+ return nullptr;
}
void* stateStorage = (char*)storage + sizeof(BitmapProcShaderContext);
@@ -87,7 +87,7 @@
state->fOrigBitmap = fRawBitmap;
if (!state->chooseProcs(totalInverse, *rec.fPaint)) {
state->~SkBitmapProcState();
- return NULL;
+ return nullptr;
}
return new (storage) BitmapProcShaderContext(*this, rec, state);
@@ -212,7 +212,7 @@
*ctx = fState;
return (ShadeProc)fState->getShaderProc32();
}
- return NULL;
+ return nullptr;
}
void SkBitmapProcShader::BitmapProcShaderContext::shadeSpan16(int x, int y, uint16_t dstC[],
@@ -301,19 +301,19 @@
SkShader* shader;
SkColor color;
if (src.isNull() || bitmap_is_too_big(src)) {
- if (NULL == allocator) {
+ if (nullptr == allocator) {
shader = new SkEmptyShader;
} else {
shader = allocator->createT<SkEmptyShader>();
}
} else if (can_use_color_shader(src, &color)) {
- if (NULL == allocator) {
+ if (nullptr == allocator) {
shader = new SkColorShader(color);
} else {
shader = allocator->createT<SkColorShader>(color);
}
} else {
- if (NULL == allocator) {
+ if (nullptr == allocator) {
shader = new SkBitmapProcShader(src, tmx, tmy, localMatrix);
} else {
shader = allocator->createT<SkBitmapProcShader>(src, tmx, tmy, localMatrix);
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index 5179ff8..30f860a 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -18,7 +18,7 @@
class SkBitmapProcShader : public SkShader {
public:
SkBitmapProcShader(const SkBitmap& src, TileMode tx, TileMode ty,
- const SkMatrix* localMatrix = NULL);
+ const SkMatrix* localMatrix = nullptr);
// overrides from SkShader
bool isOpaque() const override;
@@ -72,7 +72,7 @@
// yet found a situation where the size below isn't big enough.
typedef SkSmallAllocator<3, 1152> SkTBlitterAllocator;
-// If alloc is non-NULL, it will be used to allocate the returned SkShader, and MUST outlive
+// If alloc is non-nullptr, it will be used to allocate the returned SkShader, and MUST outlive
// the SkShader.
SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode,
const SkMatrix* localMatrix, SkTBlitterAllocator* alloc);
diff --git a/src/core/SkBitmapProcState.cpp b/src/core/SkBitmapProcState.cpp
index 2227010..31109aa 100644
--- a/src/core/SkBitmapProcState.cpp
+++ b/src/core/SkBitmapProcState.cpp
@@ -37,7 +37,7 @@
#include "SkBitmapProcState_filter.h"
#include "SkBitmapProcState_procs.h"
-SkBitmapProcState::SkBitmapProcState() : fBMState(NULL) {}
+SkBitmapProcState::SkBitmapProcState() : fBMState(nullptr) {}
SkBitmapProcState::~SkBitmapProcState() {
SkInPlaceDeleteCheck(fBMState, fBMStateStorage.get());
@@ -122,7 +122,7 @@
fBMState = controller.requestBitmap(fOrigBitmap, inv, paint.getFilterQuality(),
fBMStateStorage.get(), fBMStateStorage.size());
// Note : we allow the controller to return an empty (zero-dimension) result. Should we?
- if (NULL == fBMState || fBMState->pixmap().info().isEmpty()) {
+ if (nullptr == fBMState || fBMState->pixmap().info().isEmpty()) {
return false;
}
fPixmap = fBMState->pixmap();
@@ -174,10 +174,10 @@
fAlphaScale = SkAlpha255To256(paint.getAlpha());
- fShaderProc32 = NULL;
- fShaderProc16 = NULL;
- fSampleProc32 = NULL;
- fSampleProc16 = NULL;
+ fShaderProc32 = nullptr;
+ fShaderProc16 = nullptr;
+ fSampleProc32 = nullptr;
+ fSampleProc16 = nullptr;
// recompute the triviality of the matrix here because we may have
// changed it!
@@ -201,8 +201,8 @@
bool SkBitmapProcState::chooseScanlineProcs(bool trivialMatrix, bool clampClamp,
const SkPaint& paint) {
fMatrixProc = this->chooseMatrixProc(trivialMatrix);
- // TODO(dominikg): SkASSERT(fMatrixProc) instead? chooseMatrixProc never returns NULL.
- if (NULL == fMatrixProc) {
+ // TODO(dominikg): SkASSERT(fMatrixProc) instead? chooseMatrixProc never returns nullptr.
+ if (nullptr == fMatrixProc) {
return false;
}
@@ -338,11 +338,11 @@
SI8_D16_filter_DX,
// Don't support 4444 -> 565
- NULL, NULL, NULL, NULL,
+ nullptr, nullptr, nullptr, nullptr,
// Don't support A8 -> 565
- NULL, NULL, NULL, NULL,
+ nullptr, nullptr, nullptr, nullptr,
// Don't support G8 -> 565 (but we could)
- NULL, NULL, NULL, NULL
+ nullptr, nullptr, nullptr, nullptr
};
#endif
@@ -364,7 +364,7 @@
fShaderProc32 = Clamp_S32_opaque_D32_nofilter_DX_shaderproc;
}
- if (NULL == fShaderProc32) {
+ if (nullptr == fShaderProc32) {
fShaderProc32 = this->chooseShaderProc32();
}
}
@@ -381,7 +381,7 @@
int count) {
SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
SkASSERT(s.fInvKy == 0);
- SkASSERT(count > 0 && colors != NULL);
+ SkASSERT(count > 0 && colors != nullptr);
SkASSERT(kNone_SkFilterQuality == s.fFilterLevel);
const int maxX = s.fPixmap.width() - 1;
@@ -455,7 +455,7 @@
int count) {
SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
SkASSERT(s.fInvKy == 0);
- SkASSERT(count > 0 && colors != NULL);
+ SkASSERT(count > 0 && colors != nullptr);
SkASSERT(kNone_SkFilterQuality == s.fFilterLevel);
const int stopX = s.fPixmap.width();
@@ -495,7 +495,7 @@
int count) {
SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) == 0);
SkASSERT(s.fInvKy == 0);
- SkASSERT(count > 0 && colors != NULL);
+ SkASSERT(count > 0 && colors != nullptr);
SkASSERT(1 == s.fPixmap.width());
int iY0;
@@ -633,7 +633,7 @@
SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() {
if (kN32_SkColorType != fPixmap.colorType()) {
- return NULL;
+ return nullptr;
}
static const unsigned kMask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
@@ -648,13 +648,13 @@
}
if (fAlphaScale < 256) {
- return NULL;
+ return nullptr;
}
if (fInvType > SkMatrix::kTranslate_Mask) {
- return NULL;
+ return nullptr;
}
if (kNone_SkFilterQuality != fFilterLevel) {
- return NULL;
+ return nullptr;
}
SkShader::TileMode tx = (SkShader::TileMode)fTileModeX;
@@ -672,7 +672,7 @@
}
return DoNothing_shaderproc;
}
- return NULL;
+ return nullptr;
}
///////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkBitmapProcState.h b/src/core/SkBitmapProcState.h
index 57fd273..814c79a 100644
--- a/src/core/SkBitmapProcState.h
+++ b/src/core/SkBitmapProcState.h
@@ -123,7 +123,7 @@
ShaderProc32 fShaderProc32; // chooseProcs
ShaderProc16 fShaderProc16; // chooseProcs
- // These are used if the shaderproc is NULL
+ // These are used if the shaderproc is nullptr
MatrixProc fMatrixProc; // chooseProcs
SampleProc32 fSampleProc32; // chooseProcs
SampleProc16 fSampleProc16; // chooseProcs
diff --git a/src/core/SkBitmapProcState_sample.h b/src/core/SkBitmapProcState_sample.h
index 5322a36..f70b758 100644
--- a/src/core/SkBitmapProcState_sample.h
+++ b/src/core/SkBitmapProcState_sample.h
@@ -41,7 +41,7 @@
void MAKENAME(_nofilter_DXDY)(const SkBitmapProcState& s,
const uint32_t* SK_RESTRICT xy,
int count, DSTTYPE* SK_RESTRICT colors) {
- SkASSERT(count > 0 && colors != NULL);
+ SkASSERT(count > 0 && colors != nullptr);
SkASSERT(kNone_SkFilterQuality == s.fFilterLevel);
SkDEBUGCODE(CHECKSTATE(s);)
@@ -83,7 +83,7 @@
void MAKENAME(_nofilter_DX)(const SkBitmapProcState& s,
const uint32_t* SK_RESTRICT xy,
int count, DSTTYPE* SK_RESTRICT colors) {
- SkASSERT(count > 0 && colors != NULL);
+ SkASSERT(count > 0 && colors != nullptr);
SkASSERT(s.fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask));
SkASSERT(kNone_SkFilterQuality == s.fFilterLevel);
SkDEBUGCODE(CHECKSTATE(s);)
@@ -138,7 +138,7 @@
void MAKENAME(_filter_DX)(const SkBitmapProcState& s,
const uint32_t* SK_RESTRICT xy,
int count, DSTTYPE* SK_RESTRICT colors) {
- SkASSERT(count > 0 && colors != NULL);
+ SkASSERT(count > 0 && colors != nullptr);
SkASSERT(s.fFilterLevel != kNone_SkFilterQuality);
SkDEBUGCODE(CHECKSTATE(s);)
@@ -184,7 +184,7 @@
void MAKENAME(_filter_DXDY)(const SkBitmapProcState& s,
const uint32_t* SK_RESTRICT xy,
int count, DSTTYPE* SK_RESTRICT colors) {
- SkASSERT(count > 0 && colors != NULL);
+ SkASSERT(count > 0 && colors != nullptr);
SkASSERT(s.fFilterLevel != kNone_SkFilterQuality);
SkDEBUGCODE(CHECKSTATE(s);)
diff --git a/src/core/SkBitmapProcState_shaderproc.h b/src/core/SkBitmapProcState_shaderproc.h
index 2708b01..94b2d3b 100644
--- a/src/core/SkBitmapProcState_shaderproc.h
+++ b/src/core/SkBitmapProcState_shaderproc.h
@@ -20,7 +20,7 @@
SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
SkMatrix::kScale_Mask)) == 0);
SkASSERT(s.fInvKy == 0);
- SkASSERT(count > 0 && colors != NULL);
+ SkASSERT(count > 0 && colors != nullptr);
SkASSERT(s.fFilterLevel != kNone_SkFilterQuality);
SkDEBUGCODE(CHECKSTATE(s);)
diff --git a/src/core/SkBitmapScaler.cpp b/src/core/SkBitmapScaler.cpp
index be79857..ff053a9 100644
--- a/src/core/SkBitmapScaler.cpp
+++ b/src/core/SkBitmapScaler.cpp
@@ -251,7 +251,7 @@
bool SkBitmapScaler::Resize(SkBitmap* resultPtr, const SkPixmap& source, ResizeMethod method,
float destWidth, float destHeight,
SkBitmap::Allocator* allocator) {
- if (NULL == source.addr() || source.colorType() != kN32_SkColorType ||
+ if (nullptr == source.addr() || source.colorType() != kN32_SkColorType ||
source.width() < 1 || source.height() < 1)
{
return false;
@@ -263,7 +263,7 @@
return false;
}
- SkConvolutionProcs convolveProcs= { 0, NULL, NULL, NULL, NULL };
+ SkConvolutionProcs convolveProcs= { 0, nullptr, nullptr, nullptr, nullptr };
PlatformConvolutionProcs(&convolveProcs);
SkRect destSubset = { 0, 0, destWidth, destHeight };
@@ -293,7 +293,7 @@
result.setInfo(SkImageInfo::MakeN32(SkScalarCeilToInt(destSubset.width()),
SkScalarCeilToInt(destSubset.height()),
source.alphaType()));
- result.allocPixels(allocator, NULL);
+ result.allocPixels(allocator, nullptr);
if (!result.readyToDraw()) {
return false;
}
diff --git a/src/core/SkBitmapScaler.h b/src/core/SkBitmapScaler.h
index c4c7f0a..1b7eef5 100644
--- a/src/core/SkBitmapScaler.h
+++ b/src/core/SkBitmapScaler.h
@@ -80,7 +80,7 @@
};
static bool Resize(SkBitmap* result, const SkPixmap& src, ResizeMethod method,
- float dest_width, float dest_height, SkBitmap::Allocator* = NULL);
+ float dest_width, float dest_height, SkBitmap::Allocator* = nullptr);
/** Platforms can also optionally overwrite the convolution functions
if we have SIMD versions of them.
diff --git a/src/core/SkBlitMask.h b/src/core/SkBlitMask.h
index d39c094..f36f9f3 100644
--- a/src/core/SkBlitMask.h
+++ b/src/core/SkBlitMask.h
@@ -54,7 +54,7 @@
/**
* Return either platform specific optimized blitcolor BlitLCD16RowProc,
- * or NULL if no optimized routine is available.
+ * or nullptr if no optimized routine is available.
*/
static BlitLCD16RowProc PlatformBlitRowProcs16(bool isOpaque);
@@ -64,13 +64,13 @@
/**
* Public entry-point to return a blitmask RowProc.
- * May return NULL if config or format are not supported.
+ * May return nullptr if config or format are not supported.
*/
static RowProc RowFactory(SkColorType, SkMask::Format, RowFlags);
/**
* Return either platform specific optimized blitmask RowProc,
- * or NULL if no optimized routine is available.
+ * or nullptr if no optimized routine is available.
*/
static RowProc PlatformRowProcs(SkColorType, SkMask::Format, RowFlags);
};
diff --git a/src/core/SkBlitMask_D32.cpp b/src/core/SkBlitMask_D32.cpp
index fb2991c..3cc791a 100644
--- a/src/core/SkBlitMask_D32.cpp
+++ b/src/core/SkBlitMask_D32.cpp
@@ -31,10 +31,10 @@
const uint16_t* srcRow = (const uint16_t*)mask;
SkPMColor opaqueDst;
- SkBlitMask::BlitLCD16RowProc proc = NULL;
+ SkBlitMask::BlitLCD16RowProc proc = nullptr;
bool isOpaque = (0xFF == SkColorGetA(color));
proc = SkBlitMask::BlitLCD16RowFactory(isOpaque);
- SkASSERT(proc != NULL);
+ SkASSERT(proc != nullptr);
if (isOpaque) {
opaqueDst = SkPreMultiplyColor(color);
@@ -283,8 +283,8 @@
static const RowProc gProcs[] = {
// need X coordinate to handle BW
- false ? (RowProc)BW_RowProc_Blend : NULL, // suppress unused warning
- false ? (RowProc)BW_RowProc_Opaque : NULL, // suppress unused warning
+ false ? (RowProc)BW_RowProc_Blend : nullptr, // suppress unused warning
+ false ? (RowProc)BW_RowProc_Opaque : nullptr, // suppress unused warning
(RowProc)A8_RowProc_Blend, (RowProc)A8_RowProc_Opaque,
(RowProc)LCD16_RowProc_Blend, (RowProc)LCD16_RowProc_Opaque,
};
@@ -297,7 +297,7 @@
case SkMask::kA8_Format: index = 2; break;
case SkMask::kLCD16_Format: index = 4; break;
default:
- return NULL;
+ return nullptr;
}
if (flags & kSrcIsOpaque_RowFlag) {
index |= 1;
@@ -307,5 +307,5 @@
default:
break;
}
- return NULL;
+ return nullptr;
}
diff --git a/src/core/SkBlitRow_D16.cpp b/src/core/SkBlitRow_D16.cpp
index 5aaa7a5..9ac84c6 100644
--- a/src/core/SkBlitRow_D16.cpp
+++ b/src/core/SkBlitRow_D16.cpp
@@ -246,7 +246,7 @@
flags &= kFlags16_Mask;
SkBlitRow::Proc16 proc = PlatformFactory565(flags);
- if (NULL == proc) {
+ if (nullptr == proc) {
proc = gDefault_565_Procs[flags];
}
return proc;
@@ -274,7 +274,7 @@
SkASSERT(flags < SK_ARRAY_COUNT(gDefault_565_ColorProcs));
SkBlitRow::ColorProc16 proc = PlatformColorFactory565(flags);
- if (NULL == proc) {
+ if (nullptr == proc) {
proc = gDefault_565_ColorProcs[flags];
}
return proc;
diff --git a/src/core/SkBlitRow_D32.cpp b/src/core/SkBlitRow_D32.cpp
index 559ee18..0f8cbe8 100644
--- a/src/core/SkBlitRow_D32.cpp
+++ b/src/core/SkBlitRow_D32.cpp
@@ -124,7 +124,7 @@
flags &= kFlags32_Mask;
SkBlitRow::Proc32 proc = PlatformProcs32(flags);
- if (NULL == proc) {
+ if (nullptr == proc) {
proc = gDefault_Procs32[flags];
}
SkASSERT(proc);
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index 62cd73e..1bc9963 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -29,11 +29,11 @@
}
SkShader::Context* SkBlitter::getShaderContext() const {
- return NULL;
+ return nullptr;
}
const SkPixmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
- return NULL;
+ return nullptr;
}
void SkBlitter::blitH(int x, int y, int width) {
@@ -243,7 +243,7 @@
void SkNullBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {}
const SkPixmap* SkNullBlitter::justAnOpaqueColor(uint32_t* value) {
- return NULL;
+ return nullptr;
}
bool SkNullBlitter::isNullBlitter() const { return true; }
@@ -553,7 +553,7 @@
if (clip->isEmpty() || (ir && !SkIRect::Intersects(clipR, *ir))) {
blitter = &fNullBlitter;
} else if (clip->isRect()) {
- if (ir == NULL || !clipR.contains(*ir)) {
+ if (ir == nullptr || !clipR.contains(*ir)) {
fRectBlitter.init(blitter, clipR);
blitter = &fRectBlitter;
}
@@ -589,12 +589,12 @@
}
Context* onCreateContext(const ContextRec& rec, void* storage) const override {
- SkShader::Context* proxyContext = NULL;
+ SkShader::Context* proxyContext = nullptr;
if (fProxy) {
char* proxyContextStorage = (char*) storage + sizeof(Sk3DShaderContext);
proxyContext = fProxy->createContext(rec, proxyContextStorage);
if (!proxyContext) {
- return NULL;
+ return nullptr;
}
}
return new (storage) Sk3DShaderContext(*this, rec, proxyContext);
@@ -606,7 +606,7 @@
Sk3DShaderContext(const Sk3DShader& shader, const ContextRec& rec,
SkShader::Context* proxyContext)
: INHERITED(shader, rec)
- , fMask(NULL)
+ , fMask(nullptr)
, fProxyContext(proxyContext)
{
if (!fProxyContext) {
@@ -627,8 +627,8 @@
fProxyContext->shadeSpan(x, y, span, count);
}
- if (fMask == NULL) {
- if (fProxyContext == NULL) {
+ if (fMask == nullptr) {
+ if (fProxyContext == nullptr) {
sk_memset32(span, fPMColor, count);
}
return;
@@ -761,7 +761,7 @@
fProxy->blitMask(mask, clip);
((SkMask*)&mask)->fFormat = SkMask::k3D_Format;
- fShaderContext->set3DMask(NULL);
+ fShaderContext->set3DMask(nullptr);
} else {
fProxy->blitMask(mask, clip);
}
@@ -782,7 +782,7 @@
const SkPaint& origPaint,
SkTBlitterAllocator* allocator,
bool drawCoverage) {
- SkASSERT(allocator != NULL);
+ SkASSERT(allocator != nullptr);
// which check, in case we're being called by a client with a dummy device
// (e.g. they have a bounder that always aborts the draw)
@@ -794,11 +794,11 @@
SkShader* shader = origPaint.getShader();
SkColorFilter* cf = origPaint.getColorFilter();
SkXfermode* mode = origPaint.getXfermode();
- Sk3DShader* shader3D = NULL;
+ Sk3DShader* shader3D = nullptr;
SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
- if (origPaint.getMaskFilter() != NULL &&
+ if (origPaint.getMaskFilter() != nullptr &&
origPaint.getMaskFilter()->getFormat() == SkMask::k3D_Format) {
shader3D = new Sk3DShader(shader);
// we know we haven't initialized lazyPaint yet, so just do it
@@ -810,8 +810,8 @@
bool deviceIsOpaque = kRGB_565_SkColorType == device.colorType();
switch (SkInterpretXfermode(*paint, deviceIsOpaque)) {
case kSrcOver_SkXfermodeInterpretation:
- mode = NULL;
- paint.writable()->setXfermode(NULL);
+ mode = nullptr;
+ paint.writable()->setXfermode(nullptr);
break;
case kSkipDrawing_SkXfermodeInterpretation:{
return allocator->createT<SkNullBlitter>();
@@ -828,13 +828,13 @@
*/
if (SkXfermode::IsMode(mode, SkXfermode::kClear_Mode)) {
SkPaint* p = paint.writable();
- shader = p->setShader(NULL);
- cf = p->setColorFilter(NULL);
+ shader = p->setShader(nullptr);
+ cf = p->setColorFilter(nullptr);
mode = p->setXfermodeMode(SkXfermode::kSrc_Mode);
p->setColor(0);
}
- if (NULL == shader) {
+ if (nullptr == shader) {
if (mode) {
// xfermodes (and filters) require shaders for our current blitters
shader = new SkColorShader(paint->getColor());
@@ -845,8 +845,8 @@
// our color and move on.
SkPaint* writablePaint = paint.writable();
writablePaint->setColor(cf->filterColor(paint->getColor()));
- writablePaint->setColorFilter(NULL);
- cf = NULL;
+ writablePaint->setColorFilter(nullptr);
+ cf = nullptr;
}
}
@@ -861,9 +861,9 @@
/*
* We create a SkShader::Context object, and store it on the blitter.
*/
- SkShader::Context* shaderContext = NULL;
+ SkShader::Context* shaderContext = nullptr;
if (shader) {
- SkShader::ContextRec rec(*paint, matrix, NULL);
+ SkShader::ContextRec rec(*paint, matrix, nullptr);
size_t contextSize = shader->contextSize();
if (contextSize) {
// Try to create the ShaderContext
@@ -880,12 +880,12 @@
}
}
- SkBlitter* blitter = NULL;
+ SkBlitter* blitter = nullptr;
switch (device.colorType()) {
case kAlpha_8_SkColorType:
if (drawCoverage) {
- SkASSERT(NULL == shader);
- SkASSERT(NULL == paint->getXfermode());
+ SkASSERT(nullptr == shader);
+ SkASSERT(nullptr == paint->getXfermode());
blitter = allocator->createT<SkA8_Coverage_Blitter>(device, *paint);
} else if (shader) {
blitter = allocator->createT<SkA8_Shader_Blitter>(device, *paint, shaderContext);
@@ -933,7 +933,7 @@
public:
SkZeroShaderContext(const SkShader& shader, const SkShader::ContextRec& rec)
// Override rec with the identity matrix, so it is guaranteed to be invertible.
- : INHERITED(shader, SkShader::ContextRec(*rec.fPaint, SkMatrix::I(), NULL)) {}
+ : INHERITED(shader, SkShader::ContextRec(*rec.fPaint, SkMatrix::I(), nullptr)) {}
void shadeSpan(int x, int y, SkPMColor colors[], int count) override {
sk_bzero(colors, count * sizeof(SkPMColor));
@@ -967,7 +967,7 @@
// shader to create it. It is therefore safe to re-use the storage.
fShaderContext->~Context();
SkShader::Context* ctx = fShader->createContext(rec, (void*)fShaderContext);
- if (NULL == ctx) {
+ if (nullptr == ctx) {
// Need a valid context in fShaderContext's storage, so we can later (or our caller) call
// the in-place destructor.
new (fShaderContext) SkZeroShaderContext(*fShader, rec);
diff --git a/src/core/SkBlitter.h b/src/core/SkBlitter.h
index baa9ccc..5740a5e 100644
--- a/src/core/SkBlitter.h
+++ b/src/core/SkBlitter.h
@@ -50,7 +50,7 @@
virtual void blitMask(const SkMask&, const SkIRect& clip);
/** If the blitter just sets a single value for each pixel, return the
- bitmap it draws into, and assign value. If not, return NULL and ignore
+ bitmap it draws into, and assign value. If not, return nullptr and ignore
the value parameter.
*/
virtual const SkPixmap* justAnOpaqueColor(uint32_t* value);
@@ -109,7 +109,7 @@
* This function allocates memory for the blitter that the blitter then owns.
* The memory can be used by the calling function at will, but it will be
* released when the blitter's destructor is called. This function returns
- * NULL if no persistent memory is needed by the blitter.
+ * nullptr if no persistent memory is needed by the blitter.
*/
virtual void* allocBlitMemory(size_t sz) {
return fBlitMemory.reset(sz, SkAutoMalloc::kReuse_OnShrink);
@@ -229,7 +229,7 @@
class SkBlitterClipper {
public:
SkBlitter* apply(SkBlitter* blitter, const SkRegion* clip,
- const SkIRect* bounds = NULL);
+ const SkIRect* bounds = nullptr);
private:
SkNullBlitter fNullBlitter;
diff --git a/src/core/SkBlitter_A8.cpp b/src/core/SkBlitter_A8.cpp
index ce7d6e7..51748b0 100644
--- a/src/core/SkBlitter_A8.cpp
+++ b/src/core/SkBlitter_A8.cpp
@@ -21,7 +21,7 @@
*value = 255;
return &fDevice;
}
- return NULL;
+ return nullptr;
}
void SkA8_Blitter::blitH(int x, int y, int width) {
@@ -231,7 +231,7 @@
SkShader::Context* shaderContext)
: INHERITED(device, paint, shaderContext)
{
- if ((fXfermode = paint.getXfermode()) != NULL) {
+ if ((fXfermode = paint.getXfermode()) != nullptr) {
fXfermode->ref();
SkASSERT(fShaderContext);
}
@@ -260,7 +260,7 @@
shaderContext->shadeSpan(x, y, span, width);
if (fXfermode) {
- fXfermode->xferA8(device, span, width, NULL);
+ fXfermode->xferA8(device, span, width, nullptr);
} else {
for (int i = width - 1; i >= 0; --i) {
unsigned srcA = SkGetPackedA32(span[i]);
@@ -298,7 +298,7 @@
}
int aa = *antialias;
if (aa) {
- if (opaque && aa == 255 && mode == NULL) {
+ if (opaque && aa == 255 && mode == nullptr) {
memset(device, 0xFF, count);
} else {
shaderContext->shadeSpan(x, y, span, count);
@@ -355,9 +355,9 @@
SkA8_Coverage_Blitter::SkA8_Coverage_Blitter(const SkPixmap& device,
const SkPaint& paint) : SkRasterBlitter(device) {
- SkASSERT(NULL == paint.getShader());
- SkASSERT(NULL == paint.getXfermode());
- SkASSERT(NULL == paint.getColorFilter());
+ SkASSERT(nullptr == paint.getShader());
+ SkASSERT(nullptr == paint.getXfermode());
+ SkASSERT(nullptr == paint.getColorFilter());
}
void SkA8_Coverage_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
@@ -430,5 +430,5 @@
}
const SkPixmap* SkA8_Coverage_Blitter::justAnOpaqueColor(uint32_t*) {
- return NULL;
+ return nullptr;
}
diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp
index 683acf0..e44ad02 100644
--- a/src/core/SkBlitter_ARGB32.cpp
+++ b/src/core/SkBlitter_ARGB32.cpp
@@ -59,7 +59,7 @@
*value = fPMColor;
return &fDevice;
}
- return NULL;
+ return nullptr;
}
#if defined _WIN32 && _MSC_VER >= 1300 // disable warning : local variable used without having been initialized
@@ -338,7 +338,7 @@
fProc32Blend = SkBlitRow::Factory32(flags | SkBlitRow::kGlobalAlpha_Flag32);
fShadeDirectlyIntoDevice = false;
- if (fXfermode == NULL) {
+ if (fXfermode == nullptr) {
if (shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) {
fShadeDirectlyIntoDevice = true;
}
@@ -371,7 +371,7 @@
SkPMColor* span = fBuffer;
fShaderContext->shadeSpan(x, y, span, width);
if (fXfermode) {
- fXfermode->xfer32(device, span, width, NULL);
+ fXfermode->xfer32(device, span, width, nullptr);
} else {
fProc32(device, span, width, 255);
}
@@ -401,7 +401,7 @@
SkXfermode* xfer = fXfermode;
if (xfer) {
do {
- xfer->xfer32(device, span, width, NULL);
+ xfer->xfer32(device, span, width, nullptr);
y += 1;
device = (uint32_t*)((char*)device + deviceRB);
} while (--height > 0);
@@ -438,7 +438,7 @@
if (xfer) {
do {
shaderContext->shadeSpan(x, y, span, width);
- xfer->xfer32(device, span, width, NULL);
+ xfer->xfer32(device, span, width, nullptr);
y += 1;
device = (uint32_t*)((char*)device + deviceRB);
} while (--height > 0);
@@ -471,7 +471,7 @@
if (aa) {
shaderContext->shadeSpan(x, y, span, count);
if (aa == 255) {
- xfer->xfer32(device, span, count, NULL);
+ xfer->xfer32(device, span, count, nullptr);
} else {
// count is almost always 1
for (int i = count - 1; i >= 0; --i) {
@@ -539,7 +539,7 @@
SkASSERT(mask.fBounds.contains(clip));
SkShader::Context* shaderContext = fShaderContext;
- SkBlitMask::RowProc proc = NULL;
+ SkBlitMask::RowProc proc = nullptr;
if (!fXfermode) {
unsigned flags = 0;
if (shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) {
@@ -547,7 +547,7 @@
}
proc = SkBlitMask::RowFactory(kN32_SkColorType, mask.fFormat,
(SkBlitMask::RowFlags)flags);
- if (NULL == proc) {
+ if (nullptr == proc) {
this->INHERITED::blitMask(mask, clip);
return;
}
diff --git a/src/core/SkBlitter_RGB16.cpp b/src/core/SkBlitter_RGB16.cpp
index d87c636..06dfeea 100644
--- a/src/core/SkBlitter_RGB16.cpp
+++ b/src/core/SkBlitter_RGB16.cpp
@@ -172,9 +172,9 @@
#ifdef USE_BLACK_BLITTER
SkRGB16_Black_Blitter::SkRGB16_Black_Blitter(const SkPixmap& device, const SkPaint& paint)
: INHERITED(device, paint) {
- SkASSERT(paint.getShader() == NULL);
- SkASSERT(paint.getColorFilter() == NULL);
- SkASSERT(paint.getXfermode() == NULL);
+ SkASSERT(paint.getShader() == nullptr);
+ SkASSERT(paint.getColorFilter() == nullptr);
+ SkASSERT(paint.getXfermode() == nullptr);
SkASSERT(paint.getColor() == SK_ColorBLACK);
}
@@ -568,7 +568,7 @@
*value = fRawColor16;
return &fDevice;
}
- return NULL;
+ return nullptr;
}
void SkRGB16_Blitter::blitH(int x, int y, int width) {
@@ -822,7 +822,7 @@
SkShader::Context* shaderContext)
: INHERITED(device, paint, shaderContext)
{
- SkASSERT(paint.getXfermode() == NULL);
+ SkASSERT(paint.getXfermode() == nullptr);
fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * sizeof(SkPMColor));
@@ -970,7 +970,7 @@
SkPMColor* span = fBuffer;
fShaderContext->shadeSpan(x, y, span, width);
- fXfermode->xfer16(device, span, width, NULL);
+ fXfermode->xfer16(device, span, width, nullptr);
}
void SkRGB16_Shader_Xfermode_Blitter::blitAntiH(int x, int y,
@@ -1006,7 +1006,7 @@
SkPMColor* localSpan = span;
for (;;) {
if (aa == 0xFF) {
- mode->xfer16(device, localSpan, count, NULL);
+ mode->xfer16(device, localSpan, count, nullptr);
} else {
SkASSERT(aa);
memset(aaExpand, aa, count);
@@ -1033,17 +1033,17 @@
SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
SkShader::Context* shaderContext,
SkTBlitterAllocator* allocator) {
- SkASSERT(allocator != NULL);
+ SkASSERT(allocator != nullptr);
SkBlitter* blitter;
SkShader* shader = paint.getShader();
SkXfermode* mode = paint.getXfermode();
// we require a shader if there is an xfermode, handled by our caller
- SkASSERT(NULL == mode || shader);
+ SkASSERT(nullptr == mode || shader);
if (shader) {
- SkASSERT(shaderContext != NULL);
+ SkASSERT(shaderContext != nullptr);
if (mode) {
blitter = allocator->createT<SkRGB16_Shader_Xfermode_Blitter>(device, paint,
shaderContext);
diff --git a/src/core/SkBlitter_Sprite.cpp b/src/core/SkBlitter_Sprite.cpp
index 6dc5785..605fa43 100644
--- a/src/core/SkBlitter_Sprite.cpp
+++ b/src/core/SkBlitter_Sprite.cpp
@@ -51,7 +51,7 @@
paint and return null if it is set, forcing the client to take the slow shader case
(which does respect soft edges).
*/
- SkASSERT(allocator != NULL);
+ SkASSERT(allocator != nullptr);
SkSpriteBlitter* blitter;
@@ -63,7 +63,7 @@
blitter = SkSpriteBlitter::ChooseD32(source, paint, allocator);
break;
default:
- blitter = NULL;
+ blitter = nullptr;
break;
}
diff --git a/src/core/SkBuffer.cpp b/src/core/SkBuffer.cpp
index 51c368a..86c3bed 100644
--- a/src/core/SkBuffer.cpp
+++ b/src/core/SkBuffer.cpp
@@ -22,7 +22,7 @@
const void* SkRBuffer::skip(size_t size)
{
const void* result = fPos;
- readNoSizeCheck(NULL, size);
+ readNoSizeCheck(nullptr, size);
return result;
}
@@ -45,8 +45,8 @@
void* SkWBuffer::skip(size_t size)
{
void* result = fPos;
- writeNoSizeCheck(NULL, size);
- return fData == NULL ? NULL : result;
+ writeNoSizeCheck(nullptr, size);
+ return fData == nullptr ? nullptr : result;
}
void SkWBuffer::writeNoSizeCheck(const void* buffer, size_t size)
diff --git a/src/core/SkCachedData.cpp b/src/core/SkCachedData.cpp
index 439c2ff..cfa4c61 100644
--- a/src/core/SkCachedData.cpp
+++ b/src/core/SkCachedData.cpp
@@ -151,7 +151,7 @@
SkASSERT(ptr);
this->setData(ptr);
} else {
- this->setData(NULL); // signal failure to lock, contents are gone
+ this->setData(nullptr); // signal failure to lock, contents are gone
}
break;
}
@@ -173,7 +173,7 @@
}
break;
}
- this->setData(NULL); // signal that we're in an unlocked state
+ this->setData(nullptr); // signal that we're in an unlocked state
}
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -192,7 +192,7 @@
}
} else {
SkASSERT((fInCache && 1 == fRefCnt) || (0 == fRefCnt));
- SkASSERT(NULL == fData);
+ SkASSERT(nullptr == fData);
}
}
#endif
diff --git a/src/core/SkCachedData.h b/src/core/SkCachedData.h
index d44fbc5..739be72 100644
--- a/src/core/SkCachedData.h
+++ b/src/core/SkCachedData.h
@@ -36,7 +36,7 @@
}
protected:
- // called when fData changes. could be NULL.
+ // called when fData changes. could be nullptr.
virtual void onDataChange(void* oldData, void* newData) {}
private:
@@ -93,7 +93,7 @@
* ref's the data (typically from a find(key, visitor) call).
*
* Thus the data will always be "locked" when a non-cache has a ref on it (whether or not
- * the lock succeeded to recover the memory -- check data() to see if it is NULL).
+ * the lock succeeded to recover the memory -- check data() to see if it is nullptr).
*/
/*
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 03c5173..7043ec3 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -194,16 +194,16 @@
DeviceCM(SkBaseDevice* device, const SkPaint* paint, SkCanvas* canvas,
bool conservativeRasterClip, bool deviceIsBitmapDevice)
- : fNext(NULL)
+ : fNext(nullptr)
, fClip(conservativeRasterClip)
, fDeviceIsBitmapDevice(deviceIsBitmapDevice)
{
- if (NULL != device) {
+ if (nullptr != device) {
device->ref();
device->onAttachToCanvas(canvas);
}
fDevice = device;
- fPaint = paint ? new SkPaint(*paint) : NULL;
+ fPaint = paint ? new SkPaint(*paint) : nullptr;
}
~DeviceCM() {
@@ -284,9 +284,9 @@
int fDeferredSaveCount;
MCRec(bool conservativeRasterClip) : fRasterClip(conservativeRasterClip) {
- fFilter = NULL;
- fLayer = NULL;
- fTopLayer = NULL;
+ fFilter = nullptr;
+ fLayer = nullptr;
+ fTopLayer = nullptr;
fMatrix.reset();
fDeferredSaveCount = 0;
@@ -295,7 +295,7 @@
}
MCRec(const MCRec& prev) : fRasterClip(prev.fRasterClip), fMatrix(prev.fMatrix) {
fFilter = SkSafeRef(prev.fFilter);
- fLayer = NULL;
+ fLayer = nullptr;
fTopLayer = prev.fTopLayer;
fDeferredSaveCount = 0;
@@ -346,13 +346,13 @@
fRC = &rec->fClip;
fDevice = rec->fDevice;
if (!fDevice->accessPixels(&fDst)) {
- fDst.reset(fDevice->imageInfo(), NULL, 0);
+ fDst.reset(fDevice->imageInfo(), nullptr, 0);
}
fPaint = rec->fPaint;
SkDEBUGCODE(this->validate();)
fCurrLayer = rec->fNext;
- // fCurrLayer may be NULL now
+ // fCurrLayer may be nullptr now
return true;
}
@@ -383,21 +383,21 @@
/**
* If the paint has an imagefilter, but it can be simplified to just a colorfilter, return that
- * colorfilter, else return NULL.
+ * colorfilter, else return nullptr.
*/
static SkColorFilter* image_to_color_filter(const SkPaint& paint) {
SkImageFilter* imgf = paint.getImageFilter();
if (!imgf) {
- return NULL;
+ return nullptr;
}
SkColorFilter* imgCF;
if (!imgf->asAColorFilter(&imgCF)) {
- return NULL;
+ return nullptr;
}
SkColorFilter* paintCF = paint.getColorFilter();
- if (NULL == paintCF) {
+ if (nullptr == paintCF) {
// there is no existing paint colorfilter, so we can just return the imagefilter's
return imgCF;
}
@@ -412,7 +412,7 @@
public:
AutoDrawLooper(SkCanvas* canvas, const SkSurfaceProps& props, const SkPaint& paint,
bool skipLayerForImageFilter = false,
- const SkRect* bounds = NULL) : fOrigPaint(paint) {
+ const SkRect* bounds = nullptr) : fOrigPaint(paint) {
fCanvas = canvas;
fFilter = canvas->getDrawFilter();
fPaint = &fOrigPaint;
@@ -424,7 +424,7 @@
if (simplifiedCF) {
SkPaint* paint = set_if_needed(&fLazyPaintInit, fOrigPaint);
paint->setColorFilter(simplifiedCF)->unref();
- paint->setImageFilter(NULL);
+ paint->setImageFilter(nullptr);
fPaint = paint;
}
@@ -459,7 +459,7 @@
fLooperContext = looper->createContext(canvas, buffer);
fIsSimple = false;
} else {
- fLooperContext = NULL;
+ fLooperContext = nullptr;
// can we be marked as simple?
fIsSimple = !fFilter && !fTempLayerForImageFilter;
}
@@ -516,7 +516,7 @@
};
bool AutoDrawLooper::doNext(SkDrawFilter::Type drawType) {
- fPaint = NULL;
+ fPaint = nullptr;
SkASSERT(!fIsSimple);
SkASSERT(fLooperContext || fFilter || fTempLayerForImageFilter);
@@ -525,8 +525,8 @@
paint->setFlags(fNewPaintFlags);
if (fTempLayerForImageFilter) {
- paint->setImageFilter(NULL);
- paint->setXfermode(NULL);
+ paint->setImageFilter(nullptr);
+ paint->setXfermode(nullptr);
}
if (fLooperContext && !fLooperContext->next(fCanvas, paint)) {
@@ -538,7 +538,7 @@
fDone = true;
return false;
}
- if (NULL == fLooperContext) {
+ if (nullptr == fLooperContext) {
// no looper means we only draw once
fDone = true;
}
@@ -552,7 +552,7 @@
// call this after any possible paint modifiers
if (fPaint->nothingToDraw()) {
- fPaint = NULL;
+ fPaint = nullptr;
return false;
}
return true;
@@ -602,7 +602,7 @@
fAllowSimplifyClip = false;
fDeviceCMDirty = true;
fSaveCount = 1;
- fMetaData = NULL;
+ fMetaData = nullptr;
fClipStack.reset(new SkClipStack);
@@ -611,11 +611,11 @@
SkASSERT(sizeof(DeviceCM) <= sizeof(fDeviceCMStorage));
fMCRec->fLayer = (DeviceCM*)fDeviceCMStorage;
- new (fDeviceCMStorage) DeviceCM(NULL, NULL, NULL, fConservativeRasterClip, false);
+ new (fDeviceCMStorage) DeviceCM(nullptr, nullptr, nullptr, fConservativeRasterClip, false);
fMCRec->fTopLayer = fMCRec->fLayer;
- fSurfaceBase = NULL;
+ fSurfaceBase = nullptr;
if (device) {
// The root device and the canvas should always have the same pixel geometry
@@ -636,7 +636,7 @@
{
inc_canvas();
- this->init(NULL, kDefault_InitFlags);
+ this->init(nullptr, kDefault_InitFlags);
}
static SkBitmap make_nopixels(int width, int height) {
@@ -739,7 +739,7 @@
SkMetaData& SkCanvas::getMetaData() {
// metadata users are rare, so we lazily allocate it. If that changes we
// can decide to just make it a field in the device (rather than a ptr)
- if (NULL == fMetaData) {
+ if (nullptr == fMetaData) {
fMetaData = new SkMetaData;
}
return *fMetaData;
@@ -789,7 +789,7 @@
}
bool weAllocated = false;
- if (NULL == bitmap->pixelRef()) {
+ if (nullptr == bitmap->pixelRef()) {
if (!bitmap->tryAllocPixels()) {
return false;
}
@@ -805,7 +805,7 @@
}
if (weAllocated) {
- bitmap->setPixelRef(NULL);
+ bitmap->setPixelRef(nullptr);
}
return false;
}
@@ -867,7 +867,7 @@
default:
break;
}
- if (NULL == pixels || rowBytes < origInfo.minRowBytes()) {
+ if (nullptr == pixels || rowBytes < origInfo.minRowBytes()) {
return false;
}
@@ -915,13 +915,13 @@
const SkRasterClip& totalClip = fMCRec->fRasterClip;
DeviceCM* layer = fMCRec->fTopLayer;
- if (NULL == layer->fNext) { // only one layer
- layer->updateMC(totalMatrix, totalClip, *fClipStack, NULL);
+ if (nullptr == layer->fNext) { // only one layer
+ layer->updateMC(totalMatrix, totalClip, *fClipStack, nullptr);
} else {
SkRasterClip clip(totalClip);
do {
layer->updateMC(totalMatrix, clip, *fClipStack, &clip);
- } while ((layer = layer->fNext) != NULL);
+ } while ((layer = layer->fNext) != nullptr);
}
fDeviceCMDirty = false;
}
@@ -1056,7 +1056,7 @@
int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint) {
if (gIgnoreSaveLayerBounds) {
- bounds = NULL;
+ bounds = nullptr;
}
SaveLayerStrategy strategy = this->willSaveLayer(bounds, paint, kARGB_ClipLayer_SaveFlag);
fSaveCount += 1;
@@ -1066,7 +1066,7 @@
int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags) {
if (gIgnoreSaveLayerBounds) {
- bounds = NULL;
+ bounds = nullptr;
}
SaveLayerStrategy strategy = this->willSaveLayer(bounds, paint, flags);
fSaveCount += 1;
@@ -1087,7 +1087,7 @@
fDeviceCMDirty = true;
SkIRect ir;
- if (!this->clipRectBounds(bounds, flags, &ir, paint ? paint->getImageFilter() : NULL)) {
+ if (!this->clipRectBounds(bounds, flags, &ir, paint ? paint->getImageFilter() : nullptr)) {
return;
}
@@ -1110,7 +1110,7 @@
isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
SkBaseDevice* device = this->getTopDevice();
- if (NULL == device) {
+ if (nullptr == device) {
SkDebugf("Unable to find device for layer.");
return;
}
@@ -1120,11 +1120,11 @@
const SkBaseDevice::TileUsage usage = SkBaseDevice::kNever_TileUsage;
const SkBaseDevice::CreateInfo createInfo = SkBaseDevice::CreateInfo(info, usage, geo);
SkBaseDevice* newDev = device->onCreateDevice(createInfo, paint);
- if (NULL == newDev) {
+ if (nullptr == newDev) {
// If onCreateDevice didn't succeed, try raster (e.g. PDF couldn't handle the paint)
const SkSurfaceProps surfaceProps(fProps.flags(), createInfo.fPixelGeometry);
newDev = SkBitmapDevice::Create(createInfo.fInfo, surfaceProps);
- if (NULL == newDev) {
+ if (nullptr == newDev) {
SkErrorInternals::SetError(kInternalError_SkError,
"Unable to create device for layer.");
return;
@@ -1151,7 +1151,7 @@
int SkCanvas::saveLayerAlpha(const SkRect* bounds, U8CPU alpha,
SaveFlags flags) {
if (0xFF == alpha) {
- return this->saveLayer(bounds, NULL, flags);
+ return this->saveLayer(bounds, nullptr, flags);
} else {
SkPaint tmpPaint;
tmpPaint.setAlpha(alpha);
@@ -1170,7 +1170,7 @@
// reserve our layer (if any)
DeviceCM* layer = fMCRec->fLayer; // may be null
// now detach it from fMCRec so we can pop(). Gets freed after its drawn
- fMCRec->fLayer = NULL;
+ fMCRec->fLayer = nullptr;
// now do the normal restore()
fMCRec->~MCRec(); // balanced in save()
@@ -1198,7 +1198,7 @@
}
SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
- if (NULL == props) {
+ if (nullptr == props) {
props = &fProps;
}
return this->onNewSurface(info, *props);
@@ -1206,7 +1206,7 @@
SkSurface* SkCanvas::onNewSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
SkBaseDevice* dev = this->getDevice();
- return dev ? dev->newSurface(info, props) : NULL;
+ return dev ? dev->newSurface(info, props) : nullptr;
}
SkImageInfo SkCanvas::imageInfo() const {
@@ -1221,7 +1221,7 @@
const void* SkCanvas::peekPixels(SkImageInfo* info, size_t* rowBytes) {
SkPixmap pmap;
if (!this->onPeekPixels(&pmap)) {
- return NULL;
+ return nullptr;
}
if (info) {
*info = pmap.info();
@@ -1240,7 +1240,7 @@
void* SkCanvas::accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin) {
SkPixmap pmap;
if (!this->onAccessTopLayerPixels(&pmap)) {
- return NULL;
+ return nullptr;
}
if (info) {
*info = pmap.info();
@@ -1261,13 +1261,13 @@
SkAutoROCanvasPixels::SkAutoROCanvasPixels(SkCanvas* canvas) {
fAddr = canvas->peekPixels(&fInfo, &fRowBytes);
- if (NULL == fAddr) {
+ if (nullptr == fAddr) {
fInfo = canvas->imageInfo();
if (kUnknown_SkColorType == fInfo.colorType() || !fBitmap.tryAllocPixels(fInfo)) {
- return; // failure, fAddr is NULL
+ return; // failure, fAddr is nullptr
}
if (!canvas->readPixels(&fBitmap, 0, 0)) {
- return; // failure, fAddr is NULL
+ return; // failure, fAddr is nullptr
}
fAddr = fBitmap.getPixels();
fRowBytes = fBitmap.rowBytes();
@@ -1292,14 +1292,14 @@
}
SkLazyPaint lazy;
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = lazy.init();
}
SkDEBUGCODE(bitmap.validate();)
SkRect storage;
- const SkRect* bounds = NULL;
+ const SkRect* bounds = nullptr;
if (paint && paint->canComputeFastBounds()) {
bitmap.getBounds(&storage);
matrix.mapRect(&storage);
@@ -1318,7 +1318,7 @@
void SkCanvas::internalDrawDevice(SkBaseDevice* srcDev, int x, int y,
const SkPaint* paint, bool deviceIsBitmapDevice) {
SkPaint tmp;
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = &tmp;
}
@@ -1340,7 +1340,7 @@
SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
if (filter->filterImage(&proxy, src, ctx, &dst, &offset)) {
SkPaint tmpUnfiltered(*paint);
- tmpUnfiltered.setImageFilter(NULL);
+ tmpUnfiltered.setImageFilter(nullptr);
dstDev->drawSprite(iter, dst, pos.x() + offset.x(), pos.y() + offset.y(),
tmpUnfiltered);
}
@@ -1370,7 +1370,7 @@
SkDEBUGCODE(bitmap.validate();)
SkPaint tmp;
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = &tmp;
}
@@ -1391,7 +1391,7 @@
SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
if (filter->filterImage(&proxy, bitmap, ctx, &dst, &offset)) {
SkPaint tmpUnfiltered(*paint);
- tmpUnfiltered.setImageFilter(NULL);
+ tmpUnfiltered.setImageFilter(nullptr);
iter.fDevice->drawSprite(iter, dst, pos.x() + offset.x(), pos.y() + offset.y(),
tmpUnfiltered);
}
@@ -1648,7 +1648,7 @@
SkClipStack::B2TIter iter(*fClipStack);
const SkClipStack::Element* element;
- while ((element = iter.next()) != NULL) {
+ while ((element = iter.next()) != nullptr) {
switch (element->getType()) {
case SkClipStack::Element::kRect_Type:
element->getRect().round(&ir);
@@ -1672,7 +1672,7 @@
SkClipStack::B2TIter iter(*fClipStack);
const SkClipStack::Element* element;
- while ((element = iter.next()) != NULL) {
+ while ((element = iter.next()) != nullptr) {
element->replay(visitor);
}
}
@@ -1770,7 +1770,7 @@
GrRenderTarget* SkCanvas::internal_private_accessTopLayerRenderTarget() {
SkBaseDevice* dev = this->getTopDevice();
- return dev ? dev->accessRenderTarget() : NULL;
+ return dev ? dev->accessRenderTarget() : nullptr;
}
GrContext* SkCanvas::getGrContext() {
@@ -1784,7 +1784,7 @@
}
#endif
- return NULL;
+ return nullptr;
}
@@ -1967,7 +1967,7 @@
}
void SkCanvas::internalDrawPaint(const SkPaint& paint) {
- LOOPER_BEGIN_CHECK_COMPLETE_OVERWRITE(paint, SkDrawFilter::kPaint_Type, NULL, false)
+ LOOPER_BEGIN_CHECK_COMPLETE_OVERWRITE(paint, SkDrawFilter::kPaint_Type, nullptr, false)
while (iter.next()) {
iter.fDevice->drawPaint(iter, looper.paint());
@@ -1984,7 +1984,7 @@
}
SkRect r, storage;
- const SkRect* bounds = NULL;
+ const SkRect* bounds = nullptr;
if (paint.canComputeFastBounds()) {
// special-case 2 points (common for drawing a single line)
if (2 == count) {
@@ -1998,7 +1998,7 @@
}
}
- SkASSERT(pts != NULL);
+ SkASSERT(pts != nullptr);
LOOPER_BEGIN(paint, SkDrawFilter::kPoint_Type, bounds)
@@ -2012,7 +2012,7 @@
void SkCanvas::onDrawRect(const SkRect& r, const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawRect()");
SkRect storage;
- const SkRect* bounds = NULL;
+ const SkRect* bounds = nullptr;
if (paint.canComputeFastBounds()) {
// Skia will draw an inverted rect, because it explicitly "sorts" it downstream.
// To prevent accidental rejecting at this stage, we have to sort it before we check.
@@ -2037,7 +2037,7 @@
void SkCanvas::onDrawOval(const SkRect& oval, const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawOval()");
SkRect storage;
- const SkRect* bounds = NULL;
+ const SkRect* bounds = nullptr;
if (paint.canComputeFastBounds()) {
bounds = &paint.computeFastBounds(oval, &storage);
if (this->quickReject(*bounds)) {
@@ -2057,7 +2057,7 @@
void SkCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawRRect()");
SkRect storage;
- const SkRect* bounds = NULL;
+ const SkRect* bounds = nullptr;
if (paint.canComputeFastBounds()) {
bounds = &paint.computeFastBounds(rrect.getBounds(), &storage);
if (this->quickReject(*bounds)) {
@@ -2087,7 +2087,7 @@
void SkCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
const SkPaint& paint) {
SkRect storage;
- const SkRect* bounds = NULL;
+ const SkRect* bounds = nullptr;
if (paint.canComputeFastBounds()) {
bounds = &paint.computeFastBounds(outer.getBounds(), &storage);
if (this->quickReject(*bounds)) {
@@ -2111,7 +2111,7 @@
}
SkRect storage;
- const SkRect* bounds = NULL;
+ const SkRect* bounds = nullptr;
if (!path.isInverseFillType() && paint.canComputeFastBounds()) {
const SkRect& pathBounds = path.getBounds();
bounds = &paint.computeFastBounds(pathBounds, &storage);
@@ -2141,7 +2141,7 @@
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawImage()");
SkRect bounds = SkRect::MakeXYWH(x, y,
SkIntToScalar(image->width()), SkIntToScalar(image->height()));
- if (NULL == paint || paint->canComputeFastBounds()) {
+ if (nullptr == paint || paint->canComputeFastBounds()) {
if (paint) {
paint->computeFastBounds(bounds, &bounds);
}
@@ -2151,7 +2151,7 @@
}
SkLazyPaint lazy;
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = lazy.init();
}
@@ -2169,7 +2169,7 @@
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawImageRect()");
SkRect storage;
const SkRect* bounds = &dst;
- if (NULL == paint || paint->canComputeFastBounds()) {
+ if (nullptr == paint || paint->canComputeFastBounds()) {
if (paint) {
bounds = &paint->computeFastBounds(dst, &storage);
}
@@ -2178,7 +2178,7 @@
}
}
SkLazyPaint lazy;
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = lazy.init();
}
@@ -2196,7 +2196,7 @@
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawBitmap()");
SkDEBUGCODE(bitmap.validate();)
- if (NULL == paint || paint->canComputeFastBounds()) {
+ if (nullptr == paint || paint->canComputeFastBounds()) {
SkRect bounds = {
x, y,
x + SkIntToScalar(bitmap.width()),
@@ -2225,7 +2225,7 @@
SkRect storage;
const SkRect* bounds = &dst;
- if (NULL == paint || paint->canComputeFastBounds()) {
+ if (nullptr == paint || paint->canComputeFastBounds()) {
if (paint) {
bounds = &paint->computeFastBounds(dst, &storage);
}
@@ -2235,7 +2235,7 @@
}
SkLazyPaint lazy;
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = lazy.init();
}
@@ -2262,7 +2262,7 @@
SkRect storage;
const SkRect* bounds = &dst;
- if (NULL == paint || paint->canComputeFastBounds()) {
+ if (nullptr == paint || paint->canComputeFastBounds()) {
if (paint) {
bounds = &paint->computeFastBounds(dst, &storage);
}
@@ -2272,7 +2272,7 @@
}
SkLazyPaint lazy;
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = lazy.init();
}
@@ -2292,7 +2292,7 @@
SkRect storage;
const SkRect* bounds = &dst;
- if (NULL == paint || paint->canComputeFastBounds()) {
+ if (nullptr == paint || paint->canComputeFastBounds()) {
if (paint) {
bounds = &paint->computeFastBounds(dst, &storage);
}
@@ -2302,7 +2302,7 @@
}
SkLazyPaint lazy;
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = lazy.init();
}
@@ -2349,12 +2349,12 @@
void SkCanvas::DrawTextDecorations(const SkDraw& draw, const SkPaint& paint,
const char text[], size_t byteLength,
SkScalar x, SkScalar y) {
- SkASSERT(byteLength == 0 || text != NULL);
+ SkASSERT(byteLength == 0 || text != nullptr);
// nothing to draw
- if (text == NULL || byteLength == 0 ||
+ if (text == nullptr || byteLength == 0 ||
draw.fClip->isEmpty() ||
- (paint.getAlpha() == 0 && paint.getXfermode() == NULL)) {
+ (paint.getAlpha() == 0 && paint.getXfermode() == nullptr)) {
return;
}
@@ -2409,7 +2409,7 @@
void SkCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint& paint) {
- LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, NULL)
+ LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, nullptr)
while (iter.next()) {
SkDeviceFilteredPaint dfp(iter.fDevice, looper.paint());
@@ -2425,7 +2425,7 @@
const SkPaint& paint) {
SkPoint textOffset = SkPoint::Make(0, 0);
- LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, NULL)
+ LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, nullptr)
while (iter.next()) {
SkDeviceFilteredPaint dfp(iter.fDevice, looper.paint());
@@ -2441,7 +2441,7 @@
SkPoint textOffset = SkPoint::Make(0, constY);
- LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, NULL)
+ LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, nullptr)
while (iter.next()) {
SkDeviceFilteredPaint dfp(iter.fDevice, looper.paint());
@@ -2454,7 +2454,7 @@
void SkCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
const SkMatrix* matrix, const SkPaint& paint) {
- LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, NULL)
+ LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, nullptr)
while (iter.next()) {
iter.fDevice->drawTextOnPath(iter, text, byteLength, path,
@@ -2468,7 +2468,7 @@
const SkPaint& paint) {
SkRect storage;
- const SkRect* bounds = NULL;
+ const SkRect* bounds = nullptr;
if (paint.canComputeFastBounds()) {
storage = blob->bounds().makeOffset(x, y);
bounds = &paint.computeFastBounds(storage, &storage);
@@ -2481,7 +2481,7 @@
// We cannot filter in the looper as we normally do, because the paint is
// incomplete at this point (text-related attributes are embedded within blob run paints).
SkDrawFilter* drawFilter = fMCRec->fFilter;
- fMCRec->fFilter = NULL;
+ fMCRec->fFilter = nullptr;
LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, bounds)
@@ -2530,7 +2530,7 @@
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawVertices()");
- LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, NULL)
+ LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, nullptr)
while (iter.next()) {
iter.fDevice->drawVertices(iter, vmode, vertexCount, verts, texs,
@@ -2544,7 +2544,7 @@
void SkCanvas::drawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawPatch()");
- if (NULL == cubics) {
+ if (nullptr == cubics) {
return;
}
@@ -2562,7 +2562,7 @@
void SkCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
- LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, NULL)
+ LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, nullptr)
while (iter.next()) {
iter.fDevice->drawPatch(iter, cubics, colors, texCoords, xmode, paint);
@@ -2577,7 +2577,7 @@
SkMatrix matrix = SkMatrix::MakeTrans(x, y);
this->onDrawDrawable(dr, &matrix);
} else {
- this->onDrawDrawable(dr, NULL);
+ this->onDrawDrawable(dr, nullptr);
}
}
}
@@ -2585,7 +2585,7 @@
void SkCanvas::drawDrawable(SkDrawable* dr, const SkMatrix* matrix) {
if (dr) {
if (matrix && matrix->isIdentity()) {
- matrix = NULL;
+ matrix = nullptr;
}
this->onDrawDrawable(dr, matrix);
}
@@ -2614,7 +2614,7 @@
pnt = *paint;
}
- LOOPER_BEGIN(pnt, SkDrawFilter::kPath_Type, NULL)
+ LOOPER_BEGIN(pnt, SkDrawFilter::kPath_Type, nullptr)
while (iter.next()) {
iter.fDevice->drawAtlas(iter, atlas, xform, tex, colors, count, mode, pnt);
}
@@ -2761,7 +2761,7 @@
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawPicture()");
if (picture) {
if (matrix && matrix->isIdentity()) {
- matrix = NULL;
+ matrix = nullptr;
}
if (picture->approximateOpCount() <= kMaxPictureOpsToUnrollInsteadOfRef) {
SkAutoCanvasMatrixPaint acmp(this, matrix, paint, picture->cullRect());
@@ -2830,7 +2830,7 @@
const SkPaint& SkCanvas::LayerIter::paint() const {
const SkPaint* paint = fImpl->getPaint();
- if (NULL == paint) {
+ if (nullptr == paint) {
paint = &fDefaultPaint;
}
return *paint;
@@ -2869,12 +2869,12 @@
SkCanvas* SkCanvas::NewRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes) {
if (!supported_for_raster_canvas(info)) {
- return NULL;
+ return nullptr;
}
SkBitmap bitmap;
if (!bitmap.installPixels(info, pixels, rowBytes)) {
- return NULL;
+ return nullptr;
}
return new SkCanvas(bitmap);
}
diff --git a/src/core/SkChunkAlloc.cpp b/src/core/SkChunkAlloc.cpp
index 4a71c2d..3f30276 100644
--- a/src/core/SkChunkAlloc.cpp
+++ b/src/core/SkChunkAlloc.cpp
@@ -30,7 +30,7 @@
}
void reset() {
- fNext = NULL;
+ fNext = nullptr;
fFreeSize = this->blockSize();
fFreePtr = this->startOfData();
}
@@ -60,7 +60,7 @@
minSize = MIN_CHUNKALLOC_BLOCK_SIZE;
}
- fBlock = NULL;
+ fBlock = nullptr;
fMinSize = minSize;
fChunkSize = fMinSize;
fTotalCapacity = 0;
@@ -75,7 +75,7 @@
void SkChunkAlloc::reset() {
Block::FreeChain(fBlock);
- fBlock = NULL;
+ fBlock = nullptr;
fChunkSize = fMinSize; // reset to our initial minSize
fTotalCapacity = 0;
fTotalUsed = 0;
@@ -142,7 +142,7 @@
if (!fBlock || bytes > fBlock->fFreeSize) {
Block* block = this->newBlock(bytes, ftype);
if (!block) {
- return NULL;
+ return nullptr;
}
#ifdef SK_DEBUG
if (fBlock) {
@@ -164,7 +164,7 @@
Block* block = this->addBlockIfNecessary(bytes, ftype);
if (!block) {
- return NULL;
+ return nullptr;
}
char* ptr = block->fFreePtr;
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index 9541cc6..f54d57f 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -395,7 +395,7 @@
fFiniteBoundType = kNormal_BoundsType;
if (SkRegion::kReplace_Op == fOp ||
- (SkRegion::kIntersect_Op == fOp && NULL == prior) ||
+ (SkRegion::kIntersect_Op == fOp && nullptr == prior) ||
(SkRegion::kIntersect_Op == fOp && prior->fIsIntersectionOfRects &&
prior->rectRectIntersectAllowed(this->getRect(), fDoAA))) {
fIsIntersectionOfRects = true;
@@ -431,7 +431,7 @@
SkRect prevFinite;
SkClipStack::BoundsType prevType;
- if (NULL == prior) {
+ if (nullptr == prior) {
// no prior clip means the entire plane is writable
prevFinite.setEmpty(); // there are no pixels that cannot be drawn to
prevType = kInsideOut_BoundsType;
@@ -529,7 +529,7 @@
fSaveCount = b.fSaveCount;
SkDeque::F2BIter recIter(b.fDeque);
for (const Element* element = (const Element*)recIter.next();
- element != NULL;
+ element != nullptr;
element = (const Element*)recIter.next()) {
new (fDeque.push_back()) Element(*element);
}
@@ -550,14 +550,14 @@
const Element* myElement = (const Element*)myIter.next();
const Element* bElement = (const Element*)bIter.next();
- while (myElement != NULL && bElement != NULL) {
+ while (myElement != nullptr && bElement != nullptr) {
if (*myElement != *bElement) {
return false;
}
myElement = (const Element*)myIter.next();
bElement = (const Element*)bIter.next();
}
- return myElement == NULL && bElement == NULL;
+ return myElement == nullptr && bElement == nullptr;
}
void SkClipStack::reset() {
@@ -599,7 +599,7 @@
Element* element = (Element*)fDeque.back();
- if (NULL == element) {
+ if (nullptr == element) {
// the clip is wide open - the infinite plane w/ no pixels un-writeable
canvFiniteBound->setEmpty();
*boundType = kInsideOut_BoundsType;
@@ -620,7 +620,7 @@
Iter iter(*this, Iter::kTop_IterStart);
const Element* element = iter.prev();
- while (element != NULL) {
+ while (element != nullptr) {
if (SkRegion::kIntersect_Op != element->getOp() && SkRegion::kReplace_Op != element->getOp())
return false;
if (element->isInverseFilled()) {
@@ -747,7 +747,7 @@
///////////////////////////////////////////////////////////////////////////////
-SkClipStack::Iter::Iter() : fStack(NULL) {
+SkClipStack::Iter::Iter() : fStack(nullptr) {
}
SkClipStack::Iter::Iter(const SkClipStack& stack, IterStart startLoc)
@@ -765,13 +765,13 @@
const SkClipStack::Element* SkClipStack::Iter::skipToTopmost(SkRegion::Op op) {
- if (NULL == fStack) {
- return NULL;
+ if (nullptr == fStack) {
+ return nullptr;
}
fIter.reset(fStack->fDeque, SkDeque::Iter::kBack_IterStart);
- const SkClipStack::Element* element = NULL;
+ const SkClipStack::Element* element = nullptr;
for (element = (const SkClipStack::Element*) fIter.prev();
element;
@@ -784,7 +784,7 @@
// return on the next "next" or "prev" call) the element
// in front of it in the deque. Bump the iterator forward a
// step so we get the expected result.
- if (NULL == fIter.next()) {
+ if (nullptr == fIter.next()) {
// The reverse iterator has run off the front of the deque
// (i.e., the "op" clip is the first clip) and can't
// recover. Reset the iterator to start at the front.
@@ -794,7 +794,7 @@
}
}
- if (NULL == element) {
+ if (nullptr == element) {
// There were no "op" clips
fIter.reset(fStack->fDeque, SkDeque::Iter::kFront_IterStart);
}
@@ -899,7 +899,7 @@
SkDebugf("\n");
break;
case kPath_Type:
- this->getPath().dump(NULL, true, false);
+ this->getPath().dump(nullptr, true, false);
break;
}
}
diff --git a/src/core/SkColorFilter.cpp b/src/core/SkColorFilter.cpp
index e1670b8..c67869f 100644
--- a/src/core/SkColorFilter.cpp
+++ b/src/core/SkColorFilter.cpp
@@ -130,7 +130,7 @@
int count = inner->privateComposedFilterCount() + outer->privateComposedFilterCount();
if (count > SK_MAX_COMPOSE_COLORFILTER_COUNT) {
- return NULL;
+ return nullptr;
}
return new SkComposeColorFilter(outer, inner, count);
}
diff --git a/src/core/SkColorTable.cpp b/src/core/SkColorTable.cpp
index 5a4e0a4..13c4795 100644
--- a/src/core/SkColorTable.cpp
+++ b/src/core/SkColorTable.cpp
@@ -76,7 +76,7 @@
SkDEBUGCODE(success =) buffer.readColorArray(fColors, fCount);
} else {
fCount = 0;
- fColors = NULL;
+ fColors = nullptr;
}
#ifdef SK_DEBUG
SkASSERT((unsigned)fCount <= 256);
diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp
index 094dfdb..853e157 100644
--- a/src/core/SkComposeShader.cpp
+++ b/src/core/SkComposeShader.cpp
@@ -58,7 +58,7 @@
SkAutoTUnref<SkShader> shaderB(buffer.readShader());
SkAutoTUnref<SkXfermode> mode(buffer.readXfermode());
if (!shaderA.get() || !shaderB.get()) {
- return NULL;
+ return nullptr;
}
return new SkComposeShader(shaderA, shaderB, mode);
}
@@ -99,7 +99,7 @@
if (!contextA || !contextB) {
safe_call_destructor(contextA);
safe_call_destructor(contextB);
- return NULL;
+ return nullptr;
}
return new (storage) ComposeShaderContext(*this, rec, contextA, contextB);
@@ -143,7 +143,7 @@
SkPMColor tmp[TMP_COLOR_COUNT];
- if (NULL == mode) { // implied SRC_OVER
+ if (nullptr == mode) { // implied SRC_OVER
// TODO: when we have a good test-case, should use SkBlitRow::Proc32
// for these loops
do {
@@ -179,7 +179,7 @@
shaderContextA->shadeSpan(x, y, result, n);
shaderContextB->shadeSpan(x, y, tmp, n);
- mode->xfer32(result, tmp, n, NULL);
+ mode->xfer32(result, tmp, n, nullptr);
if (256 != scale) {
for (int i = 0; i < n; i++) {
diff --git a/src/core/SkConfig8888.cpp b/src/core/SkConfig8888.cpp
index f49ab45..53f35c3 100644
--- a/src/core/SkConfig8888.cpp
+++ b/src/core/SkConfig8888.cpp
@@ -237,9 +237,9 @@
return false;
}
- const SkPMColor* table = NULL;
+ const SkPMColor* table = nullptr;
if (kIndex_8_SkColorType == srcInfo.colorType()) {
- if (NULL == ctable) {
+ if (nullptr == ctable) {
return false;
}
table = ctable->readColors();
@@ -276,11 +276,11 @@
// TODO: switch the allocation of tmpDst to call sk_calloc_throw
{
SkBitmap bm;
- if (!bm.installPixels(srcInfo, const_cast<void*>(srcPixels), srcRB, ctable, NULL, NULL)) {
+ if (!bm.installPixels(srcInfo, const_cast<void*>(srcPixels), srcRB, ctable, nullptr, nullptr)) {
return false;
}
SkAutoTUnref<SkCanvas> canvas(SkCanvas::NewRasterDirect(dstInfo, dstPixels, dstRB));
- if (NULL == canvas.get()) {
+ if (nullptr == canvas.get()) {
return false;
}
diff --git a/src/core/SkConfig8888.h b/src/core/SkConfig8888.h
index 954f2b5..ff28726 100644
--- a/src/core/SkConfig8888.h
+++ b/src/core/SkConfig8888.h
@@ -19,7 +19,7 @@
static bool CopyPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
const SkImageInfo& srcInfo, const void* srcPixels, size_t srcRowBytes,
- SkColorTable* srcCTable = NULL);
+ SkColorTable* srcCTable = nullptr);
};
struct SkDstPixelInfo : SkPixelInfo {
diff --git a/src/core/SkConvolver.cpp b/src/core/SkConvolver.cpp
index bf00956..3a088aa 100644
--- a/src/core/SkConvolver.cpp
+++ b/src/core/SkConvolver.cpp
@@ -352,7 +352,7 @@
*filterLength = filter.fTrimmedLength;
*specifiedFilterlength = filter.fLength;
if (filter.fTrimmedLength == 0) {
- return NULL;
+ return nullptr;
}
return &fFilterValues[filter.fDataLocation];
diff --git a/src/core/SkConvolver.h b/src/core/SkConvolver.h
index 4beb755..4e4d806 100644
--- a/src/core/SkConvolver.h
+++ b/src/core/SkConvolver.h
@@ -91,7 +91,7 @@
*filterOffset = filter.fOffset;
*filterLength = filter.fTrimmedLength;
if (filter.fTrimmedLength == 0) {
- return NULL;
+ return nullptr;
}
return &fFilterValues[filter.fDataLocation];
}
@@ -102,7 +102,7 @@
// |specifiedFilterLength| may be different if leading/trailing zeros of the
// original floating point form were clipped.
// There will be |filterLength| values in the return array.
- // Returns NULL if the filter is 0-length (for instance when all floating
+ // Returns nullptr if the filter is 0-length (for instance when all floating
// point values passed to AddFilter were clipped to 0).
SK_API const ConvolutionFixed* GetSingleFilter(int* specifiedFilterLength,
int* filterOffset,
diff --git a/src/core/SkData.cpp b/src/core/SkData.cpp
index 4590e3b..9e65d2a 100644
--- a/src/core/SkData.cpp
+++ b/src/core/SkData.cpp
@@ -26,8 +26,8 @@
SkData::SkData(size_t size) {
fPtr = (char*)(this + 1); // contents are immediately after this
fSize = size;
- fReleaseProc = NULL;
- fReleaseProcContext = NULL;
+ fReleaseProc = nullptr;
+ fReleaseProcContext = nullptr;
}
SkData::~SkData() {
@@ -37,7 +37,7 @@
}
bool SkData::equals(const SkData* other) const {
- if (NULL == other) {
+ if (nullptr == other) {
return false;
}
@@ -81,7 +81,7 @@
///////////////////////////////////////////////////////////////////////////////
// As a template argument these must have external linkage.
-SkData* sk_new_empty_data() { return new SkData(NULL, 0, NULL, NULL); }
+SkData* sk_new_empty_data() { return new SkData(nullptr, 0, nullptr, nullptr); }
namespace { void sk_unref_data(SkData* ptr) { return SkSafeUnref(ptr); } }
SK_DECLARE_STATIC_LAZY_PTR(SkData, empty, sk_new_empty_data, sk_unref_data);
@@ -96,7 +96,7 @@
}
SkData* SkData::NewFromMalloc(const void* data, size_t length) {
- return new SkData(data, length, sk_free_releaseproc, NULL);
+ return new SkData(data, length, sk_free_releaseproc, nullptr);
}
SkData* SkData::NewWithCopy(const void* src, size_t length) {
@@ -105,7 +105,7 @@
}
SkData* SkData::NewUninitialized(size_t length) {
- return PrivateNewWithCopy(NULL, length);
+ return PrivateNewWithCopy(nullptr, length);
}
SkData* SkData::NewWithProc(const void* ptr, size_t length, ReleaseProc proc, void* context) {
@@ -121,17 +121,17 @@
SkData* SkData::NewFromFILE(SkFILE* f) {
size_t size;
void* addr = sk_fmmap(f, &size);
- if (NULL == addr) {
- return NULL;
+ if (nullptr == addr) {
+ return nullptr;
}
return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
}
SkData* SkData::NewFromFileName(const char path[]) {
- SkFILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : NULL;
- if (NULL == f) {
- return NULL;
+ SkFILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : nullptr;
+ if (nullptr == f) {
+ return nullptr;
}
SkData* data = NewFromFILE(f);
sk_fclose(f);
@@ -141,11 +141,11 @@
SkData* SkData::NewFromFD(int fd) {
size_t size;
void* addr = sk_fdmmap(fd, &size);
- if (NULL == addr) {
- return NULL;
+ if (nullptr == addr) {
+ return nullptr;
}
- return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, NULL);
+ return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, nullptr);
}
// assumes context is a SkData
@@ -178,7 +178,7 @@
SkData* SkData::NewWithCString(const char cstr[]) {
size_t size;
- if (NULL == cstr) {
+ if (nullptr == cstr) {
cstr = "";
size = 1;
} else {
@@ -192,7 +192,7 @@
SkData* SkData::NewFromStream(SkStream* stream, size_t size) {
SkAutoDataUnref data(SkData::NewUninitialized(size));
if (stream->read(data->writable_data(), size) != size) {
- return NULL;
+ return nullptr;
}
return data.detach();
}
diff --git a/src/core/SkDataTable.cpp b/src/core/SkDataTable.cpp
index 20bc430..32e30af 100644
--- a/src/core/SkDataTable.cpp
+++ b/src/core/SkDataTable.cpp
@@ -16,9 +16,9 @@
SkDataTable::SkDataTable() {
fCount = 0;
fElemSize = 0; // 0 signals that we use fDir instead of fElems
- fU.fDir = NULL;
- fFreeProc = NULL;
- fFreeProcContext = NULL;
+ fU.fDir = nullptr;
+ fFreeProc = nullptr;
+ fFreeProcContext = nullptr;
}
SkDataTable::SkDataTable(const void* array, size_t elemSize, int count,
@@ -78,7 +78,7 @@
SkDataTable* SkDataTable::NewEmpty() {
static SkDataTable* gEmpty;
- if (NULL == gEmpty) {
+ if (nullptr == gEmpty) {
gEmpty = new SkDataTable;
}
gEmpty->ref();
@@ -137,7 +137,7 @@
static void chunkalloc_freeproc(void* context) { delete (SkChunkAlloc*)context; }
SkDataTableBuilder::SkDataTableBuilder(size_t minChunkSize)
- : fHeap(NULL)
+ : fHeap(nullptr)
, fMinChunkSize(minChunkSize) {}
SkDataTableBuilder::~SkDataTableBuilder() { this->reset(); }
@@ -147,12 +147,12 @@
fDir.reset();
if (fHeap) {
delete fHeap;
- fHeap = NULL;
+ fHeap = nullptr;
}
}
void SkDataTableBuilder::append(const void* src, size_t size) {
- if (NULL == fHeap) {
+ if (nullptr == fHeap) {
fHeap = new SkChunkAlloc(fMinChunkSize);
}
@@ -177,7 +177,7 @@
SkDataTable* table = new SkDataTable((SkDataTable::Dir*)dir, count, chunkalloc_freeproc, fHeap);
// we have to detach our fHeap, since we are giving that to the table
- fHeap = NULL;
+ fHeap = nullptr;
fDir.reset();
return table;
}
diff --git a/src/core/SkDeque.cpp b/src/core/SkDeque.cpp
index 27f3efc..2e469d1 100644
--- a/src/core/SkDeque.cpp
+++ b/src/core/SkDeque.cpp
@@ -20,20 +20,20 @@
const char* start() const { return (const char*)(this + 1); }
void init(size_t size) {
- fNext = fPrev = NULL;
- fBegin = fEnd = NULL;
+ fNext = fPrev = nullptr;
+ fBegin = fEnd = nullptr;
fStop = (char*)this + size;
}
};
SkDeque::SkDeque(size_t elemSize, int allocCount)
: fElemSize(elemSize)
- , fInitialStorage(NULL)
+ , fInitialStorage(nullptr)
, fCount(0)
, fAllocCount(allocCount) {
SkASSERT(allocCount >= 1);
- fFrontBlock = fBackBlock = NULL;
- fFront = fBack = NULL;
+ fFrontBlock = fBackBlock = nullptr;
+ fFront = fBack = nullptr;
}
SkDeque::SkDeque(size_t elemSize, void* storage, size_t storageSize, int allocCount)
@@ -41,17 +41,17 @@
, fInitialStorage(storage)
, fCount(0)
, fAllocCount(allocCount) {
- SkASSERT(storageSize == 0 || storage != NULL);
+ SkASSERT(storageSize == 0 || storage != nullptr);
SkASSERT(allocCount >= 1);
if (storageSize >= sizeof(Block) + elemSize) {
fFrontBlock = (Block*)storage;
fFrontBlock->init(storageSize);
} else {
- fFrontBlock = NULL;
+ fFrontBlock = nullptr;
}
fBackBlock = fFrontBlock;
- fFront = fBack = NULL;
+ fFront = fBack = nullptr;
}
SkDeque::~SkDeque() {
@@ -70,7 +70,7 @@
void* SkDeque::push_front() {
fCount += 1;
- if (NULL == fFrontBlock) {
+ if (nullptr == fFrontBlock) {
fFrontBlock = this->allocateBlock(fAllocCount);
fBackBlock = fFrontBlock; // update our linklist
}
@@ -78,7 +78,7 @@
Block* first = fFrontBlock;
char* begin;
- if (NULL == first->fBegin) {
+ if (nullptr == first->fBegin) {
INIT_CHUNK:
first->fEnd = first->fStop;
begin = first->fStop - fElemSize;
@@ -96,8 +96,8 @@
first->fBegin = begin;
- if (NULL == fFront) {
- SkASSERT(NULL == fBack);
+ if (nullptr == fFront) {
+ SkASSERT(nullptr == fBack);
fFront = fBack = begin;
} else {
SkASSERT(fBack);
@@ -110,7 +110,7 @@
void* SkDeque::push_back() {
fCount += 1;
- if (NULL == fBackBlock) {
+ if (nullptr == fBackBlock) {
fBackBlock = this->allocateBlock(fAllocCount);
fFrontBlock = fBackBlock; // update our linklist
}
@@ -118,7 +118,7 @@
Block* last = fBackBlock;
char* end;
- if (NULL == last->fBegin) {
+ if (nullptr == last->fBegin) {
INIT_CHUNK:
last->fBegin = last->start();
end = last->fBegin + fElemSize;
@@ -137,8 +137,8 @@
last->fEnd = end;
end -= fElemSize;
- if (NULL == fBack) {
- SkASSERT(NULL == fFront);
+ if (nullptr == fBack) {
+ SkASSERT(nullptr == fFront);
fFront = fBack = end;
} else {
SkASSERT(fFront);
@@ -154,14 +154,14 @@
Block* first = fFrontBlock;
- SkASSERT(first != NULL);
+ SkASSERT(first != nullptr);
- if (first->fBegin == NULL) { // we were marked empty from before
+ if (first->fBegin == nullptr) { // we were marked empty from before
first = first->fNext;
- first->fPrev = NULL;
+ first->fPrev = nullptr;
this->freeBlock(fFrontBlock);
fFrontBlock = first;
- SkASSERT(first != NULL); // else we popped too far
+ SkASSERT(first != nullptr); // else we popped too far
}
char* begin = first->fBegin + fElemSize;
@@ -172,9 +172,9 @@
SkASSERT(first->fBegin);
fFront = first->fBegin;
} else {
- first->fBegin = first->fEnd = NULL; // mark as empty
- if (NULL == first->fNext) {
- fFront = fBack = NULL;
+ first->fBegin = first->fEnd = nullptr; // mark as empty
+ if (nullptr == first->fNext) {
+ fFront = fBack = nullptr;
} else {
SkASSERT(first->fNext->fBegin);
fFront = first->fNext->fBegin;
@@ -188,14 +188,14 @@
Block* last = fBackBlock;
- SkASSERT(last != NULL);
+ SkASSERT(last != nullptr);
- if (last->fEnd == NULL) { // we were marked empty from before
+ if (last->fEnd == nullptr) { // we were marked empty from before
last = last->fPrev;
- last->fNext = NULL;
+ last->fNext = nullptr;
this->freeBlock(fBackBlock);
fBackBlock = last;
- SkASSERT(last != NULL); // else we popped too far
+ SkASSERT(last != nullptr); // else we popped too far
}
char* end = last->fEnd - fElemSize;
@@ -206,9 +206,9 @@
SkASSERT(last->fEnd);
fBack = last->fEnd - fElemSize;
} else {
- last->fBegin = last->fEnd = NULL; // mark as empty
- if (NULL == last->fPrev) {
- fFront = fBack = NULL;
+ last->fBegin = last->fEnd = nullptr; // mark as empty
+ if (nullptr == last->fPrev) {
+ fFront = fBack = nullptr;
} else {
SkASSERT(last->fPrev->fEnd);
fBack = last->fPrev->fEnd - fElemSize;
@@ -238,7 +238,7 @@
///////////////////////////////////////////////////////////////////////////////
-SkDeque::Iter::Iter() : fCurBlock(NULL), fPos(NULL), fElemSize(0) {}
+SkDeque::Iter::Iter() : fCurBlock(nullptr), fPos(nullptr), fElemSize(0) {}
SkDeque::Iter::Iter(const SkDeque& d, IterStart startLoc) {
this->reset(d, startLoc);
@@ -255,8 +255,8 @@
if (next == fCurBlock->fEnd) { // exhausted this chunk, move to next
do {
fCurBlock = fCurBlock->fNext;
- } while (fCurBlock != NULL && fCurBlock->fBegin == NULL);
- next = fCurBlock ? fCurBlock->fBegin : NULL;
+ } while (fCurBlock != nullptr && fCurBlock->fBegin == nullptr);
+ next = fCurBlock ? fCurBlock->fBegin : nullptr;
}
fPos = next;
}
@@ -274,8 +274,8 @@
if (prev < fCurBlock->fBegin) { // exhausted this chunk, move to prior
do {
fCurBlock = fCurBlock->fPrev;
- } while (fCurBlock != NULL && fCurBlock->fEnd == NULL);
- prev = fCurBlock ? fCurBlock->fEnd - fElemSize : NULL;
+ } while (fCurBlock != nullptr && fCurBlock->fEnd == nullptr);
+ prev = fCurBlock ? fCurBlock->fEnd - fElemSize : nullptr;
}
fPos = prev;
}
@@ -286,23 +286,23 @@
// of the doubly linked list until a non-empty one is found. The fPos
// member is then set to the first (or last) element in the block. If
// there are no elements in the deque both fCurBlock and fPos will come
-// out of this routine NULL.
+// out of this routine nullptr.
void SkDeque::Iter::reset(const SkDeque& d, IterStart startLoc) {
fElemSize = d.fElemSize;
if (kFront_IterStart == startLoc) {
// initialize the iterator to start at the front
fCurBlock = d.fFrontBlock;
- while (fCurBlock && NULL == fCurBlock->fBegin) {
+ while (fCurBlock && nullptr == fCurBlock->fBegin) {
fCurBlock = fCurBlock->fNext;
}
- fPos = fCurBlock ? fCurBlock->fBegin : NULL;
+ fPos = fCurBlock ? fCurBlock->fBegin : nullptr;
} else {
// initialize the iterator to start at the back
fCurBlock = d.fBackBlock;
- while (fCurBlock && NULL == fCurBlock->fEnd) {
+ while (fCurBlock && nullptr == fCurBlock->fEnd) {
fCurBlock = fCurBlock->fPrev;
}
- fPos = fCurBlock ? fCurBlock->fEnd - fElemSize : NULL;
+ fPos = fCurBlock ? fCurBlock->fEnd - fElemSize : nullptr;
}
}
diff --git a/src/core/SkDescriptor.h b/src/core/SkDescriptor.h
index e559215..1f6f4a8 100644
--- a/src/core/SkDescriptor.h
+++ b/src/core/SkDescriptor.h
@@ -37,10 +37,10 @@
uint32_t getLength() const { return fLength; }
- void* addEntry(uint32_t tag, size_t length, const void* data = NULL) {
+ void* addEntry(uint32_t tag, size_t length, const void* data = nullptr) {
SkASSERT(tag);
SkASSERT(SkAlign4(length) == length);
- SkASSERT(this->findEntry(tag, NULL) == NULL);
+ SkASSERT(this->findEntry(tag, nullptr) == nullptr);
Entry* entry = (Entry*)((char*)this + fLength);
entry->fTag = tag;
@@ -77,7 +77,7 @@
}
entry = (const Entry*)((const char*)(entry + 1) + entry->fLen);
}
- return NULL;
+ return nullptr;
}
SkDescriptor* copy() const {
@@ -134,9 +134,9 @@
class SkAutoDescriptor : SkNoncopyable {
public:
- SkAutoDescriptor() : fDesc(NULL) {}
- SkAutoDescriptor(size_t size) : fDesc(NULL) { this->reset(size); }
- SkAutoDescriptor(const SkDescriptor& desc) : fDesc(NULL) {
+ SkAutoDescriptor() : fDesc(nullptr) {}
+ SkAutoDescriptor(size_t size) : fDesc(nullptr) { this->reset(size); }
+ SkAutoDescriptor(const SkDescriptor& desc) : fDesc(nullptr) {
size_t size = desc.getLength();
this->reset(size);
memcpy(fDesc, &desc, size);
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index f8275fa..a76a2ff 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -27,7 +27,7 @@
#endif
{
fOrigin.setZero();
- fMetaData = NULL;
+ fMetaData = nullptr;
}
SkBaseDevice::~SkBaseDevice() { delete fMetaData; }
@@ -35,7 +35,7 @@
SkMetaData& SkBaseDevice::getMetaData() {
// metadata users are rare, so we lazily allocate it. If that changes we
// can decide to just make it a field in the device (rather than a ptr)
- if (NULL == fMetaData) {
+ if (nullptr == fMetaData) {
fMetaData = new SkMetaData;
}
return *fMetaData;
@@ -78,7 +78,7 @@
path.addRRect(inner);
path.setFillType(SkPath::kEvenOdd_FillType);
- const SkMatrix* preMatrix = NULL;
+ const SkMatrix* preMatrix = nullptr;
const bool pathIsMutable = true;
this->drawPath(draw, path, paint, preMatrix, pathIsMutable);
}
@@ -212,7 +212,7 @@
path.rewind();
path.addPoly(quad, 4, true);
path.setConvexity(SkPath::kConvex_Convexity);
- this->drawPath(draw, path, pnt, NULL, true);
+ this->drawPath(draw, path, pnt, nullptr, true);
}
}
@@ -263,7 +263,7 @@
bool SkBaseDevice::accessPixels(SkPixmap* pmap) {
SkPixmap tempStorage;
- if (NULL == pmap) {
+ if (nullptr == pmap) {
pmap = &tempStorage;
}
return this->onAccessPixels(pmap);
@@ -271,7 +271,7 @@
bool SkBaseDevice::peekPixels(SkPixmap* pmap) {
SkPixmap tempStorage;
- if (NULL == pmap) {
+ if (nullptr == pmap) {
pmap = &tempStorage;
}
return this->onPeekPixels(pmap);
@@ -357,10 +357,10 @@
void SkBaseDevice::drawTextOnPath(const SkDraw& draw, const void* text, size_t byteLength,
const SkPath& follow, const SkMatrix* matrix,
const SkPaint& paint) {
- SkASSERT(byteLength == 0 || text != NULL);
+ SkASSERT(byteLength == 0 || text != nullptr);
// nothing to draw
- if (text == NULL || byteLength == 0 || draw.fRC->isEmpty()) {
+ if (text == nullptr || byteLength == 0 || draw.fRC->isEmpty()) {
return;
}
@@ -395,7 +395,7 @@
m.postConcat(*matrix);
}
morphpath(&tmp, *iterPath, meas, m);
- this->drawPath(draw, tmp, iter.getPaint(), NULL, true);
+ this->drawPath(draw, tmp, iter.getPaint(), nullptr, true);
}
}
}
diff --git a/src/core/SkDeviceLooper.cpp b/src/core/SkDeviceLooper.cpp
index 840a050..c4e4013 100644
--- a/src/core/SkDeviceLooper.cpp
+++ b/src/core/SkDeviceLooper.cpp
@@ -16,8 +16,8 @@
{
// sentinels that next() has not yet been called, and so our mapper functions
// should not be called either.
- fCurrDst = NULL;
- fCurrRC = NULL;
+ fCurrDst = nullptr;
+ fCurrRC = nullptr;
if (!rc.isEmpty()) {
// clip must be contained by the bitmap
@@ -102,7 +102,7 @@
case kSimple_State:
// first time for simple
- if (NULL == fCurrDst) {
+ if (nullptr == fCurrDst) {
fCurrDst = &fBaseDst;
fCurrRC = &fBaseRC;
fCurrOffset.set(0, 0);
diff --git a/src/core/SkDeviceProfile.cpp b/src/core/SkDeviceProfile.cpp
index 11d5c85..e1c10c8 100644
--- a/src/core/SkDeviceProfile.cpp
+++ b/src/core/SkDeviceProfile.cpp
@@ -51,7 +51,7 @@
SkDeviceProfile* SkDeviceProfile::GetDefault() {
SkAutoMutexAcquire amc(gMutex);
- if (NULL == gDefaultProfile) {
+ if (nullptr == gDefaultProfile) {
gDefaultProfile = SkDeviceProfile::Create(DEFAULT_GAMMAEXP,
DEFAULT_CONTRASTSCALE,
DEFAULT_LCDCONFIG,
@@ -63,7 +63,7 @@
SkDeviceProfile* SkDeviceProfile::RefGlobal() {
SkAutoMutexAcquire amc(gMutex);
- if (NULL == gGlobalProfile) {
+ if (nullptr == gGlobalProfile) {
gGlobalProfile = SkDeviceProfile::GetDefault();
}
gGlobalProfile->ref();
diff --git a/src/core/SkDeviceProfile.h b/src/core/SkDeviceProfile.h
index d949444..2872b13 100644
--- a/src/core/SkDeviceProfile.h
+++ b/src/core/SkDeviceProfile.h
@@ -52,7 +52,7 @@
/**
* Returns the global default profile, that is used if no global profile is
- * specified with SetGlobal(), or if NULL is specified to SetGlobal().
+ * specified with SetGlobal(), or if nullptr is specified to SetGlobal().
* The references count is *not* incremented, and the caller should not
* call unref().
*/
@@ -69,7 +69,7 @@
* Make the specified profile be the global value for all subsequently
* instantiated devices. Does not affect any existing devices.
* Increments the reference count on the profile.
- * Specify NULL for the "identity" profile (where there is no gamma or
+ * Specify nullptr for the "identity" profile (where there is no gamma or
* contrast correction).
*/
static void SetGlobal(SkDeviceProfile*);
diff --git a/src/core/SkDiscardableMemory.h b/src/core/SkDiscardableMemory.h
index f3159fe..8952b8d 100644
--- a/src/core/SkDiscardableMemory.h
+++ b/src/core/SkDiscardableMemory.h
@@ -19,13 +19,13 @@
public:
/**
* Factory method that creates, initializes and locks an SkDiscardableMemory
- * object. If either of these steps fails, a NULL pointer will be returned.
+ * object. If either of these steps fails, a nullptr pointer will be returned.
*/
static SkDiscardableMemory* Create(size_t bytes);
/**
* Factory class that creates, initializes and locks an SkDiscardableMemory
- * object. If either of these steps fails, a NULL pointer will be returned.
+ * object. If either of these steps fails, a nullptr pointer will be returned.
*/
class Factory : public SkRefCnt {
public:
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index 6464d4a..8e1a132 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -42,7 +42,7 @@
class SkAutoBlitterChoose : SkNoncopyable {
public:
SkAutoBlitterChoose() {
- fBlitter = NULL;
+ fBlitter = nullptr;
}
SkAutoBlitterChoose(const SkPixmap& dst, const SkMatrix& matrix,
const SkPaint& paint, bool drawCoverage = false) {
@@ -73,7 +73,7 @@
class SkAutoBitmapShaderInstall : SkNoncopyable {
public:
SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint,
- const SkMatrix* localMatrix = NULL)
+ const SkMatrix* localMatrix = nullptr)
: fPaint(paint) /* makes a copy of the paint */ {
fPaint.setShader(SkCreateBitmapShader(src, SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode,
@@ -86,7 +86,7 @@
// since fAllocator will destroy shader, we insist that owners == 2
SkASSERT(2 == fPaint.getShader()->getRefCnt());
- fPaint.setShader(NULL); // unref the shader by 1
+ fPaint.setShader(nullptr); // unref the shader by 1
}
@@ -155,12 +155,12 @@
// todo: we can apply colorfilter up front if no shader, so we wouldn't
// need to abort this fastpath
if (paint.getShader() || paint.getColorFilter()) {
- return NULL;
+ return nullptr;
}
SkXfermode::Mode mode;
if (!SkXfermode::AsMode(paint.getXfermode(), &mode)) {
- return NULL;
+ return nullptr;
}
SkColor color = paint.getColor();
@@ -214,7 +214,7 @@
default:
break;
}
- return NULL;
+ return nullptr;
}
static void CallBitmapXferProc(const SkPixmap& dst, const SkIRect& rect, BitmapXferProc proc,
@@ -451,7 +451,7 @@
if (0 == width) {
fMode = mode;
fPaint = &paint;
- fClip = NULL;
+ fClip = nullptr;
fRC = rc;
fRadius = SK_FixedHalf;
return true;
@@ -467,7 +467,7 @@
fMode = mode;
fPaint = &paint;
- fClip = NULL;
+ fClip = nullptr;
fRC = rc;
fRadius = SkScalarToFixed(SkScalarMul(width, sx)) >> 1;
return true;
@@ -477,7 +477,7 @@
}
PtProcRec::Proc PtProcRec::chooseProc(SkBlitter** blitterPtr) {
- Proc proc = NULL;
+ Proc proc = nullptr;
SkBlitter* blitter = *blitterPtr;
if (fRC->isBW()) {
@@ -546,7 +546,7 @@
return;
}
- SkASSERT(pts != NULL);
+ SkASSERT(pts != nullptr);
SkDEBUGCODE(this->validate();)
// nothing to draw
@@ -642,7 +642,7 @@
// 'asPoints' managed to find some fast path
SkPaint newP(paint);
- newP.setPathEffect(NULL);
+ newP.setPathEffect(nullptr);
newP.setStyle(SkPaint::kFill_Style);
if (!pointData.fFirst.isEmpty()) {
@@ -720,9 +720,9 @@
path.moveTo(pts[i]);
path.lineTo(pts[i+1]);
if (fDevice) {
- fDevice->drawPath(*this, path, p, NULL, true);
+ fDevice->drawPath(*this, path, p, nullptr, true);
} else {
- this->drawPath(path, p, NULL, true);
+ this->drawPath(path, p, nullptr, true);
}
path.rewind();
}
@@ -820,7 +820,7 @@
SkPath tmp;
tmp.addRect(prePaintRect);
tmp.setFillType(SkPath::kWinding_FillType);
- draw.drawPath(tmp, paint, NULL, true);
+ draw.drawPath(tmp, paint, nullptr, true);
return;
}
@@ -901,10 +901,10 @@
SkMask dstM;
if (paint.getMaskFilter() &&
- paint.getMaskFilter()->filterMask(&dstM, srcM, *fMatrix, NULL)) {
+ paint.getMaskFilter()->filterMask(&dstM, srcM, *fMatrix, nullptr)) {
mask = &dstM;
} else {
- dstM.fImage = NULL;
+ dstM.fImage = nullptr;
}
SkAutoMaskFreeImage ami(dstM.fImage);
@@ -998,7 +998,7 @@
// Now fall back to the default case of using a path.
SkPath path;
path.addRRect(rrect);
- this->drawPath(path, paint, NULL, true);
+ this->drawPath(path, paint, nullptr, true);
}
static SkScalar compute_res_scale_for_stroking(const SkMatrix& matrix) {
@@ -1076,7 +1076,7 @@
if (paint->getPathEffect() || paint->getStyle() != SkPaint::kFill_Style) {
SkRect cullRect;
- const SkRect* cullRectPtr = NULL;
+ const SkRect* cullRectPtr = nullptr;
if (this->computeConservativeLocalClipBounds(&cullRect)) {
cullRectPtr = &cullRect;
}
@@ -1102,9 +1102,9 @@
// transform the path into device space
pathPtr->transform(*matrix, devPathPtr);
- SkBlitter* blitter = NULL;
+ SkBlitter* blitter = nullptr;
SkAutoBlitterChoose blitterStorage;
- if (NULL == customBlitter) {
+ if (nullptr == customBlitter) {
blitterStorage.choose(fDst, *fMatrix, *paint, drawCoverage);
blitter = blitterStorage.get();
} else {
@@ -1333,7 +1333,7 @@
}
const SkPixmap& pmap = unlocker.pixmap();
- if (NULL == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
+ if (nullptr == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
SkTBlitterAllocator allocator;
// blitter will be owned by the allocator.
SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator);
@@ -1453,8 +1453,8 @@
int left = Sk48Dot16FloorToInt(fx);
int top = Sk48Dot16FloorToInt(fy);
SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
- SkASSERT((NULL == state.fClip && state.fAAClip) ||
- (state.fClip && NULL == state.fAAClip && state.fClip->isRect()));
+ SkASSERT((nullptr == state.fClip && state.fAAClip) ||
+ (state.fClip && nullptr == state.fAAClip && state.fClip->isRect()));
left += glyph.fLeft;
top += glyph.fTop;
@@ -1477,9 +1477,9 @@
}
uint8_t* aa = (uint8_t*)glyph.fImage;
- if (NULL == aa) {
+ if (nullptr == aa) {
aa = (uint8_t*)state.fCache->findImage(glyph);
- if (NULL == aa) {
+ if (nullptr == aa) {
return; // can't rasterize glyph
}
}
@@ -1507,9 +1507,9 @@
if (!clipper.done()) {
const SkIRect& cr = clipper.rect();
const uint8_t* aa = (const uint8_t*)glyph.fImage;
- if (NULL == aa) {
+ if (nullptr == aa) {
aa = (uint8_t*)state.fCache->findImage(glyph);
- if (NULL == aa) {
+ if (nullptr == aa) {
return;
}
}
@@ -1553,7 +1553,7 @@
}
if (draw->fRC->isBW()) {
- fAAClip = NULL;
+ fAAClip = nullptr;
fClip = &draw->fRC->bwRgn();
fClipBounds = fClip->getBounds();
if (fClip->isRect()) {
@@ -1563,7 +1563,7 @@
}
} else { // aaclip
fAAClip = &draw->fRC->aaRgn();
- fClip = NULL;
+ fClip = nullptr;
fClipBounds = fAAClip->getBounds();
return D1G_RectClip;
}
@@ -1583,12 +1583,12 @@
void SkDraw::drawText(const char text[], size_t byteLength,
SkScalar x, SkScalar y, const SkPaint& paint) const {
- SkASSERT(byteLength == 0 || text != NULL);
+ SkASSERT(byteLength == 0 || text != nullptr);
SkDEBUGCODE(this->validate();)
// nothing to draw
- if (text == NULL || byteLength == 0 || fRC->isEmpty()) {
+ if (text == nullptr || byteLength == 0 || fRC->isEmpty()) {
return;
}
@@ -1633,7 +1633,7 @@
SkAAClipBlitter aaBlitter;
SkAutoBlitterChoose blitterChooser;
- SkBlitter* blitter = NULL;
+ SkBlitter* blitter = nullptr;
if (needsRasterTextBlit(*this)) {
blitterChooser.choose(fDst, *fMatrix, paint);
blitter = blitterChooser.get();
@@ -1691,10 +1691,10 @@
// Temporarily jam in kFill, so we only ever ask for the raw outline from the cache.
paint.setStyle(SkPaint::kFill_Style);
- paint.setPathEffect(NULL);
+ paint.setPathEffect(nullptr);
SkDrawCacheProc glyphCacheProc = paint.getDrawCacheProc();
- SkAutoGlyphCache autoCache(paint, &fDevice->surfaceProps(), NULL);
+ SkAutoGlyphCache autoCache(paint, &fDevice->surfaceProps(), nullptr);
SkGlyphCache* cache = autoCache.getCache();
const char* stop = text + byteLength;
@@ -1731,13 +1731,13 @@
void SkDraw::drawPosText(const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
const SkPoint& offset, const SkPaint& paint) const {
- SkASSERT(byteLength == 0 || text != NULL);
+ SkASSERT(byteLength == 0 || text != nullptr);
SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
SkDEBUGCODE(this->validate();)
// nothing to draw
- if (text == NULL || byteLength == 0 || fRC->isEmpty()) {
+ if (text == nullptr || byteLength == 0 || fRC->isEmpty()) {
return;
}
@@ -1752,7 +1752,7 @@
SkAAClipBlitterWrapper wrapper;
SkAutoBlitterChoose blitterChooser;
- SkBlitter* blitter = NULL;
+ SkBlitter* blitter = nullptr;
if (needsRasterTextBlit(*this)) {
blitterChooser.choose(fDst, *fMatrix, paint);
blitter = blitterChooser.get();
@@ -1915,7 +1915,7 @@
SK_TO_STRING_OVERRIDE()
// For serialization. This will never be called.
- Factory getFactory() const override { sk_throw(); return NULL; }
+ Factory getFactory() const override { sk_throw(); return nullptr; }
protected:
Context* onCreateContext(const ContextRec& rec, void* storage) const override {
@@ -2053,26 +2053,26 @@
SkPaint p(paint);
SkShader* shader = p.getShader();
- if (NULL == shader) {
+ if (nullptr == shader) {
// if we have no shader, we ignore the texture coordinates
- textures = NULL;
- } else if (NULL == textures) {
+ textures = nullptr;
+ } else if (nullptr == textures) {
// if we don't have texture coordinates, ignore the shader
- p.setShader(NULL);
- shader = NULL;
+ p.setShader(nullptr);
+ shader = nullptr;
}
// setup the custom shader (if needed)
SkAutoTUnref<SkComposeShader> composeShader;
if (colors) {
- if (NULL == textures) {
+ if (nullptr == textures) {
// just colors (no texture)
shader = p.setShader(&triShader);
} else {
// colors * texture
SkASSERT(shader);
bool releaseMode = false;
- if (NULL == xmode) {
+ if (nullptr == xmode) {
xmode = SkXfermode::Create(SkXfermode::kModulate_Mode);
releaseMode = true;
}
@@ -2155,9 +2155,9 @@
#ifdef SK_DEBUG
void SkDraw::validate() const {
- SkASSERT(fMatrix != NULL);
- SkASSERT(fClip != NULL);
- SkASSERT(fRC != NULL);
+ SkASSERT(fMatrix != nullptr);
+ SkASSERT(fClip != nullptr);
+ SkASSERT(fRC != nullptr);
const SkIRect& cr = fRC->getBounds();
SkIRect br;
@@ -2193,7 +2193,7 @@
srcM.fBounds = *bounds;
srcM.fFormat = SkMask::kA8_Format;
- srcM.fImage = NULL;
+ srcM.fImage = nullptr;
if (!filter->filterMask(&dstM, srcM, *filterMatrix, &margin)) {
return false;
}
diff --git a/src/core/SkDrawLooper.cpp b/src/core/SkDrawLooper.cpp
index 1af68a2..aa53f2e 100644
--- a/src/core/SkDrawLooper.cpp
+++ b/src/core/SkDrawLooper.cpp
@@ -21,7 +21,7 @@
for (;;) {
SkPaint p(paint);
if (context->next(&canvas, &p)) {
- p.setLooper(NULL);
+ p.setLooper(nullptr);
if (!p.canComputeFastBounds()) {
return false;
}
@@ -48,7 +48,7 @@
if (context->next(&canvas, &p)) {
SkRect r(src);
- p.setLooper(NULL);
+ p.setLooper(nullptr);
p.computeFastBounds(r, &r);
canvas.getTotalMatrix().mapRect(&r);
diff --git a/src/core/SkDrawable.cpp b/src/core/SkDrawable.cpp
index 5052270..8fea38b 100644
--- a/src/core/SkDrawable.cpp
+++ b/src/core/SkDrawable.cpp
@@ -76,7 +76,7 @@
SkPictureRecorder recorder;
const SkRect bounds = this->getBounds();
- SkCanvas* canvas = recorder.beginRecording(bounds, NULL, 0);
+ SkCanvas* canvas = recorder.beginRecording(bounds, nullptr, 0);
this->draw(canvas);
if (false) {
draw_bbox(canvas, bounds);
diff --git a/src/core/SkEdgeBuilder.cpp b/src/core/SkEdgeBuilder.cpp
index 43181fd..92c8330 100644
--- a/src/core/SkEdgeBuilder.cpp
+++ b/src/core/SkEdgeBuilder.cpp
@@ -19,7 +19,7 @@
///////////////////////////////////////////////////////////////////////////////
SkEdgeBuilder::SkEdgeBuilder() : fAlloc(16*1024) {
- fEdgeList = NULL;
+ fEdgeList = nullptr;
}
void SkEdgeBuilder::addLine(const SkPoint pts[]) {
diff --git a/src/core/SkEmptyShader.h b/src/core/SkEmptyShader.h
index 7b87c28..6453e0e 100644
--- a/src/core/SkEmptyShader.h
+++ b/src/core/SkEmptyShader.h
@@ -14,14 +14,14 @@
/**
* \class SkEmptyShader
- * A Shader that always draws nothing. Its createContext always returns NULL.
+ * A Shader that always draws nothing. Its createContext always returns nullptr.
*/
class SK_API SkEmptyShader : public SkShader {
public:
SkEmptyShader() {}
size_t contextSize() const override {
- // Even though createContext returns NULL we have to return a value of at least
+ // Even though createContext returns nullptr we have to return a value of at least
// sizeof(SkShader::Context) to satisfy SkSmallAllocator.
return sizeof(SkShader::Context);
}
@@ -31,7 +31,7 @@
protected:
SkShader::Context* onCreateContext(const ContextRec&, void*) const override {
- return NULL;
+ return nullptr;
}
void flatten(SkWriteBuffer& buffer) const override {
diff --git a/src/core/SkEndian.h b/src/core/SkEndian.h
index 0955fcc..954afb0 100644
--- a/src/core/SkEndian.h
+++ b/src/core/SkEndian.h
@@ -39,7 +39,7 @@
low two bytes of each value in the array.
*/
static inline void SkEndianSwap16s(uint16_t array[], int count) {
- SkASSERT(count == 0 || array != NULL);
+ SkASSERT(count == 0 || array != nullptr);
while (--count >= 0) {
*array = SkEndianSwap16(*array);
@@ -68,7 +68,7 @@
bytes of each value in the array.
*/
static inline void SkEndianSwap32s(uint32_t array[], int count) {
- SkASSERT(count == 0 || array != NULL);
+ SkASSERT(count == 0 || array != nullptr);
while (--count >= 0) {
*array = SkEndianSwap32(*array);
@@ -104,7 +104,7 @@
bytes of each value in the array.
*/
static inline void SkEndianSwap64s(uint64_t array[], int count) {
- SkASSERT(count == 0 || array != NULL);
+ SkASSERT(count == 0 || array != nullptr);
while (--count >= 0) {
*array = SkEndianSwap64(*array);
diff --git a/src/core/SkError.cpp b/src/core/SkError.cpp
index 23db8ac..9e4385b 100644
--- a/src/core/SkError.cpp
+++ b/src/core/SkError.cpp
@@ -31,7 +31,7 @@
*(reinterpret_cast<SkErrorCallbackFunction *>(SkTLS::Get(CreateThreadErrorCallback, \
DeleteThreadErrorCallback)))
- void *CreateThreadErrorContext() { return new void **(NULL); }
+ void *CreateThreadErrorContext() { return new void **(nullptr); }
void DeleteThreadErrorContext(void *v) { delete reinterpret_cast<void **>(v); }
#define THREAD_ERROR_CONTEXT \
(*reinterpret_cast<void **>(SkTLS::Get(CreateThreadErrorContext, DeleteThreadErrorContext)))
@@ -60,7 +60,7 @@
// ------------ Private Error functions ---------
void SkErrorInternals::SetErrorCallback(SkErrorCallbackFunction cb, void *context) {
- if (cb == NULL) {
+ if (cb == nullptr) {
THREAD_ERROR_CALLBACK = SkErrorInternals::DefaultErrorCallback;
} else {
THREAD_ERROR_CALLBACK = cb;
@@ -89,7 +89,7 @@
va_list args;
char *str = THREAD_ERROR_STRING;
- const char *error_name = NULL;
+ const char *error_name = nullptr;
switch( code ) {
case kNoError_SkError:
error_name = "No Error";
diff --git a/src/core/SkFilterShader.cpp b/src/core/SkFilterShader.cpp
index d972489..b52c2be 100644
--- a/src/core/SkFilterShader.cpp
+++ b/src/core/SkFilterShader.cpp
@@ -30,7 +30,7 @@
SkAutoTUnref<SkShader> shader(buffer.readShader());
SkAutoTUnref<SkColorFilter> filter(buffer.readColorFilter());
if (!shader.get() || !filter.get()) {
- return NULL;
+ return nullptr;
}
return new SkFilterShader(shader, filter);
}
@@ -59,8 +59,8 @@
SkShader::Context* SkFilterShader::onCreateContext(const ContextRec& rec, void* storage) const {
char* shaderContextStorage = (char*)storage + sizeof(FilterShaderContext);
SkShader::Context* shaderContext = fShader->createContext(rec, shaderContextStorage);
- if (NULL == shaderContext) {
- return NULL;
+ if (nullptr == shaderContext) {
+ return nullptr;
}
return new (storage) FilterShaderContext(*this, shaderContext, rec);
}
diff --git a/src/core/SkFlattenable.cpp b/src/core/SkFlattenable.cpp
index 27efe7e..87e720e 100644
--- a/src/core/SkFlattenable.cpp
+++ b/src/core/SkFlattenable.cpp
@@ -17,7 +17,7 @@
return index;
}
const char* name = SkFlattenable::FactoryToName(factory);
- if (NULL == name) {
+ if (nullptr == name) {
return 0;
}
*fNames.append() = name;
@@ -28,7 +28,7 @@
if (fNextAddedFactory < fNames.count()) {
return fNames[fNextAddedFactory++];
}
- return NULL;
+ return nullptr;
}
///////////////////////////////////////////////////////////////////////////////
@@ -98,7 +98,7 @@
return entries[i].fFactory;
}
}
- return NULL;
+ return nullptr;
}
bool SkFlattenable::NameToType(const char name[], SkFlattenable::Type* type) {
@@ -128,5 +128,5 @@
return entries[i].fName;
}
}
- return NULL;
+ return nullptr;
}
diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
index d6895a4..c39cc18 100644
--- a/src/core/SkFont.cpp
+++ b/src/core/SkFont.cpp
@@ -31,13 +31,13 @@
SkFont* SkFont::Create(SkTypeface* face, SkScalar size, SkScalar scaleX, SkScalar skewX,
MaskType mt, uint32_t flags) {
if (size <= 0 || !SkScalarIsFinite(size)) {
- return NULL;
+ return nullptr;
}
if (scaleX <= 0 || !SkScalarIsFinite(scaleX)) {
- return NULL;
+ return nullptr;
}
if (!SkScalarIsFinite(skewX)) {
- return NULL;
+ return nullptr;
}
flags &= kAllFlags;
return new SkFont(face, size, scaleX, skewX, mt, flags);
@@ -82,7 +82,7 @@
count = SkToInt(byteLength >> 1);
break;
}
- if (NULL == glyphs) {
+ if (nullptr == glyphs) {
return count;
}
diff --git a/src/core/SkFontDescriptor.h b/src/core/SkFontDescriptor.h
index 933a36a..21fecdc 100644
--- a/src/core/SkFontDescriptor.h
+++ b/src/core/SkFontDescriptor.h
@@ -32,7 +32,7 @@
fAxis[i] = that.fAxis[i];
}
}
- bool hasStream() const { return fStream.get() != NULL; }
+ bool hasStream() const { return fStream.get() != nullptr; }
SkStreamAsset* duplicateStream() const { return fStream->duplicate(); }
SkStreamAsset* detachStream() { return fStream.detach(); }
SkStreamAsset* getStream() { return fStream.get(); }
@@ -61,7 +61,7 @@
const char* getFamilyName() const { return fFamilyName.c_str(); }
const char* getFullName() const { return fFullName.c_str(); }
const char* getPostscriptName() const { return fPostscriptName.c_str(); }
- bool hasFontData() const { return fFontData.get() != NULL; }
+ bool hasFontData() const { return fFontData.get() != nullptr; }
SkFontData* detachFontData() { return fFontData.detach(); }
void setFamilyName(const char* name) { fFamilyName.set(name); }
diff --git a/src/core/SkFontMgr.cpp b/src/core/SkFontMgr.cpp
index 35ad6c3..7c06690 100644
--- a/src/core/SkFontMgr.cpp
+++ b/src/core/SkFontMgr.cpp
@@ -22,10 +22,10 @@
}
SkTypeface* createTypeface(int index) override {
SkDEBUGFAIL("SkFontStyleSet::createTypeface called on empty set");
- return NULL;
+ return nullptr;
}
SkTypeface* matchStyle(const SkFontStyle&) override {
- return NULL;
+ return nullptr;
}
};
@@ -43,7 +43,7 @@
}
SkFontStyleSet* onCreateStyleSet(int index) const override {
SkDEBUGFAIL("onCreateStyleSet called with bad index");
- return NULL;
+ return nullptr;
}
SkFontStyleSet* onMatchFamily(const char[]) const override {
return SkFontStyleSet::CreateEmpty();
@@ -51,36 +51,36 @@
virtual SkTypeface* onMatchFamilyStyle(const char[],
const SkFontStyle&) const override {
- return NULL;
+ return nullptr;
}
virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
const SkFontStyle& style,
const char* bcp47[],
int bcp47Count,
SkUnichar character) const override {
- return NULL;
+ return nullptr;
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface*,
const SkFontStyle&) const override {
- return NULL;
+ return nullptr;
}
SkTypeface* onCreateFromData(SkData*, int) const override {
- return NULL;
+ return nullptr;
}
SkTypeface* onCreateFromStream(SkStreamAsset* stream, int) const override {
delete stream;
- return NULL;
+ return nullptr;
}
SkTypeface* onCreateFromFile(const char[], int) const override {
- return NULL;
+ return nullptr;
}
SkTypeface* onLegacyCreateTypeface(const char [], unsigned) const override {
- return NULL;
+ return nullptr;
}
};
static SkFontStyleSet* emptyOnNull(SkFontStyleSet* fsset) {
- if (NULL == fsset) {
+ if (nullptr == fsset) {
fsset = SkFontStyleSet::CreateEmpty();
}
return fsset;
@@ -119,22 +119,22 @@
}
SkTypeface* SkFontMgr::createFromData(SkData* data, int ttcIndex) const {
- if (NULL == data) {
- return NULL;
+ if (nullptr == data) {
+ return nullptr;
}
return this->onCreateFromData(data, ttcIndex);
}
SkTypeface* SkFontMgr::createFromStream(SkStreamAsset* stream, int ttcIndex) const {
- if (NULL == stream) {
- return NULL;
+ if (nullptr == stream) {
+ return nullptr;
}
return this->onCreateFromStream(stream, ttcIndex);
}
SkTypeface* SkFontMgr::createFromFontData(SkFontData* data) const {
- if (NULL == data) {
- return NULL;
+ if (nullptr == data) {
+ return nullptr;
}
return this->onCreateFromFontData(data);
}
@@ -147,8 +147,8 @@
}
SkTypeface* SkFontMgr::createFromFile(const char path[], int ttcIndex) const {
- if (NULL == path) {
- return NULL;
+ if (nullptr == path) {
+ return nullptr;
}
return this->onCreateFromFile(path, ttcIndex);
}
diff --git a/src/core/SkFontStream.cpp b/src/core/SkFontStream.cpp
index 580da37..b2ffe8d 100644
--- a/src/core/SkFontStream.cpp
+++ b/src/core/SkFontStream.cpp
@@ -101,7 +101,7 @@
///////////////////////////////////////////////////////////////////////////////
struct SfntHeader {
- SfntHeader() : fCount(0), fDir(NULL) {}
+ SfntHeader() : fCount(0), fDir(nullptr) {}
~SfntHeader() { sk_free(fDir); }
/** If it returns true, then fCount and fDir are properly initialized.
diff --git a/src/core/SkFontStream.h b/src/core/SkFontStream.h
index 0f7a052..0a2322f 100644
--- a/src/core/SkFontStream.h
+++ b/src/core/SkFontStream.h
@@ -42,7 +42,7 @@
size_t offset, size_t length, void* data);
static size_t GetTableSize(SkStream* stream, int ttcIndex, SkFontTableTag tag) {
- return GetTableData(stream, ttcIndex, tag, 0, ~0U, NULL);
+ return GetTableData(stream, ttcIndex, tag, 0, ~0U, nullptr);
}
};
diff --git a/src/core/SkGeometry.cpp b/src/core/SkGeometry.cpp
index 7462009..01b6180 100644
--- a/src/core/SkGeometry.cpp
+++ b/src/core/SkGeometry.cpp
@@ -912,7 +912,7 @@
SkScalar tValues[3]) {
SkScalar t_storage[3];
- if (tValues == NULL) {
+ if (tValues == nullptr) {
tValues = t_storage;
}
diff --git a/src/core/SkGeometry.h b/src/core/SkGeometry.h
index bd3abe1..79cad2e 100644
--- a/src/core/SkGeometry.h
+++ b/src/core/SkGeometry.h
@@ -39,7 +39,7 @@
/** Set pt to the point on the src quadratic specified by t. t must be
0 <= t <= 1.0
*/
-void SkEvalQuadAt(const SkPoint src[3], SkScalar t, SkPoint* pt, SkVector* tangent = NULL);
+void SkEvalQuadAt(const SkPoint src[3], SkScalar t, SkPoint* pt, SkVector* tangent = nullptr);
/**
* output is : eval(t) == coeff[0] * t^2 + coeff[1] * t + coeff[2]
@@ -164,7 +164,7 @@
int SkFindCubicMaxCurvature(const SkPoint src[4], SkScalar tValues[3]);
int SkChopCubicAtMaxCurvature(const SkPoint src[4], SkPoint dst[13],
- SkScalar tValues[3] = NULL);
+ SkScalar tValues[3] = nullptr);
bool SkChopMonoCubicAtX(SkPoint src[4], SkScalar y, SkPoint dst[7]);
bool SkChopMonoCubicAtY(SkPoint src[4], SkScalar x, SkPoint dst[7]);
@@ -239,7 +239,7 @@
* tangent value's length is arbitrary, and only its direction should
* be used.
*/
- void evalAt(SkScalar t, SkPoint* pos, SkVector* tangent = NULL) const;
+ void evalAt(SkScalar t, SkPoint* pos, SkVector* tangent = nullptr) const;
void chopAt(SkScalar t, SkConic dst[2]) const;
void chop(SkConic dst[2]) const;
diff --git a/src/core/SkGlyph.h b/src/core/SkGlyph.h
index 4699859..c747995 100644
--- a/src/core/SkGlyph.h
+++ b/src/core/SkGlyph.h
@@ -131,8 +131,8 @@
void initCommon(uint32_t id) {
fID = id;
- fImage = NULL;
- fPath = NULL;
+ fImage = nullptr;
+ fPath = nullptr;
fMaskFormat = MASK_FORMAT_UNKNOWN;
fForceBW = 0;
}
diff --git a/src/core/SkGlyphCache.cpp b/src/core/SkGlyphCache.cpp
index ff52004..e6d66f0 100644
--- a/src/core/SkGlyphCache.cpp
+++ b/src/core/SkGlyphCache.cpp
@@ -43,13 +43,13 @@
SkASSERT(desc);
SkASSERT(ctx);
- fPrev = fNext = NULL;
+ fPrev = fNext = nullptr;
fScalerContext->getFontMetrics(&fFontMetrics);
fMemoryUsed = sizeof(*this);
- fAuxProcList = NULL;
+ fAuxProcList = nullptr;
}
SkGlyphCache::~SkGlyphCache() {
@@ -60,7 +60,7 @@
}
SkGlyphCache::CharGlyphRec* SkGlyphCache::getCharGlyphRec(PackedUnicharID packedUnicharID) {
- if (NULL == fPackedUnicharIDToPackedGlyphID.get()) {
+ if (nullptr == fPackedUnicharIDToPackedGlyphID.get()) {
// Allocate the array.
fPackedUnicharIDToPackedGlyphID.reset(kHashCount);
// Initialize array to map character and position with the impossible glyph ID. This
@@ -161,7 +161,7 @@
SkGlyph* SkGlyphCache::lookupByPackedGlyphID(PackedGlyphID packedGlyphID, MetricsType type) {
SkGlyph* glyph = fGlyphMap.find(packedGlyphID);
- if (NULL == glyph) {
+ if (nullptr == glyph) {
glyph = this->allocateNewGlyph(packedGlyphID, type);
} else {
if (type == kFull_MetricsType && glyph->isJustAdvance()) {
@@ -194,7 +194,7 @@
const void* SkGlyphCache::findImage(const SkGlyph& glyph) {
if (glyph.fWidth > 0 && glyph.fWidth < kMaxGlyphWidth) {
- if (NULL == glyph.fImage) {
+ if (nullptr == glyph.fImage) {
size_t size = glyph.computeImageSize();
const_cast<SkGlyph&>(glyph).fImage = fGlyphAlloc.alloc(size,
SkChunkAlloc::kReturnNil_AllocFailType);
@@ -214,7 +214,7 @@
const SkPath* SkGlyphCache::findPath(const SkGlyph& glyph) {
if (glyph.fWidth) {
- if (glyph.fPath == NULL) {
+ if (glyph.fPath == nullptr) {
const_cast<SkGlyph&>(glyph).fPath = new SkPath;
fScalerContext->getPath(glyph, glyph.fPath);
fMemoryUsed += sizeof(SkPath) +
@@ -260,7 +260,7 @@
}
void SkGlyphCache::setAuxProc(void (*proc)(void*), void* data) {
- if (proc == NULL) {
+ if (proc == nullptr) {
return;
}
@@ -357,12 +357,12 @@
globals.validate();
- for (cache = globals.internalGetHead(); cache != NULL; cache = cache->fNext) {
+ for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
if (cache->fDesc->equals(*desc)) {
globals.internalDetachCache(cache);
if (!proc(cache, context)) {
globals.internalAttachCacheToHead(cache);
- cache = NULL;
+ cache = nullptr;
}
return cache;
}
@@ -388,14 +388,14 @@
if (!proc(cache, context)) { // need to reattach
globals.attachCacheToHead(cache);
- cache = NULL;
+ cache = nullptr;
}
return cache;
}
void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
SkASSERT(cache);
- SkASSERT(cache->fNext == NULL);
+ SkASSERT(cache->fNext == nullptr);
get_globals().attachCacheToHead(cache);
}
@@ -431,7 +431,7 @@
globals.validate();
- for (cache = globals.internalGetHead(); cache != NULL; cache = cache->fNext) {
+ for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
visitor(*cache, context);
}
}
@@ -489,7 +489,7 @@
// we start at the tail and proceed backwards, as the linklist is in LRU
// order, with unimportant entries at the tail.
SkGlyphCache* cache = this->internalGetTail();
- while (cache != NULL &&
+ while (cache != nullptr &&
(bytesFreed < bytesNeeded || countFreed < countNeeded)) {
SkGlyphCache* prev = cache->fPrev;
bytesFreed += cache->fMemoryUsed;
@@ -513,7 +513,7 @@
}
void SkGlyphCache_Globals::internalAttachCacheToHead(SkGlyphCache* cache) {
- SkASSERT(NULL == cache->fPrev && NULL == cache->fNext);
+ SkASSERT(nullptr == cache->fPrev && nullptr == cache->fNext);
if (fHead) {
fHead->fPrev = cache;
cache->fNext = fHead;
@@ -537,7 +537,7 @@
if (cache->fNext) {
cache->fNext->fPrev = cache->fPrev;
}
- cache->fPrev = cache->fNext = NULL;
+ cache->fPrev = cache->fNext = nullptr;
}
///////////////////////////////////////////////////////////////////////////////
@@ -562,7 +562,7 @@
int computedCount = 0;
const SkGlyphCache* head = fHead;
- while (head != NULL) {
+ while (head != nullptr) {
computedBytes += head->fMemoryUsed;
computedCount += 1;
head = head->fNext;
diff --git a/src/core/SkGlyphCache.h b/src/core/SkGlyphCache.h
index dc2aa57..7062041 100644
--- a/src/core/SkGlyphCache.h
+++ b/src/core/SkGlyphCache.h
@@ -117,7 +117,7 @@
/** Find a matching cache entry, and call proc() with it. If none is found create a new one.
If the proc() returns true, detach the cache and return it, otherwise leave it and return
- NULL.
+ nullptr.
*/
static SkGlyphCache* VisitCache(SkTypeface*, const SkDescriptor* desc,
bool (*proc)(const SkGlyphCache*, void*),
@@ -136,7 +136,7 @@
win is that different thread will never block each other while a strike is being used.
*/
static SkGlyphCache* DetachCache(SkTypeface* typeface, const SkDescriptor* desc) {
- return VisitCache(typeface, desc, DetachProc, NULL);
+ return VisitCache(typeface, desc, DetachProc, nullptr);
}
static void Dump();
@@ -163,7 +163,7 @@
}
}
void forget() {
- fCache = NULL;
+ fCache = nullptr;
}
private:
const SkGlyphCache* fCache;
@@ -249,7 +249,7 @@
void release() {
if (fCache) {
SkGlyphCache::AttachCache(fCache);
- fCache = NULL;
+ fCache = nullptr;
}
}
@@ -263,10 +263,10 @@
SkAutoGlyphCacheBase(const SkPaint& /*paint*/,
const SkSurfaceProps* /*surfaceProps*/,
const SkMatrix* /*matrix*/) {
- fCache = NULL;
+ fCache = nullptr;
}
SkAutoGlyphCacheBase() {
- fCache = NULL;
+ fCache = nullptr;
}
~SkAutoGlyphCacheBase() {
if (fCache) {
diff --git a/src/core/SkGlyphCache_Globals.h b/src/core/SkGlyphCache_Globals.h
index 70d8020..e1825a2 100644
--- a/src/core/SkGlyphCache_Globals.h
+++ b/src/core/SkGlyphCache_Globals.h
@@ -26,7 +26,7 @@
class SkGlyphCache_Globals {
public:
SkGlyphCache_Globals() {
- fHead = NULL;
+ fHead = nullptr;
fTotalMemoryUsed = 0;
fCacheSizeLimit = SK_DEFAULT_FONT_CACHE_LIMIT;
fCacheCount = 0;
diff --git a/src/core/SkImageCacherator.h b/src/core/SkImageCacherator.h
index c9aa121..dc6b0f2 100644
--- a/src/core/SkImageCacherator.h
+++ b/src/core/SkImageCacherator.h
@@ -34,7 +34,7 @@
/**
* Returns a ref() on the texture produced by this generator. The caller must call unref()
- * when it is done. Will return NULL on failure.
+ * when it is done. Will return nullptr on failure.
*
* The caller is responsible for calling texture->unref() when they are done.
*/
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index 90f14c5..cda3e05 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -182,7 +182,7 @@
fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)),
fUniqueID(next_image_filter_unique_id()) {
for (int i = 0; i < inputCount; ++i) {
- if (NULL == inputs[i] || inputs[i]->usesSrcInput()) {
+ if (nullptr == inputs[i] || inputs[i]->usesSrcInput()) {
fUsesSrcInput = true;
}
fInputs[i] = inputs[i];
@@ -207,13 +207,13 @@
fInputs = new SkImageFilter* [fInputCount];
common.detachInputs(fInputs);
for (int i = 0; i < fInputCount; ++i) {
- if (NULL == fInputs[i] || fInputs[i]->usesSrcInput()) {
+ if (nullptr == fInputs[i] || fInputs[i]->usesSrcInput()) {
fUsesSrcInput = true;
}
}
} else {
fInputCount = 0;
- fInputs = NULL;
+ fInputs = nullptr;
}
}
@@ -221,8 +221,8 @@
buffer.writeInt(fInputCount);
for (int i = 0; i < fInputCount; i++) {
SkImageFilter* input = getInput(i);
- buffer.writeBool(input != NULL);
- if (input != NULL) {
+ buffer.writeBool(input != nullptr);
+ if (input != nullptr) {
buffer.writeFlattenable(input);
}
}
@@ -307,7 +307,7 @@
}
bool SkImageFilter::canFilterImageGPU() const {
- return this->asFragmentProcessor(NULL, NULL, NULL, SkMatrix::I(), SkIRect());
+ return this->asFragmentProcessor(nullptr, nullptr, nullptr, SkMatrix::I(), SkIRect());
}
bool SkImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context& ctx,
@@ -464,7 +464,7 @@
if (kUnknown_SkColorType == info.colorType()) {
return false;
}
- SkAutoTUnref<GrTexture> resultTex(GrRefCachedBitmapTexture(context, *result, NULL));
+ SkAutoTUnref<GrTexture> resultTex(GrRefCachedBitmapTexture(context, *result, nullptr));
result->setPixelRef(new SkGrPixelRef(info, resultTex))->unref();
}
return true;
@@ -587,8 +587,8 @@
SkBaseDevice::kNever_TileUsage,
kUnknown_SkPixelGeometry,
true /*forImageFilter*/);
- SkBaseDevice* dev = fDevice->onCreateDevice(cinfo, NULL);
- if (NULL == dev) {
+ SkBaseDevice* dev = fDevice->onCreateDevice(cinfo, nullptr);
+ if (nullptr == dev) {
const SkSurfaceProps surfaceProps(fDevice->fSurfaceProps.flags(),
kUnknown_SkPixelGeometry);
dev = SkBitmapDevice::Create(cinfo.fInfo, surfaceProps);
diff --git a/src/core/SkImageGenerator.cpp b/src/core/SkImageGenerator.cpp
index ffccb61..33da50a 100644
--- a/src/core/SkImageGenerator.cpp
+++ b/src/core/SkImageGenerator.cpp
@@ -18,7 +18,7 @@
if (kUnknown_SkColorType == info.colorType()) {
return false;
}
- if (NULL == pixels) {
+ if (nullptr == pixels) {
return false;
}
if (rowBytes < info.minRowBytes()) {
@@ -26,15 +26,15 @@
}
if (kIndex_8_SkColorType == info.colorType()) {
- if (NULL == ctable || NULL == ctableCount) {
+ if (nullptr == ctable || nullptr == ctableCount) {
return false;
}
} else {
if (ctableCount) {
*ctableCount = 0;
}
- ctableCount = NULL;
- ctable = NULL;
+ ctableCount = nullptr;
+ ctable = nullptr;
}
const bool success = this->onGetPixels(info, pixels, rowBytes, ctable, ctableCount);
@@ -49,7 +49,7 @@
if (kIndex_8_SkColorType == info.colorType()) {
return false;
}
- return this->getPixels(info, pixels, rowBytes, NULL, NULL);
+ return this->getPixels(info, pixels, rowBytes, nullptr, nullptr);
}
bool SkImageGenerator::getYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
@@ -62,9 +62,9 @@
((planes[0]) && (planes[1]) && (planes[2]) &&
(0 != rowBytes[0]) && (0 != rowBytes[1]) && (0 != rowBytes[2]));
bool isValidWithoutPlanes =
- ((NULL == planes) ||
- ((NULL == planes[0]) && (NULL == planes[1]) && (NULL == planes[2]))) &&
- ((NULL == rowBytes) ||
+ ((nullptr == planes) ||
+ ((nullptr == planes[0]) && (nullptr == planes[1]) && (nullptr == planes[2]))) &&
+ ((nullptr == rowBytes) ||
((0 == rowBytes[0]) && (0 == rowBytes[1]) && (0 == rowBytes[2])));
// Either we have all planes and rowBytes information or we have none of it
@@ -115,7 +115,7 @@
/////////////////////////////////////////////////////////////////////////////////////////////
SkData* SkImageGenerator::onRefEncodedData() {
- return NULL;
+ return nullptr;
}
bool SkImageGenerator::onGetPixels(const SkImageInfo& info, void* dst, size_t rb,
@@ -138,8 +138,8 @@
}
SkImageGenerator* SkImageGenerator::NewFromEncoded(SkData* data) {
- if (NULL == data) {
- return NULL;
+ if (nullptr == data) {
+ return nullptr;
}
if (gFactory) {
if (SkImageGenerator* generator = gFactory(data)) {
diff --git a/src/core/SkImageGeneratorPriv.h b/src/core/SkImageGeneratorPriv.h
index 5d018bc..bf03596 100644
--- a/src/core/SkImageGeneratorPriv.h
+++ b/src/core/SkImageGeneratorPriv.h
@@ -17,7 +17,7 @@
* the generator. If it succeeds, it will modify destination
* bitmap.
*
- * If generator is NULL, will safely return false.
+ * If generator is nullptr, will safely return false.
*
* If this fails or when the SkDiscardablePixelRef that is
* installed into destination is destroyed, it will call
@@ -27,8 +27,8 @@
* @param destination Upon success, this bitmap will be
* configured and have a pixelref installed.
*
- * @param factory If not NULL, this object will be used as a
- * source of discardable memory when decoding. If NULL, then
+ * @param factory If not nullptr, this object will be used as a
+ * source of discardable memory when decoding. If nullptr, then
* SkDiscardableMemory::Create() will be called.
*
* @return true iff successful.
diff --git a/src/core/SkImageInfo.cpp b/src/core/SkImageInfo.cpp
index 8429ef2..b90f858 100644
--- a/src/core/SkImageInfo.cpp
+++ b/src/core/SkImageInfo.cpp
@@ -90,7 +90,7 @@
default:
break;
}
- if (NULL == fPixels || fRowBytes < fInfo.minRowBytes()) {
+ if (nullptr == fPixels || fRowBytes < fInfo.minRowBytes()) {
return false;
}
if (0 == fInfo.width() || 0 == fInfo.height()) {
diff --git a/src/core/SkLayerInfo.h b/src/core/SkLayerInfo.h
index 5d598ef..04ae179 100644
--- a/src/core/SkLayerInfo.h
+++ b/src/core/SkLayerInfo.h
@@ -18,7 +18,7 @@
// Information about a given saveLayer/restore block in an SkPicture
class BlockInfo {
public:
- BlockInfo() : fPicture(NULL), fPaint(NULL), fKey(NULL), fKeySize(0) {}
+ BlockInfo() : fPicture(nullptr), fPaint(nullptr), fKey(nullptr), fKeySize(0) {}
~BlockInfo() {
SkSafeUnref(fPicture);
delete fPaint;
@@ -27,8 +27,8 @@
// The picture owning the layer. If the owning picture is the top-most
// one (i.e., the picture for which this SkLayerInfo was created) then
- // this pointer is NULL. If it is a nested picture then the pointer
- // is non-NULL and owns a ref on the picture.
+ // this pointer is nullptr. If it is a nested picture then the pointer
+ // is non-nullptr and owns a ref on the picture.
const SkPicture* fPicture;
// The device space bounds of this layer.
SkRect fBounds;
@@ -46,7 +46,7 @@
// layer's top-left point to the origin (which must be part of the
// initial matrix).
SkMatrix fLocalMat;
- // The paint to use on restore. Can be NULL since it is optional.
+ // The paint to use on restore. Can be nullptr since it is optional.
const SkPaint* fPaint;
// The index of this saveLayer in the picture.
size_t fSaveLayerOpID;
diff --git a/src/core/SkLazyFnPtr.h b/src/core/SkLazyFnPtr.h
index 9e9bc11..1535782 100644
--- a/src/core/SkLazyFnPtr.h
+++ b/src/core/SkLazyFnPtr.h
@@ -42,7 +42,7 @@
F get() {
// First, try reading to see if it's already set.
F fn = (F)sk_atomic_load(&fPtr, sk_memory_order_relaxed);
- if (fn != NULL) {
+ if (fn != nullptr) {
return fn;
}
@@ -50,11 +50,11 @@
fn = Choose();
// No particular memory barriers needed; we're not guarding anything but the pointer itself.
- F prev = (F)sk_atomic_cas(&fPtr, NULL, (void*)fn);
+ F prev = (F)sk_atomic_cas(&fPtr, nullptr, (void*)fn);
- // If prev != NULL, someone snuck in and set fPtr concurrently.
- // If prev == NULL, we did write fn to fPtr.
- return prev != NULL ? prev : fn;
+ // If prev != nullptr, someone snuck in and set fPtr concurrently.
+ // If prev == nullptr, we did write fn to fPtr.
+ return prev != nullptr ? prev : fn;
}
private:
diff --git a/src/core/SkLightingShader.cpp b/src/core/SkLightingShader.cpp
index 0e20db4..a8d346a 100644
--- a/src/core/SkLightingShader.cpp
+++ b/src/core/SkLightingShader.cpp
@@ -176,22 +176,22 @@
GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuilder();
// add uniforms
- const char* lightDirUniName = NULL;
+ const char* lightDirUniName = nullptr;
fLightDirUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec3f_GrSLType, kDefault_GrSLPrecision,
"LightDir", &lightDirUniName);
- const char* lightColorUniName = NULL;
+ const char* lightColorUniName = nullptr;
fLightColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec3f_GrSLType, kDefault_GrSLPrecision,
"LightColor", &lightColorUniName);
- const char* ambientColorUniName = NULL;
+ const char* ambientColorUniName = nullptr;
fAmbientColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec3f_GrSLType, kDefault_GrSLPrecision,
"AmbientColor", &ambientColorUniName);
- const char* xformUniName = NULL;
+ const char* xformUniName = nullptr;
fXformUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, kDefault_GrSLPrecision,
"Xform", &xformUniName);
@@ -578,13 +578,13 @@
SkBitmap diffuse;
if (!buf.readBitmap(&diffuse)) {
- return NULL;
+ return nullptr;
}
diffuse.setImmutable();
SkBitmap normal;
if (!buf.readBitmap(&normal)) {
- return NULL;
+ return nullptr;
}
normal.setImmutable();
@@ -597,7 +597,7 @@
SkColor3f color;
if (!buf.readScalarArray(&color.fX, 3)) {
- return NULL;
+ return nullptr;
}
if (isAmbient) {
@@ -605,7 +605,7 @@
} else {
SkVector3 dir;
if (!buf.readScalarArray(&dir.fX, 3)) {
- return NULL;
+ return nullptr;
}
builder.add(SkLight(color, dir));
}
@@ -665,7 +665,7 @@
SkMatrix normTotalInv;
if (!this->computeNormTotalInverse(rec, &normTotalInv)) {
- return NULL;
+ return nullptr;
}
void* diffuseStateStorage = (char*)storage + sizeof(LightingShaderContext);
@@ -677,7 +677,7 @@
diffuseState->fOrigBitmap = fDiffuseMap;
if (!diffuseState->chooseProcs(diffTotalInv, *rec.fPaint)) {
diffuseState->~SkBitmapProcState();
- return NULL;
+ return nullptr;
}
void* normalStateStorage = (char*)storage + sizeof(LightingShaderContext) + sizeof(SkBitmapProcState);
@@ -690,7 +690,7 @@
if (!normalState->chooseProcs(normTotalInv, *rec.fPaint)) {
diffuseState->~SkBitmapProcState();
normalState->~SkBitmapProcState();
- return NULL;
+ return nullptr;
}
return new (storage) LightingShaderContext(*this, rec, diffuseState, normalState);
diff --git a/src/core/SkLightingShader.h b/src/core/SkLightingShader.h
index d286487..f87db31 100644
--- a/src/core/SkLightingShader.h
+++ b/src/core/SkLightingShader.h
@@ -73,7 +73,7 @@
@param ambient the linear (unpremul) ambient light color. Range is 0..1/channel.
@param localMatrix the matrix mapping the textures to the dest rect
- NULL will be returned if:
+ nullptr will be returned if:
either 'diffuse' or 'normal' are empty
either 'diffuse' or 'normal' are too big (> 65535 on a side)
'diffuse' and 'normal' aren't the same size
diff --git a/src/core/SkLocalMatrixShader.cpp b/src/core/SkLocalMatrixShader.cpp
index b9a0960..ce5a7ca 100644
--- a/src/core/SkLocalMatrixShader.cpp
+++ b/src/core/SkLocalMatrixShader.cpp
@@ -12,7 +12,7 @@
buffer.readMatrix(&lm);
SkAutoTUnref<SkShader> shader(buffer.readShader());
if (!shader.get()) {
- return NULL;
+ return nullptr;
}
return SkShader::CreateLocalMatrixShader(shader, lm);
}
@@ -48,8 +48,8 @@
#endif
SkShader* SkShader::CreateLocalMatrixShader(SkShader* proxy, const SkMatrix& localMatrix) {
- if (NULL == proxy) {
- return NULL;
+ if (nullptr == proxy) {
+ return nullptr;
}
if (localMatrix.isIdentity()) {
diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp
index 4916510..0196e04 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -27,7 +27,7 @@
// that expect the pixelref to succeed even when there is a mismatch
// with colortables. fix?
#if 0
- if (kIndex8_SkColorType == info.fColorType && NULL == ctable) {
+ if (kIndex8_SkColorType == info.fColorType && nullptr == ctable) {
return false;
}
if (kIndex8_SkColorType != info.fColorType && ctable) {
@@ -42,9 +42,9 @@
size_t rowBytes,
SkColorTable* ctable) {
if (!is_valid(info, ctable)) {
- return NULL;
+ return nullptr;
}
- return new SkMallocPixelRef(info, addr, rowBytes, ctable, NULL, NULL);
+ return new SkMallocPixelRef(info, addr, rowBytes, ctable, nullptr, nullptr);
}
@@ -52,16 +52,16 @@
size_t requestedRowBytes,
SkColorTable* ctable) {
if (!is_valid(info, ctable)) {
- return NULL;
+ return nullptr;
}
// only want to permit 31bits of rowBytes
int64_t minRB = (int64_t)info.minRowBytes64();
if (minRB < 0 || !sk_64_isS32(minRB)) {
- return NULL; // allocation will be too large
+ return nullptr; // allocation will be too large
}
if (requestedRowBytes > 0 && (int32_t)requestedRowBytes < minRB) {
- return NULL; // cannot meet requested rowbytes
+ return nullptr; // cannot meet requested rowbytes
}
int32_t rowBytes;
@@ -73,17 +73,17 @@
int64_t bigSize = (int64_t)info.height() * rowBytes;
if (!sk_64_isS32(bigSize)) {
- return NULL;
+ return nullptr;
}
size_t size = sk_64_asS32(bigSize);
SkASSERT(size >= info.getSafeSize(rowBytes));
void* addr = sk_malloc_flags(size, 0);
- if (NULL == addr) {
- return NULL;
+ if (nullptr == addr) {
+ return nullptr;
}
- return new SkMallocPixelRef(info, addr, rowBytes, ctable, sk_free_releaseproc, NULL);
+ return new SkMallocPixelRef(info, addr, rowBytes, ctable, sk_free_releaseproc, nullptr);
}
SkMallocPixelRef* SkMallocPixelRef::NewWithProc(const SkImageInfo& info,
@@ -93,7 +93,7 @@
SkMallocPixelRef::ReleaseProc proc,
void* context) {
if (!is_valid(info, ctable)) {
- return NULL;
+ return nullptr;
}
return new SkMallocPixelRef(info, addr, rowBytes, ctable, proc, context);
}
@@ -106,19 +106,19 @@
size_t rowBytes,
SkColorTable* ctable,
SkData* data) {
- SkASSERT(data != NULL);
+ SkASSERT(data != nullptr);
if (!is_valid(info, ctable)) {
- return NULL;
+ return nullptr;
}
if ((rowBytes < info.minRowBytes())
|| (data->size() < info.getSafeSize(rowBytes))) {
- return NULL;
+ return nullptr;
}
data->ref();
SkMallocPixelRef* pr =
new SkMallocPixelRef(info, const_cast<void*>(data->data()), rowBytes, ctable,
sk_data_releaseproc, static_cast<void*>(data));
- SkASSERT(pr != NULL);
+ SkASSERT(pr != nullptr);
// We rely on the immutability of the pixels to make the
// const_cast okay.
pr->setImmutable();
@@ -131,14 +131,14 @@
size_t rowBytes, SkColorTable* ctable,
bool ownsPixels)
: INHERITED(info)
- , fReleaseProc(ownsPixels ? sk_free_releaseproc : NULL)
- , fReleaseProcContext(NULL) {
+ , fReleaseProc(ownsPixels ? sk_free_releaseproc : nullptr)
+ , fReleaseProcContext(nullptr) {
// This constructor is now DEPRICATED.
SkASSERT(is_valid(info, ctable));
SkASSERT(rowBytes >= info.minRowBytes());
if (kIndex_8_SkColorType != info.colorType()) {
- ctable = NULL;
+ ctable = nullptr;
}
fStorage = storage;
@@ -161,7 +161,7 @@
SkASSERT(rowBytes >= info.minRowBytes());
if (kIndex_8_SkColorType != info.colorType()) {
- ctable = NULL;
+ ctable = nullptr;
}
fStorage = storage;
@@ -175,7 +175,7 @@
SkMallocPixelRef::~SkMallocPixelRef() {
SkSafeUnref(fCTable);
- if (fReleaseProc != NULL) {
+ if (fReleaseProc != nullptr) {
fReleaseProc(fStorage, fReleaseProcContext);
}
}
diff --git a/src/core/SkMaskCache.cpp b/src/core/SkMaskCache.cpp
index cc729c3..da7b538 100644
--- a/src/core/SkMaskCache.cpp
+++ b/src/core/SkMaskCache.cpp
@@ -64,7 +64,7 @@
SkCachedData* tmpData = rec.fValue.fData;
tmpData->ref();
- if (NULL == tmpData->data()) {
+ if (nullptr == tmpData->data()) {
tmpData->unref();
return false;
}
@@ -79,7 +79,7 @@
MaskValue result;
RRectBlurKey key(sigma, rrect, style, quality);
if (!CHECK_LOCAL(localCache, find, Find, key, RRectBlurRec::Visitor, &result)) {
- return NULL;
+ return nullptr;
}
*mask = result.fMask;
@@ -159,7 +159,7 @@
SkCachedData* tmpData = rec.fValue.fData;
tmpData->ref();
- if (NULL == tmpData->data()) {
+ if (nullptr == tmpData->data()) {
tmpData->unref();
return false;
}
@@ -175,7 +175,7 @@
MaskValue result;
RectsBlurKey key(sigma, style, quality, rects, count);
if (!CHECK_LOCAL(localCache, find, Find, key, RectsBlurRec::Visitor, &result)) {
- return NULL;
+ return nullptr;
}
*mask = result.fMask;
diff --git a/src/core/SkMaskCache.h b/src/core/SkMaskCache.h
index f98387b..9df1bf8 100644
--- a/src/core/SkMaskCache.h
+++ b/src/core/SkMaskCache.h
@@ -21,24 +21,24 @@
* On success, return a ref to the SkCachedData that holds the pixels, and have mask
* already point to that memory.
*
- * On failure, return NULL.
+ * On failure, return nullptr.
*/
static SkCachedData* FindAndRef(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRRect& rrect, SkMask* mask,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
static SkCachedData* FindAndRef(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRect rects[], int count, SkMask* mask,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
/**
* Add a mask and its pixel-data to the cache.
*/
static void Add(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRRect& rrect, const SkMask& mask, SkCachedData* data,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
static void Add(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRect rects[], int count, const SkMask& mask, SkCachedData* data,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
};
#endif
diff --git a/src/core/SkMaskFilter.cpp b/src/core/SkMaskFilter.cpp
index 5e7cee6..7c48bca 100644
--- a/src/core/SkMaskFilter.cpp
+++ b/src/core/SkMaskFilter.cpp
@@ -222,11 +222,11 @@
// cannot be used, return false to allow our caller to recover and perform
// the drawing another way.
NinePatch patch;
- patch.fMask.fImage = NULL;
+ patch.fMask.fImage = nullptr;
if (kTrue_FilterReturn != this->filterRRectToNine(devRRect, matrix,
clip.getBounds(),
&patch)) {
- SkASSERT(NULL == patch.fMask.fImage);
+ SkASSERT(nullptr == patch.fMask.fImage);
return false;
}
draw_nine(patch.fMask, patch.fOuterRect, patch.fCenter, true, clip, blitter);
@@ -246,7 +246,7 @@
switch (this->filterRectsToNine(rects, rectCount, matrix, clip.getBounds(), &patch)) {
case kFalse_FilterReturn:
- SkASSERT(NULL == patch.fMask.fImage);
+ SkASSERT(nullptr == patch.fMask.fImage);
return false;
case kTrue_FilterReturn:
@@ -255,7 +255,7 @@
return true;
case kUnimplemented_FilterReturn:
- SkASSERT(NULL == patch.fMask.fImage);
+ SkASSERT(nullptr == patch.fMask.fImage);
// fall through
break;
}
@@ -270,7 +270,7 @@
}
SkAutoMaskFreeImage autoSrc(srcM.fImage);
- if (!this->filterMask(&dstM, srcM, matrix, NULL)) {
+ if (!this->filterMask(&dstM, srcM, matrix, nullptr)) {
return false;
}
SkAutoMaskFreeImage autoDst(dstM.fImage);
@@ -351,7 +351,7 @@
void SkMaskFilter::computeFastBounds(const SkRect& src, SkRect* dst) const {
SkMask srcM, dstM;
- srcM.fImage = NULL;
+ srcM.fImage = nullptr;
srcM.fBounds = src.roundOut();
srcM.fRowBytes = 0;
srcM.fFormat = SkMask::kA8_Format;
diff --git a/src/core/SkMaskGamma.h b/src/core/SkMaskGamma.h
index be5d034..16ea47b 100644
--- a/src/core/SkMaskGamma.h
+++ b/src/core/SkMaskGamma.h
@@ -168,7 +168,7 @@
* convert a linear alpha value for a given channel to a gamma correcting alpha
* value for that channel. This class is immutable.
*
- * If fR, fG, or fB is NULL, all of them will be. This indicates that no mask
+ * If fR, fG, or fB is nullptr, all of them will be. This indicates that no mask
* pre blend should be applied. SkTMaskPreBlend::isApplicable() is provided as
* a convenience function to test for the absence of this case.
*/
@@ -182,7 +182,7 @@
friend class SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>;
public:
/** Creates a non applicable SkTMaskPreBlend. */
- SkTMaskPreBlend() : fParent(), fR(NULL), fG(NULL), fB(NULL) { }
+ SkTMaskPreBlend() : fParent(), fR(nullptr), fG(nullptr), fB(nullptr) { }
/**
* This copy contructor exists for correctness, but should never be called
@@ -193,7 +193,7 @@
~SkTMaskPreBlend() { }
- /** True if this PreBlend should be applied. When false, fR, fG, and fB are NULL. */
+ /** True if this PreBlend should be applied. When false, fR, fG, and fB are nullptr. */
bool isApplicable() const { return SkToBool(this->fG); }
const uint8_t* fR;
diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp
index f5e4e80..13a9ac2 100644
--- a/src/core/SkMatrix.cpp
+++ b/src/core/SkMatrix.cpp
@@ -858,7 +858,7 @@
// translate only
inv->setTranslate(-fMat[kMTransX], -fMat[kMTransY]);
}
- } else { // inv is NULL, just check if we're invertible
+ } else { // inv is nullptr, just check if we're invertible
if (!fMat[kMScaleX] || !fMat[kMScaleY]) {
invertible = false;
}
@@ -878,7 +878,7 @@
SkMatrix* tmp = inv;
SkMatrix storage;
- if (applyingInPlace || NULL == tmp) {
+ if (applyingInPlace || nullptr == tmp) {
tmp = &storage; // we either need to avoid trampling memory or have no memory
}
diff --git a/src/core/SkMatrixImageFilter.cpp b/src/core/SkMatrixImageFilter.cpp
index b6f6fc8..823647f 100644
--- a/src/core/SkMatrixImageFilter.cpp
+++ b/src/core/SkMatrixImageFilter.cpp
@@ -72,7 +72,7 @@
dstRect.roundOut(&dstBounds);
SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(dstBounds.width(), dstBounds.height()));
- if (NULL == device.get()) {
+ if (nullptr == device.get()) {
return false;
}
diff --git a/src/core/SkMatrixImageFilter.h b/src/core/SkMatrixImageFilter.h
index 83f2cfa..86734b6 100644
--- a/src/core/SkMatrixImageFilter.h
+++ b/src/core/SkMatrixImageFilter.h
@@ -24,13 +24,13 @@
/** Construct a 2D transformation image filter.
* @param transform The matrix to apply when drawing the src bitmap
* @param filterLevel The quality of filtering to apply when scaling.
- * @param input The input image filter. If NULL, the src bitmap
+ * @param input The input image filter. If nullptr, the src bitmap
* passed to filterImage() is used instead.
*/
static SkMatrixImageFilter* Create(const SkMatrix& transform,
SkFilterQuality,
- SkImageFilter* input = NULL);
+ SkImageFilter* input = nullptr);
virtual ~SkMatrixImageFilter();
void computeFastBounds(const SkRect&, SkRect*) const override;
diff --git a/src/core/SkMetaData.cpp b/src/core/SkMetaData.cpp
index dfc2a94..dd6ed05 100644
--- a/src/core/SkMetaData.cpp
+++ b/src/core/SkMetaData.cpp
@@ -27,11 +27,11 @@
return ptr;
}
-SkMetaData::SkMetaData() : fRec(NULL)
+SkMetaData::SkMetaData() : fRec(nullptr)
{
}
-SkMetaData::SkMetaData(const SkMetaData& src) : fRec(NULL)
+SkMetaData::SkMetaData(const SkMetaData& src) : fRec(nullptr)
{
*this = src;
}
@@ -55,7 +55,7 @@
Rec::Free(rec);
rec = next;
}
- fRec = NULL;
+ fRec = nullptr;
}
SkMetaData& SkMetaData::operator=(const SkMetaData& src)
@@ -86,7 +86,7 @@
SkASSERT(count > 0);
if (count > 0)
return (SkScalar*)this->set(name, values, sizeof(SkScalar), kScalar_Type, count);
- return NULL;
+ return nullptr;
}
void SkMetaData::setString(const char name[], const char value[])
@@ -179,7 +179,7 @@
memcpy(values, rec->data(), rec->fDataCount * rec->fDataLen);
return (const SkScalar*)rec->data();
}
- return NULL;
+ return nullptr;
}
bool SkMetaData::findPtr(const char name[], void** ptr, PtrProc* proc) const {
@@ -201,8 +201,8 @@
const char* SkMetaData::findString(const char name[]) const
{
const Rec* rec = this->find(name, kString_Type);
- SkASSERT(rec == NULL || rec->fDataLen == sizeof(char));
- return rec ? (const char*)rec->data() : NULL;
+ SkASSERT(rec == nullptr || rec->fDataLen == sizeof(char));
+ return rec ? (const char*)rec->data() : nullptr;
}
bool SkMetaData::findBool(const char name[], bool* value) const
@@ -227,7 +227,7 @@
}
return rec->data();
}
- return NULL;
+ return nullptr;
}
const SkMetaData::Rec* SkMetaData::find(const char name[], Type type) const
@@ -239,12 +239,12 @@
return rec;
rec = rec->fNext;
}
- return NULL;
+ return nullptr;
}
bool SkMetaData::remove(const char name[], Type type) {
Rec* rec = fRec;
- Rec* prev = NULL;
+ Rec* prev = nullptr;
while (rec) {
Rec* next = rec->fNext;
if (rec->fType == type && !strcmp(rec->name(), name)) {
@@ -309,7 +309,7 @@
}
const char* SkMetaData::Iter::next(SkMetaData::Type* t, int* count) {
- const char* name = NULL;
+ const char* name = nullptr;
if (fRec) {
if (t) {
diff --git a/src/core/SkMipMap.cpp b/src/core/SkMipMap.cpp
index 8a62f88..6e0aaed 100644
--- a/src/core/SkMipMap.cpp
+++ b/src/core/SkMipMap.cpp
@@ -206,7 +206,7 @@
proc_nocheck = downsample8_nocheck;
break;
default:
- return NULL; // don't build mipmaps for any other colortypes (yet)
+ return nullptr; // don't build mipmaps for any other colortypes (yet)
}
// whip through our loop to compute the exact size needed
@@ -226,29 +226,29 @@
}
}
if (0 == countLevels) {
- return NULL;
+ return nullptr;
}
size_t storageSize = SkMipMap::AllocLevelsSize(countLevels, size);
if (0 == storageSize) {
- return NULL;
+ return nullptr;
}
SkAutoPixmapUnlock srcUnlocker;
if (!src.requestLock(&srcUnlocker)) {
- return NULL;
+ return nullptr;
}
const SkPixmap& srcPixmap = srcUnlocker.pixmap();
- // Try to catch where we might have returned NULL for src crbug.com/492818
- if (NULL == srcPixmap.addr()) {
+ // Try to catch where we might have returned nullptr for src crbug.com/492818
+ if (nullptr == srcPixmap.addr()) {
sk_throw();
}
SkMipMap* mipmap;
if (fact) {
SkDiscardableMemory* dm = fact(storageSize);
- if (NULL == dm) {
- return NULL;
+ if (nullptr == dm) {
+ return nullptr;
}
mipmap = new SkMipMap(storageSize, dm);
} else {
@@ -321,7 +321,7 @@
///////////////////////////////////////////////////////////////////////////////
bool SkMipMap::extractLevel(SkScalar scale, Level* levelPtr) const {
- if (NULL == fLevels) {
+ if (nullptr == fLevels) {
return false;
}
diff --git a/src/core/SkMipMap.h b/src/core/SkMipMap.h
index e22c0a2..36c17ba 100644
--- a/src/core/SkMipMap.h
+++ b/src/core/SkMipMap.h
@@ -31,7 +31,7 @@
protected:
void onDataChange(void* oldData, void* newData) override {
- fLevels = (Level*)newData; // could be NULL
+ fLevels = (Level*)newData; // could be nullptr
}
private:
diff --git a/src/core/SkMultiPictureDraw.cpp b/src/core/SkMultiPictureDraw.cpp
index 8cbb9ca..4003808 100644
--- a/src/core/SkMultiPictureDraw.cpp
+++ b/src/core/SkMultiPictureDraw.cpp
@@ -37,7 +37,7 @@
if (paint) {
fPaint = new SkPaint(*paint);
} else {
- fPaint = NULL;
+ fPaint = nullptr;
}
}
@@ -68,8 +68,8 @@
const SkPicture* picture,
const SkMatrix* matrix,
const SkPaint* paint) {
- if (NULL == canvas || NULL == picture) {
- SkDEBUGFAIL("parameters to SkMultiPictureDraw::add should be non-NULL");
+ if (nullptr == canvas || nullptr == picture) {
+ SkDEBUGFAIL("parameters to SkMultiPictureDraw::add should be non-nullptr");
return;
}
@@ -179,7 +179,7 @@
// Render the entire picture using new layers
GrRecordReplaceDraw(picture, canvas, context->getLayerCache(),
- initialMatrix, NULL);
+ initialMatrix, nullptr);
GrLayerHoister::UnlockLayers(context, needRendering);
GrLayerHoister::UnlockLayers(context, recycled);
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 7fd0b9d..c109720 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -40,16 +40,16 @@
//#define SK_REPORT_API_RANGE_CHECK
SkPaint::SkPaint() {
- fTypeface = NULL;
- fPathEffect = NULL;
- fShader = NULL;
- fXfermode = NULL;
- fMaskFilter = NULL;
- fColorFilter = NULL;
- fRasterizer = NULL;
- fLooper = NULL;
- fImageFilter = NULL;
- fAnnotation = NULL;
+ fTypeface = nullptr;
+ fPathEffect = nullptr;
+ fShader = nullptr;
+ fXfermode = nullptr;
+ fMaskFilter = nullptr;
+ fColorFilter = nullptr;
+ fRasterizer = nullptr;
+ fLooper = nullptr;
+ fImageFilter = nullptr;
+ fAnnotation = nullptr;
fTextSize = SkPaintDefaults_TextSize;
fTextScaleX = SK_Scalar1;
@@ -398,9 +398,9 @@
return 0;
}
- SkASSERT(textData != NULL);
+ SkASSERT(textData != nullptr);
- if (NULL == glyphs) {
+ if (nullptr == glyphs) {
switch (this->getTextEncoding()) {
case kUTF8_TextEncoding:
return SkUTF8_CountUnichars((const char*)textData, byteLength);
@@ -425,7 +425,7 @@
return SkToInt(byteLength >> 1);
}
- SkAutoGlyphCache autoCache(*this, NULL, NULL);
+ SkAutoGlyphCache autoCache(*this, nullptr, nullptr);
SkGlyphCache* cache = autoCache.getCache();
const char* text = (const char*)textData;
@@ -465,7 +465,7 @@
return true;
}
- SkASSERT(textData != NULL);
+ SkASSERT(textData != nullptr);
// handle this encoding before the setup for the glyphcache
if (this->getTextEncoding() == kGlyphID_TextEncoding) {
@@ -479,7 +479,7 @@
return true;
}
- SkAutoGlyphCache autoCache(*this, NULL, NULL);
+ SkAutoGlyphCache autoCache(*this, nullptr, nullptr);
SkGlyphCache* cache = autoCache.getCache();
switch (this->getTextEncoding()) {
@@ -525,11 +525,11 @@
return;
}
- SkASSERT(glyphs != NULL);
- SkASSERT(textData != NULL);
+ SkASSERT(glyphs != nullptr);
+ SkASSERT(textData != nullptr);
SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
- SkAutoGlyphCache autoCache(*this, &props, NULL);
+ SkAutoGlyphCache autoCache(*this, &props, nullptr);
SkGlyphCache* cache = autoCache.getCache();
for (int index = 0; index < count; index++) {
@@ -541,24 +541,24 @@
static const SkGlyph& sk_getMetrics_utf8_next(SkGlyphCache* cache,
const char** text) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
return cache->getUnicharMetrics(SkUTF8_NextUnichar(text));
}
static const SkGlyph& sk_getMetrics_utf16_next(SkGlyphCache* cache,
const char** text) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
return cache->getUnicharMetrics(SkUTF16_NextUnichar((const uint16_t**)text));
}
static const SkGlyph& sk_getMetrics_utf32_next(SkGlyphCache* cache,
const char** text) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
const int32_t* ptr = *(const int32_t**)text;
SkUnichar uni = *ptr++;
@@ -568,8 +568,8 @@
static const SkGlyph& sk_getMetrics_glyph_next(SkGlyphCache* cache,
const char** text) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
const uint16_t* ptr = *(const uint16_t**)text;
unsigned glyphID = *ptr;
@@ -580,24 +580,24 @@
static const SkGlyph& sk_getAdvance_utf8_next(SkGlyphCache* cache,
const char** text) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
return cache->getUnicharAdvance(SkUTF8_NextUnichar(text));
}
static const SkGlyph& sk_getAdvance_utf16_next(SkGlyphCache* cache,
const char** text) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
return cache->getUnicharAdvance(SkUTF16_NextUnichar((const uint16_t**)text));
}
static const SkGlyph& sk_getAdvance_utf32_next(SkGlyphCache* cache,
const char** text) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
const int32_t* ptr = *(const int32_t**)text;
SkUnichar uni = *ptr++;
@@ -607,8 +607,8 @@
static const SkGlyph& sk_getAdvance_glyph_next(SkGlyphCache* cache,
const char** text) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
const uint16_t* ptr = *(const uint16_t**)text;
unsigned glyphID = *ptr;
@@ -644,32 +644,32 @@
static const SkGlyph& sk_getMetrics_utf8_00(SkGlyphCache* cache,
const char** text, SkFixed, SkFixed) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
return cache->getUnicharMetrics(SkUTF8_NextUnichar(text));
}
static const SkGlyph& sk_getMetrics_utf8_xy(SkGlyphCache* cache,
const char** text, SkFixed x, SkFixed y) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
return cache->getUnicharMetrics(SkUTF8_NextUnichar(text), x, y);
}
static const SkGlyph& sk_getMetrics_utf16_00(SkGlyphCache* cache,
const char** text, SkFixed, SkFixed) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
return cache->getUnicharMetrics(SkUTF16_NextUnichar((const uint16_t**)text));
}
static const SkGlyph& sk_getMetrics_utf16_xy(SkGlyphCache* cache,
const char** text, SkFixed x, SkFixed y) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
return cache->getUnicharMetrics(SkUTF16_NextUnichar((const uint16_t**)text),
x, y);
@@ -677,8 +677,8 @@
static const SkGlyph& sk_getMetrics_utf32_00(SkGlyphCache* cache,
const char** text, SkFixed, SkFixed) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
const int32_t* ptr = *(const int32_t**)text;
SkUnichar uni = *ptr++;
@@ -688,8 +688,8 @@
static const SkGlyph& sk_getMetrics_utf32_xy(SkGlyphCache* cache,
const char** text, SkFixed x, SkFixed y) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
const int32_t* ptr = *(const int32_t**)text;
SkUnichar uni = *ptr++;
@@ -699,8 +699,8 @@
static const SkGlyph& sk_getMetrics_glyph_00(SkGlyphCache* cache,
const char** text, SkFixed, SkFixed) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
const uint16_t* ptr = *(const uint16_t**)text;
unsigned glyphID = *ptr;
@@ -711,8 +711,8 @@
static const SkGlyph& sk_getMetrics_glyph_xy(SkGlyphCache* cache,
const char** text, SkFixed x, SkFixed y) {
- SkASSERT(cache != NULL);
- SkASSERT(text != NULL);
+ SkASSERT(cache != nullptr);
+ SkASSERT(text != nullptr);
const uint16_t* ptr = *(const uint16_t**)text;
unsigned glyphID = *ptr;
@@ -835,7 +835,7 @@
return 0;
}
- SkMeasureCacheProc glyphCacheProc = this->getMeasureCacheProc(NULL != bounds);
+ SkMeasureCacheProc glyphCacheProc = this->getMeasureCacheProc(nullptr != bounds);
int xyIndex;
JoinBoundsProc joinBoundsProc;
@@ -857,7 +857,7 @@
SkAutoKern autokern;
- if (NULL == bounds) {
+ if (nullptr == bounds) {
if (this->isDevKernText()) {
int rsb;
for (; text < stop; n++) {
@@ -897,13 +897,13 @@
SkScalar SkPaint::measureText(const void* textData, size_t length, SkRect* bounds) const {
const char* text = (const char*)textData;
- SkASSERT(text != NULL || length == 0);
+ SkASSERT(text != nullptr || length == 0);
SkCanonicalizePaint canon(*this);
const SkPaint& paint = canon.getPaint();
SkScalar scale = canon.getScale();
- SkAutoGlyphCache autoCache(paint, NULL, NULL);
+ SkAutoGlyphCache autoCache(paint, nullptr, nullptr);
SkGlyphCache* cache = autoCache.getCache();
SkScalar width = 0;
@@ -944,7 +944,7 @@
return length;
}
- SkASSERT(textD != NULL);
+ SkASSERT(textD != nullptr);
const char* text = (const char*)textD;
const char* stop = text + length;
@@ -957,7 +957,7 @@
maxWidth /= scale;
}
- SkAutoGlyphCache autoCache(paint, NULL, NULL);
+ SkAutoGlyphCache autoCache(paint, nullptr, nullptr);
SkGlyphCache* cache = autoCache.getCache();
SkMeasureCacheProc glyphCacheProc = paint.getMeasureCacheProc(false);
@@ -1022,18 +1022,18 @@
const SkPaint& paint = canon.getPaint();
SkScalar scale = canon.getScale();
- SkMatrix zoomMatrix, *zoomPtr = NULL;
+ SkMatrix zoomMatrix, *zoomPtr = nullptr;
if (zoom) {
zoomMatrix.setScale(zoom, zoom);
zoomPtr = &zoomMatrix;
}
FontMetrics storage;
- if (NULL == metrics) {
+ if (nullptr == metrics) {
metrics = &storage;
}
- paint.descriptorProc(NULL, zoomPtr, FontMetricsDescProc, metrics, true);
+ paint.descriptorProc(nullptr, zoomPtr, FontMetricsDescProc, metrics, true);
if (scale) {
metrics->fTop = SkScalarMul(metrics->fTop, scale);
@@ -1068,7 +1068,7 @@
SkASSERT(textData);
- if (NULL == widths && NULL == bounds) {
+ if (nullptr == widths && nullptr == bounds) {
return this->countText(textData, byteLength);
}
@@ -1076,10 +1076,10 @@
const SkPaint& paint = canon.getPaint();
SkScalar scale = canon.getScale();
- SkAutoGlyphCache autoCache(paint, NULL, NULL);
+ SkAutoGlyphCache autoCache(paint, nullptr, nullptr);
SkGlyphCache* cache = autoCache.getCache();
SkMeasureCacheProc glyphCacheProc;
- glyphCacheProc = paint.getMeasureCacheProc(NULL != bounds);
+ glyphCacheProc = paint.getMeasureCacheProc(nullptr != bounds);
const char* text = (const char*)textData;
const char* stop = text + byteLength;
@@ -1168,10 +1168,10 @@
void SkPaint::getTextPath(const void* textData, size_t length,
SkScalar x, SkScalar y, SkPath* path) const {
- SkASSERT(length == 0 || textData != NULL);
+ SkASSERT(length == 0 || textData != nullptr);
const char* text = (const char*)textData;
- if (text == NULL || length == 0 || path == NULL) {
+ if (text == nullptr || length == 0 || path == nullptr) {
return;
}
@@ -1196,10 +1196,10 @@
void SkPaint::getPosTextPath(const void* textData, size_t length,
const SkPoint pos[], SkPath* path) const {
- SkASSERT(length == 0 || textData != NULL);
+ SkASSERT(length == 0 || textData != nullptr);
const char* text = (const char*)textData;
- if (text == NULL || length == 0 || path == NULL) {
+ if (text == nullptr || length == 0 || path == nullptr) {
return;
}
@@ -1213,7 +1213,7 @@
unsigned int i = 0;
const SkPath* iterPath;
- while (iter.next(&iterPath, NULL)) {
+ while (iter.next(&iterPath, nullptr)) {
matrix.postTranslate(pos[i].fX - prevPos.fX, pos[i].fY - prevPos.fY);
if (iterPath) {
path->addPath(*iterPath, matrix);
@@ -1229,7 +1229,7 @@
m.postSkew(fTextSkewX, 0);
SkTypeface* typeface = this->getTypeface();
- if (NULL == typeface) {
+ if (nullptr == typeface) {
typeface = SkTypeface::GetDefaultTypeface();
}
@@ -1240,7 +1240,7 @@
static void add_flattenable(SkDescriptor* desc, uint32_t tag,
SkWriteBuffer* buffer) {
- buffer->writeToMemory(desc->addEntry(tag, buffer->bytesWritten(), NULL));
+ buffer->writeToMemory(desc->addEntry(tag, buffer->bytesWritten(), nullptr));
}
static SkMask::Format compute_mask_format(const SkPaint& paint) {
@@ -1329,10 +1329,10 @@
const SkSurfaceProps* surfaceProps,
const SkMatrix* deviceMatrix,
Rec* rec) {
- SkASSERT(deviceMatrix == NULL || !deviceMatrix->hasPerspective());
+ SkASSERT(deviceMatrix == nullptr || !deviceMatrix->hasPerspective());
SkTypeface* typeface = paint.getTypeface();
- if (NULL == typeface) {
+ if (nullptr == typeface) {
typeface = SkTypeface::GetDefaultTypeface();
}
rec->fFontID = typeface->uniqueID();
@@ -1498,8 +1498,8 @@
*/
SK_DECLARE_STATIC_MUTEX(gMaskGammaCacheMutex);
-static SkMaskGamma* gLinearMaskGamma = NULL;
-static SkMaskGamma* gMaskGamma = NULL;
+static SkMaskGamma* gLinearMaskGamma = nullptr;
+static SkMaskGamma* gMaskGamma = nullptr;
static SkScalar gContrast = SK_ScalarMin;
static SkScalar gPaintGamma = SK_ScalarMin;
static SkScalar gDeviceGamma = SK_ScalarMin;
@@ -1510,7 +1510,7 @@
static const SkMaskGamma& cachedMaskGamma(SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma) {
gMaskGammaCacheMutex.assertHeld();
if (0 == contrast && SK_Scalar1 == paintGamma && SK_Scalar1 == deviceGamma) {
- if (NULL == gLinearMaskGamma) {
+ if (nullptr == gLinearMaskGamma) {
gLinearMaskGamma = new SkMaskGamma;
}
return *gLinearMaskGamma;
@@ -1529,9 +1529,9 @@
SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
SkSafeUnref(gLinearMaskGamma);
- gLinearMaskGamma = NULL;
+ gLinearMaskGamma = nullptr;
SkSafeUnref(gMaskGamma);
- gMaskGamma = NULL;
+ gMaskGamma = nullptr;
SkDEBUGCODE(gContrast = SK_ScalarMin;)
SkDEBUGCODE(gPaintGamma = SK_ScalarMin;)
SkDEBUGCODE(gDeviceGamma = SK_ScalarMin;)
@@ -1975,7 +1975,7 @@
if (flatFlags & kHasTypeface_FlatFlag) {
this->setTypeface(buffer.readTypeface());
} else {
- this->setTypeface(NULL);
+ this->setTypeface(nullptr);
}
if (flatFlags & kHasEffects_FlatFlag) {
@@ -1992,14 +1992,14 @@
this->setAnnotation(SkAnnotation::Create(buffer))->unref();
}
} else {
- this->setPathEffect(NULL);
- this->setShader(NULL);
- this->setXfermode(NULL);
- this->setMaskFilter(NULL);
- this->setColorFilter(NULL);
- this->setRasterizer(NULL);
- this->setLooper(NULL);
- this->setImageFilter(NULL);
+ this->setPathEffect(nullptr);
+ this->setShader(nullptr);
+ this->setXfermode(nullptr);
+ this->setMaskFilter(nullptr);
+ this->setColorFilter(nullptr);
+ this->setRasterizer(nullptr);
+ this->setLooper(nullptr);
+ this->setImageFilter(nullptr);
}
}
@@ -2303,14 +2303,14 @@
fGlyphCacheProc = paint.getMeasureCacheProc(true);
fPaint.setLinearText(true);
- fPaint.setMaskFilter(NULL); // don't want this affecting our path-cache lookup
+ fPaint.setMaskFilter(nullptr); // don't want this affecting our path-cache lookup
- if (fPaint.getPathEffect() == NULL && !has_thick_frame(fPaint)) {
+ if (fPaint.getPathEffect() == nullptr && !has_thick_frame(fPaint)) {
applyStrokeAndPathEffects = false;
}
// can't use our canonical size if we need to apply patheffects
- if (fPaint.getPathEffect() == NULL) {
+ if (fPaint.getPathEffect() == nullptr) {
fPaint.setTextSize(SkIntToScalar(SkPaint::kCanonicalTextSizeForPaths));
fScale = paint.getTextSize() / SkPaint::kCanonicalTextSizeForPaths;
if (has_thick_frame(fPaint)) {
@@ -2322,13 +2322,13 @@
if (!applyStrokeAndPathEffects) {
fPaint.setStyle(SkPaint::kFill_Style);
- fPaint.setPathEffect(NULL);
+ fPaint.setPathEffect(nullptr);
}
- fCache = fPaint.detachCache(NULL, NULL, false);
+ fCache = fPaint.detachCache(nullptr, nullptr, false);
SkPaint::Style style = SkPaint::kFill_Style;
- SkPathEffect* pe = NULL;
+ SkPathEffect* pe = nullptr;
if (!applyStrokeAndPathEffects) {
style = paint.getStyle(); // restore
@@ -2344,7 +2344,7 @@
if (paint.getTextAlign() != SkPaint::kLeft_Align) { // need to measure first
int count;
SkScalar width = SkScalarMul(fPaint.measure_text(fCache, text, length,
- &count, NULL), fScale);
+ &count, nullptr), fScale);
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
width = SkScalarHalf(width);
}
@@ -2376,7 +2376,7 @@
}
} else {
if (path) {
- *path = NULL;
+ *path = nullptr;
}
}
if (xpos) {
@@ -2398,7 +2398,7 @@
static bool affects_alpha(const SkImageFilter* imf) {
// TODO: check if we should allow imagefilters to broadcast that they don't affect alpha
// ala colorfilters
- return imf != NULL;
+ return imf != nullptr;
}
bool SkPaint::nothingToDraw() const {
diff --git a/src/core/SkPaintPriv.h b/src/core/SkPaintPriv.h
index 708f861..a03f9b3 100644
--- a/src/core/SkPaintPriv.h
+++ b/src/core/SkPaintPriv.h
@@ -23,7 +23,7 @@
};
/**
- * Returns true if drawing with this paint (or NULL) will ovewrite all affected pixels.
+ * Returns true if drawing with this paint (or nullptr) will ovewrite all affected pixels.
*
* Note: returns conservative true, meaning it may return false even though the paint might
* in fact overwrite its pixels.
@@ -35,13 +35,13 @@
}
/**
- * Returns true if drawing this bitmap with this paint (or NULL) will ovewrite all affected
+ * Returns true if drawing this bitmap with this paint (or nullptr) will ovewrite all affected
* pixels.
*/
static bool Overwrites(const SkBitmap&, const SkPaint* paint);
/**
- * Returns true if drawing this image with this paint (or NULL) will ovewrite all affected
+ * Returns true if drawing this image with this paint (or nullptr) will ovewrite all affected
* pixels.
*/
static bool Overwrites(const SkImage*, const SkPaint* paint);
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 05fc730..8da1580 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -137,7 +137,7 @@
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)
@@ -385,7 +385,7 @@
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;
@@ -531,7 +531,7 @@
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;
@@ -1434,7 +1434,7 @@
void SkPath::transform(const SkMatrix& matrix, SkPath* dst) const {
SkDEBUGCODE(this->validate();)
- if (dst == NULL) {
+ if (dst == nullptr) {
dst = (SkPath*)this;
}
@@ -1522,15 +1522,15 @@
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;
}
@@ -1551,7 +1551,7 @@
}
bool SkPath::Iter::isClosedContour() const {
- if (fVerbs == NULL || fVerbs == fVerbStop) {
+ if (fVerbs == nullptr || fVerbs == fVerbStop) {
return false;
}
if (fForceClose) {
@@ -1617,7 +1617,7 @@
// 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
@@ -1776,12 +1776,12 @@
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) {
@@ -1850,7 +1850,7 @@
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);
}
@@ -1913,7 +1913,7 @@
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;
@@ -2006,11 +2006,11 @@
}
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
diff --git a/src/core/SkPathMeasure.cpp b/src/core/SkPathMeasure.cpp
index 17ae95e..caff6df 100644
--- a/src/core/SkPathMeasure.cpp
+++ b/src/core/SkPathMeasure.cpp
@@ -297,7 +297,7 @@
}
} break;
case kCubic_SegType:
- SkEvalCubicAt(pts, t, pos, tangent, NULL);
+ SkEvalCubicAt(pts, t, pos, tangent, nullptr);
if (tangent) {
tangent->normalize();
}
@@ -402,7 +402,7 @@
////////////////////////////////////////////////////////////////////////////////
SkPathMeasure::SkPathMeasure() {
- fPath = NULL;
+ fPath = nullptr;
fLength = -1; // signal we need to compute it
fForceClosed = false;
fFirstPtIndex = -1;
@@ -435,7 +435,7 @@
}
SkScalar SkPathMeasure::getLength() {
- if (fPath == NULL) {
+ if (fPath == nullptr) {
return 0;
}
if (fLength < 0) {
@@ -452,7 +452,7 @@
return ~0;
}
- SkASSERT(base != NULL); // base may be NULL if count is zero
+ SkASSERT(base != nullptr); // base may be nullptr if count is zero
int lo = 0;
int hi = count - 1;
@@ -511,7 +511,7 @@
bool SkPathMeasure::getPosTan(SkScalar distance, SkPoint* pos,
SkVector* tangent) {
- if (NULL == fPath) {
+ if (nullptr == fPath) {
return false;
}
@@ -538,7 +538,7 @@
bool SkPathMeasure::getMatrix(SkScalar distance, SkMatrix* matrix,
MatrixFlags flags) {
- if (NULL == fPath) {
+ if (nullptr == fPath) {
return false;
}
@@ -584,7 +584,7 @@
SkASSERT(seg <= stopSeg);
if (startWithMoveTo) {
- compute_pos_tan(&fPts[seg->fPtIndex], seg->fType, startT, &p, NULL);
+ compute_pos_tan(&fPts[seg->fPtIndex], seg->fType, startT, &p, nullptr);
dst->moveTo(p);
}
diff --git a/src/core/SkPathRef.cpp b/src/core/SkPathRef.cpp
index e3317a6..be7c66c 100644
--- a/src/core/SkPathRef.cpp
+++ b/src/core/SkPathRef.cpp
@@ -35,8 +35,8 @@
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;)
@@ -130,7 +130,7 @@
int32_t packed;
if (!buffer->readS32(&packed)) {
delete ref;
- return NULL;
+ return nullptr;
}
ref->fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
@@ -143,7 +143,7 @@
!buffer->readS32(&pointCount) ||
!buffer->readS32(&conicCount)) {
delete ref;
- return NULL;
+ return nullptr;
}
ref->resetToSize(verbCount, pointCount, conicCount);
@@ -156,7 +156,7 @@
!buffer->read(ref->fConicWeights.begin(), conicCount * sizeof(SkScalar)) ||
!buffer->read(&ref->fBounds, sizeof(SkRect))) {
delete ref;
- return NULL;
+ return nullptr;
}
ref->fBoundsIsDirty = false;
@@ -443,7 +443,7 @@
}
void SkPathRef::addGenIDChangeListener(GenIDChangeListener* listener) {
- if (NULL == listener || this == empty.get()) {
+ if (nullptr == listener || this == empty.get()) {
delete listener;
return;
}
@@ -465,11 +465,11 @@
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);
diff --git a/src/core/SkPictureContentInfo.cpp b/src/core/SkPictureContentInfo.cpp
index 9fa6a64..42d42c4 100644
--- a/src/core/SkPictureContentInfo.cpp
+++ b/src/core/SkPictureContentInfo.cpp
@@ -45,7 +45,7 @@
}
void SkPictureContentInfo::onDrawPoints(size_t count, const SkPaint& paint) {
- if (paint.getPathEffect() != NULL) {
+ if (paint.getPathEffect() != nullptr) {
SkPathEffect::DashInfo info;
SkPathEffect::DashType dashType = paint.getPathEffect()->asADash(&info);
if (2 == count && SkPaint::kRound_Cap != paint.getStrokeCap() &&
diff --git a/src/core/SkPictureData.cpp b/src/core/SkPictureData.cpp
index e70cd66..2cc2841 100644
--- a/src/core/SkPictureData.cpp
+++ b/src/core/SkPictureData.cpp
@@ -80,14 +80,14 @@
}
void SkPictureData::init() {
- fPictureRefs = NULL;
+ fPictureRefs = nullptr;
fPictureCount = 0;
- fTextBlobRefs = NULL;
+ fTextBlobRefs = nullptr;
fTextBlobCount = 0;
- fImageRefs = NULL;
+ fImageRefs = nullptr;
fImageCount = 0;
- fOpData = NULL;
- fFactoryPlayback = NULL;
+ fOpData = nullptr;
+ fFactoryPlayback = nullptr;
}
SkPictureData::~SkPictureData() {
@@ -133,7 +133,7 @@
for (int i = 0; i < count; i++) {
const char* name = SkFlattenable::FactoryToName(array[i]);
- if (NULL == name || 0 == *name) {
+ if (nullptr == name || 0 == *name) {
size += SkWStream::SizeOfPackedUInt(0);
} else {
size_t len = strlen(name);
@@ -171,7 +171,7 @@
for (int i = 0; i < count; i++) {
const char* name = SkFlattenable::FactoryToName(array[i]);
- if (NULL == name || 0 == *name) {
+ if (nullptr == name || 0 == *name) {
stream->writePackedUInt(0);
} else {
size_t len = strlen(name);
@@ -355,7 +355,7 @@
switch (tag) {
case SK_PICT_READER_TAG:
- SkASSERT(NULL == fOpData);
+ SkASSERT(nullptr == fOpData);
fOpData = SkData::NewFromStream(stream, size);
if (!fOpData) {
return false;
@@ -443,7 +443,7 @@
int height = buffer.read32();
if (width <= 0 || height <= 0) { // SkImage never has a zero dimension
buffer.validate(false);
- return NULL;
+ return nullptr;
}
SkAutoTUnref<SkData> encoded(buffer.readByteArrayAsData());
@@ -451,7 +451,7 @@
int originY = buffer.read32();
if (0 == encoded->size() || originX < 0 || originY < 0) {
buffer.validate(false);
- return NULL;
+ return nullptr;
}
const SkIRect subset = SkIRect::MakeXYWH(originX, originY, width, height);
@@ -467,7 +467,7 @@
template <typename T>
bool new_array_from_buffer(SkReadBuffer& buffer, uint32_t inCount,
const T*** array, int* outCount, const T* (*factory)(SkReadBuffer&)) {
- if (!buffer.validate((0 == *outCount) && (NULL == *array))) {
+ if (!buffer.validate((0 == *outCount) && (nullptr == *array))) {
return false;
}
if (0 == inCount) {
@@ -479,7 +479,7 @@
int i = 0;
for (; i < *outCount; i++) {
(*array)[i] = factory(buffer);
- if (NULL == (*array)[i]) {
+ if (nullptr == (*array)[i]) {
success = false;
break;
}
@@ -491,7 +491,7 @@
}
// Delete the array
delete[] * array;
- *array = NULL;
+ *array = nullptr;
*outCount = 0;
return false;
}
@@ -542,10 +542,10 @@
case SK_PICT_READER_TAG: {
SkAutoDataUnref data(SkData::NewUninitialized(size));
if (!buffer.readByteArray(data->writable_data(), size) ||
- !buffer.validate(NULL == fOpData)) {
+ !buffer.validate(nullptr == fOpData)) {
return false;
}
- SkASSERT(NULL == fOpData);
+ SkASSERT(nullptr == fOpData);
fOpData = data.detach();
} break;
case SK_PICT_PICTURE_TAG:
@@ -571,7 +571,7 @@
}
if (!data->parseStream(stream, proc, topLevelTFPlayback)) {
- return NULL;
+ return nullptr;
}
return data.detach();
}
@@ -582,7 +582,7 @@
buffer.setVersion(info.fVersion);
if (!data->parseBuffer(buffer)) {
- return NULL;
+ return nullptr;
}
return data.detach();
}
@@ -631,11 +631,11 @@
bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason,
GrPixelConfig config, SkScalar dpi) const {
- if (context != NULL) {
+ if (context != nullptr) {
return this->suitableForGpuRasterization(context, reason,
context->getRecommendedSampleCount(config, dpi));
} else {
- return this->suitableForGpuRasterization(NULL, reason);
+ return this->suitableForGpuRasterization(nullptr, reason);
}
}
diff --git a/src/core/SkPictureData.h b/src/core/SkPictureData.h
index a68a8c8..4e4deef 100644
--- a/src/core/SkPictureData.h
+++ b/src/core/SkPictureData.h
@@ -111,7 +111,7 @@
const SkPaint* getPaint(SkReader32* reader) const {
int index = reader->readInt();
if (index == 0) {
- return NULL;
+ return nullptr;
}
return &fPaints[index - 1];
}
diff --git a/src/core/SkPictureFlat.cpp b/src/core/SkPictureFlat.cpp
index 3556004..02d8592 100644
--- a/src/core/SkPictureFlat.cpp
+++ b/src/core/SkPictureFlat.cpp
@@ -18,10 +18,10 @@
///////////////////////////////////////////////////////////////////////////////
-SkTypefacePlayback::SkTypefacePlayback() : fCount(0), fArray(NULL) {}
+SkTypefacePlayback::SkTypefacePlayback() : fCount(0), fArray(nullptr) {}
SkTypefacePlayback::~SkTypefacePlayback() {
- this->reset(NULL);
+ this->reset(nullptr);
}
void SkTypefacePlayback::reset(const SkRefCntSet* rec) {
@@ -31,7 +31,7 @@
}
delete[] fArray;
- if (rec!= NULL && rec->count() > 0) {
+ if (rec!= nullptr && rec->count() > 0) {
fCount = rec->count();
fArray = new SkRefCnt* [fCount];
rec->copyToArray(fArray);
@@ -40,12 +40,12 @@
}
} else {
fCount = 0;
- fArray = NULL;
+ fArray = nullptr;
}
}
void SkTypefacePlayback::setCount(int count) {
- this->reset(NULL);
+ this->reset(nullptr);
fCount = count;
fArray = new SkRefCnt* [count];
@@ -61,10 +61,10 @@
///////////////////////////////////////////////////////////////////////////////
SkFlatController::SkFlatController(uint32_t writeBufferFlags)
-: fBitmapHeap(NULL)
-, fTypefaceSet(NULL)
-, fTypefacePlayback(NULL)
-, fFactorySet(NULL)
+: fBitmapHeap(nullptr)
+, fTypefaceSet(nullptr)
+, fTypefacePlayback(nullptr)
+, fFactorySet(nullptr)
, fWriteBufferFlags(writeBufferFlags) {}
SkFlatController::~SkFlatController() {
diff --git a/src/core/SkPictureFlat.h b/src/core/SkPictureFlat.h
index 176f486..98a43ec 100644
--- a/src/core/SkPictureFlat.h
+++ b/src/core/SkPictureFlat.h
@@ -296,8 +296,8 @@
// Unflatten this into result, using bitmapHeap and facePlayback for bitmaps and fonts if given
template <typename Traits, typename T>
void unflatten(T* result,
- SkBitmapHeap* bitmapHeap = NULL,
- SkTypefacePlayback* facePlayback = NULL) const {
+ SkBitmapHeap* bitmapHeap = nullptr,
+ SkTypefacePlayback* facePlayback = nullptr) const {
SkReadBuffer buffer(this->data(), fFlatSize);
if (bitmapHeap) {
@@ -411,28 +411,28 @@
* Similar to find. Allows the caller to specify an SkFlatData to replace in
* the case of an add. Also tells the caller whether a new SkFlatData was
* added and whether the old one was replaced. The parameters added and
- * replaced are required to be non-NULL. Rather than returning the index of
+ * replaced are required to be non-nullptr. Rather than returning the index of
* the entry in the dictionary, it returns the actual SkFlatData.
*/
const SkFlatData* findAndReplace(const T& element,
const SkFlatData* toReplace,
bool* added,
bool* replaced) {
- SkASSERT(added != NULL && replaced != NULL);
+ SkASSERT(added != nullptr && replaced != nullptr);
const int oldCount = this->count();
SkFlatData* flat = this->findAndReturnMutableFlat(element);
*added = this->count() > oldCount;
// If we don't want to replace anything, we're done.
- if (!*added || toReplace == NULL) {
+ if (!*added || toReplace == nullptr) {
*replaced = false;
return flat;
}
// If we don't have the thing to replace, we're done.
const SkFlatData* found = fHash.find(*toReplace);
- if (found == NULL) {
+ if (found == nullptr) {
*replaced = false;
return flat;
}
@@ -469,7 +469,7 @@
/**
* Find or insert a flattened version of element into the dictionary.
- * Caller does not take ownership of the result. This will not return NULL.
+ * Caller does not take ownership of the result. This will not return nullptr.
*/
const SkFlatData* findAndReturnFlat(const T& element) {
return this->findAndReturnMutableFlat(element);
@@ -484,7 +484,7 @@
}
// Without a bitmap heap, we'll flatten bitmaps into paints. That's never what you want.
- SkASSERT(fController->getBitmapHeap() != NULL);
+ SkASSERT(fController->getBitmapHeap() != nullptr);
fScratch.setBitmapHeap(fController->getBitmapHeap());
fScratch.setTypefaceRecorder(fController->getTypefaceSet());
fScratch.setNamedFactoryRecorder(fController->getNamedFactorySet());
@@ -497,7 +497,7 @@
const SkFlatData& scratch = this->resetScratch(element, this->count()+1);
SkFlatData* candidate = fHash.find(scratch);
- if (candidate != NULL) {
+ if (candidate != nullptr) {
return candidate;
}
@@ -520,7 +520,7 @@
// Reinterpret data in fScratch as an SkFlatData.
SkFlatData* scratch = (SkFlatData*)fScratch.getWriter32()->contiguousArray();
- SkASSERT(scratch != NULL);
+ SkASSERT(scratch != nullptr);
scratch->stampHeader(index, SkToS32(dataSize));
return *scratch;
}
@@ -534,7 +534,7 @@
// Copy scratch into the new SkFlatData.
SkFlatData* scratch = (SkFlatData*)fScratch.getWriter32()->contiguousArray();
- SkASSERT(scratch != NULL);
+ SkASSERT(scratch != nullptr);
memcpy(detached, scratch, fScratch.bytesWritten());
// We can now reuse fScratch, and detached will live until fController dies.
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
index eb7c476..b994071 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -44,7 +44,7 @@
if (reader->readBool()) {
return &reader->skipT<SkRect>();
} else {
- return NULL;
+ return nullptr;
}
}
@@ -164,13 +164,13 @@
const int count = reader->readU32();
const SkRSXform* xform = (const SkRSXform*)reader->skip(count * sizeof(SkRSXform));
const SkRect* tex = (const SkRect*)reader->skip(count * sizeof(SkRect));
- const SkColor* colors = NULL;
+ const SkColor* colors = nullptr;
SkXfermode::Mode mode = SkXfermode::kDst_Mode;
if (flags & DRAW_ATLAS_HAS_COLORS) {
colors = (const SkColor*)reader->skip(count * sizeof(SkColor));
mode = (SkXfermode::Mode)reader->readU32();
}
- const SkRect* cull = NULL;
+ const SkRect* cull = nullptr;
if (flags & DRAW_ATLAS_HAS_CULL) {
cull = (const SkRect*)reader->skip(sizeof(SkRect));
}
@@ -275,11 +275,11 @@
const SkPoint* cubics = (const SkPoint*)reader->skip(SkPatchUtils::kNumCtrlPts *
sizeof(SkPoint));
uint32_t flag = reader->readInt();
- const SkColor* colors = NULL;
+ const SkColor* colors = nullptr;
if (flag & DRAW_VERTICES_HAS_COLORS) {
colors = (const SkColor*)reader->skip(SkPatchUtils::kNumCorners * sizeof(SkColor));
}
- const SkPoint* texCoords = NULL;
+ const SkPoint* texCoords = nullptr;
if (flag & DRAW_VERTICES_HAS_TEXS) {
texCoords = (const SkPoint*)reader->skip(SkPatchUtils::kNumCorners *
sizeof(SkPoint));
@@ -418,9 +418,9 @@
SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader->readInt();
int vCount = reader->readInt();
const SkPoint* verts = (const SkPoint*)reader->skip(vCount * sizeof(SkPoint));
- const SkPoint* texs = NULL;
- const SkColor* colors = NULL;
- const uint16_t* indices = NULL;
+ const SkPoint* texs = nullptr;
+ const SkColor* colors = nullptr;
+ const uint16_t* indices = nullptr;
int iCount = 0;
if (flags & DRAW_VERTICES_HAS_TEXS) {
texs = (const SkPoint*)reader->skip(vCount * sizeof(SkPoint));
diff --git a/src/core/SkPictureRecord.cpp b/src/core/SkPictureRecord.cpp
index 2281d16..28561c7 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -275,7 +275,7 @@
void SkPictureRecord::recordConcat(const SkMatrix& matrix) {
this->validate(fWriter.bytesWritten(), 0);
// op + matrix
- size_t size = kUInt32Size + matrix.writeToMemory(NULL);
+ size_t size = kUInt32Size + matrix.writeToMemory(nullptr);
size_t initialOffset = this->addDraw(CONCAT, &size);
this->addMatrix(matrix);
this->validate(initialOffset, size);
@@ -284,7 +284,7 @@
void SkPictureRecord::didSetMatrix(const SkMatrix& matrix) {
this->validate(fWriter.bytesWritten(), 0);
// op + matrix
- size_t size = kUInt32Size + matrix.writeToMemory(NULL);
+ size_t size = kUInt32Size + matrix.writeToMemory(nullptr);
size_t initialOffset = this->addDraw(SET_MATRIX, &size);
this->addMatrix(matrix);
this->validate(initialOffset, size);
@@ -440,7 +440,7 @@
size_t SkPictureRecord::recordClipRegion(const SkRegion& region, SkRegion::Op op) {
// op + clip params + region
- size_t size = 2 * kUInt32Size + region.writeToMemory(NULL);
+ size_t size = 2 * kUInt32Size + region.writeToMemory(nullptr);
// recordRestoreOffsetPlaceholder doesn't always write an offset
if (!fRestoreOffsetStack.isEmpty()) {
// + restore offset
@@ -694,7 +694,7 @@
const SkMatrix* matrix, const SkPaint& paint) {
// op + paint index + length + 'length' worth of data + path index + matrix
const SkMatrix& m = matrix ? *matrix : SkMatrix::I();
- size_t size = 3 * kUInt32Size + SkAlign4(byteLength) + kUInt32Size + m.writeToMemory(NULL);
+ size_t size = 3 * kUInt32Size + SkAlign4(byteLength) + kUInt32Size + m.writeToMemory(nullptr);
size_t initialOffset = this->addDraw(DRAW_TEXT_ON_PATH, &size);
SkASSERT(initialOffset+get_paint_offset(DRAW_TEXT_ON_PATH, size) == fWriter.bytesWritten());
this->addPaint(paint);
@@ -726,12 +726,12 @@
size_t size = 2 * kUInt32Size;
size_t initialOffset;
- if (NULL == matrix && NULL == paint) {
+ if (nullptr == matrix && nullptr == paint) {
initialOffset = this->addDraw(DRAW_PICTURE, &size);
this->addPicture(picture);
} else {
const SkMatrix& m = matrix ? *matrix : SkMatrix::I();
- size += m.writeToMemory(NULL) + kUInt32Size; // matrix + paint
+ size += m.writeToMemory(nullptr) + kUInt32Size; // matrix + paint
initialOffset = this->addDraw(DRAW_PICTURE_MATRIX_PAINT, &size);
SkASSERT(initialOffset + get_paint_offset(DRAW_PICTURE_MATRIX_PAINT, size)
== fWriter.bytesWritten());
@@ -887,7 +887,7 @@
///////////////////////////////////////////////////////////////////////////////
SkSurface* SkPictureRecord::onNewSurface(const SkImageInfo& info, const SkSurfaceProps&) {
- return NULL;
+ return nullptr;
}
// If we already have a stored, can we reuse it instead of also storing b?
@@ -1028,7 +1028,7 @@
}
void SkPictureRecord::addRectPtr(const SkRect* rect) {
- if (fWriter.writeBool(rect != NULL)) {
+ if (fWriter.writeBool(rect != nullptr)) {
fWriter.writeRect(*rect);
}
}
@@ -1038,7 +1038,7 @@
}
void SkPictureRecord::addIRectPtr(const SkIRect* rect) {
- if (fWriter.writeBool(rect != NULL)) {
+ if (fWriter.writeBool(rect != nullptr)) {
*(SkIRect*)fWriter.reserve(sizeof(SkIRect)) = *rect;
}
}
diff --git a/src/core/SkPictureRecorder.cpp b/src/core/SkPictureRecorder.cpp
index 8612aa7..6397ca0 100644
--- a/src/core/SkPictureRecorder.cpp
+++ b/src/core/SkPictureRecorder.cpp
@@ -25,7 +25,7 @@
SkPictureRecorder::~SkPictureRecorder() {}
SkCanvas* SkPictureRecorder::beginRecording(const SkRect& cullRect,
- SkBBHFactory* bbhFactory /* = NULL */,
+ SkBBHFactory* bbhFactory /* = nullptr */,
uint32_t recordFlags /* = 0 */) {
fCullRect = cullRect;
fFlags = recordFlags;
@@ -69,7 +69,7 @@
SkDrawableList* drawableList = fRecorder->getDrawableList();
SkBigPicture::SnapshotArray* pictList =
- drawableList ? drawableList->newDrawableSnapshot() : NULL;
+ drawableList ? drawableList->newDrawableSnapshot() : nullptr;
if (fBBH.get()) {
if (saveLayerData) {
@@ -98,18 +98,18 @@
void SkPictureRecorder::partialReplay(SkCanvas* canvas) const {
- if (NULL == canvas) {
+ if (nullptr == canvas) {
return;
}
int drawableCount = 0;
- SkDrawable* const* drawables = NULL;
+ SkDrawable* const* drawables = nullptr;
SkDrawableList* drawableList = fRecorder->getDrawableList();
if (drawableList) {
drawableCount = drawableList->count();
drawables = drawableList->begin();
}
- SkRecordDraw(*fRecord, canvas, NULL, drawables, drawableCount, NULL/*bbh*/, NULL/*callback*/);
+ SkRecordDraw(*fRecord, canvas, nullptr, drawables, drawableCount, nullptr/*bbh*/, nullptr/*callback*/);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -135,17 +135,17 @@
SkRect onGetBounds() override { return fBounds; }
void onDraw(SkCanvas* canvas) override {
- SkDrawable* const* drawables = NULL;
+ SkDrawable* const* drawables = nullptr;
int drawableCount = 0;
if (fDrawableList) {
drawables = fDrawableList->begin();
drawableCount = fDrawableList->count();
}
- SkRecordDraw(*fRecord, canvas, NULL, drawables, drawableCount, fBBH, NULL/*callback*/);
+ SkRecordDraw(*fRecord, canvas, nullptr, drawables, drawableCount, fBBH, nullptr/*callback*/);
}
SkPicture* onNewPictureSnapshot() override {
- SkBigPicture::SnapshotArray* pictList = NULL;
+ SkBigPicture::SnapshotArray* pictList = nullptr;
if (fDrawableList) {
// TODO: should we plumb-down the BBHFactory and recordFlags from our host
// PictureRecorder?
@@ -157,7 +157,7 @@
if (fBBH && fDoSaveLayerInfo) {
saveLayerData.reset(new SkLayerInfo);
- SkBBoxHierarchy* bbh = NULL; // we've already computed fBBH (received in constructor)
+ SkBBoxHierarchy* bbh = nullptr; // we've already computed fBBH (received in constructor)
// TODO: update saveLayer info computation to reuse the already computed
// bounds in 'fBBH'
SkRecordComputeLayers(fBounds, *fRecord, pictList, bbh, saveLayerData);
@@ -191,8 +191,8 @@
SkToBool(fFlags & kComputeSaveLayerInfo_RecordFlag));
// release our refs now, so only the drawable will be the owner.
- fRecord.reset(NULL);
- fBBH.reset(NULL);
+ fRecord.reset(nullptr);
+ fBBH.reset(nullptr);
return drawable;
}
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index 569ef3d..0b3c9e8 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -85,12 +85,12 @@
result->reset(SkRef(rec.fShader.get()));
SkBitmap tile;
- if (rec.fShader.get()->isABitmap(&tile, NULL, NULL)) {
+ if (rec.fShader.get()->isABitmap(&tile, nullptr, nullptr)) {
// FIXME: this doesn't protect the pixels from being discarded as soon as we unlock.
// Should be handled via a pixel ref generator instead
// (https://code.google.com/p/skia/issues/detail?id=3220).
SkAutoLockPixels alp(tile, true);
- return tile.getPixels() != NULL;
+ return tile.getPixels() != nullptr;
}
return false;
}
@@ -99,8 +99,8 @@
static bool cache_try_alloc_pixels(SkBitmap* bitmap) {
SkBitmap::Allocator* allocator = SkResourceCache::GetAllocator();
- return NULL != allocator
- ? allocator->allocPixelRef(bitmap, NULL)
+ return nullptr != allocator
+ ? allocator->allocPixelRef(bitmap, nullptr)
: bitmap->tryAllocPixels();
}
@@ -141,7 +141,7 @@
if (buffer.isVersionLT(SkReadBuffer::kPictureShaderHasPictureBool_Version)) {
// Older code blindly serialized pictures. We don't trust them.
buffer.validate(false);
- return NULL;
+ return nullptr;
}
// Newer code won't serialize pictures in disallow-cross-process-picture mode.
// Assert that they didn't serialize anything except a false here.
@@ -187,7 +187,7 @@
//
// TODO: replace this with decomposeScale() -- but beware LayoutTest rebaselines!
//
- if (!SkDecomposeUpper2x2(m, NULL, &scale, NULL)) {
+ if (!SkDecomposeUpper2x2(m, nullptr, &scale, nullptr)) {
// Decomposition failed, use an approximation.
scale.set(SkScalarSqrt(m.getScaleX() * m.getScaleX() + m.getSkewX() * m.getSkewX()),
SkScalarSqrt(m.getScaleY() * m.getScaleY() + m.getSkewY() * m.getSkewY()));
@@ -262,8 +262,8 @@
SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const {
SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix));
- if (NULL == bitmapShader.get()) {
- return NULL;
+ if (nullptr == bitmapShader.get()) {
+ return nullptr;
}
return PictureShaderContext::Create(storage, *this, rec, bitmapShader);
}
@@ -273,9 +273,9 @@
SkShader::Context* SkPictureShader::PictureShaderContext::Create(void* storage,
const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader) {
PictureShaderContext* ctx = new (storage) PictureShaderContext(shader, rec, bitmapShader);
- if (NULL == ctx->fBitmapShaderContext) {
+ if (nullptr == ctx->fBitmapShaderContext) {
ctx->~PictureShaderContext();
- ctx = NULL;
+ ctx = nullptr;
}
return ctx;
}
@@ -349,7 +349,7 @@
if (!bitmapShader) {
return false;
}
- return bitmapShader->asFragmentProcessor(context, paint, viewM, NULL, paintColor,
+ return bitmapShader->asFragmentProcessor(context, paint, viewM, nullptr, paintColor,
procDataManager, fp);
}
#else
diff --git a/src/core/SkPixelRef.cpp b/src/core/SkPixelRef.cpp
index 7bcaffe..d711761 100644
--- a/src/core/SkPixelRef.cpp
+++ b/src/core/SkPixelRef.cpp
@@ -95,7 +95,7 @@
if (kIndex_8_SkColorType == info.colorType()) {
SkASSERT(ctable);
} else {
- SkASSERT(NULL == ctable);
+ SkASSERT(nullptr == ctable);
}
}
@@ -198,8 +198,8 @@
}
if (fPreLocked) {
- result->fUnlockProc = NULL;
- result->fUnlockContext = NULL;
+ result->fUnlockProc = nullptr;
+ result->fUnlockContext = nullptr;
result->fCTable = fRec.fColorTable;
result->fPixels = fRec.fPixels;
result->fRowBytes = fRec.fRowBytes;
@@ -241,7 +241,7 @@
}
void SkPixelRef::addGenIDChangeListener(GenIDChangeListener* listener) {
- if (NULL == listener || !this->genIDIsUnique()) {
+ if (nullptr == listener || !this->genIDIsUnique()) {
// No point in tracking this if we're not going to call it.
delete listener;
return;
@@ -320,7 +320,7 @@
void SkPixelRef::onNotifyPixelsChanged() { }
SkData* SkPixelRef::onRefEncodedData() {
- return NULL;
+ return nullptr;
}
bool SkPixelRef::onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
diff --git a/src/core/SkPixmap.cpp b/src/core/SkPixmap.cpp
index 339dea0..c63bef9 100644
--- a/src/core/SkPixmap.cpp
+++ b/src/core/SkPixmap.cpp
@@ -12,7 +12,7 @@
#include "SkUtils.h"
void SkAutoPixmapUnlock::reset(const SkPixmap& pm, void (*unlock)(void*), void* ctx) {
- SkASSERT(pm.addr() != NULL);
+ SkASSERT(pm.addr() != nullptr);
this->unlock();
fPixmap = pm;
@@ -24,8 +24,8 @@
/////////////////////////////////////////////////////////////////////////////////////////////////
void SkPixmap::reset() {
- fPixels = NULL;
- fCTable = NULL;
+ fPixels = nullptr;
+ fCTable = nullptr;
fRowBytes = 0;
fInfo = SkImageInfo::MakeUnknown();
}
@@ -43,7 +43,7 @@
bool SkPixmap::reset(const SkMask& src) {
if (SkMask::kA8_Format == src.fFormat) {
this->reset(SkImageInfo::MakeA8(src.fBounds.width(), src.fBounds.height()),
- src.fImage, src.fRowBytes, NULL);
+ src.fImage, src.fRowBytes, nullptr);
return true;
}
this->reset();
@@ -62,7 +62,7 @@
SkASSERT(static_cast<unsigned>(r.fLeft) < static_cast<unsigned>(this->width()));
SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
- const void* pixels = NULL;
+ const void* pixels = nullptr;
if (fPixels) {
const size_t bpp = fInfo.bytesPerPixel();
pixels = (const uint8_t*)fPixels + r.fTop * fRowBytes + r.fLeft * bpp;
@@ -76,7 +76,7 @@
if (kUnknown_SkColorType == requestedDstInfo.colorType()) {
return false;
}
- if (NULL == dstPixels || dstRB < requestedDstInfo.minRowBytes()) {
+ if (nullptr == dstPixels || dstRB < requestedDstInfo.minRowBytes()) {
return false;
}
if (0 == requestedDstInfo.width() || 0 == requestedDstInfo.height()) {
@@ -116,7 +116,7 @@
}
bool SkPixmap::erase(SkColor color, const SkIRect& inArea) const {
- if (NULL == fPixels) {
+ if (nullptr == fPixels) {
return false;
}
SkIRect area;
@@ -207,7 +207,7 @@
//////////////////////////////////////////////////////////////////////////////////////////////////
-SkAutoPixmapStorage::SkAutoPixmapStorage() : fStorage(NULL) {}
+SkAutoPixmapStorage::SkAutoPixmapStorage() : fStorage(nullptr) {}
SkAutoPixmapStorage::~SkAutoPixmapStorage() {
this->freeStorage();
@@ -222,7 +222,7 @@
return false;
}
void* pixels = sk_malloc_flags(size, 0);
- if (NULL == pixels) {
+ if (nullptr == pixels) {
return false;
}
this->reset(info, pixels, rb);
diff --git a/src/core/SkPtrRecorder.cpp b/src/core/SkPtrRecorder.cpp
index aae28d0..be169d7 100644
--- a/src/core/SkPtrRecorder.cpp
+++ b/src/core/SkPtrRecorder.cpp
@@ -23,7 +23,7 @@
}
uint32_t SkPtrSet::find(void* ptr) const {
- if (NULL == ptr) {
+ if (nullptr == ptr) {
return 0;
}
@@ -39,7 +39,7 @@
}
uint32_t SkPtrSet::add(void* ptr) {
- if (NULL == ptr) {
+ if (nullptr == ptr) {
return 0;
}
diff --git a/src/core/SkPtrRecorder.h b/src/core/SkPtrRecorder.h
index 325471e..2d755e6 100644
--- a/src/core/SkPtrRecorder.h
+++ b/src/core/SkPtrRecorder.h
@@ -26,7 +26,7 @@
/**
* Search for the specified ptr in the set. If it is found, return its
- * 32bit ID [1..N], or if not found, return 0. Always returns 0 for NULL.
+ * 32bit ID [1..N], or if not found, return 0. Always returns 0 for nullptr.
*/
uint32_t find(void*) const;
@@ -34,7 +34,7 @@
* Add the specified ptr to the set, returning a unique 32bit ID for it
* [1...N]. Duplicate ptrs will return the same ID.
*
- * If the ptr is NULL, it is not added, and 0 is returned.
+ * If the ptr is nullptr, it is not added, and 0 is returned.
*/
uint32_t add(void*);
@@ -71,7 +71,7 @@
* Return the next ptr in the set or null if the end was reached.
*/
void* next() {
- return fIndex < fSet.fList.count() ? fSet.fList[fIndex++].fPtr : NULL;
+ return fIndex < fSet.fList.count() ? fSet.fList[fIndex++].fPtr : nullptr;
}
private:
@@ -85,7 +85,7 @@
private:
struct Pair {
- void* fPtr; // never NULL
+ void* fPtr; // never nullptr
uint32_t fIndex; // 1...N
};
diff --git a/src/core/SkRRect.cpp b/src/core/SkRRect.cpp
index 0d1887d..ef81121 100644
--- a/src/core/SkRRect.cpp
+++ b/src/core/SkRRect.cpp
@@ -359,7 +359,7 @@
}
bool SkRRect::transform(const SkMatrix& matrix, SkRRect* dst) const {
- if (NULL == dst) {
+ if (nullptr == dst) {
return false;
}
diff --git a/src/core/SkRWBuffer.cpp b/src/core/SkRWBuffer.cpp
index 7c77513..e9147dc 100644
--- a/src/core/SkRWBuffer.cpp
+++ b/src/core/SkRWBuffer.cpp
@@ -24,7 +24,7 @@
static SkBufferBlock* Alloc(size_t length) {
size_t capacity = LengthToCapacity(length);
SkBufferBlock* block = (SkBufferBlock*)sk_malloc_throw(sizeof(SkBufferBlock) + capacity);
- block->fNext = NULL;
+ block->fNext = nullptr;
block->fUsed = 0;
block->fCapacity = capacity;
return block;
@@ -68,7 +68,7 @@
size_t size = sizeof(SkBufferHead) + capacity;
SkBufferHead* head = (SkBufferHead*)sk_malloc_throw(size);
head->fRefCnt = 1;
- head->fBlock.fNext = NULL;
+ head->fBlock.fNext = nullptr;
head->fBlock.fUsed = 0;
head->fBlock.fCapacity = capacity;
return head;
@@ -94,7 +94,7 @@
}
}
- void validate(size_t minUsed, SkBufferBlock* tail = NULL) const {
+ void validate(size_t minUsed, SkBufferBlock* tail = nullptr) const {
#ifdef SK_DEBUG
SkASSERT(fRefCnt > 0);
size_t totalUsed = 0;
@@ -140,13 +140,13 @@
fBlock = &buffer->fHead->fBlock;
fRemaining = buffer->fUsed;
} else {
- fBlock = NULL;
+ fBlock = nullptr;
fRemaining = 0;
}
}
const void* SkROBuffer::Iter::data() const {
- return fRemaining ? fBlock->startData() : NULL;
+ return fRemaining ? fBlock->startData() : nullptr;
}
size_t SkROBuffer::Iter::size() const {
@@ -161,7 +161,7 @@
return fRemaining != 0;
}
-SkRWBuffer::SkRWBuffer(size_t initialCapacity) : fHead(NULL), fTail(NULL), fTotalUsed(0) {}
+SkRWBuffer::SkRWBuffer(size_t initialCapacity) : fHead(nullptr), fTail(nullptr), fTotalUsed(0) {}
SkRWBuffer::~SkRWBuffer() {
this->validate();
@@ -176,7 +176,7 @@
fTotalUsed += length;
- if (NULL == fHead) {
+ if (nullptr == fHead) {
fHead = SkBufferHead::Alloc(length);
fTail = &fHead->fBlock;
}
@@ -199,12 +199,12 @@
void* SkRWBuffer::append(size_t length) {
this->validate();
if (0 == length) {
- return NULL;
+ return nullptr;
}
fTotalUsed += length;
- if (NULL == fHead) {
+ if (nullptr == fHead) {
fHead = SkBufferHead::Alloc(length);
fTail = &fHead->fBlock;
} else if (fTail->avail() < length) {
@@ -223,7 +223,7 @@
if (fHead) {
fHead->validate(fTotalUsed, fTail);
} else {
- SkASSERT(NULL == fTail);
+ SkASSERT(nullptr == fTail);
SkASSERT(0 == fTotalUsed);
}
}
diff --git a/src/core/SkRWBuffer.h b/src/core/SkRWBuffer.h
index 89cb425..9d88a60 100644
--- a/src/core/SkRWBuffer.h
+++ b/src/core/SkRWBuffer.h
@@ -34,7 +34,7 @@
void reset(const SkROBuffer*);
/**
- * Return the current continuous block of memory, or NULL if the iterator is exhausted
+ * Return the current continuous block of memory, or nullptr if the iterator is exhausted
*/
const void* data() const;
diff --git a/src/core/SkRasterClip.cpp b/src/core/SkRasterClip.cpp
index 35197c1..89c22e8 100644
--- a/src/core/SkRasterClip.cpp
+++ b/src/core/SkRasterClip.cpp
@@ -313,7 +313,7 @@
}
void SkRasterClip::translate(int dx, int dy, SkRasterClip* dst) const {
- if (NULL == dst) {
+ if (nullptr == dst) {
return;
}
@@ -386,8 +386,8 @@
///////////////////////////////////////////////////////////////////////////////
SkAAClipBlitterWrapper::SkAAClipBlitterWrapper() {
- SkDEBUGCODE(fClipRgn = NULL;)
- SkDEBUGCODE(fBlitter = NULL;)
+ SkDEBUGCODE(fClipRgn = nullptr;)
+ SkDEBUGCODE(fBlitter = nullptr;)
}
SkAAClipBlitterWrapper::SkAAClipBlitterWrapper(const SkRasterClip& clip,
diff --git a/src/core/SkRasterizer.cpp b/src/core/SkRasterizer.cpp
index ab9e011..87b9caa 100644
--- a/src/core/SkRasterizer.cpp
+++ b/src/core/SkRasterizer.cpp
@@ -23,7 +23,7 @@
srcM.fFormat = SkMask::kA8_Format;
srcM.fBounds.set(0, 0, 1, 1);
- srcM.fImage = NULL;
+ srcM.fImage = nullptr;
if (!filter->filterMask(&dstM, srcM, matrix, &margin)) {
return false;
}
@@ -42,6 +42,6 @@
SkPath devPath;
fillPath.transform(matrix, &devPath);
- return SkDraw::DrawToMask(devPath, clipBounds, NULL, NULL, mask, mode,
+ return SkDraw::DrawToMask(devPath, clipBounds, nullptr, nullptr, mask, mode,
SkPaint::kFill_Style);
}
diff --git a/src/core/SkReadBuffer.cpp b/src/core/SkReadBuffer.cpp
index 58a4ac4..00e3e2c 100644
--- a/src/core/SkReadBuffer.cpp
+++ b/src/core/SkReadBuffer.cpp
@@ -24,16 +24,16 @@
SkReadBuffer::SkReadBuffer() {
fFlags = default_flags();
fVersion = 0;
- fMemoryPtr = NULL;
+ fMemoryPtr = nullptr;
- fBitmapStorage = NULL;
- fTFArray = NULL;
+ fBitmapStorage = nullptr;
+ fTFArray = nullptr;
fTFCount = 0;
- fFactoryTDArray = NULL;
- fFactoryArray = NULL;
+ fFactoryTDArray = nullptr;
+ fFactoryArray = nullptr;
fFactoryCount = 0;
- fBitmapDecoder = NULL;
+ fBitmapDecoder = nullptr;
#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
fDecodedBitmapIndex = -1;
#endif // DEBUG_NON_DETERMINISTIC_ASSERT
@@ -43,16 +43,16 @@
fFlags = default_flags();
fVersion = 0;
fReader.setMemory(data, size);
- fMemoryPtr = NULL;
+ fMemoryPtr = nullptr;
- fBitmapStorage = NULL;
- fTFArray = NULL;
+ fBitmapStorage = nullptr;
+ fTFArray = nullptr;
fTFCount = 0;
- fFactoryTDArray = NULL;
- fFactoryArray = NULL;
+ fFactoryTDArray = nullptr;
+ fFactoryArray = nullptr;
fFactoryCount = 0;
- fBitmapDecoder = NULL;
+ fBitmapDecoder = nullptr;
#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
fDecodedBitmapIndex = -1;
#endif // DEBUG_NON_DETERMINISTIC_ASSERT
@@ -66,14 +66,14 @@
stream->read(fMemoryPtr, length);
fReader.setMemory(fMemoryPtr, length);
- fBitmapStorage = NULL;
- fTFArray = NULL;
+ fBitmapStorage = nullptr;
+ fTFArray = nullptr;
fTFCount = 0;
- fFactoryTDArray = NULL;
- fFactoryArray = NULL;
+ fFactoryTDArray = nullptr;
+ fFactoryArray = nullptr;
fFactoryCount = 0;
- fBitmapDecoder = NULL;
+ fBitmapDecoder = nullptr;
#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
fDecodedBitmapIndex = -1;
#endif // DEBUG_NON_DETERMINISTIC_ASSERT
@@ -223,7 +223,7 @@
const void* data = this->skip(length);
const int32_t xOffset = this->readInt();
const int32_t yOffset = this->readInt();
- if (fBitmapDecoder != NULL && fBitmapDecoder(data, length, bitmap)) {
+ if (fBitmapDecoder != nullptr && fBitmapDecoder(data, length, bitmap)) {
if (bitmap->width() == width && bitmap->height() == height) {
#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
if (0 != xOffset || 0 != yOffset) {
@@ -281,7 +281,7 @@
if (index) {
SkDebugf("====== typeface index %d\n", index);
}
- return NULL;
+ return nullptr;
} else {
SkASSERT(fTFArray);
return fTFArray[index - 1];
@@ -293,12 +293,12 @@
// TODO: confirm that ft matches the factory we decide to use
//
- SkFlattenable::Factory factory = NULL;
+ SkFlattenable::Factory factory = nullptr;
if (fFactoryCount > 0) {
int32_t index = fReader.readU32();
if (0 == index) {
- return NULL; // writer failed to give us the flattenable
+ return nullptr; // writer failed to give us the flattenable
}
index -= 1; // we stored the index-base-1
SkASSERT(index < fFactoryCount);
@@ -306,20 +306,20 @@
} else if (fFactoryTDArray) {
int32_t index = fReader.readU32();
if (0 == index) {
- return NULL; // writer failed to give us the flattenable
+ return nullptr; // writer failed to give us the flattenable
}
index -= 1; // we stored the index-base-1
factory = (*fFactoryTDArray)[index];
} else {
factory = (SkFlattenable::Factory)readFunctionPtr();
- if (NULL == factory) {
- return NULL; // writer failed to give us the flattenable
+ if (nullptr == factory) {
+ return nullptr; // writer failed to give us the flattenable
}
}
// if we get here, factory may still be null, but if that is the case, the
// failure was ours, not the writer.
- SkFlattenable* obj = NULL;
+ SkFlattenable* obj = nullptr;
uint32_t sizeRecorded = fReader.readU32();
if (factory) {
size_t offset = fReader.offset();
@@ -351,7 +351,7 @@
return;
}
} else {
- if (NULL == this->readFunctionPtr()) {
+ if (nullptr == this->readFunctionPtr()) {
return;
}
}
diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h
index 2564051..06b5a77 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -185,7 +185,7 @@
* were created/written by the writer. SkPicture uses this.
*/
void setFactoryPlayback(SkFlattenable::Factory array[], int count) {
- fFactoryTDArray = NULL;
+ fFactoryTDArray = nullptr;
fFactoryArray = array;
fFactoryCount = count;
}
@@ -197,7 +197,7 @@
*/
void setFactoryArray(SkTDArray<SkFlattenable::Factory>* array) {
fFactoryTDArray = array;
- fFactoryArray = NULL;
+ fFactoryArray = nullptr;
fFactoryCount = 0;
}
diff --git a/src/core/SkReader32.h b/src/core/SkReader32.h
index 3d874d1..68dda23 100644
--- a/src/core/SkReader32.h
+++ b/src/core/SkReader32.h
@@ -20,7 +20,7 @@
class SkReader32 : SkNoncopyable {
public:
- SkReader32() : fCurr(NULL), fStop(NULL), fBase(NULL) {}
+ SkReader32() : fCurr(nullptr), fStop(nullptr), fBase(nullptr) {}
SkReader32(const void* data, size_t size) {
this->setMemory(data, size);
}
@@ -94,7 +94,7 @@
}
void read(void* dst, size_t size) {
- SkASSERT(0 == size || dst != NULL);
+ SkASSERT(0 == size || dst != nullptr);
SkASSERT(ptr_align_4(fCurr));
memcpy(dst, fCurr, size);
fCurr += SkAlign4(size);
@@ -124,10 +124,10 @@
/**
* Read the length of a string (written by SkWriter32::writeString) into
- * len (if len is not NULL) and return the null-ternimated address of the
+ * len (if len is not nullptr) and return the null-ternimated address of the
* string within the reader's buffer.
*/
- const char* readString(size_t* len = NULL);
+ const char* readString(size_t* len = nullptr);
/**
* Read the string (written by SkWriter32::writeString) and return it in
@@ -152,7 +152,7 @@
#ifdef SK_DEBUG
static bool ptr_align_4(const void* ptr) {
- return (((const char*)ptr - (const char*)NULL) & 3) == 0;
+ return (((const char*)ptr - (const char*)nullptr) & 3) == 0;
}
#endif
};
diff --git a/src/core/SkRecordDraw.cpp b/src/core/SkRecordDraw.cpp
index fe8f5f4..1a03348 100644
--- a/src/core/SkRecordDraw.cpp
+++ b/src/core/SkRecordDraw.cpp
@@ -64,7 +64,7 @@
SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
stop = SkTMin(stop, record.count());
- SkRecords::Draw draw(canvas, drawablePicts, NULL, drawableCount, &initialCTM);
+ SkRecords::Draw draw(canvas, drawablePicts, nullptr, drawableCount, &initialCTM);
for (int i = start; i < stop; i++) {
record.visit<void>(i, draw);
}
@@ -123,10 +123,10 @@
SkASSERT(r.index >= 0);
SkASSERT(r.index < fDrawableCount);
if (fDrawables) {
- SkASSERT(NULL == fDrawablePicts);
+ SkASSERT(nullptr == fDrawablePicts);
fCanvas->drawDrawable(fDrawables[r.index], r.matrix);
} else {
- fCanvas->drawPicture(fDrawablePicts[r.index], r.matrix, NULL);
+ fCanvas->drawPicture(fDrawablePicts[r.index], r.matrix, nullptr);
}
}
@@ -280,7 +280,7 @@
// The bounds of these ops must be calculated when we hit the Restore
// from the bounds of the ops in the same Save block.
- void trackBounds(const Save&) { this->pushSaveBlock(NULL); }
+ void trackBounds(const Save&) { this->pushSaveBlock(nullptr); }
void trackBounds(const SaveLayer& op) { this->pushSaveBlock(op.paint); }
void trackBounds(const Restore&) { fBounds[fCurrentOp] = this->popSaveBlock(); }
@@ -324,7 +324,7 @@
// https://crbug.com/401593
SkXfermode* xfermode = paint->getXfermode();
SkXfermode::Mode mode;
- // SrcOver is ok, and is also the common case with a NULL xfermode.
+ // SrcOver is ok, and is also the common case with a nullptr xfermode.
// So we should make that the fast path and bypass the mode extraction
// and test.
if (xfermode && xfermode->asMode(&mode)) {
@@ -525,7 +525,7 @@
}
Bounds bounds(const DrawDrawable& op) const {
- return this->adjustAndMap(op.worstCaseBounds, NULL);
+ return this->adjustAndMap(op.worstCaseBounds, nullptr);
}
static void AdjustTextForFontMetrics(SkRect* rect, const SkPaint& paint) {
@@ -644,14 +644,14 @@
template <typename T> void trackSaveLayers(const T& op) {
/* most ops aren't involved in saveLayers */
}
- void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, NULL, NULL); }
+ void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, nullptr, nullptr); }
void trackSaveLayers(const SaveLayer& sl) { this->pushSaveLayerInfo(true, sl.bounds, sl.paint); }
void trackSaveLayers(const Restore& r) { this->popSaveLayerInfo(); }
void trackSaveLayersForPicture(const SkPicture* picture, const SkPaint* paint) {
// For sub-pictures, we wrap their layer information within the parent
// picture's rendering hierarchy
- const SkLayerInfo* childData = NULL;
+ const SkLayerInfo* childData = nullptr;
if (const SkBigPicture* bp = picture->asSkBigPicture()) {
childData = static_cast<const SkLayerInfo*>(bp->accelData());
}
@@ -677,7 +677,7 @@
SkLayerInfo::BlockInfo& dst = fAccelData->addBlock();
- // If src.fPicture is NULL the layer is in dp.picture; otherwise
+ // If src.fPicture is nullptr the layer is in dp.picture; otherwise
// it belongs to a sub-picture.
dst.fPicture = src.fPicture ? src.fPicture : picture;
dst.fPicture->ref();
@@ -710,7 +710,7 @@
void trackSaveLayers(const DrawDrawable& dp) {
SkASSERT(fPictList);
SkASSERT(dp.index >= 0 && dp.index < fPictList->count());
- const SkPaint* paint = NULL; // drawables don't get a side-car paint
+ const SkPaint* paint = nullptr; // drawables don't get a side-car paint
this->trackSaveLayersForPicture(fPictList->begin()[dp.index], paint);
}
@@ -757,7 +757,7 @@
SkLayerInfo::BlockInfo& block = fAccelData->addBlock();
- SkASSERT(NULL == block.fPicture); // This layer is in the top-most picture
+ SkASSERT(nullptr == block.fPicture); // This layer is in the top-most picture
block.fBounds = fFillBounds.getBounds(sli.fStartIndex);
block.fLocalMat = fFillBounds.ctm();
diff --git a/src/core/SkRecordDraw.h b/src/core/SkRecordDraw.h
index 5af74dc..c2db37a 100644
--- a/src/core/SkRecordDraw.h
+++ b/src/core/SkRecordDraw.h
@@ -45,7 +45,7 @@
public:
explicit Draw(SkCanvas* canvas, SkPicture const* const drawablePicts[],
SkDrawable* const drawables[], int drawableCount,
- const SkMatrix* initialCTM = NULL)
+ const SkMatrix* initialCTM = nullptr)
: fInitialCTM(initialCTM ? *initialCTM : canvas->getTotalMatrix())
, fCanvas(canvas)
, fDrawablePicts(drawablePicts)
diff --git a/src/core/SkRecordOpts.cpp b/src/core/SkRecordOpts.cpp
index 07aac3e..8faa45c 100644
--- a/src/core/SkRecordOpts.cpp
+++ b/src/core/SkRecordOpts.cpp
@@ -151,13 +151,13 @@
bool onMatch(SkRecord* record, Pattern* pattern, int begin, int end) {
// A SaveLayer's bounds field is just a hint, so we should be free to ignore it.
SkPaint* layerPaint = pattern->first<SaveLayer>()->paint;
- if (NULL == layerPaint) {
+ if (nullptr == layerPaint) {
// There wasn't really any point to this SaveLayer at all.
return KillSaveLayerAndRestore(record, begin);
}
SkPaint* drawPaint = pattern->second<SkPaint>();
- if (drawPaint == NULL) {
+ if (drawPaint == nullptr) {
// We can just give the draw the SaveLayer's paint.
// TODO(mtklein): figure out how to do this clearly
return false;
@@ -197,7 +197,7 @@
bool onMatch(SkRecord* record, Pattern* pattern, int begin, int end) {
SkPaint* opacityPaint = pattern->first<SaveLayer>()->paint;
- if (NULL == opacityPaint) {
+ if (nullptr == opacityPaint) {
// There wasn't really any point to this SaveLayer at all.
return KillSaveLayerAndRestore(record, begin);
}
@@ -205,7 +205,7 @@
// This layer typically contains a filter, but this should work for layers with for other
// purposes too.
SkPaint* filterLayerPaint = pattern->fourth<SaveLayer>()->paint;
- if (filterLayerPaint == NULL) {
+ if (filterLayerPaint == nullptr) {
// We can just give the inner SaveLayer the paint of the outer SaveLayer.
// TODO(mtklein): figure out how to do this clearly
return false;
diff --git a/src/core/SkRecordPattern.h b/src/core/SkRecordPattern.h
index 174665a..ecc61b3 100644
--- a/src/core/SkRecordPattern.h
+++ b/src/core/SkRecordPattern.h
@@ -19,7 +19,7 @@
template <typename T>
class Is {
public:
- Is() : fPtr(NULL) {}
+ Is() : fPtr(nullptr) {}
typedef T type;
type* get() { return fPtr; }
@@ -31,7 +31,7 @@
template <typename U>
bool operator()(U*) {
- fPtr = NULL;
+ fPtr = nullptr;
return false;
}
@@ -43,7 +43,7 @@
class IsDraw {
SK_CREATE_MEMBER_DETECTOR(paint);
public:
- IsDraw() : fPaint(NULL) {}
+ IsDraw() : fPaint(nullptr) {}
typedef SkPaint type;
type* get() { return fPaint; }
@@ -56,13 +56,13 @@
template <typename T>
SK_WHEN(!HasMember_paint<T>, bool) operator()(T*) {
- fPaint = NULL;
+ fPaint = nullptr;
return false;
}
// SaveLayer has an SkPaint named paint, but it's not a draw.
bool operator()(SaveLayer*) {
- fPaint = NULL;
+ fPaint = nullptr;
return false;
}
diff --git a/src/core/SkRecorder.cpp b/src/core/SkRecorder.cpp
index 0fe9e28..9eccca1 100644
--- a/src/core/SkRecorder.cpp
+++ b/src/core/SkRecorder.cpp
@@ -21,7 +21,7 @@
SkBigPicture::SnapshotArray* SkDrawableList::newDrawableSnapshot() {
const int count = fArray.count();
if (0 == count) {
- return NULL;
+ return nullptr;
}
SkAutoTMalloc<const SkPicture*> pics(count);
for (int i = 0; i < count; ++i) {
@@ -60,9 +60,9 @@
}
void SkRecorder::forgetRecord() {
- fDrawableList.reset(NULL);
+ fDrawableList.reset(nullptr);
fApproxBytesUsedBySubPictures = 0;
- fRecord = NULL;
+ fRecord = nullptr;
}
// To make appending to fRecord a little less verbose.
@@ -82,8 +82,8 @@
// (For most types we just pass by value and let copy constructors do their thing.)
template <typename T>
T* SkRecorder::copy(const T* src) {
- if (NULL == src) {
- return NULL;
+ if (nullptr == src) {
+ return nullptr;
}
return new (fRecord->alloc<T>()) T(*src);
}
@@ -92,8 +92,8 @@
// It will work with POD or non-POD, though currently we only use it for POD.
template <typename T>
T* SkRecorder::copy(const T src[], size_t count) {
- if (NULL == src) {
- return NULL;
+ if (nullptr == src) {
+ return nullptr;
}
T* dst = fRecord->alloc<T>(count);
for (size_t i = 0; i < count; i++) {
@@ -107,8 +107,8 @@
// but I found no corresponding speedup for other arrays.
template <>
char* SkRecorder::copy(const char src[], size_t count) {
- if (NULL == src) {
- return NULL;
+ if (nullptr == src) {
+ return nullptr;
}
char* dst = fRecord->alloc<char>(count);
memcpy(dst, src, count);
@@ -302,8 +302,8 @@
vmode,
vertexCount,
this->copy(vertices, vertexCount),
- texs ? this->copy(texs, vertexCount) : NULL,
- colors ? this->copy(colors, vertexCount) : NULL,
+ texs ? this->copy(texs, vertexCount) : nullptr,
+ colors ? this->copy(colors, vertexCount) : nullptr,
xmode,
this->copy(indices, indexCount),
indexCount);
@@ -312,9 +312,9 @@
void SkRecorder::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
APPEND(DrawPatch, paint,
- cubics ? this->copy(cubics, SkPatchUtils::kNumCtrlPts) : NULL,
- colors ? this->copy(colors, SkPatchUtils::kNumCorners) : NULL,
- texCoords ? this->copy(texCoords, SkPatchUtils::kNumCorners) : NULL,
+ cubics ? this->copy(cubics, SkPatchUtils::kNumCtrlPts) : nullptr,
+ colors ? this->copy(colors, SkPatchUtils::kNumCorners) : nullptr,
+ texCoords ? this->copy(texCoords, SkPatchUtils::kNumCorners) : nullptr,
xmode);
}
diff --git a/src/core/SkRecorder.h b/src/core/SkRecorder.h
index 57b4568..92197a0 100644
--- a/src/core/SkRecorder.h
+++ b/src/core/SkRecorder.h
@@ -122,7 +122,7 @@
void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
- SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) override { return NULL; }
+ SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) override { return nullptr; }
void flushMiniRecorder();
diff --git a/src/core/SkRefDict.cpp b/src/core/SkRefDict.cpp
index 44eddf0..9364a39 100644
--- a/src/core/SkRefDict.cpp
+++ b/src/core/SkRefDict.cpp
@@ -16,15 +16,15 @@
SkRefCnt* fData;
};
-SkRefDict::SkRefDict() : fImpl(NULL) {}
+SkRefDict::SkRefDict() : fImpl(nullptr) {}
SkRefDict::~SkRefDict() {
this->removeAll();
}
SkRefCnt* SkRefDict::find(const char name[]) const {
- if (NULL == name) {
- return NULL;
+ if (nullptr == name) {
+ return nullptr;
}
Impl* rec = fImpl;
@@ -34,16 +34,16 @@
}
rec = rec->fNext;
}
- return NULL;
+ return nullptr;
}
void SkRefDict::set(const char name[], SkRefCnt* data) {
- if (NULL == name) {
+ if (nullptr == name) {
return;
}
Impl* rec = fImpl;
- Impl* prev = NULL;
+ Impl* prev = nullptr;
while (rec) {
if (rec->fName.equals(name)) {
if (data) {
@@ -85,5 +85,5 @@
delete rec;
rec = next;
}
- fImpl = NULL;
+ fImpl = nullptr;
}
diff --git a/src/core/SkRefDict.h b/src/core/SkRefDict.h
index 55b9bfe..9583df1 100644
--- a/src/core/SkRefDict.h
+++ b/src/core/SkRefDict.h
@@ -22,15 +22,15 @@
~SkRefDict();
/**
- * Return the data associated with name[], or NULL if no matching entry
+ * Return the data associated with name[], or nullptr if no matching entry
* is found. The reference-count of the entry is not affected.
*/
SkRefCnt* find(const char name[]) const;
/**
- * If data is NULL, remove (if present) the entry matching name and call
+ * If data is nullptr, remove (if present) the entry matching name and call
* prev_data->unref() on the data for the matching entry.
- * If data is not-NULL, replace the existing entry matching name and
+ * If data is not-nullptr, replace the existing entry matching name and
* call (prev_data->unref()), or add a new one. In either case,
* data->ref() is called.
*/
@@ -39,7 +39,7 @@
/**
* Remove the matching entry (if found) and unref its data.
*/
- void remove(const char name[]) { this->set(name, NULL); }
+ void remove(const char name[]) { this->set(name, nullptr); }
/**
* Remove all entries, and unref() their associated data.
diff --git a/src/core/SkRegion.cpp b/src/core/SkRegion.cpp
index b87fbc8..3a542c6 100644
--- a/src/core/SkRegion.cpp
+++ b/src/core/SkRegion.cpp
@@ -194,8 +194,8 @@
// 4 ints, up to 10 digits each plus sign, 3 commas, '(', ')', SkRegion() and '\0'
const int max = (count*((11*4)+5))+11+1;
char* result = (char*)sk_malloc_throw(max);
- if (result == NULL) {
- return NULL;
+ if (result == nullptr) {
+ return nullptr;
}
count = sprintf(result, "SkRegion(");
iter.reset(*this);
@@ -408,7 +408,7 @@
* A contains B is equivalent to
* B - A == 0
*/
- return !Oper(rgn, *this, kDifference_Op, NULL);
+ return !Oper(rgn, *this, kDifference_Op, nullptr);
}
const SkRegion::RunType* SkRegion::getRuns(RunType tmpStorage[],
@@ -498,7 +498,7 @@
}
// both of us are complex
- return Oper(*this, rgn, kIntersect_Op, NULL);
+ return Oper(*this, rgn, kIntersect_Op, nullptr);
}
///////////////////////////////////////////////////////////////////////////////
@@ -533,7 +533,7 @@
void SkRegion::translate(int dx, int dy, SkRegion* dst) const {
SkDEBUGCODE(this->validate();)
- if (NULL == dst) {
+ if (nullptr == dst) {
return;
}
if (this->isEmpty()) {
@@ -1074,7 +1074,7 @@
// sk_memset32((uint32_t*)array.get(), 0x7FFFFFFF, dstCount);
#endif
- int count = operate(a_runs, b_runs, array.get(), op, NULL == result);
+ int count = operate(a_runs, b_runs, array.get(), op, nullptr == result);
SkASSERT(count <= dstCount);
if (result) {
@@ -1095,7 +1095,7 @@
#include "SkBuffer.h"
size_t SkRegion::writeToMemory(void* storage) const {
- if (NULL == storage) {
+ if (nullptr == storage) {
size_t size = sizeof(int32_t); // -1 (empty), 0 (rect), runCount
if (!this->isEmpty()) {
size += sizeof(fBounds);
@@ -1295,7 +1295,7 @@
fDone = false;
if (rgn.isRect()) {
fRect = rgn.fBounds;
- fRuns = NULL;
+ fRuns = nullptr;
} else {
fRuns = rgn.fRunHead->readonly_runs();
fRect.set(fRuns[3], fRuns[0], fRuns[4], fRuns[1]);
@@ -1310,7 +1310,7 @@
return;
}
- if (fRuns == NULL) { // rect case
+ if (fRuns == nullptr) { // rect case
fDone = true;
return;
}
@@ -1402,7 +1402,7 @@
}
fLeft = left;
fRight = right;
- fRuns = NULL; // means we're a rect, not a rgn
+ fRuns = nullptr; // means we're a rect, not a rgn
fDone = false;
} else {
const SkRegion::RunType* runs = rgn.fRunHead->findScanline(y);
@@ -1433,7 +1433,7 @@
return false;
}
- if (fRuns == NULL) { // we're a rect
+ if (fRuns == nullptr) { // we're a rect
fDone = true; // ok, now we're done
if (left) {
*left = fLeft;
diff --git a/src/core/SkRegionPriv.h b/src/core/SkRegionPriv.h
index 9ddefc0..160c55d 100644
--- a/src/core/SkRegionPriv.h
+++ b/src/core/SkRegionPriv.h
@@ -142,7 +142,7 @@
/**
* Return the scanline that contains the Y value. This requires that the Y
* value is already known to be contained within the bounds of the region,
- * and so this routine never returns NULL.
+ * and so this routine never returns nullptr.
*
* It returns the beginning of the scanline, starting with its Bottom value.
*/
diff --git a/src/core/SkRegion_path.cpp b/src/core/SkRegion_path.cpp
index b07d679..9289641 100644
--- a/src/core/SkRegion_path.cpp
+++ b/src/core/SkRegion_path.cpp
@@ -32,7 +32,7 @@
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();
@@ -94,7 +94,7 @@
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))
@@ -108,7 +108,7 @@
};
SkRgnBuilder::SkRgnBuilder()
- : fStorage(NULL) {
+ : fStorage(nullptr) {
}
SkRgnBuilder::~SkRgnBuilder() {
@@ -147,17 +147,17 @@
}
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);
@@ -197,7 +197,7 @@
}
int SkRgnBuilder::computeRunCount() const {
- if (fCurrScanline == NULL) {
+ if (fCurrScanline == nullptr) {
return 0;
}
@@ -208,7 +208,7 @@
}
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);
@@ -219,7 +219,7 @@
}
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;
@@ -397,7 +397,7 @@
fY0 = (SkRegion::RunType)(y0);
fY1 = (SkRegion::RunType)(y1);
fFlags = 0;
- SkDEBUGCODE(fNext = NULL;)
+ SkDEBUGCODE(fNext = nullptr;)
}
int top() const {
@@ -423,7 +423,7 @@
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;
@@ -436,7 +436,7 @@
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;
@@ -484,7 +484,7 @@
};
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);
@@ -522,7 +522,7 @@
#ifdef SK_DEBUG
for (e = start; e != stop; e++) {
- SkASSERT(e->fNext != NULL);
+ SkASSERT(e->fNext != nullptr);
SkASSERT(e->fFlags == Edge::kCompleteLink);
}
#endif
diff --git a/src/core/SkResourceCache.cpp b/src/core/SkResourceCache.cpp
index 911a090..4d2453c 100644
--- a/src/core/SkResourceCache.cpp
+++ b/src/core/SkResourceCache.cpp
@@ -59,17 +59,17 @@
///////////////////////////////////////////////////////////////////////////////
void SkResourceCache::init() {
- fHead = NULL;
- fTail = NULL;
+ fHead = nullptr;
+ fTail = nullptr;
fHash = new Hash;
fTotalBytesUsed = 0;
fCount = 0;
fSingleAllocationByteLimit = 0;
- fAllocator = NULL;
+ fAllocator = nullptr;
// One of these should be explicit set by the caller after we return.
fTotalByteLimit = 0;
- fDiscardableFactory = NULL;
+ fDiscardableFactory = nullptr;
}
#include "SkDiscardableMemory.h"
@@ -116,20 +116,20 @@
}
// A previous call to onUnlock may have deleted our DM, so check for that
- if (NULL == fDM) {
+ if (nullptr == fDM) {
return false;
}
if (!fDM->lock()) {
// since it failed, we delete it now, to free-up the resource
delete fDM;
- fDM = NULL;
+ fDM = nullptr;
return false;
}
SUCCESS:
rec->fPixels = fDM->data();
- rec->fColorTable = NULL;
+ rec->fColorTable = nullptr;
rec->fRowBytes = fRB;
return true;
}
@@ -164,7 +164,7 @@
}
SkDiscardableMemory* dm = fFactory(size);
- if (NULL == dm) {
+ if (nullptr == dm) {
return false;
}
@@ -371,7 +371,7 @@
if (fDiscardableFactory) {
SkDiscardableMemory* dm = fDiscardableFactory(bytes);
- return dm ? new SkCachedData(bytes, dm) : NULL;
+ return dm ? new SkCachedData(bytes, dm) : nullptr;
} else {
return new SkCachedData(sk_malloc_throw(bytes), bytes);
}
@@ -396,7 +396,7 @@
next->fPrev = prev;
}
- rec->fNext = rec->fPrev = NULL;
+ rec->fNext = rec->fPrev = nullptr;
}
void SkResourceCache::moveToHead(Rec* rec) {
@@ -421,7 +421,7 @@
void SkResourceCache::addToHead(Rec* rec) {
this->validate();
- rec->fPrev = NULL;
+ rec->fPrev = nullptr;
rec->fNext = fHead;
if (fHead) {
fHead->fPrev = rec;
@@ -440,22 +440,22 @@
#ifdef SK_DEBUG
void SkResourceCache::validate() const {
- if (NULL == fHead) {
- SkASSERT(NULL == fTail);
+ if (nullptr == fHead) {
+ SkASSERT(nullptr == fTail);
SkASSERT(0 == fTotalBytesUsed);
return;
}
if (fHead == fTail) {
- SkASSERT(NULL == fHead->fPrev);
- SkASSERT(NULL == fHead->fNext);
+ SkASSERT(nullptr == fHead->fPrev);
+ SkASSERT(nullptr == fHead->fNext);
SkASSERT(fHead->bytesUsed() == fTotalBytesUsed);
return;
}
- SkASSERT(NULL == fHead->fPrev);
+ SkASSERT(nullptr == fHead->fPrev);
SkASSERT(fHead->fNext);
- SkASSERT(NULL == fTail->fNext);
+ SkASSERT(nullptr == fTail->fNext);
SkASSERT(fTail->fPrev);
size_t used = 0;
@@ -506,7 +506,7 @@
// if we're not discardable (i.e. we are fixed-budget) then cap the single-limit
// to our budget.
- if (NULL == fDiscardableFactory) {
+ if (nullptr == fDiscardableFactory) {
if (0 == limit) {
limit = fTotalByteLimit;
} else {
@@ -527,7 +527,7 @@
///////////////////////////////////////////////////////////////////////////////
SK_DECLARE_STATIC_MUTEX(gMutex);
-static SkResourceCache* gResourceCache = NULL;
+static SkResourceCache* gResourceCache = nullptr;
static void cleanup_gResourceCache() {
// We'll clean this up in our own tests, but disable for clients.
// Chrome seems to have funky multi-process things going on in unit tests that
@@ -542,7 +542,7 @@
static SkResourceCache* get_cache() {
// gMutex is always held when this is called, so we don't need to be fancy in here.
gMutex.assertHeld();
- if (NULL == gResourceCache) {
+ if (nullptr == gResourceCache) {
#ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE
gResourceCache = new SkResourceCache(SkDiscardableMemory::Create);
#else
diff --git a/src/core/SkResourceCache.h b/src/core/SkResourceCache.h
index 7267c67..813e2ee 100644
--- a/src/core/SkResourceCache.h
+++ b/src/core/SkResourceCache.h
@@ -79,7 +79,7 @@
// for memory usage diagnostics
virtual const char* getCategory() const = 0;
- virtual SkDiscardableMemory* diagnostic_only_getDiscardable() const { return NULL; }
+ virtual SkDiscardableMemory* diagnostic_only_getDiscardable() const { return nullptr; }
// for SkTDynamicHash::Traits
static uint32_t Hash(const Key& key) { return key.hash(); }
@@ -115,7 +115,7 @@
/**
* Returns a locked/pinned SkDiscardableMemory instance for the specified
- * number of bytes, or NULL on failure.
+ * number of bytes, or nullptr on failure.
*/
typedef SkDiscardableMemory* (*DiscardableFactory)(size_t bytes);
@@ -153,13 +153,13 @@
static void TestDumpMemoryStatistics();
/**
- * Returns the DiscardableFactory used by the global cache, or NULL.
+ * Returns the DiscardableFactory used by the global cache, or nullptr.
*/
static DiscardableFactory GetDiscardableFactory();
/**
* Use this allocator for bitmaps, so they can use ashmem when available.
- * Returns NULL if the ResourceCache has not been initialized with a DiscardableFactory.
+ * Returns nullptr if the ResourceCache has not been initialized with a DiscardableFactory.
*/
static SkBitmap::Allocator* GetAllocator();
@@ -250,7 +250,7 @@
Hash* fHash;
DiscardableFactory fDiscardableFactory;
- // the allocator is NULL or one that matches discardables
+ // the allocator is nullptr or one that matches discardables
SkBitmap::Allocator* fAllocator;
size_t fTotalBytesUsed;
diff --git a/src/core/SkScalar.cpp b/src/core/SkScalar.cpp
index e8f6e93..7cb0a8b 100644
--- a/src/core/SkScalar.cpp
+++ b/src/core/SkScalar.cpp
@@ -13,8 +13,8 @@
SkScalar SkScalarInterpFunc(SkScalar searchKey, const SkScalar keys[],
const SkScalar values[], int length) {
SkASSERT(length > 0);
- SkASSERT(keys != NULL);
- SkASSERT(values != NULL);
+ SkASSERT(keys != nullptr);
+ SkASSERT(values != nullptr);
#ifdef SK_DEBUG
for (int i = 1; i < length; i++)
SkASSERT(keys[i] >= keys[i-1]);
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 5f0f653..70a9c30 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -63,7 +63,7 @@
static SkFlattenable* load_flattenable(const SkDescriptor* desc, uint32_t tag,
SkFlattenable::Type ft) {
- SkFlattenable* obj = NULL;
+ SkFlattenable* obj = nullptr;
uint32_t len;
const void* data = desc->findEntry(tag, &len);
@@ -76,7 +76,7 @@
}
SkScalerContext::SkScalerContext(SkTypeface* typeface, const SkDescriptor* desc)
- : fRec(*static_cast<const Rec*>(desc->findEntry(kRec_SkDescriptorTag, NULL)))
+ : fRec(*static_cast<const Rec*>(desc->findEntry(kRec_SkDescriptorTag, nullptr)))
, fTypeface(SkRef(typeface))
, fPathEffect(static_cast<SkPathEffect*>(load_flattenable(desc, kPathEffect_SkDescriptorTag,
@@ -86,7 +86,7 @@
, fRasterizer(static_cast<SkRasterizer*>(load_flattenable(desc, kRasterizer_SkDescriptorTag,
SkFlattenable::kSkRasterizer_Type)))
// Initialize based on our settings. Subclasses can also force this.
- , fGenerateImageFromPath(fRec.fFrameWidth > 0 || fPathEffect != NULL || fRasterizer != NULL)
+ , fGenerateImageFromPath(fRec.fFrameWidth > 0 || fPathEffect != nullptr || fRasterizer != nullptr)
, fPreBlend(fMaskFilter ? SkMaskGamma::PreBlend() : SkScalerContext::GetMaskPreBlend(fRec))
, fPreBlendForFilter(fMaskFilter ? SkScalerContext::GetMaskPreBlend(fRec)
@@ -103,8 +103,8 @@
rec->fFrameWidth, rec->fMiterLimit, rec->fHints, rec->fFrameAndFill,
rec->fMaskFormat, rec->fStrokeJoin);
SkDebugf(" pathEffect %x maskFilter %x\n",
- desc->findEntry(kPathEffect_SkDescriptorTag, NULL),
- desc->findEntry(kMaskFilter_SkDescriptorTag, NULL));
+ desc->findEntry(kPathEffect_SkDescriptorTag, nullptr),
+ desc->findEntry(kMaskFilter_SkDescriptorTag, nullptr));
#endif
}
@@ -154,7 +154,7 @@
if (fRasterizer) {
SkMask mask;
- if (fRasterizer->rasterize(fillPath, fillToDevMatrix, NULL,
+ if (fRasterizer->rasterize(fillPath, fillToDevMatrix, nullptr,
fMaskFilter, &mask,
SkMask::kJustComputeBounds_CreateMode)) {
glyph->fLeft = mask.fBounds.fLeft;
@@ -206,12 +206,12 @@
glyph->toMask(&src);
fRec.getMatrixFrom2x2(&matrix);
- src.fImage = NULL; // only want the bounds from the filter
- if (fMaskFilter->filterMask(&dst, src, matrix, NULL)) {
+ src.fImage = nullptr; // only want the bounds from the filter
+ if (fMaskFilter->filterMask(&dst, src, matrix, nullptr)) {
if (dst.fBounds.isEmpty() || !dst.fBounds.is16Bit()) {
goto SK_ERROR;
}
- SkASSERT(dst.fImage == NULL);
+ SkASSERT(dst.fImage == nullptr);
glyph->fLeft = dst.fBounds.fLeft;
glyph->fTop = dst.fBounds.fTop;
glyph->fWidth = SkToU16(dst.fBounds.width());
@@ -485,7 +485,7 @@
// need the original bounds, sans our maskfilter
SkMaskFilter* mf = fMaskFilter;
- fMaskFilter = NULL; // temp disable
+ fMaskFilter = nullptr; // temp disable
this->getMetrics(&tmpGlyph);
fMaskFilter = mf; // restore
@@ -514,7 +514,7 @@
mask.fFormat = SkMask::kA8_Format;
sk_bzero(glyph->fImage, mask.computeImageSize());
- if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, NULL,
+ if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, nullptr,
fMaskFilter, &mask,
SkMask::kJustRenderImage_CreateMode)) {
return;
@@ -553,7 +553,7 @@
fRec.getMatrixFrom2x2(&matrix);
- if (fMaskFilter->filterMask(&dstM, srcM, matrix, NULL)) {
+ if (fMaskFilter->filterMask(&dstM, srcM, matrix, nullptr)) {
int width = SkFastMin32(origGlyph.fWidth, dstM.fBounds.width());
int height = SkFastMin32(origGlyph.fHeight, dstM.fBounds.height());
int dstRB = origGlyph.rowBytes();
@@ -585,7 +585,7 @@
}
void SkScalerContext::getPath(const SkGlyph& glyph, SkPath* path) {
- this->internalGetPath(glyph, NULL, path, NULL);
+ this->internalGetPath(glyph, nullptr, path, nullptr);
}
void SkScalerContext::getFontMetrics(SkPaint::FontMetrics* fm) {
@@ -611,7 +611,7 @@
}
}
- if (fRec.fFrameWidth > 0 || fPathEffect != NULL) {
+ if (fRec.fFrameWidth > 0 || fPathEffect != nullptr) {
// need the path in user-space, with only the point-size applied
// so that our stroking and effects will operate the same way they
// would if the user had extracted the path themself, and then
@@ -641,7 +641,7 @@
if (fPathEffect) {
SkPath effectPath;
- if (fPathEffect->filterPath(&effectPath, localPath, &rec, NULL)) {
+ if (fPathEffect->filterPath(&effectPath, localPath, &rec, nullptr)) {
localPath.swap(effectPath);
}
}
@@ -668,7 +668,7 @@
fillToDevMatrix->reset();
}
if (devPath) {
- if (fillPath == NULL) {
+ if (fillPath == nullptr) {
devPath->swap(path);
} else {
*devPath = path;
diff --git a/src/core/SkScalerContext.h b/src/core/SkScalerContext.h
index 6addf73..302698e 100644
--- a/src/core/SkScalerContext.h
+++ b/src/core/SkScalerContext.h
@@ -113,7 +113,7 @@
* The 'total' matrix is also (optionally) available. This is useful in cases where the
* underlying library will not be used, often when working directly with font data.
*
- * The parameters 'scale' and 'remaining' are required, the other pointers may be NULL.
+ * The parameters 'scale' and 'remaining' are required, the other pointers may be nullptr.
*
* @param preMatrixScale the kind of scale to extract from the total matrix.
* @param scale the scale extracted from the total matrix (both values positive).
@@ -124,9 +124,9 @@
*/
void computeMatrices(PreMatrixScale preMatrixScale,
SkVector* scale, SkMatrix* remaining,
- SkMatrix* remainingWithoutRotation = NULL,
- SkMatrix* remainingRotation = NULL,
- SkMatrix* total = NULL);
+ SkMatrix* remainingWithoutRotation = nullptr,
+ SkMatrix* remainingRotation = nullptr,
+ SkMatrix* total = nullptr);
inline SkPaint::Hinting getHinting() const;
inline void setHinting(SkPaint::Hinting);
@@ -319,7 +319,7 @@
SkPath* devPath, SkMatrix* fillToDevMatrix);
// returns the right context from our link-list for this char. If no match
- // is found it returns NULL. If a match is found then the glyphID param is
+ // is found it returns nullptr. If a match is found then the glyphID param is
// set to the glyphID that maps to the provided char.
SkScalerContext* getContextFromChar(SkUnichar uni, uint16_t* glyphID);
diff --git a/src/core/SkScan_AntiPath.cpp b/src/core/SkScan_AntiPath.cpp
index 3f95a68..6ea6b8b 100644
--- a/src/core/SkScan_AntiPath.cpp
+++ b/src/core/SkScan_AntiPath.cpp
@@ -686,7 +686,7 @@
SkScanClipper clipper(blitter, clipRgn, ir);
const SkIRect* clipRect = clipper.getClipRect();
- if (clipper.getBlitter() == NULL) { // clipped out
+ if (clipper.getBlitter() == nullptr) { // clipped out
if (isInverse) {
blitter->blitRegion(*clipRgn);
}
@@ -700,7 +700,7 @@
sk_blit_above(blitter, ir, *clipRgn);
}
- SkIRect superRect, *superClipRect = NULL;
+ SkIRect superRect, *superClipRect = nullptr;
if (clipRect) {
superRect.set( clipRect->fLeft << SHIFT, clipRect->fTop << SHIFT,
diff --git a/src/core/SkScan_Antihair.cpp b/src/core/SkScan_Antihair.cpp
index 2bcb4c6..beddf63 100644
--- a/src/core/SkScan_Antihair.cpp
+++ b/src/core/SkScan_Antihair.cpp
@@ -17,13 +17,13 @@
/* Our attempt to compute the worst case "bounds" for the horizontal and
vertical cases has some numerical bug in it, and we sometimes undervalue
our extends. The bug is that when this happens, we will set the clip to
- NULL (for speed), and thus draw outside of the clip by a pixel, which might
+ nullptr (for speed), and thus draw outside of the clip by a pixel, which might
only look bad, but it might also access memory outside of the valid range
allcoated for the device bitmap.
This define enables our fix to outset our "bounds" by 1, thus avoiding the
chance of the bug, but at the cost of sometimes taking the rectblitter
- case (i.e. not setting the clip to NULL) when we might not actually need
+ case (i.e. not setting the clip to nullptr) when we might not actually need
to. If we can improve/fix the actual calculations, then we can remove this
step.
*/
@@ -88,7 +88,7 @@
class SkAntiHairBlitter {
public:
- SkAntiHairBlitter() : fBlitter(NULL) {}
+ SkAntiHairBlitter() : fBlitter(nullptr) {}
virtual ~SkAntiHairBlitter() {}
SkBlitter* getBlitter() const { return fBlitter; }
@@ -340,7 +340,7 @@
Horish_SkAntiHairBlitter horish_blitter;
VLine_SkAntiHairBlitter vline_blitter;
Vertish_SkAntiHairBlitter vertish_blitter;
- SkAntiHairBlitter* hairBlitter = NULL;
+ SkAntiHairBlitter* hairBlitter = nullptr;
if (SkAbs32(x1 - x0) > SkAbs32(y1 - y0)) { // mostly horizontal
if (x0 > x1) { // we want to go left-to-right
@@ -412,7 +412,7 @@
return;
}
if (clip->fTop <= top && clip->fBottom >= bottom) {
- clip = NULL;
+ clip = nullptr;
}
}
} else { // mostly vertical
@@ -488,7 +488,7 @@
return;
}
if (clip->fLeft <= left && clip->fRight >= right) {
- clip = NULL;
+ clip = nullptr;
}
}
}
@@ -526,7 +526,7 @@
return;
}
- SkASSERT(clip == NULL || !clip->getBounds().isEmpty());
+ SkASSERT(clip == nullptr || !clip->getBounds().isEmpty());
#ifdef TEST_GAMMA
build_gamma_table();
@@ -595,7 +595,7 @@
}
// fall through to no-clip case
}
- do_anti_hairline(x0, y0, x1, y1, NULL, blitter);
+ do_anti_hairline(x0, y0, x1, y1, nullptr, blitter);
}
}
@@ -699,7 +699,7 @@
void SkScan::AntiFillXRect(const SkXRect& xr, const SkRegion* clip,
SkBlitter* blitter) {
- if (NULL == clip) {
+ if (nullptr == clip) {
antifillrect(xr, blitter);
} else {
SkIRect outerBounds;
@@ -745,7 +745,7 @@
XRect_roundOut(xr, &outerBounds);
if (clip.quickContains(outerBounds)) {
- AntiFillXRect(xr, NULL, blitter);
+ AntiFillXRect(xr, nullptr, blitter);
} else {
SkAAClipBlitterWrapper wrapper(clip, blitter);
blitter = wrapper.getBlitter();
diff --git a/src/core/SkScan_Hairline.cpp b/src/core/SkScan_Hairline.cpp
index eeac5cd..7a6e3ba 100644
--- a/src/core/SkScan_Hairline.cpp
+++ b/src/core/SkScan_Hairline.cpp
@@ -355,7 +355,7 @@
}
SkAAClipBlitterWrapper wrap;
- const SkRegion* clip = NULL;
+ const SkRegion* clip = nullptr;
{
const SkIRect ibounds = path.getBounds().roundOut().makeOutset(1, 1);
@@ -462,7 +462,7 @@
if (clip.isBW()) {
HairLineRgn(pts, count, &clip.bwRgn(), blitter);
} else {
- const SkRegion* clipRgn = NULL;
+ const SkRegion* clipRgn = nullptr;
SkRect r;
r.set(pts, count);
@@ -483,7 +483,7 @@
if (clip.isBW()) {
AntiHairLineRgn(pts, count, &clip.bwRgn(), blitter);
} else {
- const SkRegion* clipRgn = NULL;
+ const SkRegion* clipRgn = nullptr;
SkRect r;
r.set(pts, count);
diff --git a/src/core/SkScan_Path.cpp b/src/core/SkScan_Path.cpp
index b7db3b4..fc79fc8 100644
--- a/src/core/SkScan_Path.cpp
+++ b/src/core/SkScan_Path.cpp
@@ -346,7 +346,7 @@
}
const SkPixmap* justAnOpaqueColor(uint32_t* value) override {
SkDEBUGFAIL("justAnOpaqueColor unexpected");
- return NULL;
+ return nullptr;
}
private:
@@ -437,14 +437,14 @@
// this returns the first and last edge after they're sorted into a dlink list
SkEdge* edge = sort_edges(list, count, &last);
- headEdge.fPrev = NULL;
+ headEdge.fPrev = nullptr;
headEdge.fNext = edge;
headEdge.fFirstY = kEDGE_HEAD_Y;
headEdge.fX = SK_MinS32;
edge->fPrev = &headEdge;
tailEdge.fPrev = last;
- tailEdge.fNext = NULL;
+ tailEdge.fNext = nullptr;
tailEdge.fFirstY = kEDGE_TAIL_Y;
last->fNext = &tailEdge;
@@ -460,7 +460,7 @@
}
InverseBlitter ib;
- PrePostProc proc = NULL;
+ PrePostProc proc = nullptr;
if (path.isInverseFillType()) {
ib.setBlitter(blitter, clipRgn.getBounds(), shiftEdgesUp);
@@ -468,9 +468,9 @@
proc = PrePostInverseBlitterProc;
}
- if (path.isConvex() && (NULL == proc)) {
+ if (path.isConvex() && (nullptr == proc)) {
SkASSERT(count >= 2); // convex walker does not handle missing right edges
- walk_convex_edges(&headEdge, path.getFillType(), blitter, start_y, stop_y, NULL);
+ walk_convex_edges(&headEdge, path.getFillType(), blitter, start_y, stop_y, nullptr);
} else {
int rightEdge;
if (clipRect) {
@@ -518,8 +518,8 @@
*/
SkScanClipper::SkScanClipper(SkBlitter* blitter, const SkRegion* clip,
const SkIRect& ir, bool skipRejectTest) {
- fBlitter = NULL; // null means blit nothing
- fClipRect = NULL;
+ fBlitter = nullptr; // null means blit nothing
+ fClipRect = nullptr;
if (clip) {
fClipRect = &clip->getBounds();
@@ -529,7 +529,7 @@
if (clip->isRect()) {
if (fClipRect->contains(ir)) {
- fClipRect = NULL;
+ fClipRect = nullptr;
} else {
// only need a wrapper blitter if we're horizontally clipped
if (fClipRect->fLeft > ir.fLeft || fClipRect->fRight < ir.fRight) {
@@ -653,14 +653,14 @@
// this returns the first and last edge after they're sorted into a dlink list
SkEdge* edge = sort_edges(list, count, &last);
- headEdge.fPrev = NULL;
+ headEdge.fPrev = nullptr;
headEdge.fNext = edge;
headEdge.fFirstY = kEDGE_HEAD_Y;
headEdge.fX = SK_MinS32;
edge->fPrev = &headEdge;
tailEdge.fPrev = last;
- tailEdge.fNext = NULL;
+ tailEdge.fNext = nullptr;
tailEdge.fFirstY = kEDGE_TAIL_Y;
last->fNext = &tailEdge;
@@ -673,8 +673,8 @@
if (clipRect && start_y < clipRect->fTop) {
start_y = clipRect->fTop;
}
- walk_convex_edges(&headEdge, SkPath::kEvenOdd_FillType, blitter, start_y, stop_y, NULL);
-// walk_edges(&headEdge, SkPath::kEvenOdd_FillType, blitter, start_y, stop_y, NULL);
+ walk_convex_edges(&headEdge, SkPath::kEvenOdd_FillType, blitter, start_y, stop_y, nullptr);
+// walk_edges(&headEdge, SkPath::kEvenOdd_FillType, blitter, start_y, stop_y, nullptr);
}
void SkScan::FillTriangle(const SkPoint pts[], const SkRasterClip& clip,
diff --git a/src/core/SkSemaphore.cpp b/src/core/SkSemaphore.cpp
index 29d0e01..5efdd2e 100644
--- a/src/core/SkSemaphore.cpp
+++ b/src/core/SkSemaphore.cpp
@@ -25,15 +25,15 @@
HANDLE fSemaphore;
OSSemaphore() {
- fSemaphore = CreateSemaphore(NULL /*security attributes, optional*/,
+ fSemaphore = CreateSemaphore(nullptr /*security attributes, optional*/,
0 /*initial count*/,
MAXLONG /*max count*/,
- NULL /*name, optional*/);
+ nullptr /*name, optional*/);
}
~OSSemaphore() { CloseHandle(fSemaphore); }
void signal(int n) {
- ReleaseSemaphore(fSemaphore, n, NULL/*returns previous count, optional*/);
+ ReleaseSemaphore(fSemaphore, n, nullptr/*returns previous count, optional*/);
}
void wait() { WaitForSingleObject(fSemaphore, INFINITE/*timeout in ms*/); }
};
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 6da73fc..51a8017 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -75,7 +75,7 @@
bool SkShader::asLuminanceColor(SkColor* colorPtr) const {
SkColor storage;
- if (NULL == colorPtr) {
+ if (nullptr == colorPtr) {
colorPtr = &storage;
}
if (this->onAsLuminanceColor(colorPtr)) {
@@ -86,14 +86,14 @@
}
SkShader::Context* SkShader::createContext(const ContextRec& rec, void* storage) const {
- if (!this->computeTotalInverse(rec, NULL)) {
- return NULL;
+ if (!this->computeTotalInverse(rec, nullptr)) {
+ return nullptr;
}
return this->onCreateContext(rec, storage);
}
SkShader::Context* SkShader::onCreateContext(const ContextRec& rec, void*) const {
- return NULL;
+ return nullptr;
}
size_t SkShader::contextSize() const {
@@ -114,7 +114,7 @@
SkShader::Context::~Context() {}
SkShader::Context::ShadeProc SkShader::Context::asAShadeProc(void** ctx) {
- return NULL;
+ return nullptr;
}
#include "SkColorPriv.h"
@@ -195,7 +195,7 @@
MatrixClass mc = kLinear_MatrixClass;
if (mat.hasPerspective()) {
- if (mat.fixedStepInX(0, NULL, NULL)) {
+ if (mat.fixedStepInX(0, nullptr, nullptr)) {
mc = kFixedStepInX_MatrixClass;
} else {
mc = kPerspective_MatrixClass;
@@ -221,7 +221,7 @@
}
SkShader* SkShader::refAsALocalMatrixShader(SkMatrix*) const {
- return NULL;
+ return nullptr;
}
SkShader* SkShader::CreateEmptyShader() { return new SkEmptyShader; }
@@ -230,7 +230,7 @@
SkShader* SkShader::CreateBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy,
const SkMatrix* localMatrix) {
- return SkCreateBitmapShader(src, tmx, tmy, localMatrix, NULL);
+ return SkCreateBitmapShader(src, tmx, tmy, localMatrix, nullptr);
}
SkShader* SkShader::CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy,
@@ -339,7 +339,7 @@
bool SkColorShader::asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix&,
const SkMatrix*, GrColor* paintColor,
GrProcessorDataManager*, GrFragmentProcessor** fp) const {
- *fp = NULL;
+ *fp = nullptr;
SkColor skColor = fColor;
U8CPU newA = SkMulDiv255Round(SkColorGetA(fColor), paint.getAlpha());
*paintColor = SkColor2GrColor(SkColorSetA(skColor, newA));
diff --git a/src/core/SkSmallAllocator.h b/src/core/SkSmallAllocator.h
index a2c132a..c7977d3 100644
--- a/src/core/SkSmallAllocator.h
+++ b/src/core/SkSmallAllocator.h
@@ -21,7 +21,7 @@
* Template class for allocating small objects without additional heap memory
* allocations. kMaxObjects is a hard limit on the number of objects that can
* be allocated using this class. After that, attempts to create more objects
- * with this class will assert and return NULL.
+ * with this class will assert and return nullptr.
* kTotalBytes is the total number of bytes provided for storage for all
* objects created by this allocator. If an object to be created is larger
* than the storage (minus storage already used), it will be allocated on the
@@ -44,7 +44,7 @@
Rec* rec = &fRecs[fNumObjects];
rec->fKillProc(rec->fObj);
// Safe to do if fObj is in fStorage, since fHeapStorage will
- // point to NULL.
+ // point to nullptr.
sk_free(rec->fHeapStorage);
}
}
@@ -54,14 +54,14 @@
* SkSmallAllocator.
* Each version behaves the same but takes a different number of
* arguments.
- * Note: If kMaxObjects have been created by this SkSmallAllocator, NULL
+ * Note: If kMaxObjects have been created by this SkSmallAllocator, nullptr
* will be returned.
*/
template<typename T>
T* createT() {
void* buf = this->reserveT<T>();
- if (NULL == buf) {
- return NULL;
+ if (nullptr == buf) {
+ return nullptr;
}
new (buf) T;
return static_cast<T*>(buf);
@@ -69,8 +69,8 @@
template<typename T, typename A1> T* createT(const A1& a1) {
void* buf = this->reserveT<T>();
- if (NULL == buf) {
- return NULL;
+ if (nullptr == buf) {
+ return nullptr;
}
new (buf) T(a1);
return static_cast<T*>(buf);
@@ -79,8 +79,8 @@
template<typename T, typename A1, typename A2>
T* createT(const A1& a1, const A2& a2) {
void* buf = this->reserveT<T>();
- if (NULL == buf) {
- return NULL;
+ if (nullptr == buf) {
+ return nullptr;
}
new (buf) T(a1, a2);
return static_cast<T*>(buf);
@@ -89,8 +89,8 @@
template<typename T, typename A1, typename A2, typename A3>
T* createT(const A1& a1, const A2& a2, const A3& a3) {
void* buf = this->reserveT<T>();
- if (NULL == buf) {
- return NULL;
+ if (nullptr == buf) {
+ return nullptr;
}
new (buf) T(a1, a2, a3);
return static_cast<T*>(buf);
@@ -99,8 +99,8 @@
template<typename T, typename A1, typename A2, typename A3, typename A4>
T* createT(const A1& a1, const A2& a2, const A3& a3, const A4& a4) {
void* buf = this->reserveT<T>();
- if (NULL == buf) {
- return NULL;
+ if (nullptr == buf) {
+ return nullptr;
}
new (buf) T(a1, a2, a3, a4);
return static_cast<T*>(buf);
@@ -117,7 +117,7 @@
SkASSERT(fNumObjects < kMaxObjects);
SkASSERT(storageRequired >= sizeof(T));
if (kMaxObjects == fNumObjects) {
- return NULL;
+ return nullptr;
}
const size_t storageRemaining = SkAlign4(kTotalBytes) - fStorageUsed;
storageRequired = SkAlign4(storageRequired);
@@ -133,7 +133,7 @@
} else {
// There is space in fStorage.
rec->fStorageSize = storageRequired;
- rec->fHeapStorage = NULL;
+ rec->fHeapStorage = nullptr;
SkASSERT(SkIsAlign4(fStorageUsed));
rec->fObj = static_cast<void*>(fStorage + (fStorageUsed / 4));
fStorageUsed += storageRequired;
diff --git a/src/core/SkSpriteBlitter_ARGB32.cpp b/src/core/SkSpriteBlitter_ARGB32.cpp
index 962e2ac..9c47844 100644
--- a/src/core/SkSpriteBlitter_ARGB32.cpp
+++ b/src/core/SkSpriteBlitter_ARGB32.cpp
@@ -69,7 +69,7 @@
SkSafeRef(fXfermode);
fBufferSize = 0;
- fBuffer = NULL;
+ fBuffer = nullptr;
unsigned flags32 = 0;
if (255 != paint.getAlpha()) {
@@ -137,7 +137,7 @@
}
if (xfermode) {
- xfermode->xfer32(dst, tmp, width, NULL);
+ xfermode->xfer32(dst, tmp, width, nullptr);
} else {
fProc32(dst, tmp, width, fAlpha);
}
@@ -182,7 +182,7 @@
colorFilter->filterSpan(buffer, width, buffer);
}
if (xfermode) {
- xfermode->xfer32(dst, buffer, width, NULL);
+ xfermode->xfer32(dst, buffer, width, nullptr);
} else {
fProc32(dst, buffer, width, fAlpha);
}
@@ -258,21 +258,21 @@
SkSpriteBlitter* SkSpriteBlitter::ChooseD32(const SkPixmap& source, const SkPaint& paint,
SkTBlitterAllocator* allocator) {
- SkASSERT(allocator != NULL);
+ SkASSERT(allocator != nullptr);
- if (paint.getMaskFilter() != NULL) {
- return NULL;
+ if (paint.getMaskFilter() != nullptr) {
+ return nullptr;
}
U8CPU alpha = paint.getAlpha();
SkXfermode* xfermode = paint.getXfermode();
SkColorFilter* filter = paint.getColorFilter();
- SkSpriteBlitter* blitter = NULL;
+ SkSpriteBlitter* blitter = nullptr;
switch (source.colorType()) {
case kARGB_4444_SkColorType:
if (alpha != 0xFF) {
- return NULL; // we only have opaque sprites
+ return nullptr; // we only have opaque sprites
}
if (xfermode || filter) {
blitter = allocator->createT<Sprite_D32_S4444_XferFilter>(source, paint);
diff --git a/src/core/SkSpriteBlitter_RGB16.cpp b/src/core/SkSpriteBlitter_RGB16.cpp
index 677dbaa..4dd4164 100644
--- a/src/core/SkSpriteBlitter_RGB16.cpp
+++ b/src/core/SkSpriteBlitter_RGB16.cpp
@@ -299,21 +299,21 @@
SkSpriteBlitter* SkSpriteBlitter::ChooseD16(const SkPixmap& source, const SkPaint& paint,
SkTBlitterAllocator* allocator) {
- SkASSERT(allocator != NULL);
+ SkASSERT(allocator != nullptr);
- if (paint.getMaskFilter() != NULL) { // may add cases for this
- return NULL;
+ if (paint.getMaskFilter() != nullptr) { // may add cases for this
+ return nullptr;
}
- if (paint.getXfermode() != NULL) { // may add cases for this
- return NULL;
+ if (paint.getXfermode() != nullptr) { // may add cases for this
+ return nullptr;
}
- if (paint.getColorFilter() != NULL) { // may add cases for this
- return NULL;
+ if (paint.getColorFilter() != nullptr) { // may add cases for this
+ return nullptr;
}
const SkAlphaType at = source.alphaType();
- SkSpriteBlitter* blitter = NULL;
+ SkSpriteBlitter* blitter = nullptr;
unsigned alpha = paint.getAlpha();
switch (source.colorType()) {
diff --git a/src/core/SkStream.cpp b/src/core/SkStream.cpp
index 8b2e8ab..5a66399 100644
--- a/src/core/SkStream.cpp
+++ b/src/core/SkStream.cpp
@@ -181,7 +181,7 @@
///////////////////////////////////////////////////////////////////////////////
SkFILEStream::SkFILEStream(const char file[]) : fName(file), fOwnership(kCallerPasses_Ownership) {
- fFILE = file ? sk_fopen(fName.c_str(), kRead_SkFILE_Flag) : NULL;
+ fFILE = file ? sk_fopen(fName.c_str(), kRead_SkFILE_Flag) : nullptr;
}
SkFILEStream::SkFILEStream(FILE* file, Ownership ownership)
@@ -199,7 +199,7 @@
fName.set(path);
if (fFILE) {
sk_fclose(fFILE);
- fFILE = NULL;
+ fFILE = nullptr;
}
if (path) {
fFILE = sk_fopen(fName.c_str(), kRead_SkFILE_Flag);
@@ -224,13 +224,13 @@
}
// we hit an error
sk_fclose(fFILE);
- fFILE = NULL;
+ fFILE = nullptr;
}
return false;
}
SkStreamAsset* SkFILEStream::duplicate() const {
- if (NULL == fFILE) {
+ if (nullptr == fFILE) {
return new SkMemoryStream();
}
@@ -246,8 +246,8 @@
}
fData.reset(SkData::NewFromFILE(fFILE));
- if (NULL == fData.get()) {
- return NULL;
+ if (nullptr == fData.get()) {
+ return nullptr;
}
return new SkMemoryStream(fData);
}
@@ -275,8 +275,8 @@
}
const void* SkFILEStream::getMemoryBase() {
- if (NULL == fData.get()) {
- return NULL;
+ if (nullptr == fData.get()) {
+ return nullptr;
}
return fData->data();
}
@@ -307,7 +307,7 @@
}
SkMemoryStream::SkMemoryStream(SkData* data) {
- if (NULL == data) {
+ if (nullptr == data) {
fData = SkData::NewEmpty();
} else {
fData = data;
@@ -339,7 +339,7 @@
SkData* SkMemoryStream::setData(SkData* data) {
fData->unref();
- if (NULL == data) {
+ if (nullptr == data) {
fData = SkData::NewEmpty();
} else {
fData = data;
@@ -368,7 +368,7 @@
}
bool SkMemoryStream::peek(void* buffer, size_t size) const {
- SkASSERT(buffer != NULL);
+ SkASSERT(buffer != nullptr);
const size_t position = fOffset;
if (size > fData->size() - position) {
// The stream is not large enough to satisfy this request.
@@ -446,7 +446,7 @@
bool SkFILEWStream::write(const void* buffer, size_t size)
{
- if (fFILE == NULL) {
+ if (fFILE == nullptr) {
return false;
}
@@ -454,7 +454,7 @@
{
SkDEBUGCODE(SkDebugf("SkFILEWStream failed writing %d bytes\n", size);)
sk_fclose(fFILE);
- fFILE = NULL;
+ fFILE = nullptr;
return false;
}
return true;
@@ -500,7 +500,7 @@
void init(size_t size)
{
- fNext = NULL;
+ fNext = nullptr;
fCurr = this->start();
fStop = this->start() + size;
}
@@ -515,7 +515,7 @@
};
SkDynamicMemoryWStream::SkDynamicMemoryWStream()
- : fHead(NULL), fTail(NULL), fBytesWritten(0), fCopy(NULL)
+ : fHead(nullptr), fTail(nullptr), fBytesWritten(0), fCopy(nullptr)
{
}
@@ -530,12 +530,12 @@
Block* block = fHead;
- while (block != NULL) {
+ while (block != nullptr) {
Block* next = block->fNext;
sk_free(block);
block = next;
}
- fHead = fTail = NULL;
+ fHead = fTail = nullptr;
fBytesWritten = 0;
}
@@ -548,7 +548,7 @@
size_t size;
- if (fTail != NULL && fTail->avail() > 0) {
+ if (fTail != nullptr && fTail->avail() > 0) {
size = SkTMin(fTail->avail(), count);
buffer = fTail->append(buffer, size);
SkASSERT(count >= size);
@@ -562,7 +562,7 @@
block->init(size);
block->append(buffer, count);
- if (fTail != NULL)
+ if (fTail != nullptr)
fTail->fNext = block;
else
fHead = fTail = block;
@@ -580,7 +580,7 @@
this->invalidateCopy();
Block* block = fHead;
- while (block != NULL) {
+ while (block != nullptr) {
size_t size = block->written();
if (offset < size) {
size_t part = offset + count > size ? size - offset : count;
@@ -601,7 +601,7 @@
if (offset + count > fBytesWritten)
return false; // test does not partially modify
Block* block = fHead;
- while (block != NULL) {
+ while (block != nullptr) {
size_t size = block->written();
if (offset < size) {
size_t part = offset + count > size ? size - offset : count;
@@ -624,7 +624,7 @@
} else {
Block* block = fHead;
- while (block != NULL) {
+ while (block != nullptr) {
size_t size = block->written();
memcpy(dst, block->start(), size);
dst = (void*)((char*)dst + size);
@@ -634,7 +634,7 @@
}
void SkDynamicMemoryWStream::writeToStream(SkWStream* dst) const {
- for (Block* block = fHead; block != NULL; block = block->fNext) {
+ for (Block* block = fHead; block != nullptr; block = block->fNext) {
dst->write(block->start(), block->written());
}
}
@@ -650,7 +650,7 @@
}
SkData* SkDynamicMemoryWStream::copyToData() const {
- if (NULL == fCopy) {
+ if (nullptr == fCopy) {
SkData* data = SkData::NewUninitialized(fBytesWritten);
// be sure to call copyTo() before we assign to fCopy
this->copyTo(data->writable_data());
@@ -662,7 +662,7 @@
void SkDynamicMemoryWStream::invalidateCopy() {
if (fCopy) {
fCopy->unref();
- fCopy = NULL;
+ fCopy = nullptr;
}
}
@@ -672,7 +672,7 @@
virtual ~SkBlockMemoryRefCnt() {
SkDynamicMemoryWStream::Block* block = fHead;
- while (block != NULL) {
+ while (block != nullptr) {
SkDynamicMemoryWStream::Block* next = block->fNext;
sk_free(block);
block = next;
@@ -701,7 +701,7 @@
count = fSize - fOffset;
}
size_t bytesLeftToRead = count;
- while (fCurrent != NULL) {
+ while (fCurrent != nullptr) {
size_t bytesLeftInCurrent = fCurrent->written() - fCurrentOffset;
size_t bytesFromCurrent = SkTMin(bytesLeftToRead, bytesLeftInCurrent);
if (buffer) {
@@ -726,7 +726,7 @@
}
bool peek(void* buff, size_t size) const override {
- SkASSERT(buff != NULL);
+ SkASSERT(buff != nullptr);
if (fOffset + size > fSize) {
return false;
}
@@ -795,10 +795,10 @@
}
const void* getMemoryBase() override {
- if (NULL == fBlockMemory->fHead->fNext) {
+ if (nullptr == fBlockMemory->fHead->fNext) {
return fBlockMemory->fHead->start();
}
- return NULL;
+ return nullptr;
}
private:
@@ -850,8 +850,8 @@
static SkData* mmap_filename(const char path[]) {
SkFILE* file = sk_fopen(path, kRead_SkFILE_Flag);
- if (NULL == file) {
- return NULL;
+ if (nullptr == file) {
+ return nullptr;
}
SkData* data = SkData::NewFromFILE(file);
@@ -870,15 +870,15 @@
SkFILEStream* stream = new SkFILEStream(path);
if (!stream->isValid()) {
delete stream;
- stream = NULL;
+ stream = nullptr;
}
return stream;
}
// Declared in SkStreamPriv.h:
size_t SkCopyStreamToStorage(SkAutoMalloc* storage, SkStream* stream) {
- SkASSERT(storage != NULL);
- SkASSERT(stream != NULL);
+ SkASSERT(storage != nullptr);
+ SkASSERT(stream != nullptr);
if (stream->hasLength()) {
const size_t length = stream->getLength();
@@ -908,7 +908,7 @@
// Declared in SkStreamPriv.h:
SkData* SkCopyStreamToData(SkStream* stream) {
- SkASSERT(stream != NULL);
+ SkASSERT(stream != nullptr);
if (stream->hasLength()) {
return SkData::NewFromStream(stream, stream->getLength());
@@ -926,7 +926,7 @@
SkStreamRewindable* SkStreamRewindableFromSkStream(SkStream* stream) {
if (!stream) {
- return NULL;
+ return nullptr;
}
SkAutoTDelete<SkStreamRewindable> dupStream(stream->duplicate());
if (dupStream) {
diff --git a/src/core/SkStreamPriv.h b/src/core/SkStreamPriv.h
index d1af117..b82f7d8 100644
--- a/src/core/SkStreamPriv.h
+++ b/src/core/SkStreamPriv.h
@@ -31,7 +31,7 @@
* @param stream SkStream to be copied into data.
* @return SkData* The resulting SkData after the copy. This data
* will have a ref count of one upon return and belongs to the
- * caller. Returns NULL on failure.
+ * caller. Returns nullptr on failure.
*/
SkData *SkCopyStreamToData(SkStream* stream);
diff --git a/src/core/SkString.cpp b/src/core/SkString.cpp
index 5c63a8b..9110d80 100644
--- a/src/core/SkString.cpp
+++ b/src/core/SkString.cpp
@@ -256,7 +256,7 @@
}
SkString::SkString(size_t len) {
- fRec = AllocRec(NULL, len);
+ fRec = AllocRec(nullptr, len);
}
SkString::SkString(const char text[]) {
@@ -295,7 +295,7 @@
}
bool SkString::equals(const char text[], size_t len) const {
- SkASSERT(len == 0 || text != NULL);
+ SkASSERT(len == 0 || text != nullptr);
return fRec->fLength == len && !memcmp(fRec->data(), text, len);
}
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index 2db5bba..1689f97 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -296,11 +296,11 @@
// cap the end
fInner.getLastPt(&pt);
fCapper(&fOuter, fPrevPt, fPrevNormal, pt,
- currIsLine ? &fInner : NULL);
+ currIsLine ? &fInner : nullptr);
fOuter.reversePathTo(fInner);
// cap the start
fCapper(&fOuter, fFirstPt, -fFirstNormal, fFirstOuterPt,
- fPrevIsLine ? &fInner : NULL);
+ fPrevIsLine ? &fInner : nullptr);
fOuter.close();
}
}
@@ -553,7 +553,7 @@
}
for (int index = 0; index < count; ++index) {
SkScalar t = tValues[index];
- SkEvalCubicAt(cubic, t, &reduction[index], NULL, NULL);
+ SkEvalCubicAt(cubic, t, &reduction[index], nullptr, nullptr);
}
static_assert(kQuad_ReductionType + 1 == kDegenerate_ReductionType, "enum_out_of_whack");
static_assert(kQuad_ReductionType + 2 == kDegenerate2_ReductionType, "enum_out_of_whack");
@@ -589,7 +589,7 @@
return kLine_ReductionType;
}
#endif
- conic.evalAt(t, reduction, NULL);
+ conic.evalAt(t, reduction, nullptr);
return kDegenerate_ReductionType;
}
@@ -738,7 +738,7 @@
bool SkPathStroker::cubicPerpRay(const SkPoint cubic[4], SkScalar t, SkPoint* tPt, SkPoint* onPt,
SkPoint* tangent) const {
SkVector dxy;
- SkEvalCubicAt(cubic, t, tPt, &dxy, NULL);
+ SkEvalCubicAt(cubic, t, tPt, &dxy, nullptr);
if (dxy.fX == 0 && dxy.fY == 0) {
if (SkScalarNearlyZero(t)) {
dxy = cubic[2] - cubic[0];
@@ -779,7 +779,7 @@
bool SkPathStroker::cubicQuadMid(const SkPoint cubic[4], const SkQuadConstruct* quadPts,
SkPoint* mid) const {
SkPoint cubicMidPt;
- return this->cubicPerpRay(cubic, quadPts->fMidT, &cubicMidPt, mid, NULL);
+ return this->cubicPerpRay(cubic, quadPts->fMidT, &cubicMidPt, mid, nullptr);
}
// Given a quad and t, return the point on curve, its perpendicular, and the perpendicular tangent.
@@ -976,7 +976,7 @@
}
// project a ray from the curve to the stroke
SkPoint ray[2]; // points near midpoint on quad, midpoint on cubic
- if (!this->cubicPerpRay(cubic, quadPts->fMidT, &ray[1], &ray[0], NULL)) {
+ if (!this->cubicPerpRay(cubic, quadPts->fMidT, &ray[1], &ray[0], nullptr)) {
return kNormalError_ResultType;
}
return this->strokeCloseEnough(quadPts->fQuad, ray, quadPts
@@ -994,7 +994,7 @@
}
// project a ray from the curve to the stroke
SkPoint ray[2]; // points near midpoint on quad, midpoint on conic
- this->conicPerpRay(conic, quadPts->fMidT, &ray[1], &ray[0], NULL);
+ this->conicPerpRay(conic, quadPts->fMidT, &ray[1], &ray[0], nullptr);
return this->strokeCloseEnough(quadPts->fQuad, ray, quadPts
STROKER_DEBUG_PARAMS(fRecursionDepth));
}
@@ -1021,7 +1021,7 @@
}
// project a ray from the curve to the stroke
SkPoint ray[2];
- this->quadPerpRay(quad, quadPts->fMidT, &ray[1], &ray[0], NULL);
+ this->quadPerpRay(quad, quadPts->fMidT, &ray[1], &ray[0], nullptr);
return this->strokeCloseEnough(quadPts->fQuad, ray, quadPts
STROKER_DEBUG_PARAMS(fRecursionDepth));
}
@@ -1429,7 +1429,7 @@
void SkStroke::strokeRect(const SkRect& origRect, SkPath* dst,
SkPath::Direction dir) const {
- SkASSERT(dst != NULL);
+ SkASSERT(dst != nullptr);
dst->reset();
SkScalar radius = SkScalarHalf(fWidth);
diff --git a/src/core/SkTDPQueue.h b/src/core/SkTDPQueue.h
index a6784bb..1545f97 100644
--- a/src/core/SkTDPQueue.h
+++ b/src/core/SkTDPQueue.h
@@ -15,7 +15,7 @@
* function that compares two Ts and returns true if the first is higher priority than the second.
*
* Optionally objects may know their index into the priority queue. The queue will update the index
- * as the objects move through the queue. This is enabled by using a non-NULL function for INDEX.
+ * as the objects move through the queue. This is enabled by using a non-nullptr function for INDEX.
* When an INDEX function is provided random deletes from the queue are allowed using remove().
* Additionally, the * priority is allowed to change as long as priorityDidChange() is called
* afterwards. In debug builds the index will be set to -1 before an element is removed from the
@@ -23,7 +23,7 @@
*/
template <typename T,
bool (*LESS)(const T&, const T&),
- int* (*INDEX)(const T&) = (int* (*)(const T&))NULL>
+ int* (*INDEX)(const T&) = (int* (*)(const T&))nullptr>
class SkTDPQueue : public SkNoncopyable {
public:
SkTDPQueue() {}
@@ -62,9 +62,9 @@
this->validate();
}
- /** Random access removal. This requires that the INDEX function is non-NULL. */
+ /** Random access removal. This requires that the INDEX function is non-nullptr. */
void remove(T entry) {
- SkASSERT(NULL != INDEX);
+ SkASSERT(nullptr != INDEX);
int index = *INDEX(entry);
SkASSERT(index >= 0 && index < fArray.count());
this->validate();
@@ -84,7 +84,7 @@
item's priority is changed to maintain correct ordering. Changing the priority is only
allowed if an INDEX function is provided. */
void priorityDidChange(T entry) {
- SkASSERT(NULL != INDEX);
+ SkASSERT(nullptr != INDEX);
int index = *INDEX(entry);
SkASSERT(index >= 0 && index < fArray.count());
this->validate(index);
diff --git a/src/core/SkTDynamicHash.h b/src/core/SkTDynamicHash.h
index 8def89b..2fa37b5 100644
--- a/src/core/SkTDynamicHash.h
+++ b/src/core/SkTDynamicHash.h
@@ -22,7 +22,7 @@
int kGrowPercent = 75> // Larger -> more memory efficient, but slower.
class SkTDynamicHash {
public:
- SkTDynamicHash() : fCount(0), fDeleted(0), fCapacity(0), fArray(NULL) {
+ SkTDynamicHash() : fCount(0), fDeleted(0), fCapacity(0), fArray(nullptr) {
SkASSERT(this->validate());
}
@@ -86,14 +86,14 @@
int count() const { return fCount; }
- // Return the entry with this key if we have it, otherwise NULL.
+ // Return the entry with this key if we have it, otherwise nullptr.
T* find(const Key& key) const {
int index = this->firstIndex(key);
for (int round = 0; round < fCapacity; round++) {
SkASSERT(index >= 0 && index < fCapacity);
T* candidate = fArray[index];
if (Empty() == candidate) {
- return NULL;
+ return nullptr;
}
if (Deleted() != candidate && GetKey(*candidate) == key) {
return candidate;
@@ -101,12 +101,12 @@
index = this->nextIndex(index, round);
}
SkASSERT(fCapacity == 0);
- return NULL;
+ return nullptr;
}
// Add an entry with this key. We require that no entry with newEntry's key is already present.
void add(T* newEntry) {
- SkASSERT(NULL == this->find(GetKey(*newEntry)));
+ SkASSERT(nullptr == this->find(GetKey(*newEntry)));
this->maybeGrow();
this->innerAdd(newEntry);
SkASSERT(this->validate());
@@ -132,7 +132,7 @@
fDeleted = 0;
fCapacity = 0;
sk_free(fArray);
- fArray = NULL;
+ fArray = nullptr;
}
protected:
@@ -157,7 +157,7 @@
private:
// We have two special values to indicate an empty or deleted entry.
- static T* Empty() { return reinterpret_cast<T*>(0); } // i.e. NULL
+ static T* Empty() { return reinterpret_cast<T*>(0); } // i.e. nullptr
static T* Deleted() { return reinterpret_cast<T*>(1); } // Also an invalid pointer.
bool validate() const {
diff --git a/src/core/SkTLList.h b/src/core/SkTLList.h
index 3a91efe..ac7f0fa 100644
--- a/src/core/SkTLList.h
+++ b/src/core/SkTLList.h
@@ -103,13 +103,13 @@
}
/** Adds a new element to the list before the location indicated by the iterator. If the
- iterator refers to a NULL location then the new element is added at the tail */
+ iterator refers to a nullptr location then the new element is added at the tail */
T* addBefore(const T& t, const Iter& location) {
return new (this->internalAddBefore(location)) T(t);
}
/** Adds a new element to the list after the location indicated by the iterator. If the
- iterator refers to a NULL location then the new element is added at the head */
+ iterator refers to a nullptr location then the new element is added at the head */
T* addAfter(const T& t, const Iter& location) {
return new (this->internalAddAfter(location)) T(t);
}
@@ -222,7 +222,7 @@
if (node) {
return reinterpret_cast<T*>(node->fObj);
} else {
- return NULL;
+ return nullptr;
}
}
};
diff --git a/src/core/SkTLS.cpp b/src/core/SkTLS.cpp
index b22446b..a47dc14 100755
--- a/src/core/SkTLS.cpp
+++ b/src/core/SkTLS.cpp
@@ -56,8 +56,8 @@
}
void* SkTLS::Get(CreateProc createProc, DeleteProc deleteProc) {
- if (NULL == createProc) {
- return NULL;
+ if (nullptr == createProc) {
+ return nullptr;
}
void* ptr = SkTLS::PlatformGetSpecific(true);
@@ -69,7 +69,7 @@
SkASSERT(rec->fDeleteProc == deleteProc);
return rec->fData;
}
- } while ((rec = rec->fNext) != NULL);
+ } while ((rec = rec->fNext) != nullptr);
// not found, so create a new one
}
@@ -86,8 +86,8 @@
}
void* SkTLS::Find(CreateProc createProc) {
- if (NULL == createProc) {
- return NULL;
+ if (nullptr == createProc) {
+ return nullptr;
}
void* ptr = SkTLS::PlatformGetSpecific(false);
@@ -98,20 +98,20 @@
if (rec->fCreateProc == createProc) {
return rec->fData;
}
- } while ((rec = rec->fNext) != NULL);
+ } while ((rec = rec->fNext) != nullptr);
}
- return NULL;
+ return nullptr;
}
void SkTLS::Delete(CreateProc createProc) {
- if (NULL == createProc) {
+ if (nullptr == createProc) {
return;
}
void* ptr = SkTLS::PlatformGetSpecific(false);
SkTLSRec* curr = (SkTLSRec*)ptr;
- SkTLSRec* prev = NULL;
+ SkTLSRec* prev = nullptr;
while (curr) {
SkTLSRec* next = curr->fNext;
if (curr->fCreateProc == createProc) {
diff --git a/src/core/SkTLS.h b/src/core/SkTLS.h
index e94f835..ace2de5 100644
--- a/src/core/SkTLS.h
+++ b/src/core/SkTLS.h
@@ -20,7 +20,7 @@
/**
* If Get() has previously been called with this CreateProc, then this
- * returns its cached data, otherwise it returns NULL. The CreateProc is
+ * returns its cached data, otherwise it returns nullptr. The CreateProc is
* never invoked in Find, it is only used as a key for searching the
* cache.
*/
@@ -52,8 +52,8 @@
* Implemented by the platform, to return the value of our (one) slot per-thread
*
* If forceCreateTheSlot is true, then we must have created the "slot" for
- * our TLS, even though we know that the return value will be NULL in that
- * case (i.e. no-slot and first-time-slot both return NULL). This ensures
+ * our TLS, even though we know that the return value will be nullptr in that
+ * case (i.e. no-slot and first-time-slot both return nullptr). This ensures
* that after calling GetSpecific, we know that we can legally call
* SetSpecific.
*
diff --git a/src/core/SkTMultiMap.h b/src/core/SkTMultiMap.h
index 5f8589d..b0d04d5 100644
--- a/src/core/SkTMultiMap.h
+++ b/src/core/SkTMultiMap.h
@@ -20,7 +20,7 @@
typename HashTraits=T>
class SkTMultiMap {
struct ValueList {
- explicit ValueList(T* value) : fValue(value), fNext(NULL) {}
+ explicit ValueList(T* value) : fValue(value), fNext(nullptr) {}
static const Key& GetKey(const ValueList& e) { return HashTraits::GetKey(*e.fValue); }
static uint32_t Hash(const Key& key) { return HashTraits::Hash(key); }
@@ -58,7 +58,7 @@
// Since we expect the caller to be fully aware of what is stored, just
// assert that the caller removes an existing value.
SkASSERT(list);
- ValueList* prev = NULL;
+ ValueList* prev = nullptr;
while (list->fValue != value) {
prev = list;
list = list->fNext;
@@ -70,7 +70,7 @@
list->fNext = next->fNext;
delete next;
} else if (prev) {
- prev->fNext = NULL;
+ prev->fNext = nullptr;
delete list;
} else {
fHash.remove(key);
@@ -85,7 +85,7 @@
if (list) {
return list->fValue;
}
- return NULL;
+ return nullptr;
}
template<class FindPredicate>
@@ -97,7 +97,7 @@
}
list = list->fNext;
}
- return NULL;
+ return nullptr;
}
int count() const { return fCount; }
diff --git a/src/core/SkTSearch.cpp b/src/core/SkTSearch.cpp
index 64c70cb..5b5f139 100644
--- a/src/core/SkTSearch.cpp
+++ b/src/core/SkTSearch.cpp
@@ -22,7 +22,7 @@
if (count <= 0)
return ~0;
- SkASSERT(base != NULL);
+ SkASSERT(base != nullptr);
int lo = 0;
int hi = count - 1;
diff --git a/src/core/SkTaskGroup.cpp b/src/core/SkTaskGroup.cpp
index 9462903..97e3ff4 100644
--- a/src/core/SkTaskGroup.cpp
+++ b/src/core/SkTaskGroup.cpp
@@ -122,7 +122,7 @@
// Send a poison pill to each thread.
SkAtomic<int> dummy(0);
for (int i = 0; i < fThreads.count(); i++) {
- this->add(NULL, NULL, &dummy);
+ this->add(nullptr, nullptr, &dummy);
}
// Wait for them all to swallow the pill and die.
for (int i = 0; i < fThreads.count(); i++) {
@@ -197,12 +197,12 @@
friend struct SkTaskGroup::Enabler;
};
-ThreadPool* ThreadPool::gGlobal = NULL;
+ThreadPool* ThreadPool::gGlobal = nullptr;
} // namespace
SkTaskGroup::Enabler::Enabler(int threads) {
- SkASSERT(ThreadPool::gGlobal == NULL);
+ SkASSERT(ThreadPool::gGlobal == nullptr);
if (threads != 0) {
ThreadPool::gGlobal = new ThreadPool(threads);
}
diff --git a/src/core/SkTextBlob.cpp b/src/core/SkTextBlob.cpp
index d2b1605..68784f4 100644
--- a/src/core/SkTextBlob.cpp
+++ b/src/core/SkTextBlob.cpp
@@ -244,7 +244,7 @@
const SkTextBlob* SkTextBlob::CreateFromBuffer(SkReadBuffer& reader) {
int runCount = reader.read32();
if (runCount < 0) {
- return NULL;
+ return nullptr;
}
SkRect bounds;
@@ -255,7 +255,7 @@
int glyphCount = reader.read32();
GlyphPositioning pos = static_cast<GlyphPositioning>(reader.read32());
if (glyphCount <= 0 || pos > kFull_Positioning) {
- return NULL;
+ return nullptr;
}
SkPoint offset;
@@ -263,7 +263,7 @@
SkPaint font;
reader.readPaint(&font);
- const SkTextBlobBuilder::RunBuffer* buf = NULL;
+ const SkTextBlobBuilder::RunBuffer* buf = nullptr;
switch (pos) {
case kDefault_Positioning:
buf = &blobBuilder.allocRun(font, glyphCount, offset.x(), offset.y(), &bounds);
@@ -275,13 +275,13 @@
buf = &blobBuilder.allocRunPos(font, glyphCount, &bounds);
break;
default:
- return NULL;
+ return nullptr;
}
if (!reader.readByteArray(buf->glyphs, glyphCount * sizeof(uint16_t)) ||
!reader.readByteArray(buf->pos,
glyphCount * sizeof(SkScalar) * ScalarsPerGlyph(pos))) {
- return NULL;
+ return nullptr;
}
}
@@ -359,7 +359,7 @@
}
SkTextBlobBuilder::~SkTextBlobBuilder() {
- if (NULL != fStorage.get()) {
+ if (nullptr != fStorage.get()) {
// We are abandoning runs and must destruct the associated font data.
// The easiest way to accomplish that is to use the blob destructor.
build()->unref();
@@ -447,7 +447,7 @@
}
if (0 == fRunCount) {
- SkASSERT(NULL == fStorage.get());
+ SkASSERT(nullptr == fStorage.get());
SkASSERT(0 == fStorageSize);
SkASSERT(0 == fStorageUsed);
@@ -573,12 +573,12 @@
}
const SkTextBlob* SkTextBlobBuilder::build() {
- SkASSERT((fRunCount > 0) == (NULL != fStorage.get()));
+ SkASSERT((fRunCount > 0) == (nullptr != fStorage.get()));
this->updateDeferredBounds();
if (0 == fRunCount) {
- SkASSERT(NULL == fStorage.get());
+ SkASSERT(nullptr == fStorage.get());
fStorageUsed = sizeof(SkTextBlob);
fStorage.realloc(fStorageUsed);
}
diff --git a/src/core/SkTraceEvent.h b/src/core/SkTraceEvent.h
index 96b6620..05dc340 100644
--- a/src/core/SkTraceEvent.h
+++ b/src/core/SkTraceEvent.h
@@ -395,7 +395,7 @@
unsigned char flags) {
return TRACE_EVENT_API_ADD_TRACE_EVENT(
phase, category_group_enabled, name, id,
- kZeroNumArgs, NULL, NULL, NULL, flags);
+ kZeroNumArgs, nullptr, nullptr, nullptr, flags);
}
template<class ARG1_TYPE>
@@ -444,7 +444,7 @@
class TRACE_EVENT_API_CLASS_EXPORT ScopedTracer {
public:
// Note: members of data_ intentionally left uninitialized. See Initialize.
- ScopedTracer() : p_data_(NULL) {}
+ ScopedTracer() : p_data_(nullptr) {}
~ScopedTracer() {
if (p_data_ && *data_.category_group_enabled)
diff --git a/src/core/SkTypeface.cpp b/src/core/SkTypeface.cpp
index 7da1118..81daf2f 100644
--- a/src/core/SkTypeface.cpp
+++ b/src/core/SkTypeface.cpp
@@ -21,7 +21,7 @@
SkTypeface::~SkTypeface() { }
-SkTypeface* (*gCreateTypefaceDelegate)(const char [], SkTypeface::Style ) = NULL;
+SkTypeface* (*gCreateTypefaceDelegate)(const char [], SkTypeface::Style ) = nullptr;
///////////////////////////////////////////////////////////////////////////////
@@ -31,14 +31,14 @@
protected:
SkEmptyTypeface() : SkTypeface(SkFontStyle(), 0, true) { }
- SkStreamAsset* onOpenStream(int* ttcIndex) const override { return NULL; }
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override { return nullptr; }
SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override {
- return NULL;
+ return nullptr;
}
void onFilterRec(SkScalerContextRec*) const override { }
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
PerGlyphInfo,
- const uint32_t*, uint32_t) const override { return NULL; }
+ const uint32_t*, uint32_t) const override { return nullptr; }
void onGetFontDescriptor(SkFontDescriptor*, bool*) const override { }
virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
uint16_t glyphs[], int glyphCount) const override {
@@ -78,7 +78,7 @@
SkAutoMutexAcquire lock(&gCreateDefaultMutex);
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
- SkTypeface* t = fm->legacyCreateTypeface(NULL, style);
+ SkTypeface* t = fm->legacyCreateTypeface(nullptr, style);
return t ? t : SkEmptyTypeface::Create();
}
@@ -99,7 +99,7 @@
}
uint32_t SkTypeface::UniqueID(const SkTypeface* face) {
- if (NULL == face) {
+ if (nullptr == face) {
face = GetDefaultTypeface();
}
return face->uniqueID();
@@ -118,7 +118,7 @@
return result;
}
}
- if (NULL == name) {
+ if (nullptr == name) {
return RefDefault(style);
}
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
@@ -202,7 +202,7 @@
///////////////////////////////////////////////////////////////////////////////
int SkTypeface::countTables() const {
- return this->onGetTableTags(NULL);
+ return this->onGetTableTags(nullptr);
}
int SkTypeface::getTableTags(SkFontTableTag tags[]) const {
@@ -210,7 +210,7 @@
}
size_t SkTypeface::getTableSize(SkFontTableTag tag) const {
- return this->onGetTableData(tag, 0, ~0U, NULL);
+ return this->onGetTableData(tag, 0, ~0U, nullptr);
}
size_t SkTypeface::getTableData(SkFontTableTag tag, size_t offset, size_t length,
@@ -220,7 +220,7 @@
SkStreamAsset* SkTypeface::openStream(int* ttcIndex) const {
int ttcIndexStorage;
- if (NULL == ttcIndex) {
+ if (nullptr == ttcIndex) {
// So our subclasses don't need to check for null param
ttcIndex = &ttcIndexStorage;
}
@@ -235,7 +235,7 @@
SkFontData* SkTypeface::onCreateFontData() const {
int index;
SkAutoTDelete<SkStreamAsset> stream(this->onOpenStream(&index));
- return new SkFontData(stream.detach(), index, NULL, 0);
+ return new SkFontData(stream.detach(), index, nullptr, 0);
};
int SkTypeface::charsToGlyphs(const void* chars, Encoding encoding,
@@ -243,7 +243,7 @@
if (glyphCount <= 0) {
return 0;
}
- if (NULL == chars || (unsigned)encoding > kUTF32_Encoding) {
+ if (nullptr == chars || (unsigned)encoding > kUTF32_Encoding) {
if (glyphs) {
sk_bzero(glyphs, glyphCount * sizeof(glyphs[0]));
}
@@ -264,13 +264,13 @@
bool SkTypeface::getKerningPairAdjustments(const uint16_t glyphs[], int count,
int32_t adjustments[]) const {
SkASSERT(count >= 0);
- // check for the only legal way to pass a NULL.. everything is 0
+ // check for the only legal way to pass a nullptr.. everything is 0
// in which case they just want to know if this face can possibly support
// kerning (true) or never (false).
- if (NULL == glyphs || NULL == adjustments) {
- SkASSERT(NULL == glyphs);
+ if (nullptr == glyphs || nullptr == adjustments) {
+ SkASSERT(nullptr == glyphs);
SkASSERT(0 == count);
- SkASSERT(NULL == adjustments);
+ SkASSERT(nullptr == adjustments);
}
return this->onGetKerningPairAdjustments(glyphs, count, adjustments);
}
@@ -352,7 +352,7 @@
paint.setLinearText(true);
SkScalerContext::Rec rec;
- SkScalerContext::MakeRec(paint, NULL, NULL, &rec);
+ SkScalerContext::MakeRec(paint, nullptr, nullptr, &rec);
SkAutoDescriptor ad(sizeof(rec) + SkDescriptor::ComputeOverhead(1));
SkDescriptor* desc = ad.getDesc();
diff --git a/src/core/SkTypefaceCache.cpp b/src/core/SkTypefaceCache.cpp
index 49779fc..5fe080d 100644
--- a/src/core/SkTypefaceCache.cpp
+++ b/src/core/SkTypefaceCache.cpp
@@ -45,7 +45,7 @@
}
curr += 1;
}
- return NULL;
+ return nullptr;
}
void SkTypefaceCache::purge(int numToPurge) {
@@ -113,6 +113,6 @@
void SkTypefaceCache::Dump() {
#ifdef SK_DEBUG
SkAutoMutexAcquire ama(gMutex);
- (void)Get().findByProcAndRef(DumpProc, NULL);
+ (void)Get().findByProcAndRef(DumpProc, nullptr);
#endif
}
diff --git a/src/core/SkTypefaceCache.h b/src/core/SkTypefaceCache.h
index 7929586..f39b0d7 100644
--- a/src/core/SkTypefaceCache.h
+++ b/src/core/SkTypefaceCache.h
@@ -44,7 +44,7 @@
/**
* Iterate through the cache, calling proc(typeface, ctx) with each
* typeface. If proc returns true, then we return that typeface (this
- * ref()s the typeface). If it never returns true, we return NULL.
+ * ref()s the typeface). If it never returns true, we return nullptr.
*/
SkTypeface* findByProcAndRef(FindProc proc, void* ctx) const;
diff --git a/src/core/SkUtils.cpp b/src/core/SkUtils.cpp
index eecf122..b3f698b 100644
--- a/src/core/SkUtils.cpp
+++ b/src/core/SkUtils.cpp
@@ -155,7 +155,7 @@
*--utf8 = (char)(~(0xFF >> count) | uni);
}
- SkASSERT(utf8 == NULL || orig == SkUTF8_ToUnichar(utf8));
+ SkASSERT(utf8 == nullptr || orig == SkUTF8_ToUnichar(utf8));
return count;
}
@@ -260,14 +260,14 @@
return 0;
}
- SkASSERT(utf16 != NULL);
+ SkASSERT(utf16 != nullptr);
const uint16_t* stop = utf16 + numberOf16BitValues;
size_t size = 0;
- if (utf8 == NULL) { // just count
+ if (utf8 == nullptr) { // just count
while (utf16 < stop) {
- size += SkUTF8_FromUnichar(SkUTF16_NextUnichar(&utf16), NULL);
+ size += SkUTF8_FromUnichar(SkUTF16_NextUnichar(&utf16), nullptr);
}
} else {
char* start = utf8;
diff --git a/src/core/SkUtilsArm.cpp b/src/core/SkUtilsArm.cpp
index 9fd19a5..9dc4e54 100644
--- a/src/core/SkUtilsArm.cpp
+++ b/src/core/SkUtilsArm.cpp
@@ -88,7 +88,7 @@
char* line = (char*) memmem(buffer, buffer_end - buffer,
features, features_len);
- if (line == NULL) { // Weird, no Features line, bad kernel?
+ if (line == nullptr) { // Weird, no Features line, bad kernel?
SkDebugf("Could not find a line starting with 'Features'"
"in /proc/cpuinfo ?\n");
break;
@@ -98,7 +98,7 @@
// Find the end of the current line
char* line_end = (char*) memchr(line, '\n', buffer_end - line);
- if (line_end == NULL)
+ if (line_end == nullptr)
line_end = buffer_end;
// Now find an instance of 'neon' in the flags list. We want to
@@ -108,7 +108,7 @@
const size_t neon_len = sizeof(neon)-1;
const char* flag = (const char*) memmem(line, line_end - line,
neon, neon_len);
- if (flag == NULL)
+ if (flag == nullptr)
break;
// Ensure it is followed by a space or a newline.
diff --git a/src/core/SkValidatingReadBuffer.cpp b/src/core/SkValidatingReadBuffer.cpp
index fd00e7d..e00613b 100644
--- a/src/core/SkValidatingReadBuffer.cpp
+++ b/src/core/SkValidatingReadBuffer.cpp
@@ -111,7 +111,7 @@
this->validate(encodingType == encoding);
*length = this->readInt();
const void* ptr = this->skip(SkAlign4(*length));
- void* data = NULL;
+ void* data = nullptr;
if (!fError) {
data = sk_malloc_throw(*length);
memcpy(data, ptr, *length);
@@ -214,7 +214,7 @@
SkTypeface* SkValidatingReadBuffer::readTypeface() {
// TODO: Implement this (securely) when needed
- return NULL;
+ return nullptr;
}
bool SkValidatingReadBuffer::validateAvailable(size_t size) {
@@ -225,24 +225,24 @@
SkString name;
this->readString(&name);
if (fError) {
- return NULL;
+ return nullptr;
}
// Is this the type we wanted ?
const char* cname = name.c_str();
SkFlattenable::Type baseType;
if (!SkFlattenable::NameToType(cname, &baseType) || (baseType != type)) {
- return NULL;
+ return nullptr;
}
SkFlattenable::Factory factory = SkFlattenable::NameToFactory(cname);
- if (NULL == factory) {
- return NULL; // writer failed to give us the flattenable
+ if (nullptr == factory) {
+ return nullptr; // writer failed to give us the flattenable
}
// if we get here, factory may still be null, but if that is the case, the
// failure was ours, not the writer.
- SkFlattenable* obj = NULL;
+ SkFlattenable* obj = nullptr;
uint32_t sizeRecorded = this->readUInt();
if (factory) {
size_t offset = fReader.offset();
@@ -253,7 +253,7 @@
if (fError) {
// we could try to fix up the offset...
SkSafeUnref(obj);
- obj = NULL;
+ obj = nullptr;
}
} else {
// we must skip the remaining data
diff --git a/src/core/SkVarAlloc.cpp b/src/core/SkVarAlloc.cpp
index 5d395d4..f953705 100644
--- a/src/core/SkVarAlloc.cpp
+++ b/src/core/SkVarAlloc.cpp
@@ -28,17 +28,17 @@
SkVarAlloc::SkVarAlloc(size_t minLgSize)
: fBytesAllocated(0)
- , fByte(NULL)
+ , fByte(nullptr)
, fRemaining(0)
, fLgSize(minLgSize)
- , fBlock(NULL) {}
+ , fBlock(nullptr) {}
SkVarAlloc::SkVarAlloc(size_t minLgSize, char* storage, size_t len)
: fBytesAllocated(0)
, fByte(storage)
, fRemaining(len)
, fLgSize(minLgSize)
- , fBlock(NULL) {}
+ , fBlock(nullptr) {}
SkVarAlloc::~SkVarAlloc() {
Block* b = fBlock;
diff --git a/src/core/SkVertState.cpp b/src/core/SkVertState.cpp
index f23b108..7c3047e 100644
--- a/src/core/SkVertState.cpp
+++ b/src/core/SkVertState.cpp
@@ -101,6 +101,6 @@
case SkCanvas::kTriangleFan_VertexMode:
return fIndices ? TriangleFanX : TriangleFan;
default:
- return NULL;
+ return nullptr;
}
}
diff --git a/src/core/SkVertState.h b/src/core/SkVertState.h
index ecf1773..ab79452 100644
--- a/src/core/SkVertState.h
+++ b/src/core/SkVertState.h
@@ -22,7 +22,7 @@
/**
* Construct a VertState from a vertex count, index array, and index count.
- * If the vertices are unindexed pass NULL for indices.
+ * If the vertices are unindexed pass nullptr for indices.
*/
VertState(int vCount, const uint16_t indices[], int indexCount)
: fIndices(indices) {
diff --git a/src/core/SkWriteBuffer.cpp b/src/core/SkWriteBuffer.cpp
index faa7f00..7ddc77f 100644
--- a/src/core/SkWriteBuffer.cpp
+++ b/src/core/SkWriteBuffer.cpp
@@ -17,19 +17,19 @@
SkWriteBuffer::SkWriteBuffer(uint32_t flags)
: fFlags(flags)
- , fFactorySet(NULL)
- , fNamedFactorySet(NULL)
- , fBitmapHeap(NULL)
- , fTFSet(NULL) {
+ , fFactorySet(nullptr)
+ , fNamedFactorySet(nullptr)
+ , fBitmapHeap(nullptr)
+ , fTFSet(nullptr) {
}
SkWriteBuffer::SkWriteBuffer(void* storage, size_t storageSize, uint32_t flags)
: fFlags(flags)
- , fFactorySet(NULL)
- , fNamedFactorySet(NULL)
+ , fFactorySet(nullptr)
+ , fNamedFactorySet(nullptr)
, fWriter(storage, storageSize)
- , fBitmapHeap(NULL)
- , fTFSet(NULL) {
+ , fBitmapHeap(nullptr)
+ , fTFSet(nullptr) {
}
SkWriteBuffer::~SkWriteBuffer() {
@@ -165,12 +165,12 @@
// the size of the encoded data. A non-zero size signifies that encoded data was written.
// 3. Call SkBitmap::flatten. After writing a boolean value of false, signifying that a heap was
// not used, write a zero to signify that the data was not encoded.
- bool useBitmapHeap = fBitmapHeap != NULL;
+ bool useBitmapHeap = fBitmapHeap != nullptr;
// Write a bool: true if the SkBitmapHeap is to be used, in which case the reader must use an
// SkBitmapHeapReader to read the SkBitmap. False if the bitmap was serialized another way.
this->writeBool(useBitmapHeap);
if (useBitmapHeap) {
- SkASSERT(NULL == fPixelSerializer);
+ SkASSERT(nullptr == fPixelSerializer);
int32_t slot = fBitmapHeap->insert(bitmap);
fWriter.write32(slot);
// crbug.com/155875
@@ -187,7 +187,7 @@
if (pixelRef) {
// see if the pixelref already has an encoded version
SkAutoDataUnref existingData(pixelRef->refEncodedData());
- if (existingData.get() != NULL) {
+ if (existingData.get() != nullptr) {
// Assumes that if the client did not set a serializer, they are
// happy to get the encoded data.
if (!fPixelSerializer || fPixelSerializer->useEncodedData(existingData->data(),
@@ -201,11 +201,11 @@
SkAutoPixmapUnlock result;
if (fPixelSerializer && bitmap.requestLock(&result)) {
const SkPixmap& pmap = result.pixmap();
- SkASSERT(NULL == fBitmapHeap);
+ SkASSERT(nullptr == fBitmapHeap);
SkAutoDataUnref data(fPixelSerializer->encodePixels(pmap.info(),
pmap.addr(),
pmap.rowBytes()));
- if (data.get() != NULL) {
+ if (data.get() != nullptr) {
// if we have to "encode" the bitmap, then we assume there is no
// offset to share, since we are effectively creating a new pixelref
write_encoded_bitmap(this, data, SkIPoint::Make(0, 0));
@@ -247,7 +247,7 @@
}
void SkWriteBuffer::writeTypeface(SkTypeface* obj) {
- if (NULL == obj || NULL == fTFSet) {
+ if (nullptr == obj || nullptr == fTFSet) {
fWriter.write32(0);
} else {
fWriter.write32(fTFSet->add(obj));
@@ -256,18 +256,18 @@
SkFactorySet* SkWriteBuffer::setFactoryRecorder(SkFactorySet* rec) {
SkRefCnt_SafeAssign(fFactorySet, rec);
- if (fNamedFactorySet != NULL) {
+ if (fNamedFactorySet != nullptr) {
fNamedFactorySet->unref();
- fNamedFactorySet = NULL;
+ fNamedFactorySet = nullptr;
}
return rec;
}
SkNamedFactorySet* SkWriteBuffer::setNamedFactoryRecorder(SkNamedFactorySet* rec) {
SkRefCnt_SafeAssign(fNamedFactorySet, rec);
- if (fFactorySet != NULL) {
+ if (fFactorySet != nullptr) {
fFactorySet->unref();
- fFactorySet = NULL;
+ fFactorySet = nullptr;
}
return rec;
}
@@ -279,9 +279,9 @@
void SkWriteBuffer::setBitmapHeap(SkBitmapHeap* bitmapHeap) {
SkRefCnt_SafeAssign(fBitmapHeap, bitmapHeap);
- if (bitmapHeap != NULL) {
- SkASSERT(NULL == fPixelSerializer);
- fPixelSerializer.reset(NULL);
+ if (bitmapHeap != nullptr) {
+ SkASSERT(nullptr == fPixelSerializer);
+ fPixelSerializer.reset(nullptr);
}
}
@@ -289,9 +289,9 @@
fPixelSerializer.reset(serializer);
if (serializer) {
serializer->ref();
- SkASSERT(NULL == fBitmapHeap);
+ SkASSERT(nullptr == fBitmapHeap);
SkSafeUnref(fBitmapHeap);
- fBitmapHeap = NULL;
+ fBitmapHeap = nullptr;
}
}
@@ -306,19 +306,19 @@
* The distinction is important, since 0-index is 32bits (always), but a
* 0-functionptr might be 32 or 64 bits.
*/
- if (NULL == flattenable) {
+ if (nullptr == flattenable) {
if (this->isValidating()) {
this->writeString("");
- } else if (fFactorySet != NULL || fNamedFactorySet != NULL) {
+ } else if (fFactorySet != nullptr || fNamedFactorySet != nullptr) {
this->write32(0);
} else {
- this->writeFunctionPtr(NULL);
+ this->writeFunctionPtr(nullptr);
}
return;
}
SkFlattenable::Factory factory = flattenable->getFactory();
- SkASSERT(factory != NULL);
+ SkASSERT(factory != nullptr);
/*
* We can write 1 of 3 versions of the flattenable:
diff --git a/src/core/SkWriter32.cpp b/src/core/SkWriter32.cpp
index a1a8b88..457cff4 100644
--- a/src/core/SkWriter32.cpp
+++ b/src/core/SkWriter32.cpp
@@ -37,7 +37,7 @@
}
void SkWriter32::writeString(const char str[], size_t len) {
- if (NULL == str) {
+ if (nullptr == str) {
str = "";
len = 0;
}
@@ -64,7 +64,7 @@
}
void SkWriter32::growToAtLeast(size_t size) {
- const bool wasExternal = (fExternal != NULL) && (fData == fExternal);
+ const bool wasExternal = (fExternal != nullptr) && (fData == fExternal);
fCapacity = 4096 + SkTMax(size, fCapacity + (fCapacity / 2));
fInternal.realloc(fCapacity);
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index 17ce215..1d40986 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -666,7 +666,7 @@
#include "effects/GrPorterDuffXferProcessor.h"
bool SkXfermode::AsXPFactory(SkXfermode* xfermode, GrXPFactory** xpf) {
- if (NULL == xfermode) {
+ if (nullptr == xfermode) {
if (xpf) {
*xpf = GrPorterDuffXPFactory::Create(kSrcOver_Mode);
}
@@ -691,7 +691,7 @@
const SkAlpha* SK_RESTRICT aa) const {
SkASSERT(dst && src && count >= 0);
- if (NULL == aa) {
+ if (nullptr == aa) {
for (int i = count - 1; i >= 0; --i) {
dst[i] = this->xferColor(src[i], dst[i]);
}
@@ -715,7 +715,7 @@
const SkAlpha* SK_RESTRICT aa) const {
SkASSERT(dst && src && count >= 0);
- if (NULL == aa) {
+ if (nullptr == aa) {
for (int i = count - 1; i >= 0; --i) {
SkPMColor dstC = SkPixel16ToPixel32(dst[i]);
dst[i] = SkPixel32ToPixel16_ToU16(this->xferColor(src[i], dstC));
@@ -740,7 +740,7 @@
const SkAlpha* SK_RESTRICT aa) const {
SkASSERT(dst && src && count >= 0);
- if (NULL == aa) {
+ if (nullptr == aa) {
for (int i = count - 1; i >= 0; --i) {
SkPMColor res = this->xferColor(src[i], (dst[i] << SK_A32_SHIFT));
dst[i] = SkToU8(SkGetPackedA32(res));
@@ -775,7 +775,7 @@
SkFlattenable* SkProcCoeffXfermode::CreateProc(SkReadBuffer& buffer) {
uint32_t mode32 = buffer.read32();
if (!buffer.validate(mode32 < SK_ARRAY_COUNT(gProcCoeffs))) {
- return NULL;
+ return nullptr;
}
return SkXfermode::Create((SkXfermode::Mode)mode32);
}
@@ -840,7 +840,7 @@
SkXfermodeProc proc = fProc;
if (proc) {
- if (NULL == aa) {
+ if (nullptr == aa) {
for (int i = count - 1; i >= 0; --i) {
dst[i] = proc(src[i], dst[i]);
}
@@ -868,7 +868,7 @@
SkXfermodeProc proc = fProc;
if (proc) {
- if (NULL == aa) {
+ if (nullptr == aa) {
for (int i = count - 1; i >= 0; --i) {
SkPMColor dstC = SkPixel16ToPixel32(dst[i]);
dst[i] = SkPixel32ToPixel16_ToU16(proc(src[i], dstC));
@@ -897,7 +897,7 @@
SkXfermodeProc proc = fProc;
if (proc) {
- if (NULL == aa) {
+ if (nullptr == aa) {
for (int i = count - 1; i >= 0; --i) {
SkPMColor res = proc(src[i], dst[i] << SK_A32_SHIFT);
dst[i] = SkToU8(SkGetPackedA32(res));
@@ -1017,20 +1017,20 @@
if ((unsigned)mode >= kModeCount) {
// report error
- return NULL;
+ return nullptr;
}
- // Skia's "default" mode is srcover. NULL in SkPaint is interpreted as srcover
- // so we can just return NULL from the factory.
+ // Skia's "default" mode is srcover. nullptr in SkPaint is interpreted as srcover
+ // so we can just return nullptr from the factory.
if (kSrcOver_Mode == mode) {
- return NULL;
+ return nullptr;
}
return SkSafeRef(cached[mode]);
}
SkXfermodeProc SkXfermode::GetProc(Mode mode) {
- SkXfermodeProc proc = NULL;
+ SkXfermodeProc proc = nullptr;
if ((unsigned)mode < kModeCount) {
proc = gProcCoeffs[mode].fProc;
}
@@ -1062,7 +1062,7 @@
}
bool SkXfermode::AsMode(const SkXfermode* xfer, Mode* mode) {
- if (NULL == xfer) {
+ if (nullptr == xfer) {
if (mode) {
*mode = kSrcOver_Mode;
}
@@ -1081,7 +1081,7 @@
}
bool SkXfermode::SupportsCoverageAsAlpha(const SkXfermode* xfer) {
- // if xfer is NULL we treat it as srcOver which always supports coverageAsAlpha
+ // if xfer is nullptr we treat it as srcOver which always supports coverageAsAlpha
if (!xfer) {
return true;
}
@@ -1090,7 +1090,7 @@
}
bool SkXfermode::IsOpaque(const SkXfermode* xfer, SrcColorOpacity opacityType) {
- // if xfer is NULL we treat it as srcOver which is opaque if our src is opaque
+ // if xfer is nullptr we treat it as srcOver which is opaque if our src is opaque
if (!xfer) {
return SkXfermode::kOpaque_SrcColorOpacity == opacityType;
}
diff --git a/src/core/SkYUVPlanesCache.cpp b/src/core/SkYUVPlanesCache.cpp
index f013599..336b581 100644
--- a/src/core/SkYUVPlanesCache.cpp
+++ b/src/core/SkYUVPlanesCache.cpp
@@ -59,7 +59,7 @@
SkCachedData* tmpData = rec.fValue.fData;
tmpData->ref();
- if (NULL == tmpData->data()) {
+ if (nullptr == tmpData->data()) {
tmpData->unref();
return false;
}
@@ -75,7 +75,7 @@
YUVValue result;
YUVPlanesKey key(genID);
if (!CHECK_LOCAL(localCache, find, Find, key, YUVPlanesRec::Visitor, &result)) {
- return NULL;
+ return nullptr;
}
*info = result.fInfo;
diff --git a/src/core/SkYUVPlanesCache.h b/src/core/SkYUVPlanesCache.h
index aa9b89e..a024192 100644
--- a/src/core/SkYUVPlanesCache.h
+++ b/src/core/SkYUVPlanesCache.h
@@ -35,16 +35,16 @@
/**
* On success, return a ref to the SkCachedData that holds the pixels.
*
- * On failure, return NULL.
+ * On failure, return nullptr.
*/
static SkCachedData* FindAndRef(uint32_t genID, Info* info,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
/**
* Add a pixelRef ID and its YUV planes data to the cache.
*/
static void Add(uint32_t genID, SkCachedData* data, Info* info,
- SkResourceCache* localCache = NULL);
+ SkResourceCache* localCache = nullptr);
};
#endif