Style Change: NULL->nullptr

src/core/SkGlyphCache.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
  */
 
 #ifndef SkGlyphCache_DEFINED
 #define SkGlyphCache_DEFINED
 
 #include "SkBitmap.h"
@@ skipping 99 matching lines @@
     //! If the proc is found, return true and set *dataPtr to its data
     bool getAuxProcData(void (*auxProc)(void*), void** dataPtr) const;
 
     //! Add a proc/data pair to the glyphcache. proc should be non-null
     void setAuxProc(void (*auxProc)(void*), void* auxData);
 
     SkScalerContext* getScalerContext() const { return fScalerContext; }
 
     /** Find a matching cache entry, and call proc() with it. If none is found create a new one.
         If the proc() returns true, detach the cache and return it, otherwise leave it and return
-        NULL.
+        nullptr.
     */
     static SkGlyphCache* VisitCache(SkTypeface*, const SkDescriptor* desc,
                                     bool (*proc)(const SkGlyphCache*, void*),
                                     void* context);
 
     /** Given a strike that was returned by either VisitCache() or DetachCache() add it back into
         the global cache list (after which the caller should not reference it anymore.
     */
     static void AttachCache(SkGlyphCache*);
 
     /** Detach a strike from the global cache matching the specified descriptor. Once detached,
         it can be queried/modified by the current thread, and when finished, be reattached to the
         global cache with AttachCache(). While detached, if another request is made with the same
         descriptor, a different strike will be generated. This is fine. It does mean we can have
         more than 1 strike for the same descriptor, but that will eventually get purged, and the
         win is that different thread will never block each other while a strike is being used.
     */
     static SkGlyphCache* DetachCache(SkTypeface* typeface, const SkDescriptor* desc) {
-        return VisitCache(typeface, desc, DetachProc, NULL);
+        return VisitCache(typeface, desc, DetachProc, nullptr);
     }
 
     static void Dump();
 
     typedef void (*Visitor)(const SkGlyphCache&, void* context);
     static void VisitAll(Visitor, void* context);
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 
     class AutoValidate : SkNoncopyable {
     public:
         AutoValidate(const SkGlyphCache* cache) : fCache(cache) {
             if (fCache) {
                 fCache->validate();
             }
         }
         ~AutoValidate() {
             if (fCache) {
                 fCache->validate();
             }
         }
         void forget() {
-            fCache = NULL;
+            fCache = nullptr;
         }
     private:
         const SkGlyphCache* fCache;
     };
 
 private:
     friend class SkGlyphCache_Globals;
 
     enum MetricsType {
         kJustAdvance_MetricsType,
@@ skipping 65 matching lines @@
     AuxProcRec*            fAuxProcList;
 };
 
 class SkAutoGlyphCacheBase {
 public:
     SkGlyphCache* getCache() const { return fCache; }
 
     void release() {
         if (fCache) {
             SkGlyphCache::AttachCache(fCache);
-            fCache = NULL;
+            fCache = nullptr;
         }
     }
 
 protected:
     // Hide the constructors so we can't create one of these directly. Create SkAutoGlyphCache or
     // SkAutoGlyphCacheNoCache instead.
     SkAutoGlyphCacheBase(SkGlyphCache* cache) : fCache(cache) {}
     SkAutoGlyphCacheBase(SkTypeface* typeface, const SkDescriptor* desc) {
         fCache = SkGlyphCache::DetachCache(typeface, desc);
     }
     SkAutoGlyphCacheBase(const SkPaint& /*paint*/,
                          const SkSurfaceProps* /*surfaceProps*/,
                          const SkMatrix* /*matrix*/) {
-        fCache = NULL;
+        fCache = nullptr;
     }
     SkAutoGlyphCacheBase() {
-        fCache = NULL;
+        fCache = nullptr;
     }
     ~SkAutoGlyphCacheBase() {
         if (fCache) {
             SkGlyphCache::AttachCache(fCache);
         }
     }
 
     SkGlyphCache*   fCache;
 
 private:
@@ skipping 26 matching lines @@
                             const SkMatrix* matrix) {
         fCache = paint.detachCache(surfaceProps, matrix, true);
     }
 
 private:
     SkAutoGlyphCacheNoGamma() : SkAutoGlyphCacheBase() {}
 };
 #define SkAutoGlyphCacheNoGamma(...) SK_REQUIRE_LOCAL_VAR(SkAutoGlyphCacheNoGamma)
 
 #endif