Style Change: NULL->nullptr

src/fonts/SkFontMgr_indirect.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 "SkFontMgr.h"
 #include "SkFontMgr_indirect.h"
@@ skipping 157 matching lines @@
     SkOnce(&fFamilyNamesInited, &fFamilyNamesMutex, SkFontMgr_Indirect::set_up_family_names, this);
     if (index >= fFamilyNames->count()) {
         familyName->reset();
         return;
     }
     familyName->set(fFamilyNames->atStr(index));
 }
 
 SkFontStyleSet* SkFontMgr_Indirect::onCreateStyleSet(int index) const {
     SkRemotableFontIdentitySet* set = fProxy->getIndex(index);
-    if (NULL == set) {
-        return NULL;
+    if (nullptr == set) {
+        return nullptr;
     }
     return new SkStyleSet_Indirect(this, index, set);
 }
 
 SkFontStyleSet* SkFontMgr_Indirect::onMatchFamily(const char familyName[]) const {
     return new SkStyleSet_Indirect(this, -1, fProxy->matchName(familyName));
 }
 
 SkTypeface* SkFontMgr_Indirect::createTypefaceFromFontId(const SkFontIdentity& id) const {
     if (id.fDataId == SkFontIdentity::kInvalidDataId) {
-        return NULL;
+        return nullptr;
     }
 
     SkAutoMutexAcquire ama(fDataCacheMutex);
 
     SkAutoTUnref<SkTypeface> dataTypeface;
     int dataTypefaceIndex = 0;
     for (int i = 0; i < fDataCache.count(); ++i) {
         const DataEntry& entry = fDataCache[i];
         if (entry.fDataId == id.fDataId) {
             if (entry.fTtcIndex == id.fTtcIndex &&
                 !entry.fTypeface->weak_expired() && entry.fTypeface->try_ref())
             {
                 return entry.fTypeface;
             }
-            if (dataTypeface.get() == NULL &&
+            if (dataTypeface.get() == nullptr &&
                 !entry.fTypeface->weak_expired() && entry.fTypeface->try_ref())
             {
                 dataTypeface.reset(entry.fTypeface);
                 dataTypefaceIndex = entry.fTtcIndex;
             }
         }
 
         if (entry.fTypeface->weak_expired()) {
             fDataCache.removeShuffle(i);
             --i;
         }
     }
 
     // No exact match, but did find a data match.
-    if (dataTypeface.get() != NULL) {
-        SkAutoTDelete<SkStreamAsset> stream(dataTypeface->openStream(NULL));
-        if (stream.get() != NULL) {
+    if (dataTypeface.get() != nullptr) {
+        SkAutoTDelete<SkStreamAsset> stream(dataTypeface->openStream(nullptr));
+        if (stream.get() != nullptr) {
             return fImpl->createFromStream(stream.detach(), dataTypefaceIndex);
         }
     }
 
     // No data match, request data and add entry.
     SkAutoTDelete<SkStreamAsset> stream(fProxy->getData(id.fDataId));
-    if (stream.get() == NULL) {
-        return NULL;
+    if (stream.get() == nullptr) {
+        return nullptr;
     }
 
     SkAutoTUnref<SkTypeface> typeface(fImpl->createFromStream(stream.detach(), id.fTtcIndex));
-    if (typeface.get() == NULL) {
-        return NULL;
+    if (typeface.get() == nullptr) {
+        return nullptr;
     }
 
     DataEntry& newEntry = fDataCache.push_back();
     typeface->weak_ref();
     newEntry.fDataId = id.fDataId;
     newEntry.fTtcIndex = id.fTtcIndex;
     newEntry.fTypeface = typeface.get();  // weak reference passed to new entry.
 
     return typeface.detach();
 }
@@ skipping 38 matching lines @@
     bool bold = SkToBool(styleBits & SkTypeface::kBold);
     bool italic = SkToBool(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> face(this->matchFamilyStyle(familyName, style));
 
-    if (NULL == face.get()) {
-        face.reset(this->matchFamilyStyle(NULL, style));
+    if (nullptr == face.get()) {
+        face.reset(this->matchFamilyStyle(nullptr, style));
     }
 
-    if (NULL == face.get()) {
+    if (nullptr == face.get()) {
         SkFontIdentity fontId = this->fProxy->matchIndexStyle(0, style);
         face.reset(this->createTypefaceFromFontId(fontId));
     }
 
     return face.detach();
 }