Style Change: NULL->nullptr

src/gpu/GrBatchFontCache.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBatchFontCache.h"
 #include "GrContext.h"
 #include "GrGpu.h"
@@ skipping 22 matching lines @@
                                                           (void*)this);
         if (!fAtlases[index]) {
             return false;
         }
     }
     return true;
 }
 
 GrBatchFontCache::GrBatchFontCache(GrContext* context)
     : fContext(context)
-    , fPreserveStrike(NULL) {
+    , fPreserveStrike(nullptr) {
     for (int i = 0; i < kMaskFormatCount; ++i) {
-        fAtlases[i] = NULL;
+        fAtlases[i] = nullptr;
     }
 
     // setup default atlas configs
     fAtlasConfigs[kA8_GrMaskFormat].fWidth = 2048;
     fAtlasConfigs[kA8_GrMaskFormat].fHeight = 2048;
     fAtlasConfigs[kA8_GrMaskFormat].fPlotWidth = 512;
     fAtlasConfigs[kA8_GrMaskFormat].fPlotHeight = 256;
 
     fAtlasConfigs[kA565_GrMaskFormat].fWidth = 1024;
     fAtlasConfigs[kA565_GrMaskFormat].fHeight = 2048;
@@ skipping 21 matching lines @@
 void GrBatchFontCache::freeAll() {
     SkTDynamicHash<GrBatchTextStrike, GrFontDescKey>::Iter iter(&fCache);
     while (!iter.done()) {
         (*iter).fIsAbandoned = true;
         (*iter).unref();
         ++iter;
     }
     fCache.rewind();
     for (int i = 0; i < kMaskFormatCount; ++i) {
         delete fAtlases[i];
-        fAtlases[i] = NULL;
+        fAtlases[i] = nullptr;
     }
 }
 
 void GrBatchFontCache::HandleEviction(GrBatchAtlas::AtlasID id, void* ptr) {
     GrBatchFontCache* fontCache = reinterpret_cast<GrBatchFontCache*>(ptr);
 
     SkTDynamicHash<GrBatchTextStrike, GrFontDescKey>::Iter iter(&fontCache->fCache);
     for (; !iter.done(); ++iter) {
         GrBatchTextStrike* strike = &*iter;
         strike->removeID(id);
@@ skipping 26 matching lines @@
     }
     ++gDumpCount;
 }
 
 void GrBatchFontCache::setAtlasSizes_ForTesting(const GrBatchAtlasConfig configs[3]) {
     // delete any old atlases, this should be safe to do as long as we are not in the middle of a
     // flush
     for (int i = 0; i < kMaskFormatCount; i++) {
         if (fAtlases[i]) {
             delete fAtlases[i];
-            fAtlases[i] = NULL;
+            fAtlases[i] = nullptr;
         }
     }
     memcpy(fAtlasConfigs, configs, sizeof(fAtlasConfigs));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /*
     The text strike is specific to a given font/style/matrix setup, which is
     represented by the GrHostFontScaler object we are given in getGlyph().
@@ skipping 17 matching lines @@
         (*iter).free();
         ++iter;
     }
 }
 
 GrGlyph* GrBatchTextStrike::generateGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
                                           GrFontScaler* scaler) {
     SkIRect bounds;
     if (GrGlyph::kDistance_MaskStyle == GrGlyph::UnpackMaskStyle(packed)) {
         if (!scaler->getPackedGlyphDFBounds(skGlyph, &bounds)) {
-            return NULL;
+            return nullptr;
         }
     } else {
         if (!scaler->getPackedGlyphBounds(skGlyph, &bounds)) {
-            return NULL;
+            return nullptr;
         }
     }
     GrMaskFormat format = scaler->getPackedGlyphMaskFormat(skGlyph);
 
     GrGlyph* glyph = (GrGlyph*)fPool.alloc(sizeof(GrGlyph), SK_MALLOC_THROW);
     glyph->init(packed, bounds, format);
     fCache.add(glyph);
     return glyph;
 }
 
@@ skipping 38 matching lines @@
 
     bool success = fBatchFontCache->addToAtlas(this, &glyph->fID, target, expectedMaskFormat,
                                                glyph->width(), glyph->height(),
                                                storage.get(), &glyph->fAtlasLocation);
     if (success) {
         SkASSERT(GrBatchAtlas::kInvalidAtlasID != glyph->fID);
         fAtlasedGlyphs++;
     }
     return success;
 }