Style Change: NULL->nullptr

src/ports/SkFontConfigInterface_direct.cpp

 /*
  * Copyright 2009 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /* migrated from chrome/src/skia/ext/SkFontHost_fontconfig_direct.cpp */
 
 #include "SkBuffer.h"
@@ skipping 59 matching lines @@
     iden->fID = 10;
     iden->fTTCIndex = 2;
     iden->fString.set("Hello world");
     iden->fStyle = SkFontStyle(300, 6, SkFontStyle::kItalic_Slant);
 }
 
 static void test_writeToMemory(const SkFontConfigInterface::FontIdentity& iden0,
                                int initValue) {
     SkFontConfigInterface::FontIdentity iden1;
 
-    size_t size0 = iden0.writeToMemory(NULL);
+    size_t size0 = iden0.writeToMemory(nullptr);
 
     SkAutoMalloc storage(size0);
     memset(storage.get(), initValue, size0);
 
     size_t size1 = iden0.writeToMemory(storage.get());
     SkASSERT(size0 == size1);
 
     SkASSERT(iden0 != iden1);
     size_t size2 = iden1.readFromMemory(storage.get(), size1);
     SkASSERT(size2 == size1);
@@ skipping 33 matching lines @@
     virtual bool matchFamilySet(const char inFamilyName[],
                                 SkString* outFamilyName,
                                 SkTArray<FontIdentity>*) override;
 
 private:
     SkMutex mutex_;
 };
 
 SkFontConfigInterface* SkFontConfigInterface::GetSingletonDirectInterface(SkBaseMutex* mutex) {
     SkAutoMutexAcquire ac(mutex);
-    static SkFontConfigInterfaceDirect* singleton = NULL;
-    if (singleton == NULL) {
+    static SkFontConfigInterfaceDirect* singleton = nullptr;
+    if (singleton == nullptr) {
         singleton = new SkFontConfigInterfaceDirect;
     }
     return singleton;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// Returns the string from the pattern, or NULL
+// Returns the string from the pattern, or nullptr
 static const char* get_name(FcPattern* pattern, const char field[],
                             int index = 0) {
     const char* name;
     if (FcPatternGetString(pattern, field, index,
                            (FcChar8**)&name) != FcResultMatch) {
-        name = NULL;
+        name = nullptr;
     }
     return name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
 // Equivalence classes, used to match the Liberation and other fonts
 // with their metric-compatible replacements.  See the discussion in
@@ skipping 193 matching lines @@
     }
     return true;
 }
 
 // Find matching font from |font_set| for the given font family.
 FcPattern* MatchFont(FcFontSet* font_set,
                      const char* post_config_family,
                      const SkString& family) {
   // Older versions of fontconfig have a bug where they cannot select
   // only scalable fonts so we have to manually filter the results.
-  FcPattern* match = NULL;
+  FcPattern* match = nullptr;
   for (int i = 0; i < font_set->nfont; ++i) {
     FcPattern* current = font_set->fonts[i];
     if (valid_pattern(current)) {
       match = current;
       break;
     }
   }
 
   if (match && !IsFallbackFontAllowed(family)) {
     bool acceptable_substitute = false;
     for (int id = 0; id < 255; ++id) {
       const char* post_match_family = get_name(match, FC_FAMILY, id);
       if (!post_match_family)
         break;
       acceptable_substitute =
           (strcasecmp(post_config_family, post_match_family) == 0 ||
            // Workaround for Issue 12530:
            //   requested family: "Bitstream Vera Sans"
            //   post_config_family: "Arial"
            //   post_match_family: "Bitstream Vera Sans"
            // -> We should treat this case as a good match.
            strcasecmp(family.c_str(), post_match_family) == 0) ||
            IsMetricCompatibleReplacement(family.c_str(), post_match_family);
       if (acceptable_substitute)
         break;
     }
     if (!acceptable_substitute)
-      return NULL;
+      return nullptr;
   }
 
   return match;
 }
 
 // Retrieves |is_bold|, |is_italic| and |font_family| properties from |font|.
 SkTypeface::Style GetFontStyle(FcPattern* font) {
     int resulting_bold;
     if (FcPatternGetInteger(font, FC_WEIGHT, 0, &resulting_bold))
         resulting_bold = FC_WEIGHT_NORMAL;
@@ skipping 60 matching lines @@
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
     }
     FcPatternAddInteger(pattern, FC_WEIGHT,
                         (style & SkTypeface::kBold) ? FC_WEIGHT_BOLD
                                                     : FC_WEIGHT_NORMAL);
     FcPatternAddInteger(pattern, FC_SLANT,
                         (style & SkTypeface::kItalic) ? FC_SLANT_ITALIC
                                                       : FC_SLANT_ROMAN);
     FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 
-    FcConfigSubstitute(NULL, pattern, FcMatchPattern);
+    FcConfigSubstitute(nullptr, pattern, FcMatchPattern);
     FcDefaultSubstitute(pattern);
 
     // Font matching:
     // CSS often specifies a fallback list of families:
     //    font-family: a, b, c, serif;
     // However, fontconfig will always do its best to find *a* font when asked
     // for something so we need a way to tell if the match which it has found is
-    // "good enough" for us. Otherwise, we can return NULL which gets piped up
+    // "good enough" for us. Otherwise, we can return nullptr which gets piped up
     // and lets WebKit know to try the next CSS family name. However, fontconfig
     // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we
     // wish to support that.
     //
     // Thus, if a specific family is requested we set @family_requested. Then we
     // record two strings: the family name after config processing and the
     // family name after resolving. If the two are equal, it's a good match.
     //
     // So consider the case where a user has mapped Arial to Helvetica in their
     // config.
@@ skipping 81 matching lines @@
         }
     }
     return false;
 }
 
 SkDataTable* SkFontConfigInterfaceDirect::getFamilyNames() {
     SkAutoMutexAcquire ac(mutex_);
 
     FcPattern* pat = FcPatternCreate();
     SkAutoTCallVProc<FcPattern, FcPatternDestroy> autoDestroyPat(pat);
-    if (NULL == pat) {
-        return NULL;
+    if (nullptr == pat) {
+        return nullptr;
     }
 
     FcObjectSet* os = FcObjectSetBuild(FC_FAMILY, (char *)0);
     SkAutoTCallVProc<FcObjectSet, FcObjectSetDestroy> autoDestroyOs(os);
-    if (NULL == os) {
-        return NULL;
+    if (nullptr == os) {
+        return nullptr;
     }
 
-    FcFontSet* fs = FcFontList(NULL, pat, os);
+    FcFontSet* fs = FcFontList(nullptr, pat, os);
     SkAutoTCallVProc<FcFontSet, FcFontSetDestroy> autoDestroyFs(fs);
-    if (NULL == fs) {
-        return NULL;
+    if (nullptr == fs) {
+        return nullptr;
     }
 
     SkTDArray<const char*> names;
     SkTDArray<size_t> sizes;
     for (int i = 0; i < fs->nfont; ++i) {
         FcPattern* match = fs->fonts[i];
         const char* famName = get_name(match, FC_FAMILY);
         if (famName && !find_name(names, famName)) {
             *names.append() = famName;
             *sizes.append() = strlen(famName) + 1;
@@ skipping 17 matching lines @@
 
     SkAutoMutexAcquire ac(mutex_);
 
     FcPattern* pattern = FcPatternCreate();
 
     if (familyName) {
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
     }
     FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 
-    FcConfigSubstitute(NULL, pattern, FcMatchPattern);
+    FcConfigSubstitute(nullptr, pattern, FcMatchPattern);
     FcDefaultSubstitute(pattern);
 
     // Font matching:
     // CSS often specifies a fallback list of families:
     //    font-family: a, b, c, serif;
     // However, fontconfig will always do its best to find *a* font when asked
     // for something so we need a way to tell if the match which it has found is
-    // "good enough" for us. Otherwise, we can return NULL which gets piped up
+    // "good enough" for us. Otherwise, we can return nullptr which gets piped up
     // and lets WebKit know to try the next CSS family name. However, fontconfig
     // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we
     // wish to support that.
     //
     // Thus, if a specific family is requested we set @family_requested. Then we
     // record two strings: the family name after config processing and the
     // family name after resolving. If the two are equal, it's a good match.
     //
     // So consider the case where a user has mapped Arial to Helvetica in their
     // config.
@@ skipping 61 matching lines @@
     }
     return true;
 
 ////////////////////
 
         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());
 #endif
     return false;
 }