Style Change: NULL->nullptr

src/core/SkResourceCache.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkResourceCache_DEFINED
 #define SkResourceCache_DEFINED
 
@@ skipping 61 matching lines @@
         Rec() {}
         virtual ~Rec() {}
 
         uint32_t getHash() const { return this->getKey().hash(); }
 
         virtual const Key& getKey() const = 0;
         virtual size_t bytesUsed() const = 0;
 
         // for memory usage diagnostics
         virtual const char* getCategory() const = 0;
-        virtual SkDiscardableMemory* diagnostic_only_getDiscardable() const { return NULL; }
+        virtual SkDiscardableMemory* diagnostic_only_getDiscardable() const { return nullptr; }
 
         // for SkTDynamicHash::Traits
         static uint32_t Hash(const Key& key) { return key.hash(); }
         static const Key& GetKey(const Rec& rec) { return rec.getKey(); }
 
     private:
         Rec*    fNext;
         Rec*    fPrev;
 
         friend class SkResourceCache;
@@ skipping 15 matching lines @@
      *  (casting context to whatever it really is).
      *
      *  The return value determines what the cache will do with the Rec. If the function returns
      *  true, then the Rec is considered "valid". If false is returned, the Rec will be considered
      *  "stale" and will be purged from the cache.
      */
     typedef bool (*FindVisitor)(const Rec&, void* context);
 
     /**
      *  Returns a locked/pinned SkDiscardableMemory instance for the specified
-     *  number of bytes, or NULL on failure.
+     *  number of bytes, or nullptr on failure.
      */
     typedef SkDiscardableMemory* (*DiscardableFactory)(size_t bytes);
 
     /*
      *  The following static methods are thread-safe wrappers around a global
      *  instance of this cache.
      */
 
     /**
      *  Returns true if the visitor was called on a matching Key, and the visitor returned true.
@@ skipping 17 matching lines @@
 
     static size_t SetSingleAllocationByteLimit(size_t);
     static size_t GetSingleAllocationByteLimit();
     static size_t GetEffectiveSingleAllocationByteLimit();
 
     static void PurgeAll();
 
     static void TestDumpMemoryStatistics();
 
     /**
-     *  Returns the DiscardableFactory used by the global cache, or NULL.
+     *  Returns the DiscardableFactory used by the global cache, or nullptr.
      */
     static DiscardableFactory GetDiscardableFactory();
 
     /**
      * Use this allocator for bitmaps, so they can use ashmem when available.
-     * Returns NULL if the ResourceCache has not been initialized with a DiscardableFactory.
+     * Returns nullptr if the ResourceCache has not been initialized with a DiscardableFactory.
      */
     static SkBitmap::Allocator* GetAllocator();
 
     static SkCachedData* NewCachedData(size_t bytes);
 
     static void PostPurgeSharedID(uint64_t sharedID);
 
     /**
      *  Call SkDebugf() with diagnostic information about the state of the cache
      */
@@ skipping 70 matching lines @@
     void dump() const;
 
 private:
     Rec*    fHead;
     Rec*    fTail;
 
     class Hash;
     Hash*   fHash;
 
     DiscardableFactory  fDiscardableFactory;
-    // the allocator is NULL or one that matches discardables
+    // the allocator is nullptr or one that matches discardables
     SkBitmap::Allocator* fAllocator;
 
     size_t  fTotalBytesUsed;
     size_t  fTotalByteLimit;
     size_t  fSingleAllocationByteLimit;
     int     fCount;
 
     SkMessageBus<PurgeSharedIDMessage>::Inbox fPurgeSharedIDInbox;
 
     void checkMessages();
     void purgeAsNeeded(bool forcePurge = false);
 
     // linklist management
     void moveToHead(Rec*);
     void addToHead(Rec*);
     void detach(Rec*);
     void remove(Rec*);
 
     void init();    // called by constructors
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 };
 #endif