Style Change: NULL->nullptr

src/ports/SkFontHost_FreeType.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 "SkAdvancedTypefaceMetrics.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 58 matching lines @@
     static void* sk_ft_alloc(FT_Memory, long size) {
         return sk_malloc_throw(size);
     }
     static void sk_ft_free(FT_Memory, void* block) {
         sk_free(block);
     }
     static void* sk_ft_realloc(FT_Memory, long cur_size, long new_size, void* block) {
         return sk_realloc_throw(block, new_size);
     }
 };
-FT_MemoryRec_ gFTMemory = { NULL, sk_ft_alloc, sk_ft_free, sk_ft_realloc };
+FT_MemoryRec_ gFTMemory = { nullptr, sk_ft_alloc, sk_ft_free, sk_ft_realloc };
 
 class FreeTypeLibrary : SkNoncopyable {
 public:
-    FreeTypeLibrary() : fLibrary(NULL), fIsLCDSupported(false), fLCDExtra(0) {
+    FreeTypeLibrary() : fLibrary(nullptr), fIsLCDSupported(false), fLCDExtra(0) {
         if (FT_New_Library(&gFTMemory, &fLibrary)) {
             return;
         }
         FT_Add_Default_Modules(fLibrary);
 
         // Setup LCD filtering. This reduces color fringes for LCD smoothed glyphs.
         // Default { 0x10, 0x40, 0x70, 0x40, 0x10 } adds up to 0x110, simulating ink spread.
         // SetLcdFilter must be called before SetLcdFilterWeights.
         if (FT_Library_SetLcdFilter(fLibrary, FT_LCD_FILTER_DEFAULT) == 0) {
             fIsLCDSupported = true;
             fLCDExtra = 2; //Using a filter adds one full pixel to each side.
 
 #ifdef SK_FONTHOST_FREETYPE_USE_NORMAL_LCD_FILTER
             // Adds to 0x110 simulating ink spread, but provides better results than default.
             static unsigned char gGaussianLikeHeavyWeights[] = { 0x1A, 0x43, 0x56, 0x43, 0x1A, };
 
 #    if SK_FONTHOST_FREETYPE_RUNTIME_VERSION > 0x020400
             FT_Library_SetLcdFilterWeights(fLibrary, gGaussianLikeHeavyWeights);
 #    elif SK_CAN_USE_DLOPEN == 1
             //The FreeType library is already loaded, so symbols are available in process.
-            void* self = dlopen(NULL, RTLD_LAZY);
+            void* self = dlopen(nullptr, RTLD_LAZY);
             if (self) {
                 FT_Library_SetLcdFilterWeightsProc setLcdFilterWeights;
                 //The following cast is non-standard, but safe for POSIX.
                 *reinterpret_cast<void**>(&setLcdFilterWeights) =
                         dlsym(self, "FT_Library_SetLcdFilterWeights");
                 dlclose(self);
 
                 if (setLcdFilterWeights) {
                     setLcdFilterWeights(fLibrary, gGaussianLikeHeavyWeights);
                 }
@@ skipping 35 matching lines @@
 
 // Private to RefFreeType and UnrefFreeType
 static int gFTCount;
 
 // Caller must lock gFTMutex before calling this function.
 static bool ref_ft_library() {
     gFTMutex.assertHeld();
     SkASSERT(gFTCount >= 0);
 
     if (0 == gFTCount) {
-        SkASSERT(NULL == gFTLibrary);
+        SkASSERT(nullptr == gFTLibrary);
         gFTLibrary = new FreeTypeLibrary;
     }
     ++gFTCount;
     return gFTLibrary->library();
 }
 
 // Caller must lock gFTMutex before calling this function.
 static void unref_ft_library() {
     gFTMutex.assertHeld();
     SkASSERT(gFTCount > 0);
 
     --gFTCount;
     if (0 == gFTCount) {
-        SkASSERT(NULL != gFTLibrary);
+        SkASSERT(nullptr != gFTLibrary);
         delete gFTLibrary;
-        SkDEBUGCODE(gFTLibrary = NULL;)
+        SkDEBUGCODE(gFTLibrary = nullptr;)
     }
 }
 
 class SkScalerContext_FreeType : public SkScalerContext_FreeType_Base {
 public:
     SkScalerContext_FreeType(SkTypeface*, const SkDescriptor* desc);
     virtual ~SkScalerContext_FreeType();
 
     bool success() const {
-        return fFTSize != NULL && fFace != NULL;
+        return fFTSize != nullptr && fFace != nullptr;
     }
 
 protected:
     unsigned generateGlyphCount() override;
     uint16_t generateCharToGlyph(SkUnichar uni) override;
     void generateAdvance(SkGlyph* glyph) override;
     void generateMetrics(SkGlyph* glyph) override;
     void generateImage(const SkGlyph& glyph) override;
     void generatePath(const SkGlyph& glyph, SkPath* path) override;
     void generateFontMetrics(SkPaint::FontMetrics*) override;
@@ skipping 53 matching lines @@
             }
             count = stream->read(buffer, count);
         }
         return count;
     }
 
     static void sk_ft_stream_close(FT_Stream) {}
 }
 
 SkFaceRec::SkFaceRec(SkStreamAsset* stream, uint32_t fontID)
-        : fNext(NULL), fSkStream(stream), fRefCnt(1), fFontID(fontID)
+        : fNext(nullptr), fSkStream(stream), fRefCnt(1), fFontID(fontID)
 {
     sk_bzero(&fFTStream, sizeof(fFTStream));
     fFTStream.size = fSkStream->getLength();
     fFTStream.descriptor.pointer = fSkStream;
     fFTStream.read  = sk_ft_stream_io;
     fFTStream.close = sk_ft_stream_close;
 }
 
 static void ft_face_setup_axes(FT_Face face, const SkFontData& data) {
     if (!(face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS)) {
         return;
     }
 
     SkDEBUGCODE(
-        FT_MM_Var* variations = NULL;
+        FT_MM_Var* variations = nullptr;
         if (FT_Get_MM_Var(face, &variations)) {
             SkDEBUGF(("INFO: font %s claims variations, but none found.\n", face->family_name));
             return;
         }
         SkAutoFree autoFreeVariations(variations);
 
         if (static_cast<FT_UInt>(data.getAxisCount()) != variations->num_axis) {
             SkDEBUGF(("INFO: font %s has %d variations, but %d were specified.\n",
                     face->family_name, variations->num_axis, data.getAxisCount()));
             return;
@@ skipping 21 matching lines @@
     while (rec) {
         if (rec->fFontID == fontID) {
             SkASSERT(rec->fFace);
             rec->fRefCnt += 1;
             return rec->fFace;
         }
         rec = rec->fNext;
     }
 
     SkAutoTDelete<SkFontData> data(typeface->createFontData());
-    if (NULL == data || !data->hasStream()) {
-        return NULL;
+    if (nullptr == data || !data->hasStream()) {
+        return nullptr;
     }
 
     // this passes ownership of stream to the rec
     rec = new SkFaceRec(data->detachStream(), fontID);
 
     FT_Open_Args args;
     memset(&args, 0, sizeof(args));
     const void* memoryBase = rec->fSkStream->getMemoryBase();
     if (memoryBase) {
         args.flags = FT_OPEN_MEMORY;
         args.memory_base = (const FT_Byte*)memoryBase;
         args.memory_size = rec->fSkStream->getLength();
     } else {
         args.flags = FT_OPEN_STREAM;
         args.stream = &rec->fFTStream;
     }
 
     FT_Error err = FT_Open_Face(gFTLibrary->library(), &args, data->getIndex(), &rec->fFace);
     if (err) {
         SkDEBUGF(("ERROR: unable to open font '%x'\n", fontID));
         delete rec;
-        return NULL;
+        return nullptr;
     }
     SkASSERT(rec->fFace);
 
     ft_face_setup_axes(rec->fFace, *data);
 
     // FreeType will set the charmap to the "most unicode" cmap if it exists.
-    // If there are no unicode cmaps, the charmap is set to NULL.
+    // If there are no unicode cmaps, the charmap is set to nullptr.
     // However, "symbol" cmaps should also be considered "fallback unicode" cmaps
     // because they are effectively private use area only (even if they aren't).
     // This is the last on the fallback list at
     // https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6cmap.html
     if (!rec->fFace->charmap) {
         FT_Select_Charmap(rec->fFace, FT_ENCODING_MS_SYMBOL);
     }
 
     rec->fNext = gFaceRecHead;
     gFaceRecHead = rec;
     return rec->fFace;
 }
 
 // Caller must lock gFTMutex before calling this function.
 static void unref_ft_face(FT_Face face) {
     gFTMutex.assertHeld();
 
     SkFaceRec*  rec = gFaceRecHead;
-    SkFaceRec*  prev = NULL;
+    SkFaceRec*  prev = nullptr;
     while (rec) {
         SkFaceRec* next = rec->fNext;
         if (rec->fFace == face) {
             if (--rec->fRefCnt == 0) {
                 if (prev) {
                     prev->fNext = next;
                 } else {
                     gFaceRecHead = next;
                 }
                 FT_Done_Face(face);
                 delete rec;
             }
             return;
         }
         prev = rec;
         rec = next;
     }
     SkDEBUGFAIL("shouldn't get here, face not in list");
 }
 
 class AutoFTAccess {
 public:
-    AutoFTAccess(const SkTypeface* tf) : fFace(NULL) {
+    AutoFTAccess(const SkTypeface* tf) : fFace(nullptr) {
         gFTMutex.acquire();
         if (!ref_ft_library()) {
             sk_throw();
         }
         fFace = ref_ft_face(tf);
     }
 
     ~AutoFTAccess() {
         if (fFace) {
             unref_ft_face(fFace);
@@ skipping 51 matching lines @@
         (*glyphToUnicode)[glyphIndex] = charCode;
         charCode = FT_Get_Next_Char(face, charCode, &glyphIndex);
     }
 }
 
 SkAdvancedTypefaceMetrics* SkTypeface_FreeType::onGetAdvancedTypefaceMetrics(
         PerGlyphInfo perGlyphInfo,
         const uint32_t* glyphIDs,
         uint32_t glyphIDsCount) const {
 #if defined(SK_BUILD_FOR_MAC)
-    return NULL;
+    return nullptr;
 #else
     AutoFTAccess fta(this);
     FT_Face face = fta.face();
     if (!face) {
-        return NULL;
+        return nullptr;
     }
 
     SkAdvancedTypefaceMetrics* info = new SkAdvancedTypefaceMetrics;
     info->fFontName.set(FT_Get_Postscript_Name(face));
     info->fFlags = SkAdvancedTypefaceMetrics::kEmpty_FontFlag;
     if (FT_HAS_MULTIPLE_MASTERS(face)) {
         info->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
                 info->fFlags, SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag);
     }
     if (!canEmbed(face)) {
@@ skipping 16 matching lines @@
     } else if (strcmp(fontType, "CID Type 1") == 0) {
         info->fType = SkAdvancedTypefaceMetrics::kType1CID_Font;
         cid = true;
     } else if (strcmp(fontType, "CFF") == 0) {
         info->fType = SkAdvancedTypefaceMetrics::kCFF_Font;
     } else if (strcmp(fontType, "TrueType") == 0) {
         info->fType = SkAdvancedTypefaceMetrics::kTrueType_Font;
         cid = true;
         TT_Header* ttHeader;
         if ((ttHeader = (TT_Header*)FT_Get_Sfnt_Table(face,
-                                                      ft_sfnt_head)) != NULL) {
+                                                      ft_sfnt_head)) != nullptr) {
             info->fEmSize = ttHeader->Units_Per_EM;
         }
     } else {
         info->fType = SkAdvancedTypefaceMetrics::kOther_Font;
     }
 
     info->fStyle = 0;
     if (FT_IS_FIXED_WIDTH(face))
         info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style;
     if (face->style_flags & FT_STYLE_FLAG_ITALIC)
         info->fStyle |= SkAdvancedTypefaceMetrics::kItalic_Style;
 
     PS_FontInfoRec ps_info;
     TT_Postscript* tt_info;
     if (FT_Get_PS_Font_Info(face, &ps_info) == 0) {
         info->fItalicAngle = ps_info.italic_angle;
     } else if ((tt_info =
                 (TT_Postscript*)FT_Get_Sfnt_Table(face,
-                                                  ft_sfnt_post)) != NULL) {
+                                                  ft_sfnt_post)) != nullptr) {
         info->fItalicAngle = SkFixedToScalar(tt_info->italicAngle);
     } else {
         info->fItalicAngle = 0;
     }
 
     info->fAscent = face->ascender;
     info->fDescent = face->descender;
 
     // Figure out a good guess for StemV - Min width of i, I, !, 1.
     // This probably isn't very good with an italic font.
     int16_t min_width = SHRT_MAX;
     info->fStemV = 0;
     char stem_chars[] = {'i', 'I', '!', '1'};
     for (size_t i = 0; i < SK_ARRAY_COUNT(stem_chars); i++) {
         FT_BBox bbox;
         if (GetLetterCBox(face, stem_chars[i], &bbox)) {
             int16_t width = bbox.xMax - bbox.xMin;
             if (width > 0 && width < min_width) {
                 min_width = width;
                 info->fStemV = min_width;
             }
         }
     }
 
     TT_PCLT* pclt_info;
     TT_OS2* os2_table;
-    if ((pclt_info = (TT_PCLT*)FT_Get_Sfnt_Table(face, ft_sfnt_pclt)) != NULL) {
+    if ((pclt_info = (TT_PCLT*)FT_Get_Sfnt_Table(face, ft_sfnt_pclt)) != nullptr) {
         info->fCapHeight = pclt_info->CapHeight;
         uint8_t serif_style = pclt_info->SerifStyle & 0x3F;
         if (serif_style >= 2 && serif_style <= 6)
             info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style;
         else if (serif_style >= 9 && serif_style <= 12)
             info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style;
-    } else if (((os2_table = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2)) != NULL) &&
+    } else if (((os2_table = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2)) != nullptr) &&
                // sCapHeight is available only when version 2 or later.
                os2_table->version != 0xFFFF &&
                os2_table->version >= 2) {
         info->fCapHeight = os2_table->sCapHeight;
     } else {
         // Figure out a good guess for CapHeight: average the height of M and X.
         FT_BBox m_bbox, x_bbox;
         bool got_m, got_x;
         got_m = GetLetterCBox(face, 'M', &m_bbox);
         got_x = GetLetterCBox(face, 'X', &x_bbox);
@@ skipping 92 matching lines @@
            (bothZero(rec.fPost2x2[0][1], rec.fPost2x2[1][0]) ||
             bothZero(rec.fPost2x2[0][0], rec.fPost2x2[1][1]));
 }
 
 SkScalerContext* SkTypeface_FreeType::onCreateScalerContext(
                                                const SkDescriptor* desc) const {
     SkScalerContext_FreeType* c =
             new SkScalerContext_FreeType(const_cast<SkTypeface_FreeType*>(this), desc);
     if (!c->success()) {
         delete c;
-        c = NULL;
+        c = nullptr;
     }
     return c;
 }
 
 void SkTypeface_FreeType::onFilterRec(SkScalerContextRec* rec) const {
     //BOGUS: http://code.google.com/p/chromium/issues/detail?id=121119
     //Cap the requested size as larger sizes give bogus values.
     //Remove when http://code.google.com/p/skia/issues/detail?id=554 is fixed.
     if (rec->fTextSize > SkIntToScalar(1 << 14)) {
         rec->fTextSize = SkIntToScalar(1 << 14);
@@ skipping 55 matching lines @@
         if (err) {
             return false;
         }
         adjustments[i] = delta.x;
     }
     return true;
 }
 
 static FT_Int chooseBitmapStrike(FT_Face face, SkFixed scaleY) {
     // early out if face is bad
-    if (face == NULL) {
-        SkDEBUGF(("chooseBitmapStrike aborted due to NULL face\n"));
+    if (face == nullptr) {
+        SkDEBUGF(("chooseBitmapStrike aborted due to nullptr face\n"));
         return -1;
     }
     // determine target ppem
     FT_Pos targetPPEM = SkFixedToFDot6(scaleY);
     // find a bitmap strike equal to or just larger than the requested size
     FT_Int chosenStrikeIndex = -1;
     FT_Pos chosenPPEM = 0;
     for (FT_Int strikeIndex = 0; strikeIndex < face->num_fixed_sizes; ++strikeIndex) {
         FT_Pos thisPPEM = face->available_sizes[strikeIndex].y_ppem;
         if (thisPPEM == targetPPEM) {
@@ skipping 31 matching lines @@
     : SkScalerContext_FreeType_Base(typeface, desc)
 {
     SkAutoMutexAcquire  ac(gFTMutex);
 
     if (!ref_ft_library()) {
         sk_throw();
     }
 
     // load the font file
     fStrikeIndex = -1;
-    fFTSize = NULL;
+    fFTSize = nullptr;
     fFace = ref_ft_face(typeface);
-    if (NULL == fFace) {
+    if (nullptr == fFace) {
         return;
     }
 
     fRec.computeMatrices(SkScalerContextRec::kFull_PreMatrixScale, &fScale, &fMatrix22Scalar);
     fMatrix22Scalar.setSkewX(-fMatrix22Scalar.getSkewX());
     fMatrix22Scalar.setSkewY(-fMatrix22Scalar.getSkewY());
 
     fScaleX = SkScalarToFixed(fScale.fX);
     fScaleY = SkScalarToFixed(fScale.fY);
     fMatrix22.xx = SkScalarToFixed(fMatrix22Scalar.getScaleX());
@@ skipping 68 matching lines @@
         }
 
         loadFlags |= FT_LOAD_COLOR;
 
         fLoadGlyphFlags = loadFlags;
     }
 
     FT_Error err = FT_New_Size(fFace, &fFTSize);
     if (err != 0) {
         SkDEBUGF(("FT_New_Size returned %x for face %s\n", err, fFace->family_name));
-        fFace = NULL;
+        fFace = nullptr;
         return;
     }
     err = FT_Activate_Size(fFTSize);
     if (err != 0) {
         SkDEBUGF(("FT_Activate_Size(%08x, 0x%x, 0x%x) returned 0x%x\n", fFace, fScaleX, fScaleY,
                   err));
-        fFTSize = NULL;
+        fFTSize = nullptr;
         return;
     }
 
     if (FT_IS_SCALABLE(fFace)) {
         err = FT_Set_Char_Size(fFace, SkFixedToFDot6(fScaleX), SkFixedToFDot6(fScaleY), 72, 72);
         if (err != 0) {
             SkDEBUGF(("FT_Set_CharSize(%08x, 0x%x, 0x%x) returned 0x%x\n",
                                     fFace, fScaleX, fScaleY,      err));
-            fFace = NULL;
+            fFace = nullptr;
             return;
         }
-        FT_Set_Transform(fFace, &fMatrix22, NULL);
+        FT_Set_Transform(fFace, &fMatrix22, nullptr);
     } else if (FT_HAS_FIXED_SIZES(fFace)) {
         fStrikeIndex = chooseBitmapStrike(fFace, fScaleY);
         if (fStrikeIndex == -1) {
             SkDEBUGF(("no glyphs for font \"%s\" size %f?\n",
                             fFace->family_name,       SkFixedToScalar(fScaleY)));
         } else {
             // FreeType does no provide linear metrics for bitmap fonts.
             linearMetrics = false;
 
             // FreeType documentation says:
             // FT_LOAD_NO_BITMAP -- Ignore bitmap strikes when loading.
             // Bitmap-only fonts ignore this flag.
             //
             // However, in FreeType 2.5.1 color bitmap only fonts do not ignore this flag.
             // Force this flag off for bitmap only fonts.
             fLoadGlyphFlags &= ~FT_LOAD_NO_BITMAP;
         }
     } else {
         SkDEBUGF(("unknown kind of font \"%s\" size %f?\n",
                             fFace->family_name,       SkFixedToScalar(fScaleY)));
     }
 
     fDoLinearMetrics = linearMetrics;
 }
 
 SkScalerContext_FreeType::~SkScalerContext_FreeType() {
     SkAutoMutexAcquire  ac(gFTMutex);
 
-    if (fFTSize != NULL) {
+    if (fFTSize != nullptr) {
         FT_Done_Size(fFTSize);
     }
 
-    if (fFace != NULL) {
+    if (fFace != nullptr) {
         unref_ft_face(fFace);
     }
 
     unref_ft_library();
 }
 
 /*  We call this before each use of the fFace, since we may be sharing
     this face with other context (at different sizes).
 */
 FT_Error SkScalerContext_FreeType::setupSize() {
     FT_Error err = FT_Activate_Size(fFTSize);
     if (err != 0) {
         SkDEBUGF(("SkScalerContext_FreeType::FT_Activate_Size(%s %s, 0x%x, 0x%x) returned 0x%x\n",
                   fFace->family_name, fFace->style_name, fScaleX, fScaleY, err));
-        fFTSize = NULL;
+        fFTSize = nullptr;
         return err;
     }
 
     // seems we need to reset this every time (not sure why, but without it
     // I get random italics from some other fFTSize)
-    FT_Set_Transform(fFace, &fMatrix22, NULL);
+    FT_Set_Transform(fFace, &fMatrix22, nullptr);
     return 0;
 }
 
 unsigned SkScalerContext_FreeType::generateGlyphCount() {
     return fFace->num_glyphs;
 }
 
 uint16_t SkScalerContext_FreeType::generateCharToGlyph(SkUnichar uni) {
     return SkToU16(FT_Get_Char_Index( fFace, uni ));
 }
@@ skipping 278 matching lines @@
     if (fRec.fFlags & SkScalerContext::kVertical_Flag) {
         FT_Vector vector;
         vector.x = fFace->glyph->metrics.vertBearingX - fFace->glyph->metrics.horiBearingX;
         vector.y = -fFace->glyph->metrics.vertBearingY - fFace->glyph->metrics.horiBearingY;
         FT_Vector_Transform(&vector, &fMatrix22);
         path->offset(SkFDot6ToScalar(vector.x), -SkFDot6ToScalar(vector.y));
     }
 }
 
 void SkScalerContext_FreeType::generateFontMetrics(SkPaint::FontMetrics* metrics) {
-    if (NULL == metrics) {
+    if (nullptr == metrics) {
         return;
     }
 
     SkAutoMutexAcquire ac(gFTMutex);
 
     if (this->setupSize()) {
         ERROR:
         sk_bzero(metrics, sizeof(*metrics));
         return;
     }
@@ skipping 194 matching lines @@
     FT_Face face = fta.face();
     if (!face) {
         if (glyphs) {
             sk_bzero(glyphs, glyphCount * sizeof(glyphs[0]));
         }
         return 0;
     }
 
     EncodingProc next_uni_proc = find_encoding_proc(encoding);
 
-    if (NULL == glyphs) {
+    if (nullptr == glyphs) {
         for (int i = 0; i < glyphCount; ++i) {
             if (0 == FT_Get_Char_Index(face, next_uni_proc(&chars))) {
                 return i;
             }
         }
         return glyphCount;
     } else {
         int first = glyphCount;
         for (int i = 0; i < glyphCount; ++i) {
             unsigned id = FT_Get_Char_Index(face, next_uni_proc(&chars));
@@ skipping 13 matching lines @@
         FT_Face face = fta.face();
         // if the face failed, we still assign a non-negative value
         fGlyphCount = face ? face->num_glyphs : 0;
     }
     return fGlyphCount;
 }
 
 SkTypeface::LocalizedStrings* SkTypeface_FreeType::onCreateFamilyNameIterator() const {
     SkTypeface::LocalizedStrings* nameIter =
         SkOTUtils::LocalizedStrings_NameTable::CreateForFamilyNames(*this);
-    if (NULL == nameIter) {
+    if (nullptr == nameIter) {
         SkString familyName;
         this->getFamilyName(&familyName);
         SkString language("und"); //undetermined
         nameIter = new SkOTUtils::LocalizedStrings_SingleName(familyName, language);
     }
     return nameIter;
 }
 
 int SkTypeface_FreeType::onGetTableTags(SkFontTableTag tags[]) const {
     AutoFTAccess fta(this);
     FT_Face face = fta.face();
 
     FT_ULong tableCount = 0;
     FT_Error error;
 
-    // When 'tag' is NULL, returns number of tables in 'length'.
-    error = FT_Sfnt_Table_Info(face, 0, NULL, &tableCount);
+    // When 'tag' is nullptr, returns number of tables in 'length'.
+    error = FT_Sfnt_Table_Info(face, 0, nullptr, &tableCount);
     if (error) {
         return 0;
     }
 
     if (tags) {
         for (FT_ULong tableIndex = 0; tableIndex < tableCount; ++tableIndex) {
             FT_ULong tableTag;
             FT_ULong tablelength;
             error = FT_Sfnt_Table_Info(face, tableIndex, &tableTag, &tablelength);
             if (error) {
                 return 0;
             }
             tags[tableIndex] = static_cast<SkFontTableTag>(tableTag);
         }
     }
     return tableCount;
 }
 
 size_t SkTypeface_FreeType::onGetTableData(SkFontTableTag tag, size_t offset,
                                            size_t length, void* data) const
 {
     AutoFTAccess fta(this);
     FT_Face face = fta.face();
 
     FT_ULong tableLength = 0;
     FT_Error error;
 
     // When 'length' is 0 it is overwritten with the full table length; 'offset' is ignored.
-    error = FT_Load_Sfnt_Table(face, tag, 0, NULL, &tableLength);
+    error = FT_Load_Sfnt_Table(face, tag, 0, nullptr, &tableLength);
     if (error) {
         return 0;
     }
 
     if (offset > tableLength) {
         return 0;
     }
     FT_ULong size = SkTMin((FT_ULong)length, tableLength - (FT_ULong)offset);
     if (data) {
         error = FT_Load_Sfnt_Table(face, tag, offset, reinterpret_cast<FT_Byte*>(data), &size);
         if (error) {
             return 0;
         }
     }
 
     return size;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-SkTypeface_FreeType::Scanner::Scanner() : fLibrary(NULL) {
+SkTypeface_FreeType::Scanner::Scanner() : fLibrary(nullptr) {
     if (FT_New_Library(&gFTMemory, &fLibrary)) {
         return;
     }
     FT_Add_Default_Modules(fLibrary);
 }
 SkTypeface_FreeType::Scanner::~Scanner() {
     if (fLibrary) {
         FT_Done_Library(fLibrary);
     }
 }
 
 FT_Face SkTypeface_FreeType::Scanner::openFace(SkStream* stream, int ttcIndex,
                                                FT_Stream ftStream) const
 {
-    if (fLibrary == NULL) {
-        return NULL;
+    if (fLibrary == nullptr) {
+        return nullptr;
     }
 
     FT_Open_Args args;
     memset(&args, 0, sizeof(args));
 
     const void* memoryBase = stream->getMemoryBase();
 
     if (memoryBase) {
         args.flags = FT_OPEN_MEMORY;
         args.memory_base = (const FT_Byte*)memoryBase;
         args.memory_size = stream->getLength();
     } else {
         memset(ftStream, 0, sizeof(*ftStream));
         ftStream->size = stream->getLength();
         ftStream->descriptor.pointer = stream;
         ftStream->read  = sk_ft_stream_io;
         ftStream->close = sk_ft_stream_close;
 
         args.flags = FT_OPEN_STREAM;
         args.stream = ftStream;
     }
 
     FT_Face face;
     if (FT_Open_Face(fLibrary, &args, ttcIndex, &face)) {
-        return NULL;
+        return nullptr;
     }
     return face;
 }
 
 bool SkTypeface_FreeType::Scanner::recognizedFont(SkStream* stream, int* numFaces) const {
     SkAutoMutexAcquire libraryLock(fLibraryMutex);
 
     FT_StreamRec streamRec;
     FT_Face face = this->openFace(stream, -1, &streamRec);
-    if (NULL == face) {
+    if (nullptr == face) {
         return false;
     }
 
     *numFaces = face->num_faces;
 
     FT_Done_Face(face);
     return true;
 }
 
 #include "SkTSearch.h"
 bool SkTypeface_FreeType::Scanner::scanFont(
     SkStream* stream, int ttcIndex,
     SkString* name, SkFontStyle* style, bool* isFixedPitch, AxisDefinitions* axes) const
 {
     SkAutoMutexAcquire libraryLock(fLibraryMutex);
 
     FT_StreamRec streamRec;
     FT_Face face = this->openFace(stream, ttcIndex, &streamRec);
-    if (NULL == face) {
+    if (nullptr == face) {
         return false;
     }
 
     int weight = SkFontStyle::kNormal_Weight;
     int width = SkFontStyle::kNormal_Width;
     SkFontStyle::Slant slant = SkFontStyle::kUpright_Slant;
     if (face->style_flags & FT_STYLE_FLAG_BOLD) {
         weight = SkFontStyle::kBold_Weight;
     }
     if (face->style_flags & FT_STYLE_FLAG_ITALIC) {
@@ skipping 50 matching lines @@
         name->set(face->family_name);
     }
     if (style) {
         *style = SkFontStyle(weight, width, slant);
     }
     if (isFixedPitch) {
         *isFixedPitch = FT_IS_FIXED_WIDTH(face);
     }
 
     if (axes && face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
-        FT_MM_Var* variations = NULL;
+        FT_MM_Var* variations = nullptr;
         FT_Error err = FT_Get_MM_Var(face, &variations);
         if (err) {
             SkDEBUGF(("INFO: font %s claims to have variations, but none found.\n",
                       face->family_name));
             return false;
         }
         SkAutoFree autoFreeVariations(variations);
 
         axes->reset(variations->num_axis);
         for (FT_UInt i = 0; i < variations->num_axis; ++i) {
             const FT_Var_Axis& ftAxis = variations->axis[i];
             (*axes)[i].fTag = ftAxis.tag;
             (*axes)[i].fMinimum = ftAxis.minimum;
             (*axes)[i].fDefault = ftAxis.def;
             (*axes)[i].fMaximum = ftAxis.maximum;
         }
     }
 
     FT_Done_Face(face);
     return true;
 }