Style Change: NULL->nullptr

gm/fontmgr.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkCanvas.h"
 #include "SkFontMgr.h"
@@ skipping 18 matching lines @@
                               const char* fontName, const char* bcp47[], int bcp47Count,
                               const SkFontStyle& fontStyle) {
     // find typeface containing the requested character and draw it
     SkString ch;
     ch.appendUnichar(character);
     SkTypeface* typeface = fm->matchFamilyStyleCharacter(fontName, fontStyle,
                                                          bcp47, bcp47Count, character);
     SkSafeUnref(paint.setTypeface(typeface));
     x = drawString(canvas, ch, x, y, paint) + 20;
 
-    if (NULL == typeface) {
+    if (nullptr == typeface) {
         return x;
     }
 
     // repeat the process, but this time use the family name of the typeface
     // from the first pass.  This emulates the behavior in Blink where it
     // it expects to get the same glyph when following this pattern.
     SkString familyName;
     typeface->getFamilyName(&familyName);
     SkTypeface* typefaceCopy = fm->legacyCreateTypeface(familyName.c_str(), typeface->style());
     SkSafeUnref(paint.setTypeface(typefaceCopy));
     return drawString(canvas, ch, x, y, paint) + 20;
 }
 
 static const char* zh = "zh";
 static const char* ja = "ja";
 
 class FontMgrGM : public skiagm::GM {
 public:
-    FontMgrGM(SkFontMgr* fontMgr = NULL) {
+    FontMgrGM(SkFontMgr* fontMgr = nullptr) {
         SkGraphics::SetFontCacheLimit(16 * 1024 * 1024);
 
         fName.set("fontmgr_iter");
         if (fontMgr) {
             fName.append("_factory");
             fFM.reset(fontMgr);
         } else {
             fFM.reset(SkFontMgr::RefDefault());
         }
         fName.append(sk_tool_utils::platform_os_name());
@@ skipping 16 matching lines @@
         paint.setLCDRenderText(true);
         paint.setSubpixelText(true);
         paint.setTextSize(17);
 
         SkFontMgr* fm = fFM;
         int count = SkMin32(fm->countFamilies(), MAX_FAMILIES);
 
         for (int i = 0; i < count; ++i) {
             SkString familyName;
             fm->getFamilyName(i, &familyName);
-            paint.setTypeface(NULL);
+            paint.setTypeface(nullptr);
             (void)drawString(canvas, familyName, 20, y, paint);
 
             SkScalar x = 220;
 
             SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
             for (int j = 0; j < set->count(); ++j) {
                 SkString sname;
                 SkFontStyle fs;
                 set->getStyle(j, &fs, &sname);
                 sname.appendf(" [%d %d %d]", fs.weight(), fs.width(), fs.isItalic());
 
                 SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
                 x = drawString(canvas, sname, x, y, paint) + 20;
 
                 // check to see that we get different glyphs in japanese and chinese
                 x = drawCharacter(canvas, 0x5203, x, y, paint, fm, familyName.c_str(), &zh, 1, fs);
                 x = drawCharacter(canvas, 0x5203, x, y, paint, fm, familyName.c_str(), &ja, 1, fs);
                 // check that emoji characters are found
-                x = drawCharacter(canvas, 0x1f601, x, y, paint, fm, familyName.c_str(), NULL,0, fs);
+                x = drawCharacter(canvas, 0x1f601, x, y, paint, fm, familyName.c_str(), nullptr,0, fs);
             }
             y += 24;
         }
     }
 
 private:
     SkAutoTUnref<SkFontMgr> fFM;
     SkString fName;
     typedef GM INHERITED;
 };
@@ skipping 67 matching lines @@
             "Helvetica Neue", "Arial"
         };
 
         SkAutoTUnref<SkFontStyleSet> fset;
         for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
             fset.reset(fFM->matchFamily(gNames[i]));
             if (fset->count() > 0) {
                 break;
             }
         }
-        if (NULL == fset.get()) {
+        if (nullptr == fset.get()) {
             return;
         }
 
         canvas->translate(20, 40);
         this->exploreFamily(canvas, paint, fset);
         canvas->translate(150, 0);
         this->iterateFamily(canvas, paint, fset);
     }
 
 private:
@@ skipping 89 matching lines @@
 
 DEF_GM(return new FontMgrGM;)
 DEF_GM(return new FontMgrMatchGM;)
 DEF_GM(return new FontMgrBoundsGM(1.0, 0);)
 DEF_GM(return new FontMgrBoundsGM(0.75, 0);)
 DEF_GM(return new FontMgrBoundsGM(1.0, -0.25);)
 
 #ifdef SK_BUILD_FOR_WIN
 DEF_GM(return new FontMgrGM(SkFontMgr_New_DirectWrite());)
 #endif