Style Change: NULL->nullptr

src/core/SkPaint.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAnnotation.h"
 #include "SkAutoKern.h"
@@ skipping 22 matching lines @@
 #include "SkTLazy.h"
 #include "SkTypeface.h"
 #include "SkSurfacePriv.h"
 #include "SkXfermode.h"
 
 // define this to get a printf for out-of-range parameter in setters
 // e.g. setTextSize(-1)
 //#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;
     fTextSkewX  = 0;
     fColor      = SK_ColorBLACK;
     fWidth      = 0;
     fMiterLimit = SkPaintDefaults_MiterLimit;
 
     // Zero all bitfields, then set some non-zero defaults.
     fBitfieldsUInt           = 0;
@@ skipping 328 matching lines @@
                            void* context) {
     *((SkGlyphCache**)context) = SkGlyphCache::DetachCache(typeface, desc);
 }
 
 int SkPaint::textToGlyphs(const void* textData, size_t byteLength,
                           uint16_t glyphs[]) const {
     if (byteLength == 0) {
         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);
         case kUTF16_TextEncoding:
             return SkUTF16_CountUnichars((const uint16_t*)textData, SkToInt(byteLength >> 1));
         case kUTF32_TextEncoding:
             return SkToInt(byteLength >> 2);
         case kGlyphID_TextEncoding:
             return SkToInt(byteLength >> 1);
         default:
             SkDEBUGFAIL("unknown text encoding");
         }
         return 0;
     }
 
     // if we get here, we have a valid glyphs[] array, so time to fill it in
 
     // handle this encoding before the setup for the glyphcache
     if (this->getTextEncoding() == kGlyphID_TextEncoding) {
         // we want to ignore the low bit of byteLength
         memcpy(glyphs, textData, byteLength >> 1 << 1);
         return SkToInt(byteLength >> 1);
     }
 
-    SkAutoGlyphCache autoCache(*this, NULL, NULL);
+    SkAutoGlyphCache autoCache(*this, nullptr, nullptr);
     SkGlyphCache*    cache = autoCache.getCache();
 
     const char* text = (const char*)textData;
     const char* stop = text + byteLength;
     uint16_t*   gptr = glyphs;
 
     switch (this->getTextEncoding()) {
         case SkPaint::kUTF8_TextEncoding:
             while (text < stop) {
                 *gptr++ = cache->unicharToGlyph(SkUTF8_NextUnichar(&text));
@@ skipping 19 matching lines @@
             SkDEBUGFAIL("unknown text encoding");
     }
     return SkToInt(gptr - glyphs);
 }
 
 bool SkPaint::containsText(const void* textData, size_t byteLength) const {
     if (0 == byteLength) {
         return true;
     }
 
-    SkASSERT(textData != NULL);
+    SkASSERT(textData != nullptr);
 
     // handle this encoding before the setup for the glyphcache
     if (this->getTextEncoding() == kGlyphID_TextEncoding) {
         const uint16_t* glyphID = static_cast<const uint16_t*>(textData);
         size_t count = byteLength >> 1;
         for (size_t i = 0; i < count; i++) {
             if (0 == glyphID[i]) {
                 return false;
             }
         }
         return true;
     }
 
-    SkAutoGlyphCache autoCache(*this, NULL, NULL);
+    SkAutoGlyphCache autoCache(*this, nullptr, nullptr);
     SkGlyphCache*    cache = autoCache.getCache();
 
     switch (this->getTextEncoding()) {
         case SkPaint::kUTF8_TextEncoding: {
             const char* text = static_cast<const char*>(textData);
             const char* stop = text + byteLength;
             while (text < stop) {
                 if (0 == cache->unicharToGlyph(SkUTF8_NextUnichar(&text))) {
                     return false;
                 }
@@ skipping 25 matching lines @@
             return false;
     }
     return true;
 }
 
 void SkPaint::glyphsToUnichars(const uint16_t glyphs[], int count, SkUnichar textData[]) const {
     if (count <= 0) {
         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++) {
         textData[index] = cache->glyphToUnichar(glyphs[index]);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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++;
     *text = (const char*)ptr;
     return cache->getUnicharMetrics(uni);
 }
 
 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;
     ptr += 1;
     *text = (const char*)ptr;
     return cache->getGlyphIDMetrics(glyphID);
 }
 
 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++;
     *text = (const char*)ptr;
     return cache->getUnicharAdvance(uni);
 }
 
 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;
     ptr += 1;
     *text = (const char*)ptr;
     return cache->getGlyphIDAdvance(glyphID);
 }
 
 SkMeasureCacheProc SkPaint::getMeasureCacheProc(bool needFullMetrics) const {
     static const SkMeasureCacheProc gMeasureCacheProcs[] = {
@@ skipping 15 matching lines @@
     }
 
     SkASSERT(index < SK_ARRAY_COUNT(gMeasureCacheProcs));
     return gMeasureCacheProcs[index];
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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);
 }
 
 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++;
     *text = (const char*)ptr;
     return cache->getUnicharMetrics(uni);
 }
 
 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++;
     *text = (const char*)ptr;
     return cache->getUnicharMetrics(uni, x, y);
 }
 
 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;
     ptr += 1;
     *text = (const char*)ptr;
     return cache->getGlyphIDMetrics(glyphID);
 }
 
 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;
     ptr += 1;
     *text = (const char*)ptr;
     return cache->getGlyphIDMetrics(glyphID, x, y);
 }
 
 SkDrawCacheProc SkPaint::getDrawCacheProc() const {
     static const SkDrawCacheProc gDrawCacheProcs[] = {
@@ skipping 102 matching lines @@
                                int* count, SkRect* bounds) const {
     SkASSERT(count);
     if (byteLength == 0) {
         *count = 0;
         if (bounds) {
             bounds->setEmpty();
         }
         return 0;
     }
 
-    SkMeasureCacheProc glyphCacheProc = this->getMeasureCacheProc(NULL != bounds);
+    SkMeasureCacheProc glyphCacheProc = this->getMeasureCacheProc(nullptr != bounds);
 
     int xyIndex;
     JoinBoundsProc joinBoundsProc;
     if (this->isVerticalText()) {
         xyIndex = 1;
         joinBoundsProc = join_bounds_y;
     } else {
         xyIndex = 0;
         joinBoundsProc = join_bounds_x;
     }
 
     int         n = 1;
     const char* stop = (const char*)text + byteLength;
     const SkGlyph* g = &glyphCacheProc(cache, &text);
     // our accumulated fixed-point advances might overflow 16.16, so we use
     // a 48.16 (64bit) accumulator, and then convert that to scalar at the
     // very end.
     Sk48Dot16 x = advance(*g, xyIndex);
 
     SkAutoKern  autokern;
 
-    if (NULL == bounds) {
+    if (nullptr == bounds) {
         if (this->isDevKernText()) {
             int rsb;
             for (; text < stop; n++) {
                 rsb = g->fRsbDelta;
                 g = &glyphCacheProc(cache, &text);
                 x += SkAutoKern_AdjustF(rsb, g->fLsbDelta) + advance(*g, xyIndex);
             }
         } else {
             for (; text < stop; n++) {
                 x += advance(glyphCacheProc(cache, &text), xyIndex);
@@ skipping 19 matching lines @@
         }
     }
     SkASSERT(text == stop);
 
     *count = n;
     return Sk48Dot16ToScalar(x);
 }
 
 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;
 
     if (length > 0) {
         int tempCount;
 
         width = paint.measure_text(cache, text, length, &tempCount, bounds);
         if (scale) {
             width = SkScalarMul(width, scale);
@@ skipping 20 matching lines @@
         return 0;
     }
 
     if (0 == fTextSize) {
         if (measuredWidth) {
             *measuredWidth = 0;
         }
         return length;
     }
 
-    SkASSERT(textD != NULL);
+    SkASSERT(textD != nullptr);
     const char* text = (const char*)textD;
     const char* stop = text + length;
 
     SkCanonicalizePaint canon(*this);
     const SkPaint& paint = canon.getPaint();
     SkScalar scale = canon.getScale();
 
     // adjust max in case we changed the textSize in paint
     if (scale) {
         maxWidth /= scale;
     }
 
-    SkAutoGlyphCache    autoCache(paint, NULL, NULL);
+    SkAutoGlyphCache    autoCache(paint, nullptr, nullptr);
     SkGlyphCache*       cache = autoCache.getCache();
 
     SkMeasureCacheProc glyphCacheProc = paint.getMeasureCacheProc(false);
     const int        xyIndex = paint.isVerticalText() ? 1 : 0;
     // use 64bits for our accumulator, to avoid overflowing 16.16
     Sk48Dot16        max = SkScalarToFixed(maxWidth);
     Sk48Dot16        width = 0;
 
     SkAutoKern  autokern;
 
@@ skipping 44 matching lines @@
 static void FontMetricsDescProc(SkTypeface* typeface, const SkDescriptor* desc,
                                 void* context) {
     SkGlyphCache::VisitCache(typeface, desc, FontMetricsCacheProc, context);
 }
 
 SkScalar SkPaint::getFontMetrics(FontMetrics* metrics, SkScalar zoom) const {
     SkCanonicalizePaint canon(*this);
     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);
         metrics->fAscent = SkScalarMul(metrics->fAscent, scale);
         metrics->fDescent = SkScalarMul(metrics->fDescent, scale);
         metrics->fBottom = SkScalarMul(metrics->fBottom, scale);
         metrics->fLeading = SkScalarMul(metrics->fLeading, scale);
         metrics->fAvgCharWidth = SkScalarMul(metrics->fAvgCharWidth, scale);
         metrics->fXMin = SkScalarMul(metrics->fXMin, scale);
         metrics->fXMax = SkScalarMul(metrics->fXMax, scale);
@@ skipping 14 matching lines @@
 }
 
 int SkPaint::getTextWidths(const void* textData, size_t byteLength,
                            SkScalar widths[], SkRect bounds[]) const {
     if (0 == byteLength) {
         return 0;
     }
 
     SkASSERT(textData);
 
-    if (NULL == widths && NULL == bounds) {
+    if (nullptr == widths && nullptr == bounds) {
         return this->countText(textData, byteLength);
     }
 
     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();
     SkMeasureCacheProc  glyphCacheProc;
-    glyphCacheProc = paint.getMeasureCacheProc(NULL != bounds);
+    glyphCacheProc = paint.getMeasureCacheProc(nullptr != bounds);
 
     const char* text = (const char*)textData;
     const char* stop = text + byteLength;
     int         count = 0;
     const int   xyIndex = paint.isVerticalText() ? 1 : 0;
 
     if (this->isDevKernText()) {
         // we adjust the widths returned here through auto-kerning
         SkAutoKern  autokern;
         SkFixed     prevWidth = 0;
@@ skipping 68 matching lines @@
     SkASSERT(text == stop);
     return count;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkDraw.h"
 
 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;
     }
 
     SkTextToPathIter    iter(text, length, *this, false);
     SkMatrix            matrix;
     SkScalar            prevXPos = 0;
 
     matrix.setScale(iter.getPathScale(), iter.getPathScale());
     matrix.postTranslate(x, y);
     path->reset();
 
     SkScalar        xpos;
     const SkPath*   iterPath;
     while (iter.next(&iterPath, &xpos)) {
         matrix.postTranslate(xpos - prevXPos, 0);
         if (iterPath) {
             path->addPath(*iterPath, matrix);
         }
         prevXPos = xpos;
     }
 }
 
 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;
     }
 
     SkTextToPathIter    iter(text, length, *this, false);
     SkMatrix            matrix;
     SkPoint             prevPos;
     prevPos.set(0, 0);
 
     matrix.setScale(iter.getPathScale(), iter.getPathScale());
     path->reset();
 
     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);
         }
         prevPos = pos[i];
         i++;
     }
 }
 
 SkRect SkPaint::getFontBounds() const {
     SkMatrix m;
     m.setScale(fTextSize * fTextScaleX, fTextSize);
     m.postSkew(fTextSkewX, 0);
 
     SkTypeface* typeface = this->getTypeface();
-    if (NULL == typeface) {
+    if (nullptr == typeface) {
         typeface = SkTypeface::GetDefaultTypeface();
     }
 
     SkRect bounds;
     m.mapRect(&bounds, typeface->getBounds());
     return bounds;
 }
 
 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) {
     uint32_t flags = paint.getFlags();
 
     // Antialiasing being disabled trumps all other settings.
     if (!(flags & SkPaint::kAntiAlias_Flag)) {
         return SkMask::kBW_Format;
     }
 
@@ skipping 68 matching lines @@
  */
 static SkScalar sk_relax(SkScalar x) {
     int n = sk_float_round2int(x * 1024);
     return n / 1024.0f;
 }
 
 void SkScalerContext::MakeRec(const SkPaint& paint,
                               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();
     rec->fTextSize = paint.getTextSize();
     rec->fPreScaleX = paint.getTextScaleX();
     rec->fPreSkewX  = paint.getTextSkewX();
 
     bool checkPost2x2 = false;
 
     if (deviceMatrix) {
@@ skipping 145 matching lines @@
     // be sure to call PostMakeRec(rec) before you actually use it!
 }
 
 /**
  * In order to call cachedDeviceLuminance, cachedPaintLuminance, or
  * cachedMaskGamma the caller must hold the gMaskGammaCacheMutex and continue
  * to hold it until the returned pointer is refed or forgotten.
  */
 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;
 /**
  * The caller must hold the gMaskGammaCacheMutex and continue to hold it until
  * the returned SkMaskGamma pointer is refed or forgotten.
  */
 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;
     }
     if (gContrast != contrast || gPaintGamma != paintGamma || gDeviceGamma != deviceGamma) {
         SkSafeUnref(gMaskGamma);
         gMaskGamma = new SkMaskGamma(contrast, paintGamma, deviceGamma);
         gContrast = contrast;
         gPaintGamma = paintGamma;
         gDeviceGamma = deviceGamma;
     }
     return *gMaskGamma;
 }
 
 /*static*/ void SkPaint::Term() {
     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;)
 }
 
 /**
  *  We ensure that the rec is self-consistent and efficient (where possible)
  */
 void SkScalerContext::PostMakeRec(const SkPaint&, SkScalerContext::Rec* rec) {
     /**
@@ skipping 423 matching lines @@
 
     uint32_t tmp = *pod++;
     this->setStrokeCap(static_cast<Cap>((tmp >> 24) & 0xFF));
     this->setStrokeJoin(static_cast<Join>((tmp >> 16) & 0xFF));
     this->setStyle(static_cast<Style>((tmp >> 8) & 0xFF));
     this->setTextEncoding(static_cast<TextEncoding>((tmp >> 0) & 0xFF));
 
     if (flatFlags & kHasTypeface_FlatFlag) {
         this->setTypeface(buffer.readTypeface());
     } else {
-        this->setTypeface(NULL);
+        this->setTypeface(nullptr);
     }
 
     if (flatFlags & kHasEffects_FlatFlag) {
         SkSafeUnref(this->setPathEffect(buffer.readPathEffect()));
         SkSafeUnref(this->setShader(buffer.readShader()));
         SkSafeUnref(this->setXfermode(buffer.readXfermode()));
         SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter()));
         SkSafeUnref(this->setColorFilter(buffer.readColorFilter()));
         SkSafeUnref(this->setRasterizer(buffer.readRasterizer()));
         SkSafeUnref(this->setLooper(buffer.readDrawLooper()));
         SkSafeUnref(this->setImageFilter(buffer.readImageFilter()));
 
         if (buffer.readBool()) {
             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);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkShader* SkPaint::setShader(SkShader* shader) {
     SkRefCnt_SafeAssign(fShader, shader);
     return shader;
 }
 
@@ skipping 283 matching lines @@
             paint.getStyle() != SkPaint::kFill_Style;
 }
 
 SkTextToPathIter::SkTextToPathIter(const char text[], size_t length,
                                    const SkPaint& paint,
                                    bool applyStrokeAndPathEffects)
     : fPaint(paint) {
     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)) {
             fPaint.setStrokeWidth(fPaint.getStrokeWidth() / fScale);
         }
     } else {
         fScale = SK_Scalar1;
     }
 
     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
         pe = paint.getPathEffect();     // restore
     }
     fPaint.setStyle(style);
     fPaint.setPathEffect(pe);
     fPaint.setMaskFilter(paint.getMaskFilter());    // restore
 
     // now compute fXOffset if needed
 
     SkScalar xOffset = 0;
     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);
         }
         xOffset = -width;
     }
     fXPos = xOffset;
     fPrevAdvance = 0;
 
     fText = text;
     fStop = text + length;
@@ skipping 11 matching lines @@
 
         fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
         fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
 
         if (glyph.fWidth) {
             if (path) {
                 *path = fCache->findPath(glyph);
             }
         } else {
             if (path) {
-                *path = NULL;
+                *path = nullptr;
             }
         }
         if (xpos) {
             *xpos = fXPos;
         }
         return true;
     }
     return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // return true if the filter exists, and may affect alpha
 static bool affects_alpha(const SkColorFilter* cf) {
     return cf && !(cf->getFlags() & SkColorFilter::kAlphaUnchanged_Flag);
 }
 
 // return true if the filter exists, and may affect alpha
 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 {
     if (fLooper) {
         return false;
     }
     SkXfermode::Mode mode;
     if (SkXfermode::AsMode(fXfermode, &mode)) {
         switch (mode) {
             case SkXfermode::kSrcOver_Mode:
@@ skipping 15 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     static_assert(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
                   "SkPaint_notPackedTightly");
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }