Style Change: NULL->nullptr

src/core/SkBitmapHeap.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkBitmapHeap_DEFINED
 #define SkBitmapHeap_DEFINED
 
@@ skipping 98 matching lines @@
      * @param heapSize  The maximum size of the heap. Because of the sequential limitation imposed
      *   by our LRU implementation we can guarantee that the heap will never grow beyond this size.
      */
     SkBitmapHeap(ExternalStorage* externalStorage, int32_t heapSize = UNLIMITED_SIZE);
 
     virtual ~SkBitmapHeap();
 
     /**
      * Retrieves the bitmap from the specified slot in the heap
      *
-     * @return  The bitmap located at that slot or NULL if external storage is being used.
+     * @return  The bitmap located at that slot or nullptr if external storage is being used.
      */
     SkBitmap* getBitmap(int32_t slot) const override {
-        SkASSERT(fExternalStorage == NULL);
+        SkASSERT(fExternalStorage == nullptr);
         SkBitmapHeapEntry* entry = getEntry(slot);
         if (entry) {
             return &entry->fBitmap;
         }
-        return NULL;
+        return nullptr;
     }
 
     /**
      * Retrieves the bitmap from the specified slot in the heap
      *
-     * @return  The bitmap located at that slot or NULL if external storage is being used.
+     * @return  The bitmap located at that slot or nullptr if external storage is being used.
      */
     void releaseRef(int32_t slot) override {
-        SkASSERT(fExternalStorage == NULL);
+        SkASSERT(fExternalStorage == nullptr);
         if (fOwnerCount != IGNORE_OWNERS) {
             SkBitmapHeapEntry* entry = getEntry(slot);
             if (entry) {
                 entry->releaseRef();
             }
         }
     }
 
     /**
      * Inserts a bitmap into the heap. The stored version of bitmap is guaranteed to be immutable
      * and is not dependent on the lifecycle of the provided bitmap.
      *
      * @param bitmap  the bitmap to be inserted into the heap
      * @return  the slot in the heap where the bitmap is stored or INVALID_SLOT if the bitmap could
      *          not be added to the heap. If it was added the slot will remain valid...
      *            (1) indefinitely if no owner count has been specified.
      *            (2) until all owners have called releaseRef on the appropriate SkBitmapHeapEntry*
      */
     int32_t insert(const SkBitmap& bitmap);
 
     /**
      * Retrieves an entry from the heap at a given slot.
      *
      * @param slot  the slot in the heap where a bitmap was stored.
-     * @return  a SkBitmapHeapEntry that wraps the bitmap or NULL if external storage is used.
+     * @return  a SkBitmapHeapEntry that wraps the bitmap or nullptr if external storage is used.
      */
     SkBitmapHeapEntry* getEntry(int32_t slot) const {
         SkASSERT(slot <= fStorage.count());
-        if (fExternalStorage != NULL) {
-            return NULL;
+        if (fExternalStorage != nullptr) {
+            return nullptr;
         }
         return fStorage[slot];
     }
 
     /**
      * Returns a count of the number of items currently in the heap
      */
     int count() const {
-        SkASSERT(fExternalStorage != NULL ||
+        SkASSERT(fExternalStorage != nullptr ||
                  fStorage.count() - fUnusedSlots.count() == fLookupTable.count());
         return fLookupTable.count();
     }
 
     /**
      * Returns the total number of bytes allocated by the bitmaps in the heap
      */
     size_t bytesAllocated() const {
         return fBytesAllocated;
     }
@@ skipping 22 matching lines @@
      */
     void endAddingOwnersDeferral(bool add);
 
 private:
     struct LookupEntry {
         LookupEntry(const SkBitmap& bm)
         : fGenerationId(bm.getGenerationID())
         , fPixelOrigin(bm.pixelRefOrigin())
         , fWidth(bm.width())
         , fHeight(bm.height())
-        , fMoreRecentlyUsed(NULL)
-        , fLessRecentlyUsed(NULL){}
+        , fMoreRecentlyUsed(nullptr)
+        , fLessRecentlyUsed(nullptr){}
 
         const uint32_t fGenerationId; // SkPixelRef GenerationID.
         const SkIPoint fPixelOrigin;
         const uint32_t fWidth;
         const uint32_t fHeight;
 
         // TODO: Generalize the LRU caching mechanism
         LookupEntry* fMoreRecentlyUsed;
         LookupEntry* fLessRecentlyUsed;
 
@@ skipping 23 matching lines @@
      *               in the lookup table is populated with the entry from the heap storage.
      */
     int findInLookupTable(const LookupEntry& key, SkBitmapHeapEntry** entry);
 
     LookupEntry* findEntryToReplace(const SkBitmap& replacement);
     bool copyBitmap(const SkBitmap& originalBitmap, SkBitmap& copiedBitmap);
 
     /**
      * Remove a LookupEntry from the LRU, in preparation for either deleting or appending as most
      * recent. Points the LookupEntry's old neighbors at each other, and sets fLeastRecentlyUsed
-     * (if there is still an entry left). Sets LookupEntry's fMoreRecentlyUsed to NULL and leaves
+     * (if there is still an entry left). Sets LookupEntry's fMoreRecentlyUsed to nullptr and leaves
      * its fLessRecentlyUsed unmodified.
      */
     void removeFromLRU(LookupEntry* entry);
 
     /**
      * Append a LookupEntry to the end of the LRU cache, marking it as the most
      * recently used. Assumes that the LookupEntry is already in fLookupTable,
      * but is not in the LRU cache. If it is in the cache, removeFromLRU should
      * be called first.
      */
@@ skipping 16 matching lines @@
     const int32_t fOwnerCount;
     size_t fBytesAllocated;
 
     bool fDeferAddingOwners;
     SkTDArray<int> fDeferredEntries;
 
     typedef SkBitmapHeapReader INHERITED;
 };
 
 #endif // SkBitmapHeap_DEFINED