Style Change: NULL->nullptr

src/ports/SkFontMgr_custom.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 "SkFontDescriptor.h"
 #include "SkFontHost_FreeType_common.h"
 #include "SkFontMgr.h"
@@ skipping 45 matching lines @@
 };
 
 /** The empty SkTypeface implementation for the custom font manager.
  *  Used as the last resort fallback typeface.
  */
 class SkTypeface_Empty : public SkTypeface_Custom {
 public:
     SkTypeface_Empty() : INHERITED(SkFontStyle(), false, true, SkString(), 0) {}
 
 protected:
-    SkStreamAsset* onOpenStream(int*) const override { return NULL; }
+    SkStreamAsset* onOpenStream(int*) const override { return nullptr; }
 
 private:
     typedef SkTypeface_Custom INHERITED;
 };
 
 /** The stream SkTypeface implementation for the custom font manager. */
 class SkTypeface_Stream : public SkTypeface_Custom {
 public:
     SkTypeface_Stream(const SkFontStyle& style, bool isFixedPitch, bool sysFont,
                       const SkString familyName, SkStreamAsset* stream, int index)
@@ skipping 72 matching lines @@
     static int match_score(const SkFontStyle& pattern, const SkFontStyle& candidate) {
         int score = 0;
         score += (pattern.width() - candidate.width()) * 100;
         score += (pattern.isItalic() == candidate.isItalic()) ? 0 : 1000;
         score += pattern.weight() - candidate.weight();
         return score;
     }
 
     SkTypeface* matchStyle(const SkFontStyle& pattern) override {
         if (0 == fStyles.count()) {
-            return NULL;
+            return nullptr;
         }
 
         SkTypeface_Custom* closest = fStyles[0];
         int minScore = std::numeric_limits<int>::max();
         for (int i = 0; i < fStyles.count(); ++i) {
             bool bold = fStyles[i]->isBold();
             bool italic = fStyles[i]->isItalic();
             SkFontStyle style = SkFontStyle(bold ? SkFontStyle::kBold_Weight
                                                  : SkFontStyle::kNormal_Weight,
                                             SkFontStyle::kNormal_Width,
@@ skipping 26 matching lines @@
  *  to load fonts from any source by changing the initialization.
  */
 class SkFontMgr_Custom : public SkFontMgr {
 public:
     typedef SkTArray<SkAutoTUnref<SkFontStyleSet_Custom>, true> Families;
     class SystemFontLoader {
     public:
         virtual ~SystemFontLoader() { }
         virtual void loadSystemFonts(const SkTypeface_FreeType::Scanner&, Families*) const = 0;
     };
-    explicit SkFontMgr_Custom(const SystemFontLoader& loader) : fDefaultFamily(NULL) {
+    explicit SkFontMgr_Custom(const SystemFontLoader& loader) : fDefaultFamily(nullptr) {
         loader.loadSystemFonts(fScanner, &fFamilies);
 
         // Try to pick a default font.
         static const char* defaultNames[] = {
-            "Arial", "Verdana", "Times New Roman", "Droid Sans", NULL
+            "Arial", "Verdana", "Times New Roman", "Droid Sans", nullptr
         };
         for (size_t i = 0; i < SK_ARRAY_COUNT(defaultNames); ++i) {
             SkFontStyleSet_Custom* set = this->onMatchFamily(defaultNames[i]);
-            if (NULL == set) {
+            if (nullptr == set) {
                 continue;
             }
 
             SkTypeface* tf = set->matchStyle(SkFontStyle(SkFontStyle::kNormal_Weight,
                                                          SkFontStyle::kNormal_Width,
                                                          SkFontStyle::kUpright_Slant));
-            if (NULL == tf) {
+            if (nullptr == tf) {
                 continue;
             }
 
             fDefaultFamily = set;
             break;
         }
-        if (NULL == fDefaultFamily) {
+        if (nullptr == fDefaultFamily) {
             fDefaultFamily = fFamilies[0];
         }
     }
 
 protected:
     int onCountFamilies() const override {
         return fFamilies.count();
     }
 
     void onGetFamilyName(int index, SkString* familyName) const override {
         SkASSERT(index < fFamilies.count());
         familyName->set(fFamilies[index]->getFamilyName());
     }
 
     SkFontStyleSet_Custom* onCreateStyleSet(int index) const override {
         SkASSERT(index < fFamilies.count());
         return SkRef(fFamilies[index].get());
     }
 
     SkFontStyleSet_Custom* onMatchFamily(const char familyName[]) const override {
         for (int i = 0; i < fFamilies.count(); ++i) {
             if (fFamilies[i]->getFamilyName().equals(familyName)) {
                 return SkRef(fFamilies[i].get());
             }
         }
-        return NULL;
+        return nullptr;
     }
 
     SkTypeface* onMatchFamilyStyle(const char familyName[],
                                    const SkFontStyle& fontStyle) const override
     {
         SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
         return sset->matchStyle(fontStyle);
     }
 
     SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
                                             const char* bcp47[], int bcp47Count,
                                             SkUnichar character) const override
     {
-        return NULL;
+        return nullptr;
     }
 
     SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
                                  const SkFontStyle& fontStyle) const override
     {
         for (int i = 0; i < fFamilies.count(); ++i) {
             for (int j = 0; j < fFamilies[i]->fStyles.count(); ++j) {
                 if (fFamilies[i]->fStyles[j] == familyMember) {
                     return fFamilies[i]->matchStyle(fontStyle);
                 }
             }
         }
-        return NULL;
+        return nullptr;
     }
 
     SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
         return this->createFromStream(new SkMemoryStream(data), ttcIndex);
     }
 
     SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
         SkAutoTDelete<SkStreamAsset> stream(bareStream);
-        if (NULL == stream || stream->getLength() <= 0) {
-            return NULL;
+        if (nullptr == stream || stream->getLength() <= 0) {
+            return nullptr;
         }
 
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
-        if (fScanner.scanFont(stream, ttcIndex, &name, &style, &isFixedPitch, NULL)) {
+        if (fScanner.scanFont(stream, ttcIndex, &name, &style, &isFixedPitch, nullptr)) {
             return new SkTypeface_Stream(style, isFixedPitch, false, name, stream.detach(),
                                          ttcIndex);
         } else {
-            return NULL;
+            return nullptr;
         }
     }
 
     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 {
         SkTypeface::Style oldStyle = (SkTypeface::Style)styleBits;
         SkFontStyle style = SkFontStyle(oldStyle & SkTypeface::kBold
                                                  ? SkFontStyle::kBold_Weight
                                                  : SkFontStyle::kNormal_Weight,
                                         SkFontStyle::kNormal_Width,
                                         oldStyle & SkTypeface::kItalic
                                                  ? SkFontStyle::kItalic_Slant
                                                  : SkFontStyle::kUpright_Slant);
-        SkTypeface* tf = NULL;
+        SkTypeface* tf = nullptr;
 
         if (familyName) {
             tf = this->onMatchFamilyStyle(familyName, style);
         }
 
-        if (NULL == tf) {
+        if (nullptr == tf) {
             tf = fDefaultFamily->matchStyle(style);
         }
 
         return SkSafeRef(tf);
     }
 
 private:
     Families fFamilies;
     SkFontStyleSet_Custom* fDefaultFamily;
     SkTypeface_FreeType::Scanner fScanner;
@@ skipping 22 matching lines @@
 
 private:
     static SkFontStyleSet_Custom* find_family(SkFontMgr_Custom::Families& families,
                                               const char familyName[])
     {
        for (int i = 0; i < families.count(); ++i) {
             if (families[i]->getFamilyName().equals(familyName)) {
                 return families[i].get();
             }
         }
-        return NULL;
+        return nullptr;
     }
 
     static void load_directory_fonts(const SkTypeface_FreeType::Scanner& scanner,
                                      const SkString& directory, const char* suffix,
                                      SkFontMgr_Custom::Families* families)
     {
         SkOSFile::Iter iter(directory.c_str(), suffix);
         SkString name;
 
         while (iter.next(&name, false)) {
             SkString filename(SkOSPath::Join(directory.c_str(), name.c_str()));
             SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(filename.c_str()));
             if (!stream.get()) {
                 SkDebugf("---- failed to open <%s>\n", filename.c_str());
                 continue;
             }
 
             int numFaces;
             if (!scanner.recognizedFont(stream, &numFaces)) {
                 SkDebugf("---- failed to open <%s> as a font\n", filename.c_str());
                 continue;
             }
 
             for (int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
                 bool isFixedPitch;
                 SkString realname;
                 SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
-                if (!scanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch, NULL)) {
+                if (!scanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch, nullptr)) {
                     SkDebugf("---- failed to open <%s> <%d> as a font\n",
                              filename.c_str(), faceIndex);
                     continue;
                 }
 
                 SkTypeface_Custom* tf = new SkTypeface_File(style, isFixedPitch,
                                                             true,  // system-font (cannot delete)
                                                             realname, filename.c_str(), faceIndex);
 
                 SkFontStyleSet_Custom* addTo = find_family(*families, realname.c_str());
-                if (NULL == addTo) {
+                if (nullptr == addTo) {
                     addTo = new SkFontStyleSet_Custom(realname);
                     families->push_back().reset(addTo);
                 }
                 addTo->appendTypeface(tf);
             }
         }
 
         SkOSFile::Iter dirIter(directory.c_str());
         while (dirIter.next(&name, true)) {
             if (name.startsWith(".")) {
@@ skipping 37 matching lines @@
 
 private:
     static SkFontStyleSet_Custom* find_family(SkFontMgr_Custom::Families& families,
                                               const char familyName[])
     {
        for (int i = 0; i < families.count(); ++i) {
             if (families[i]->getFamilyName().equals(familyName)) {
                 return families[i].get();
             }
         }
-        return NULL;
+        return nullptr;
     }
 
     static void load_embedded_font(const SkTypeface_FreeType::Scanner& scanner,
                                    const uint8_t* data, size_t size, int index,
                                    SkFontMgr_Custom::Families* families)
     {
         SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(data, size, false));
 
         int numFaces;
         if (!scanner.recognizedFont(stream, &numFaces)) {
             SkDebugf("---- failed to open <%d> as a font\n", index);
             return;
         }
 
         for (int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
             bool isFixedPitch;
             SkString realname;
             SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
-            if (!scanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch, NULL)) {
+            if (!scanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch, nullptr)) {
                 SkDebugf("---- failed to open <%d> <%d> as a font\n", index, faceIndex);
                 return;
             }
 
             SkTypeface_Custom* tf =
                     new SkTypeface_Stream(style, isFixedPitch, true,  // system-font (cannot delete)
                                           realname, stream.detach(), faceIndex);
 
             SkFontStyleSet_Custom* addTo = find_family(*families, realname.c_str());
-            if (NULL == addTo) {
+            if (nullptr == addTo) {
                 addTo = new SkFontStyleSet_Custom(realname);
                 families->push_back().reset(addTo);
             }
             addTo->appendTypeface(tf);
         }
     }
 
     const SkEmbeddedResourceHeader* fHeader;
 };
 
 SkFontMgr* SkFontMgr_New_Custom_Embedded(const SkEmbeddedResourceHeader* header) {
     return new SkFontMgr_Custom(EmbeddedSystemFontLoader(header));
 }