Style Change: NULL->nullptr

src/ports/SkRemotableFontMgr_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 "SkDataTable.h"
@@ skipping 16 matching lines @@
         IUnknown* fLoader;  // In COM only IUnknown pointers may be safely used for identity.
         void* fKey;
         UINT32 fKeySize;
 
         DataId() { }
 
         // This is actually a move!!!
         explicit DataId(DataId& that)
             : fLoader(that.fLoader), fKey(that.fKey), fKeySize(that.fKeySize)
         {
-            that.fLoader = NULL;
-            that.fKey = NULL;
+            that.fLoader = nullptr;
+            that.fKey = nullptr;
             SkDEBUGCODE(that.fKeySize = 0xFFFFFFFF;)
         }
 
         ~DataId() {
             if (fLoader) {
                 fLoader->Release();
             }
             sk_free(fKey);
         }
     };
@@ skipping 60 matching lines @@
             names.appendString(familyName);
         }
         return names.detachDataTable();
     }
 
     HRESULT FontToIdentity(IDWriteFont* font, SkFontIdentity* fontId) const {
         SkTScopedComPtr<IDWriteFontFace> fontFace;
         HRM(font->CreateFontFace(&fontFace), "Could not create font face.");
 
         UINT32 numFiles;
-        HR(fontFace->GetFiles(&numFiles, NULL));
+        HR(fontFace->GetFiles(&numFiles, nullptr));
         if (numFiles > 1) {
             return E_FAIL;
         }
 
         // data id
         SkTScopedComPtr<IDWriteFontFile> fontFile;
         HR(fontFace->GetFiles(&numFiles, &fontFile));
 
         SkTScopedComPtr<IDWriteFontFileLoader> fontFileLoader;
         HR(fontFile->GetLoader(&fontFileLoader));
@@ skipping 56 matching lines @@
                    "Could not get requested family.",
                    identity);
 
         const DWriteStyle dwStyle(pattern);
         SkTScopedComPtr<IDWriteFont> font;
         HR_GENERAL(fontFamily->GetFirstMatchingFont(dwStyle.fWeight, dwStyle.fWidth,
                                                     dwStyle.fSlant, &font),
                    "Could not match font in family.",
                    identity);
 
-        HR_GENERAL(FontToIdentity(font.get(), &identity), NULL, identity);
+        HR_GENERAL(FontToIdentity(font.get(), &identity), nullptr, identity);
 
         return identity;
     }
 
     static HRESULT getDefaultFontFamilyName(SkSMallocWCHAR* name) {
         NONCLIENTMETRICSW metrics;
         metrics.cbSize = sizeof(metrics);
         if (0 == SystemParametersInfoW(SPI_GETNONCLIENTMETRICS,
                                        sizeof(metrics),
                                        &metrics,
                                        0)) {
             return E_UNEXPECTED;
         }
 
         size_t len = wcsnlen_s(metrics.lfMessageFont.lfFaceName, LF_FACESIZE) + 1;
         if (0 != wcsncpy_s(name->reset(len), len, metrics.lfMessageFont.lfFaceName, _TRUNCATE)) {
             return E_UNEXPECTED;
         }
 
         return S_OK;
     }
 
     SkRemotableFontIdentitySet* matchName(const char familyName[]) const override {
         SkSMallocWCHAR dwFamilyName;
-        if (NULL == familyName) {
+        if (nullptr == familyName) {
             HR_GENERAL(getDefaultFontFamilyName(&dwFamilyName),
-                       NULL, SkRemotableFontIdentitySet::NewEmpty());
+                       nullptr, SkRemotableFontIdentitySet::NewEmpty());
         } else {
             HR_GENERAL(sk_cstring_to_wchar(familyName, &dwFamilyName),
-                       NULL, SkRemotableFontIdentitySet::NewEmpty());
+                       nullptr, SkRemotableFontIdentitySet::NewEmpty());
         }
 
         UINT32 index;
         BOOL exists;
         HR_GENERAL(fFontCollection->FindFamilyName(dwFamilyName.get(), &index, &exists),
                    "Failed while finding family by name.",
                    SkRemotableFontIdentitySet::NewEmpty());
         if (!exists) {
             return SkRemotableFontIdentitySet::NewEmpty();
         }
 
         return this->getIndex(index);
     }
 
     virtual SkFontIdentity matchNameStyle(const char familyName[],
                                           const SkFontStyle& style) const override
     {
         SkFontIdentity identity = { SkFontIdentity::kInvalidDataId };
 
         SkSMallocWCHAR dwFamilyName;
-        if (NULL == familyName) {
-            HR_GENERAL(getDefaultFontFamilyName(&dwFamilyName), NULL, identity);
+        if (nullptr == familyName) {
+            HR_GENERAL(getDefaultFontFamilyName(&dwFamilyName), nullptr, identity);
         } else {
-            HR_GENERAL(sk_cstring_to_wchar(familyName, &dwFamilyName), NULL, identity);
+            HR_GENERAL(sk_cstring_to_wchar(familyName, &dwFamilyName), nullptr, identity);
         }
 
         UINT32 index;
         BOOL exists;
         HR_GENERAL(fFontCollection->FindFamilyName(dwFamilyName.get(), &index, &exists),
                    "Failed while finding family by name.",
                    identity);
         if (!exists) {
             return identity;
         }
@@ skipping 106 matching lines @@
             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;
         }
 
         const SkFontIdentity FallbackIdentity() { return fIdentity; }
 
     protected:
         ULONG fRefCount;
         SkAutoTUnref<const SkRemotableFontMgr_DirectWrite> fOuter;
         UINT32 fCharacter;
         SkFontIdentity fIdentity;
     };
 
     virtual SkFontIdentity matchNameStyleCharacter(const char familyName[],
                                                    const SkFontStyle& pattern,
                                                    const char* bcp47[], int bcp47Count,
                                                    SkUnichar character) const override
     {
         SkFontIdentity identity = { SkFontIdentity::kInvalidDataId };
 
         IDWriteFactory* dwFactory = sk_get_dwrite_factory();
-        if (NULL == dwFactory) {
+        if (nullptr == dwFactory) {
             return identity;
         }
 
         // TODO: use IDWriteFactory2::GetSystemFontFallback when available.
 
         const DWriteStyle dwStyle(pattern);
 
         SkSMallocWCHAR dwFamilyName;
-        if (NULL == familyName) {
-            HR_GENERAL(getDefaultFontFamilyName(&dwFamilyName), NULL, identity);
+        if (nullptr == familyName) {
+            HR_GENERAL(getDefaultFontFamilyName(&dwFamilyName), nullptr, identity);
         } else {
-            HR_GENERAL(sk_cstring_to_wchar(familyName, &dwFamilyName), NULL, identity);
+            HR_GENERAL(sk_cstring_to_wchar(familyName, &dwFamilyName), nullptr, identity);
         }
 
         const SkSMallocWCHAR* dwBcp47;
         SkSMallocWCHAR dwBcp47Local;
         if (bcp47Count < 1) {
             dwBcp47 = &fLocaleName;
         } else {
             //TODO: support fallback stack.
-            HR_GENERAL(sk_cstring_to_wchar(bcp47[bcp47Count-1], &dwBcp47Local), NULL, identity);
+            HR_GENERAL(sk_cstring_to_wchar(bcp47[bcp47Count-1], &dwBcp47Local), nullptr, identity);
             dwBcp47 = &dwBcp47Local;
         }
 
         SkTScopedComPtr<IDWriteTextFormat> fallbackFormat;
         HR_GENERAL(dwFactory->CreateTextFormat(dwFamilyName,
                                                fFontCollection.get(),
                                                dwStyle.fWeight,
                                                dwStyle.fSlant,
                                                dwStyle.fWidth,
                                                72.0f,
                                                *dwBcp47,
                                                &fallbackFormat),
                    "Could not create text format.",
                    identity);
 
         WCHAR str[16];
         UINT32 strLen = static_cast<UINT32>(
             SkUTF16_FromUnichar(character, reinterpret_cast<uint16_t*>(str)));
         SkTScopedComPtr<IDWriteTextLayout> fallbackLayout;
         HR_GENERAL(dwFactory->CreateTextLayout(str, strLen, fallbackFormat.get(),
                                                200.0f, 200.0f,
                                                &fallbackLayout),
                    "Could not create text layout.",
                    identity);
 
         SkTScopedComPtr<FontFallbackRenderer> fontFallbackRenderer(
             new FontFallbackRenderer(this, character));
 
-        HR_GENERAL(fallbackLayout->Draw(NULL, fontFallbackRenderer.get(), 50.0f, 50.0f),
+        HR_GENERAL(fallbackLayout->Draw(nullptr, fontFallbackRenderer.get(), 50.0f, 50.0f),
                    "Could not draw layout with renderer.",
                    identity);
 
         return fontFallbackRenderer->FallbackIdentity();
     }
 
     SkStreamAsset* getData(int dataId) const override {
         SkAutoMutexAcquire ama(fDataIdCacheMutex);
         if (dataId >= fDataIdCache.count()) {
-            return NULL;
+            return nullptr;
         }
         const DataId& id = fDataIdCache[dataId];
 
         SkTScopedComPtr<IDWriteFontFileLoader> loader;
         HRNM(id.fLoader->QueryInterface(&loader), "QuerryInterface IDWriteFontFileLoader failed");
 
         SkTScopedComPtr<IDWriteFontFileStream> fontFileStream;
         HRNM(loader->CreateStreamFromKey(id.fKey, id.fKeySize, &fontFileStream),
              "Could not create font file stream.");
 
         return new SkDWriteFontFileStream(fontFileStream.get());
     }
 
 private:
     SkTScopedComPtr<IDWriteFontCollection> fFontCollection;
     SkSMallocWCHAR fLocaleName;
 
     typedef SkRemotableFontMgr INHERITED;
 };
 
 SkRemotableFontMgr* SkRemotableFontMgr_New_DirectWrite() {
     IDWriteFactory* 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 SkRemotableFontMgr_DirectWrite(sysFontCollection.get(), localeName, localeNameLen);
 }