Style Change: NULL->nullptr

src/ports/SkFontMgr_fontconfig.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDataTable.h"
 #include "SkFixed.h"
 #include "SkFontDescriptor.h"
@@ skipping 95 matching lines @@
 
 template<typename T, void (*D)(T*)> void FcTDestroy(T* t) {
     FCLocker::AssertHeld();
     D(t);
 }
 template <typename T, T* (*C)(), void (*D)(T*)> class SkAutoFc
     : public SkAutoTCallVProc<T, FcTDestroy<T, D> > {
 public:
     SkAutoFc() : SkAutoTCallVProc<T, FcTDestroy<T, D> >(C()) {
         T* obj = this->operator T*();
-        SK_ALWAYSBREAK(NULL != obj);
+        SK_ALWAYSBREAK(nullptr != obj);
     }
     explicit SkAutoFc(T* obj) : SkAutoTCallVProc<T, FcTDestroy<T, D> >(obj) {}
 };
 
 typedef SkAutoFc<FcCharSet, FcCharSetCreate, FcCharSetDestroy> SkAutoFcCharSet;
 typedef SkAutoFc<FcConfig, FcConfigCreate, FcConfigDestroy> SkAutoFcConfig;
 typedef SkAutoFc<FcFontSet, FcFontSetCreate, FcFontSetDestroy> SkAutoFcFontSet;
 typedef SkAutoFc<FcLangSet, FcLangSetCreate, FcLangSetDestroy> SkAutoFcLangSet;
 typedef SkAutoFc<FcObjectSet, FcObjectSetCreate, FcObjectSetDestroy> SkAutoFcObjectSet;
 typedef SkAutoFc<FcPattern, FcPatternCreate, FcPatternDestroy> SkAutoFcPattern;
@@ skipping 28 matching lines @@
  *  A element with the weak bit is scored after FC_LANG, without the weak bit is scored before.
  *  Note that the weak bit is stored on the element, not on the value it holds.
  */
 static SkWeakReturn is_weak(FcPattern* pattern, const char object[], int id) {
     FCLocker::AssertHeld();
 
     FcResult result;
 
     // Create a copy of the pattern with only the value 'pattern'['object'['id']] in it.
     // Internally, FontConfig pattern objects are linked lists, so faster to remove from head.
-    SkAutoFcObjectSet requestedObjectOnly(FcObjectSetBuild(object, NULL));
+    SkAutoFcObjectSet requestedObjectOnly(FcObjectSetBuild(object, nullptr));
     SkAutoFcPattern minimal(FcPatternFilter(pattern, requestedObjectOnly));
     FcBool hasId = true;
     for (int i = 0; hasId && i < id; ++i) {
         hasId = FcPatternRemove(minimal, object, 0);
     }
     if (!hasId) {
         return kNoId_WeakReturn;
     }
     FcValue value;
     result = FcPatternGet(minimal, object, 0, &value);
@@ skipping 43 matching lines @@
                         ? kIsWeak_WeakReturn : kIsStrong_WeakReturn;
 }
 
 /** Removes weak elements from either FC_FAMILY or FC_POSTSCRIPT_NAME objects in the property.
  *  This can be quite expensive, and should not be used more than once per font lookup.
  *  This removes all of the weak elements after the last strong element.
  */
 static void remove_weak(FcPattern* pattern, const char object[]) {
     FCLocker::AssertHeld();
 
-    SkAutoFcObjectSet requestedObjectOnly(FcObjectSetBuild(object, NULL));
+    SkAutoFcObjectSet requestedObjectOnly(FcObjectSetBuild(object, nullptr));
     SkAutoFcPattern minimal(FcPatternFilter(pattern, requestedObjectOnly));
 
     int lastStrongId = -1;
     int numIds;
     SkWeakReturn result;
     for (int id = 0; ; ++id) {
         result = is_weak(minimal, object, 0);
         if (kNoId_WeakReturn == result) {
             numIds = id;
             break;
@@ skipping 265 matching lines @@
             SkAutoFcPattern pattern;
             fcpattern_from_skfontstyle(style, pattern);
             FcConfigSubstitute(fFontMgr->fFC, pattern, FcMatchPattern);
             FcDefaultSubstitute(pattern);
 
             FcResult result;
             FcFontSet* fontSets[1] = { fFontSet };
             SkAutoFcPattern match(FcFontSetMatch(fFontMgr->fFC,
                                                  fontSets, SK_ARRAY_COUNT(fontSets),
                                                  pattern, &result));
-            if (NULL == match) {
-                return NULL;
+            if (nullptr == match) {
+                return nullptr;
             }
 
             return fFontMgr->createTypefaceFromFcPattern(match);
         }
 
     private:
         SkAutoTUnref<const SkFontMgr_fontconfig> fFontMgr;
         SkAutoFcFontSet fFontSet;
     };
 
@@ skipping 10 matching lines @@
     static SkDataTable* GetFamilyNames(FcConfig* fcconfig) {
         FCLocker lock;
 
         SkTDArray<const char*> names;
         SkTDArray<size_t> sizes;
 
         static const FcSetName fcNameSet[] = { FcSetSystem, FcSetApplication };
         for (int setIndex = 0; setIndex < (int)SK_ARRAY_COUNT(fcNameSet); ++setIndex) {
             // Return value of FcConfigGetFonts must not be destroyed.
             FcFontSet* allFonts(FcConfigGetFonts(fcconfig, fcNameSet[setIndex]));
-            if (NULL == allFonts) {
+            if (nullptr == allFonts) {
                 continue;
             }
 
             for (int fontIndex = 0; fontIndex < allFonts->nfont; ++fontIndex) {
                 FcPattern* current = allFonts->fonts[fontIndex];
                 for (int id = 0; ; ++id) {
                     FcChar8* fcFamilyName;
                     FcResult result = FcPatternGetString(current, FC_FAMILY, id, &fcFamilyName);
                     if (FcResultNoId == result) {
                         break;
@@ skipping 22 matching lines @@
 
     mutable SkMutex fTFCacheMutex;
     mutable SkTypefaceCache fTFCache;
     /** Creates a typeface using a typeface cache.
      *  @param pattern a complete pattern from FcFontRenderPrepare.
      */
     SkTypeface* createTypefaceFromFcPattern(FcPattern* pattern) const {
         FCLocker::AssertHeld();
         SkAutoMutexAcquire ama(fTFCacheMutex);
         SkTypeface* face = fTFCache.findByProcAndRef(FindByFcPattern, pattern);
-        if (NULL == face) {
+        if (nullptr == face) {
             FcPatternReference(pattern);
             face = SkTypeface_fontconfig::Create(pattern);
             if (face) {
                 fTFCache.add(face, SkFontStyle());
             }
         }
         return face;
     }
 
 public:
@@ skipping 50 matching lines @@
                 if (0 == FcStrCmpIgnoreCase(patternString, fontString)) {
                     return true;
                 }
             }
         }
         return false;
     }
 
     static bool FontAccessible(FcPattern* font) {
         // FontConfig can return fonts which are unreadable.
-        const char* filename = get_string(font, FC_FILE, NULL);
-        if (NULL == filename) {
+        const char* filename = get_string(font, FC_FILE, nullptr);
+        if (nullptr == filename) {
             return false;
         }
         return sk_exists(filename, kRead_SkFILE_Flag);
     }
 
     static bool FontFamilyNameMatches(FcPattern* font, FcPattern* pattern) {
         return AnyMatching(font, pattern, FC_FAMILY);
     }
 
     static bool FontContainsCharacter(FcPattern* font, uint32_t character) {
@@ skipping 16 matching lines @@
 
     SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
         FCLocker lock;
 
         SkAutoFcPattern pattern;
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
         FcConfigSubstitute(fFC, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
 
         FcPattern* matchPattern;
-        SkAutoFcPattern strongPattern(NULL);
+        SkAutoFcPattern strongPattern(nullptr);
         if (familyName) {
             strongPattern.reset(FcPatternDuplicate(pattern));
             remove_weak(strongPattern, FC_FAMILY);
             matchPattern = strongPattern;
         } else {
             matchPattern = pattern;
         }
 
         SkAutoFcFontSet matches;
         // TODO: Some families have 'duplicates' due to symbolic links.
         // The patterns are exactly the same except for the FC_FILE.
         // It should be possible to collapse these patterns by normalizing.
         static const FcSetName fcNameSet[] = { FcSetSystem, FcSetApplication };
         for (int setIndex = 0; setIndex < (int)SK_ARRAY_COUNT(fcNameSet); ++setIndex) {
             // Return value of FcConfigGetFonts must not be destroyed.
             FcFontSet* allFonts(FcConfigGetFonts(fFC, fcNameSet[setIndex]));
-            if (NULL == allFonts) {
+            if (nullptr == allFonts) {
                 continue;
             }
 
             for (int fontIndex = 0; fontIndex < allFonts->nfont; ++fontIndex) {
                 FcPattern* font = allFonts->fonts[fontIndex];
                 if (FontAccessible(font) && FontFamilyNameMatches(font, matchPattern)) {
                     FcFontSetAdd(matches, FcFontRenderPrepare(fFC, pattern, font));
                 }
             }
         }
@@ skipping 14 matching lines @@
 
         // We really want to match strong (prefered) and same (acceptable) only here.
         // If a family name was specified, assume that any weak matches after the last strong match
         // are weak (default) and ignore them.
         // The reason for is that after substitution the pattern for 'sans-serif' looks like
         // "wwwwwwwwwwwwwwswww" where there are many weak but preferred names, followed by defaults.
         // So it is possible to have weakly matching but preferred names.
         // In aliases, bindings are weak by default, so this is easy and common.
         // If no family name was specified, we'll probably only get weak matches, but that's ok.
         FcPattern* matchPattern;
-        SkAutoFcPattern strongPattern(NULL);
+        SkAutoFcPattern strongPattern(nullptr);
         if (familyName) {
             strongPattern.reset(FcPatternDuplicate(pattern));
             remove_weak(strongPattern, FC_FAMILY);
             matchPattern = strongPattern;
         } else {
             matchPattern = pattern;
         }
 
         FcResult result;
         SkAutoFcPattern font(FcFontMatch(fFC, pattern, &result));
-        if (NULL == font || !FontAccessible(font) || !FontFamilyNameMatches(font, matchPattern)) {
-            return NULL;
+        if (nullptr == font || !FontAccessible(font) || !FontFamilyNameMatches(font, matchPattern)) {
+            return nullptr;
         }
 
         return createTypefaceFromFcPattern(font);
     }
 
     virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
                                                     const SkFontStyle& style,
                                                     const char* bcp47[],
                                                     int bcp47Count,
                                                     SkUnichar character) const override
@@ skipping 20 matching lines @@
                 FcLangSetAdd(langSet, (const FcChar8*)bcp47[i]);
             }
             FcPatternAddLangSet(pattern, FC_LANG, langSet);
         }
 
         FcConfigSubstitute(fFC, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
 
         FcResult result;
         SkAutoFcPattern font(FcFontMatch(fFC, pattern, &result));
-        if (NULL == font || !FontAccessible(font) || !FontContainsCharacter(font, character)) {
-            return NULL;
+        if (nullptr == font || !FontAccessible(font) || !FontContainsCharacter(font, character)) {
+            return nullptr;
         }
 
         return createTypefaceFromFcPattern(font);
     }
 
     virtual SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
                                          const SkFontStyle& style) const override
     {
         //TODO: should the SkTypeface_fontconfig know its family?
         const SkTypeface_fontconfig* fcTypeface =
                 static_cast<const SkTypeface_fontconfig*>(typeface);
         return this->matchFamilyStyle(get_string(fcTypeface->fPattern, FC_FAMILY), style);
     }
 
     SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
         SkAutoTDelete<SkStreamAsset> stream(bareStream);
         const size_t length = stream->getLength();
         if (length <= 0 || (1u << 30) < length) {
-            return NULL;
+            return nullptr;
         }
 
         SkFontStyle style;
         bool isFixedWidth = false;
-        if (!fScanner.scanFont(stream, ttcIndex, NULL, &style, &isFixedWidth, NULL)) {
-            return NULL;
+        if (!fScanner.scanFont(stream, ttcIndex, nullptr, &style, &isFixedWidth, nullptr)) {
+            return nullptr;
         }
 
-        return new SkTypeface_stream(new SkFontData(stream.detach(), ttcIndex, NULL, 0), style,
+        return new SkTypeface_stream(new SkFontData(stream.detach(), ttcIndex, nullptr, 0), style,
                                      isFixedWidth);
     }
 
     SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
         return this->createFromStream(new SkMemoryStream(data), ttcIndex);
     }
 
     SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
         return this->createFromStream(SkStream::NewFromFile(path), ttcIndex);
     }
 
     SkTypeface* onCreateFromFontData(SkFontData* fontData) const override {
         SkStreamAsset* stream(fontData->getStream());
         const size_t length = stream->getLength();
         if (length <= 0 || (1u << 30) < length) {
-            return NULL;
+            return nullptr;
         }
 
         const int ttcIndex = fontData->getIndex();
         SkFontStyle style;
         bool isFixedWidth = false;
-        if (!fScanner.scanFont(stream, ttcIndex, NULL, &style, &isFixedWidth, NULL)) {
-            return NULL;
+        if (!fScanner.scanFont(stream, ttcIndex, nullptr, &style, &isFixedWidth, nullptr)) {
+            return nullptr;
         }
 
         return new SkTypeface_stream(fontData, style, isFixedWidth);
     }
 
     virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
                                                unsigned styleBits) const override {
         bool bold = styleBits & SkTypeface::kBold;
         bool italic = styleBits & SkTypeface::kItalic;
         SkFontStyle style = SkFontStyle(bold ? SkFontStyle::kBold_Weight
                                              : SkFontStyle::kNormal_Weight,
                                         SkFontStyle::kNormal_Width,
                                         italic ? SkFontStyle::kItalic_Slant
                                                : SkFontStyle::kUpright_Slant);
         SkAutoTUnref<SkTypeface> typeface(this->matchFamilyStyle(familyName, style));
         if (typeface.get()) {
             return typeface.detach();
         }
 
-        return this->matchFamilyStyle(NULL, style);
+        return this->matchFamilyStyle(nullptr, style);
     }
 };
 
 SK_API SkFontMgr* SkFontMgr_New_FontConfig(FcConfig* fc) {
     return new SkFontMgr_fontconfig(fc);
 }