Style Change: NULL->nullptr

src/fonts/SkFontMgr_fontconfig.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontConfigInterface.h"
 #include "SkFontConfigTypeface.h"
 #include "SkFontMgr.h"
@@ skipping 42 matching lines @@
 // borrow this global from SkFontHost_fontconfig. eventually that file should
 // go away, and be replaced with this one.
 extern SkFontConfigInterface* SkFontHost_fontconfig_ref_global();
 static SkFontConfigInterface* RefFCI() {
     return SkFontHost_fontconfig_ref_global();
 }
 
 // look for the last substring after a '/' and return that, or return null.
 static const char* find_just_name(const char* str) {
     const char* last = strrchr(str, '/');
-    return last ? last + 1 : NULL;
+    return last ? last + 1 : nullptr;
 }
 
 static bool is_lower(char c) {
     return c >= 'a' && c <= 'z';
 }
 
 static int get_int(FcPattern* pattern, const char field[]) {
     SkASSERT(gFCSafeToUse);
     int value;
     if (FcPatternGetInteger(pattern, field, 0, &value) != FcResultMatch) {
@@ skipping 42 matching lines @@
     FcPattern** iter = font_set->fonts;
     FcPattern** stop = iter + font_set->nfont;
     // find the first good match
     for (; iter < stop; ++iter) {
         if (valid_pattern(*iter)) {
             break;
         }
     }
 
     if (iter == stop || !match_name(*iter, post_config_family)) {
-        return NULL;
+        return nullptr;
     }
 
     FcPattern** firstIter = iter++;
     for (; iter < stop; ++iter) {
         if (!valid_pattern(*iter) || !match_name(*iter, post_config_family)) {
             break;
         }
     }
 
     *count = iter - firstIter;
@@ skipping 58 matching lines @@
     SkASSERT((unsigned)index < (unsigned)fRecCount);
     if (style) {
         *style = fRecs[index].fStyle;
     }
     if (styleName) {
         *styleName = fRecs[index].fStyleName;
     }
 }
 
 SkTypeface* SkFontStyleSet_FC::createTypeface(int index) {
-    return NULL;
+    return nullptr;
 }
 
 SkTypeface* SkFontStyleSet_FC::matchStyle(const SkFontStyle& pattern) {
-    return NULL;
+    return nullptr;
 }
 
 class SkFontMgr_fontconfig : public SkFontMgr {
     SkAutoTUnref<SkFontConfigInterface> fFCI;
     SkDataTable* fFamilyNames;
     SkTypeface_FreeType::Scanner fScanner;
 
 public:
     SkFontMgr_fontconfig(SkFontConfigInterface* fci)
         : fFCI(fci)
@@ skipping 18 matching lines @@
 
     SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
         FCLocker lock;
 
         FcPattern* pattern = FcPatternCreate();
 
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
 #if 0
         FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 #endif
-        FcConfigSubstitute(NULL, pattern, FcMatchPattern);
+        FcConfigSubstitute(nullptr, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
 
         const char* post_config_family = get_name(pattern, FC_FAMILY);
 
         FcResult result;
         FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result);
         if (!font_set) {
             FcPatternDestroy(pattern);
-            return NULL;
+            return nullptr;
         }
 
         int count;
         FcPattern** match = MatchFont(font_set, post_config_family, &count);
         if (!match) {
             FcPatternDestroy(pattern);
             FcFontSetDestroy(font_set);
-            return NULL;
+            return nullptr;
         }
 
         FcPatternDestroy(pattern);
 
         SkTDArray<FcPattern*> trimmedMatches;
         for (int i = 0; i < count; ++i) {
             const char* justName = find_just_name(get_name(match[i], FC_FILE));
             if (!is_lower(*justName)) {
                 *trimmedMatches.append() = match[i];
             }
         }
 
         SkFontStyleSet_FC* sset =
                 new SkFontStyleSet_FC(trimmedMatches.begin(), trimmedMatches.count());
         return sset;
     }
 
     SkTypeface* onMatchFamilyStyle(const char familyName[],
-                                   const SkFontStyle&) const override { return NULL; }
+                                   const SkFontStyle&) const override { return nullptr; }
     SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
                                             const char* bcp47[], int bcp47Count,
                                             SkUnichar character) const override {
-        return NULL;
+        return nullptr;
     }
     SkTypeface* onMatchFaceStyle(const SkTypeface*,
-                                 const SkFontStyle&) const override { return NULL; }
+                                 const SkFontStyle&) const override { return nullptr; }
 
-    SkTypeface* onCreateFromData(SkData*, int ttcIndex) const override { return NULL; }
+    SkTypeface* onCreateFromData(SkData*, int ttcIndex) const override { return nullptr; }
 
     SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
         SkAutoTDelete<SkStreamAsset> stream(bareStream);
         const size_t length = stream->getLength();
         if (!length) {
-            return NULL;
+            return nullptr;
         }
         if (length >= 1024 * 1024 * 1024) {
-            return NULL;  // don't accept too large fonts (>= 1GB) for safety.
+            return nullptr;  // don't accept too large fonts (>= 1GB) for safety.
         }
 
         // TODO should the caller give us the style or should we get it from freetype?
         SkFontStyle style;
         bool isFixedWidth = false;
-        if (!fScanner.scanFont(stream, 0, NULL, &style, &isFixedWidth, NULL)) {
-            return NULL;
+        if (!fScanner.scanFont(stream, 0, nullptr, &style, &isFixedWidth, nullptr)) {
+            return nullptr;
         }
 
         SkTypeface* face = FontConfigTypeface::Create(style, isFixedWidth, stream.detach());
         return face;
     }
 
     SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
         SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
-        return stream.get() ? this->createFromStream(stream.detach(), ttcIndex) : NULL;
+        return stream.get() ? this->createFromStream(stream.detach(), ttcIndex) : nullptr;
     }
 
     SkTypeface* onLegacyCreateTypeface(const char familyName[],
                                        unsigned styleBits) const override {
         FCLocker lock;
         return FontConfigTypeface::LegacyCreateTypeface(familyName, (SkTypeface::Style)styleBits);
     }
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     SkFontConfigInterface* fci = RefFCI();
-    return fci ? new SkFontMgr_fontconfig(fci) : NULL;
+    return fci ? new SkFontMgr_fontconfig(fci) : nullptr;
 }