Style Change: NULL->nullptr

src/gpu/GrBatchFontCache.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrBatchFontCache_DEFINED
 #define GrBatchFontCache_DEFINED
 
@@ skipping 15 matching lines @@
 public:
     GrBatchTextStrike(GrBatchFontCache*, const GrFontDescKey* fontScalerKey);
     ~GrBatchTextStrike();
 
     const GrFontDescKey* getFontScalerKey() const { return fFontScalerKey; }
     GrBatchFontCache* getBatchFontCache() const { return fBatchFontCache; }
 
     inline GrGlyph* getGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
                              GrFontScaler* scaler) {
         GrGlyph* glyph = fCache.find(packed);
-        if (NULL == glyph) {
+        if (nullptr == glyph) {
             glyph = this->generateGlyph(skGlyph, packed, scaler);
         }
         return glyph;
     }
 
     // This variant of the above function is called by TextBatch.  At this point, it is possible
     // that the maskformat of the glyph differs from what we expect.  In these cases we will just
     // draw a clear square.
     // skbug:4143 crbug:510931
     inline GrGlyph* getGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
                              GrMaskFormat expectedMaskFormat, GrFontScaler* scaler) {
         GrGlyph* glyph = fCache.find(packed);
-        if (NULL == glyph) {
+        if (nullptr == glyph) {
             glyph = this->generateGlyph(skGlyph, packed, scaler);
             glyph->fMaskFormat = expectedMaskFormat;
         }
         return glyph;
     }
 
     // returns true if glyph successfully added to texture atlas, false otherwise.  If the glyph's
     // mask format has changed, then addGlyphToAtlas will draw a clear box.  This will almost never
     // happen.
     // TODO we can handle some of these cases if we really want to, but the long term solution is to
@@ skipping 42 matching lines @@
 class GrBatchFontCache {
 public:
     GrBatchFontCache(GrContext*);
     ~GrBatchFontCache();
     // The user of the cache may hold a long-lived ref to the returned strike. However, actions by
     // another client of the cache may cause the strike to be purged while it is still reffed.
     // Therefore, the caller must check GrBatchTextStrike::isAbandoned() if there are other
     // interactions with the cache since the strike was received.
     inline GrBatchTextStrike* getStrike(GrFontScaler* scaler) {
         GrBatchTextStrike* strike = fCache.find(*(scaler->getKey()));
-        if (NULL == strike) {
+        if (nullptr == strike) {
             strike = this->generateStrike(scaler);
         }
         return strike;
     }
 
     void freeAll();
 
-    // if getTexture returns NULL, the client must not try to use other functions on the
+    // if getTexture returns nullptr, the client must not try to use other functions on the
     // GrBatchFontCache which use the atlas.  This function *must* be called first, before other
     // functions which use the atlas.
     GrTexture* getTexture(GrMaskFormat format) {
         if (this->initAtlas(format)) {
             return this->getAtlas(format)->getTexture();
         }
-        return NULL;
+        return nullptr;
     }
 
     bool hasGlyph(GrGlyph* glyph) {
         SkASSERT(glyph);
         return this->getAtlas(glyph->fMaskFormat)->hasID(glyph->fID);
     }
 
     // To ensure the GrBatchAtlas does not evict the Glyph Mask from its texture backing store,
     // the client must pass in the current batch token along with the GrGlyph.
     // A BulkUseTokenUpdater is used to manage bulk last use token updating in the Atlas.
@@ skipping 76 matching lines @@
     static void HandleEviction(GrBatchAtlas::AtlasID, void*);
 
     GrContext* fContext;
     SkTDynamicHash<GrBatchTextStrike, GrFontDescKey> fCache;
     GrBatchAtlas* fAtlases[kMaskFormatCount];
     GrBatchTextStrike* fPreserveStrike;
     GrBatchAtlasConfig fAtlasConfigs[kMaskFormatCount];
 };
 
 #endif