Style Change: NULL->nullptr

src/ports/SkFontMgr_win_dw.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 "SkDWrite.h"
 #include "SkDWriteFontFileStream.h"
 #include "SkFontMgr.h"
@@ skipping 24 matching lines @@
 
     // IDWriteFontFileLoader methods
     virtual HRESULT STDMETHODCALLTYPE CreateStreamFromKey(
         void const* fontFileReferenceKey,
         UINT32 fontFileReferenceKeySize,
         IDWriteFontFileStream** fontFileStream);
 
     // Takes ownership of stream.
     static HRESULT Create(SkStreamAsset* stream, StreamFontFileLoader** streamFontFileLoader) {
         *streamFontFileLoader = new StreamFontFileLoader(stream);
-        if (NULL == streamFontFileLoader) {
+        if (nullptr == streamFontFileLoader) {
             return E_OUTOFMEMORY;
         }
         return S_OK;
     }
 
     SkAutoTDelete<SkStreamAsset> fStream;
 
 private:
     StreamFontFileLoader(SkStreamAsset* stream) : fStream(stream), fRefCount(1) { }
     virtual ~StreamFontFileLoader() { }
 
     ULONG fRefCount;
 };
 
 HRESULT StreamFontFileLoader::QueryInterface(REFIID iid, void** ppvObject) {
     if (iid == IID_IUnknown || iid == __uuidof(IDWriteFontFileLoader)) {
         *ppvObject = this;
         AddRef();
         return S_OK;
     } else {
-        *ppvObject = NULL;
+        *ppvObject = nullptr;
         return E_NOINTERFACE;
     }
 }
 
 ULONG StreamFontFileLoader::AddRef() {
     return InterlockedIncrement(&fRefCount);
 }
 
 ULONG StreamFontFileLoader::Release() {
     ULONG newCount = InterlockedDecrement(&fRefCount);
@@ skipping 23 matching lines @@
     virtual ULONG STDMETHODCALLTYPE AddRef();
     virtual ULONG STDMETHODCALLTYPE Release();
 
     // IDWriteFontFileEnumerator methods
     virtual HRESULT STDMETHODCALLTYPE MoveNext(BOOL* hasCurrentFile);
     virtual HRESULT STDMETHODCALLTYPE GetCurrentFontFile(IDWriteFontFile** fontFile);
 
     static HRESULT Create(IDWriteFactory* factory, IDWriteFontFileLoader* fontFileLoader,
                           StreamFontFileEnumerator** streamFontFileEnumerator) {
         *streamFontFileEnumerator = new StreamFontFileEnumerator(factory, fontFileLoader);
-        if (NULL == streamFontFileEnumerator) {
+        if (nullptr == streamFontFileEnumerator) {
             return E_OUTOFMEMORY;
         }
         return S_OK;
     }
 private:
     StreamFontFileEnumerator(IDWriteFactory* factory, IDWriteFontFileLoader* fontFileLoader);
     virtual ~StreamFontFileEnumerator() { }
 
     ULONG fRefCount;
 
@@ skipping 11 matching lines @@
     , fFontFileLoader(SkRefComPtr(fontFileLoader))
     , fHasNext(true)
 { }
 
 HRESULT StreamFontFileEnumerator::QueryInterface(REFIID iid, void** ppvObject) {
     if (iid == IID_IUnknown || iid == __uuidof(IDWriteFontFileEnumerator)) {
         *ppvObject = this;
         AddRef();
         return S_OK;
     } else {
-        *ppvObject = NULL;
+        *ppvObject = nullptr;
         return E_NOINTERFACE;
     }
 }
 
 ULONG StreamFontFileEnumerator::AddRef() {
     return InterlockedIncrement(&fRefCount);
 }
 
 ULONG StreamFontFileEnumerator::Release() {
     ULONG newCount = InterlockedDecrement(&fRefCount);
     if (0 == newCount) {
         delete this;
     }
     return newCount;
 }
 
 HRESULT StreamFontFileEnumerator::MoveNext(BOOL* hasCurrentFile) {
     *hasCurrentFile = FALSE;
 
     if (!fHasNext) {
         return S_OK;
     }
     fHasNext = false;
 
     UINT32 dummy = 0;
     HR(fFactory->CreateCustomFontFileReference(
-            &dummy, //cannot be NULL
+            &dummy, //cannot be nullptr
             sizeof(dummy), //even if this is 0
             fFontFileLoader.get(),
             &fCurrentFile));
 
     *hasCurrentFile = TRUE;
     return S_OK;
 }
 
 HRESULT StreamFontFileEnumerator::GetCurrentFontFile(IDWriteFontFile** fontFile) {
-    if (fCurrentFile.get() == NULL) {
-        *fontFile = NULL;
+    if (fCurrentFile.get() == nullptr) {
+        *fontFile = nullptr;
         return E_FAIL;
     }
 
     *fontFile = SkRefComPtr(fCurrentFile.get());
     return  S_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class StreamFontCollectionLoader : public IDWriteFontCollectionLoader {
 public:
     // IUnknown methods
     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void** ppvObject);
     virtual ULONG STDMETHODCALLTYPE AddRef();
     virtual ULONG STDMETHODCALLTYPE Release();
 
     // IDWriteFontCollectionLoader methods
     virtual HRESULT STDMETHODCALLTYPE CreateEnumeratorFromKey(
         IDWriteFactory* factory,
         void const* collectionKey,
         UINT32 collectionKeySize,
         IDWriteFontFileEnumerator** fontFileEnumerator);
 
     static HRESULT Create(IDWriteFontFileLoader* fontFileLoader,
                           StreamFontCollectionLoader** streamFontCollectionLoader) {
         *streamFontCollectionLoader = new StreamFontCollectionLoader(fontFileLoader);
-        if (NULL == streamFontCollectionLoader) {
+        if (nullptr == streamFontCollectionLoader) {
             return E_OUTOFMEMORY;
         }
         return S_OK;
     }
 private:
     StreamFontCollectionLoader(IDWriteFontFileLoader* fontFileLoader)
         : fRefCount(1)
         , fFontFileLoader(SkRefComPtr(fontFileLoader))
     { }
     virtual ~StreamFontCollectionLoader() { }
 
     ULONG fRefCount;
     SkTScopedComPtr<IDWriteFontFileLoader> fFontFileLoader;
 };
 
 HRESULT StreamFontCollectionLoader::QueryInterface(REFIID iid, void** ppvObject) {
     if (iid == IID_IUnknown || iid == __uuidof(IDWriteFontCollectionLoader)) {
         *ppvObject = this;
         AddRef();
         return S_OK;
     } else {
-        *ppvObject = NULL;
+        *ppvObject = nullptr;
         return E_NOINTERFACE;
     }
 }
 
 ULONG StreamFontCollectionLoader::AddRef() {
     return InterlockedIncrement(&fRefCount);
 }
 
 ULONG StreamFontCollectionLoader::Release() {
     ULONG newCount = InterlockedDecrement(&fRefCount);
@@ skipping 21 matching lines @@
 public:
     /** localeNameLength must include the null terminator. */
     SkFontMgr_DirectWrite(IDWriteFactory* factory, IDWriteFontCollection* fontCollection,
                           WCHAR* localeName, int localeNameLength)
         : fFactory(SkRefComPtr(factory))
         , fFontCollection(SkRefComPtr(fontCollection))
         , fLocaleName(localeNameLength)
     {
 #if SK_HAS_DWRITE_2_H
         if (!SUCCEEDED(fFactory->QueryInterface(&fFactory2))) {
-            // IUnknown::QueryInterface states that if it fails, punk will be set to NULL.
+            // IUnknown::QueryInterface states that if it fails, punk will be set to nullptr.
             // http://blogs.msdn.com/b/oldnewthing/archive/2004/03/26/96777.aspx
-            SK_ALWAYSBREAK(NULL == fFactory2.get());
+            SK_ALWAYSBREAK(nullptr == fFactory2.get());
         }
 #endif
         memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR));
     }
 
 protected:
     int onCountFamilies() const override;
     void onGetFamilyName(int index, SkString* familyName) const override;
     SkFontStyleSet* onCreateStyleSet(int index) const override;
     SkFontStyleSet* onMatchFamily(const char familyName[]) const override;
@@ skipping 79 matching lines @@
     }
 
     HRB(are_same(cshFace->fDWriteFontFace.get(), ctxFace->fDWriteFontFace, same));
     if (same) {
         return true;
     }
 
     //Check if the two fonts share the same loader and have the same key.
     UINT32 cshNumFiles;
     UINT32 ctxNumFiles;
-    HRB(cshFace->fDWriteFontFace->GetFiles(&cshNumFiles, NULL));
-    HRB(ctxFace->fDWriteFontFace->GetFiles(&ctxNumFiles, NULL));
+    HRB(cshFace->fDWriteFontFace->GetFiles(&cshNumFiles, nullptr));
+    HRB(ctxFace->fDWriteFontFace->GetFiles(&ctxNumFiles, nullptr));
     if (cshNumFiles != ctxNumFiles) {
         return false;
     }
 
     SkTScopedComPtr<IDWriteFontFile> cshFontFile;
     SkTScopedComPtr<IDWriteFontFile> ctxFontFile;
     HRB(cshFace->fDWriteFontFace->GetFiles(&cshNumFiles, &cshFontFile));
     HRB(ctxFace->fDWriteFontFace->GetFiles(&ctxNumFiles, &ctxFontFile));
 
     //for (each file) { //we currently only admit fonts from one file.
@@ skipping 60 matching lines @@
            wcscmp(cshFaceName.get(), ctxFaceName.get()) == 0;
 }
 
 SkTypeface* SkFontMgr_DirectWrite::createTypefaceFromDWriteFont(
         IDWriteFontFace* fontFace,
         IDWriteFont* font,
         IDWriteFontFamily* fontFamily) const {
     SkAutoMutexAcquire ama(fTFCacheMutex);
     ProtoDWriteTypeface spec = { fontFace, font, fontFamily };
     SkTypeface* face = fTFCache.findByProcAndRef(FindByDWriteFont, &spec);
-    if (NULL == face) {
+    if (nullptr == face) {
         face = DWriteFontTypeface::Create(fFactory.get(), fontFace, font, fontFamily);
         if (face) {
             fTFCache.add(face, get_style(font));
         }
     }
     return face;
 }
 
 int SkFontMgr_DirectWrite::onCountFamilies() const {
     return fFontCollection->GetFontFamilyCount();
@@ skipping 18 matching lines @@
 
 SkFontStyleSet* SkFontMgr_DirectWrite::onMatchFamily(const char familyName[]) const {
     SkSMallocWCHAR dwFamilyName;
     HRN(sk_cstring_to_wchar(familyName, &dwFamilyName));
 
     UINT32 index;
     BOOL exists;
     HRNM(fFontCollection->FindFamilyName(dwFamilyName.get(), &index, &exists),
             "Failed while finding family by name.");
     if (!exists) {
-        return NULL;
+        return nullptr;
     }
 
     return this->onCreateStyleSet(index);
 }
 
 SkTypeface* SkFontMgr_DirectWrite::onMatchFamilyStyle(const char familyName[],
                                                       const SkFontStyle& fontstyle) const {
     SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
     return sset->matchStyle(fontstyle);
 }
 
 class FontFallbackRenderer : public IDWriteTextRenderer {
 public:
     FontFallbackRenderer(const SkFontMgr_DirectWrite* outer, UINT32 character)
-        : fRefCount(1), fOuter(SkSafeRef(outer)), fCharacter(character), fResolvedTypeface(NULL) {
+        : fRefCount(1), fOuter(SkSafeRef(outer)), fCharacter(character), fResolvedTypeface(nullptr) {
     }
 
     virtual ~FontFallbackRenderer() { }
 
     // IDWriteTextRenderer methods
     virtual HRESULT STDMETHODCALLTYPE DrawGlyphRun(
         void* clientDrawingContext,
         FLOAT baselineOriginX,
         FLOAT baselineOriginY,
         DWRITE_MEASURING_MODE measuringMode,
@@ skipping 89 matching lines @@
 
     virtual HRESULT STDMETHODCALLTYPE QueryInterface(IID const& riid, void** ppvObject) override{
         if (__uuidof(IUnknown) == riid ||
             __uuidof(IDWritePixelSnapping) == riid ||
             __uuidof(IDWriteTextRenderer) == riid)
         {
             *ppvObject = this;
             this->AddRef();
             return S_OK;
         }
-        *ppvObject = NULL;
+        *ppvObject = nullptr;
         return E_FAIL;
     }
 
     SkTypeface* FallbackTypeface() { return fResolvedTypeface; }
 
 protected:
     ULONG fRefCount;
     SkAutoTUnref<const SkFontMgr_DirectWrite> fOuter;
     UINT32 fCharacter;
     SkTypeface* fResolvedTypeface;
@@ skipping 11 matching lines @@
 
     virtual ~FontFallbackSource() { }
 
     // IDWriteTextAnalysisSource methods
     virtual HRESULT STDMETHODCALLTYPE GetTextAtPosition(
         UINT32 textPosition,
         WCHAR const** textString,
         UINT32* textLength) override
     {
         if (fLength <= textPosition) {
-            *textString = NULL;
+            *textString = nullptr;
             *textLength = 0;
             return S_OK;
         }
         *textString = fString + textPosition;
         *textLength = fLength - textPosition;
         return S_OK;
     }
 
     virtual HRESULT STDMETHODCALLTYPE GetTextBeforePosition(
         UINT32 textPosition,
         WCHAR const** textString,
         UINT32* textLength) override
     {
         if (textPosition < 1 || fLength <= textPosition) {
-            *textString = NULL;
+            *textString = nullptr;
             *textLength = 0;
             return S_OK;
         }
         *textString = fString;
         *textLength = textPosition;
         return S_OK;
     }
 
     virtual DWRITE_READING_DIRECTION STDMETHODCALLTYPE GetParagraphReadingDirection() override {
         // TODO: this is also interesting.
@@ skipping 32 matching lines @@
     }
 
     virtual HRESULT STDMETHODCALLTYPE QueryInterface(IID const& riid, void** ppvObject) override{
         if (__uuidof(IUnknown) == riid ||
             __uuidof(IDWriteTextAnalysisSource) == riid)
         {
             *ppvObject = this;
             this->AddRef();
             return S_OK;
         }
-        *ppvObject = NULL;
+        *ppvObject = nullptr;
         return E_FAIL;
     }
 
 protected:
     ULONG fRefCount;
     const WCHAR* fString;
     UINT32 fLength;
     const WCHAR* fLocale;
     IDWriteNumberSubstitution* fNumberSubstitution;
 };
 
 SkTypeface* SkFontMgr_DirectWrite::onMatchFamilyStyleCharacter(const char familyName[],
                                                                const SkFontStyle& style,
                                                                const char* bcp47[], int bcp47Count,
                                                                SkUnichar character) const
 {
     const DWriteStyle dwStyle(style);
 
-    const WCHAR* dwFamilyName = NULL;
+    const WCHAR* dwFamilyName = nullptr;
     SkSMallocWCHAR dwFamilyNameLocal;
     if (familyName) {
         HRN(sk_cstring_to_wchar(familyName, &dwFamilyNameLocal));
         dwFamilyName = dwFamilyNameLocal;
     }
 
     WCHAR str[16];
     UINT32 strLen = static_cast<UINT32>(
         SkUTF16_FromUnichar(character, reinterpret_cast<uint16_t*>(str)));
 
     const SkSMallocWCHAR* dwBcp47;
     SkSMallocWCHAR dwBcp47Local;
     if (bcp47Count < 1) {
         dwBcp47 = &fLocaleName;
     } else {
         // TODO: support fallback stack.
         // TODO: DirectWrite supports 'zh-CN' or 'zh-Hans', but 'zh' misses completely
         // and may produce a Japanese font.
         HRN(sk_cstring_to_wchar(bcp47[bcp47Count - 1], &dwBcp47Local));
         dwBcp47 = &dwBcp47Local;
     }
 
 #if SK_HAS_DWRITE_2_H
     if (fFactory2.get()) {
         SkTScopedComPtr<IDWriteFontFallback> fontFallback;
         HRNM(fFactory2->GetSystemFontFallback(&fontFallback), "Could not get system fallback.");
 
         SkTScopedComPtr<IDWriteNumberSubstitution> numberSubstitution;
-        HRNM(fFactory2->CreateNumberSubstitution(DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, NULL, TRUE,
+        HRNM(fFactory2->CreateNumberSubstitution(DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, nullptr, TRUE,
                                                  &numberSubstitution),
              "Could not create number substitution.");
         SkTScopedComPtr<FontFallbackSource> fontFallbackSource(
             new FontFallbackSource(str, strLen, *dwBcp47, numberSubstitution.get()));
 
         UINT32 mappedLength;
         SkTScopedComPtr<IDWriteFont> font;
         FLOAT scale;
         HRNM(fontFallback->MapCharacters(fontFallbackSource.get(),
                                          0, // textPosition,
                                          strLen,
                                          fFontCollection.get(),
                                          dwFamilyName,
                                          dwStyle.fWeight,
                                          dwStyle.fSlant,
                                          dwStyle.fWidth,
                                          &mappedLength,
                                          &font,
                                          &scale),
              "Could not map characters");
         if (!font.get()) {
-            return NULL;
+            return nullptr;
         }
 
         SkTScopedComPtr<IDWriteFontFace> fontFace;
         HRNM(font->CreateFontFace(&fontFace), "Could not get font face from font.");
 
         SkTScopedComPtr<IDWriteFontFamily> fontFamily;
         HRNM(font->GetFontFamily(&fontFamily), "Could not get family from font.");
         return this->createTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get());
     }
 #else
@@ skipping 13 matching lines @@
 
     SkTScopedComPtr<IDWriteTextLayout> fallbackLayout;
     HRNM(fFactory->CreateTextLayout(str, strLen, fallbackFormat.get(),
                                     200.0f, 200.0f,
                                     &fallbackLayout),
          "Could not create text layout.");
 
     SkTScopedComPtr<FontFallbackRenderer> fontFallbackRenderer(
         new FontFallbackRenderer(this, character));
 
-    HRNM(fallbackLayout->Draw(NULL, fontFallbackRenderer.get(), 50.0f, 50.0f),
+    HRNM(fallbackLayout->Draw(nullptr, fontFallbackRenderer.get(), 50.0f, 50.0f),
          "Could not draw layout with renderer.");
 
     return fontFallbackRenderer->FallbackTypeface();
 }
 
 SkTypeface* SkFontMgr_DirectWrite::onMatchFaceStyle(const SkTypeface* familyMember,
                                                     const SkFontStyle& fontstyle) const {
     SkString familyName;
     SkFontStyleSet_DirectWrite sset(
         this, ((DWriteFontTypeface*)familyMember)->fDWriteFontFamily.get()
     );
     return sset.matchStyle(fontstyle);
 }
 
 template <typename T> class SkAutoIDWriteUnregister {
 public:
     SkAutoIDWriteUnregister(IDWriteFactory* factory, T* unregister)
         : fFactory(factory), fUnregister(unregister)
     { }
 
     ~SkAutoIDWriteUnregister() {
         if (fUnregister) {
             unregister(fFactory, fUnregister);
         }
     }
 
     T* detatch() {
         T* old = fUnregister;
-        fUnregister = NULL;
+        fUnregister = nullptr;
         return old;
     }
 
 private:
     HRESULT unregister(IDWriteFactory* factory, IDWriteFontFileLoader* unregister) {
         return factory->UnregisterFontFileLoader(unregister);
     }
 
     HRESULT unregister(IDWriteFactory* factory, IDWriteFontCollectionLoader* unregister) {
         return factory->UnregisterFontCollectionLoader(unregister);
@@ skipping 11 matching lines @@
     SkAutoIDWriteUnregister<StreamFontFileLoader> autoUnregisterFontFileLoader(
         fFactory.get(), fontFileLoader.get());
 
     SkTScopedComPtr<StreamFontCollectionLoader> fontCollectionLoader;
     HRN(StreamFontCollectionLoader::Create(fontFileLoader.get(), &fontCollectionLoader));
     HRN(fFactory->RegisterFontCollectionLoader(fontCollectionLoader.get()));
     SkAutoIDWriteUnregister<StreamFontCollectionLoader> autoUnregisterFontCollectionLoader(
         fFactory.get(), fontCollectionLoader.get());
 
     SkTScopedComPtr<IDWriteFontCollection> fontCollection;
-    HRN(fFactory->CreateCustomFontCollection(fontCollectionLoader.get(), NULL, 0, &fontCollection));
+    HRN(fFactory->CreateCustomFontCollection(fontCollectionLoader.get(), nullptr, 0, &fontCollection));
 
     // Find the first non-simulated font which has the given ttc index.
     UINT32 familyCount = fontCollection->GetFontFamilyCount();
     for (UINT32 familyIndex = 0; familyIndex < familyCount; ++familyIndex) {
         SkTScopedComPtr<IDWriteFontFamily> fontFamily;
         HRN(fontCollection->GetFontFamily(familyIndex, &fontFamily));
 
         UINT32 fontCount = fontFamily->GetFontCount();
         for (UINT32 fontIndex = 0; fontIndex < fontCount; ++fontIndex) {
             SkTScopedComPtr<IDWriteFont> font;
             HRN(fontFamily->GetFont(fontIndex, &font));
             if (font->GetSimulations() != DWRITE_FONT_SIMULATIONS_NONE) {
                 continue;
             }
 
             SkTScopedComPtr<IDWriteFontFace> fontFace;
             HRN(font->CreateFontFace(&fontFace));
 
             UINT32 faceIndex = fontFace->GetIndex();
             if (faceIndex == ttcIndex) {
                 return DWriteFontTypeface::Create(fFactory.get(),
                                                   fontFace.get(), font.get(), fontFamily.get(),
                                                   autoUnregisterFontFileLoader.detatch(),
                                                   autoUnregisterFontCollectionLoader.detatch());
             }
         }
     }
 
-    return NULL;
+    return nullptr;
 }
 
 SkTypeface* SkFontMgr_DirectWrite::onCreateFromData(SkData* data, int ttcIndex) const {
     return this->createFromStream(new SkMemoryStream(data), ttcIndex);
 }
 
 SkTypeface* SkFontMgr_DirectWrite::onCreateFromFile(const char path[], int ttcIndex) const {
     return this->createFromStream(SkStream::NewFromFile(path), ttcIndex);
 }
 
@@ skipping 26 matching lines @@
 SkTypeface* SkFontMgr_DirectWrite::onLegacyCreateTypeface(const char familyName[],
                                                           unsigned styleBits) const {
     SkTScopedComPtr<IDWriteFontFamily> fontFamily;
     if (familyName) {
         SkSMallocWCHAR wideFamilyName;
         if (SUCCEEDED(sk_cstring_to_wchar(familyName, &wideFamilyName))) {
             this->getByFamilyName(wideFamilyName, &fontFamily);
         }
     }
 
-    if (NULL == fontFamily.get()) {
+    if (nullptr == fontFamily.get()) {
         // No family with given name, try default.
         HRNM(this->getDefaultFontFamily(&fontFamily), "Could not get default font family.");
     }
 
-    if (NULL == fontFamily.get()) {
+    if (nullptr == fontFamily.get()) {
         // Could not obtain the default font.
         HRNM(fFontCollection->GetFontFamily(0, &fontFamily),
              "Could not get default-default font family.");
     }
 
     SkTScopedComPtr<IDWriteFont> font;
     DWRITE_FONT_WEIGHT weight = (styleBits & SkTypeface::kBold)
                               ? DWRITE_FONT_WEIGHT_BOLD
                               : DWRITE_FONT_WEIGHT_NORMAL;
     DWRITE_FONT_STRETCH stretch = DWRITE_FONT_STRETCH_NORMAL;
@@ skipping 82 matching lines @@
     HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
 
     return fFontMgr->createTypefaceFromDWriteFont(fontFace.get(), font.get(),
                                                   fFontFamily.get());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 #include "SkTypeface_win.h"
 
 SK_API SkFontMgr* SkFontMgr_New_DirectWrite(IDWriteFactory* factory) {
-    if (NULL == factory) {
+    if (nullptr == factory) {
         factory = sk_get_dwrite_factory();
-        if (NULL == factory) {
-            return NULL;
+        if (nullptr == factory) {
+            return nullptr;
         }
     }
 
     SkTScopedComPtr<IDWriteFontCollection> sysFontCollection;
     HRNM(factory->GetSystemFontCollection(&sysFontCollection, FALSE),
          "Could not get system font collection.");
 
     WCHAR localeNameStorage[LOCALE_NAME_MAX_LENGTH];
-    WCHAR* localeName = NULL;
+    WCHAR* localeName = nullptr;
     int localeNameLen = 0;
 
     // Dynamically load GetUserDefaultLocaleName function, as it is not available on XP.
-    SkGetUserDefaultLocaleNameProc getUserDefaultLocaleNameProc = NULL;
+    SkGetUserDefaultLocaleNameProc getUserDefaultLocaleNameProc = nullptr;
     HRESULT hr = SkGetGetUserDefaultLocaleNameProc(&getUserDefaultLocaleNameProc);
-    if (NULL == getUserDefaultLocaleNameProc) {
+    if (nullptr == getUserDefaultLocaleNameProc) {
         SK_TRACEHR(hr, "Could not get GetUserDefaultLocaleName.");
     } else {
         localeNameLen = getUserDefaultLocaleNameProc(localeNameStorage, LOCALE_NAME_MAX_LENGTH);
         if (localeNameLen) {
             localeName = localeNameStorage;
         };
     }
 
     return new SkFontMgr_DirectWrite(factory, sysFontCollection.get(), localeName, localeNameLen);
 }
 
 #include "SkFontMgr_indirect.h"
 SK_API SkFontMgr* SkFontMgr_New_DirectWriteRenderer(SkRemotableFontMgr* proxy) {
     SkAutoTUnref<SkFontMgr> impl(SkFontMgr_New_DirectWrite());
-    if (impl.get() == NULL) {
-        return NULL;
+    if (impl.get() == nullptr) {
+        return nullptr;
     }
     return new SkFontMgr_Indirect(impl.get(), proxy);
 }