Style Change: NULL->nullptr

src/core/SkPictureFlat.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPictureFlat_DEFINED
 #define SkPictureFlat_DEFINED
 
@@ skipping 278 matching lines @@
         // Put the serialized contents into the data section of the new allocation.
         buffer.writeToMemory(result->data());
         // Stamp the index, size and checksum in the header.
         result->stampHeader(index, SkToS32(size));
         return result;
     }
 
     // Unflatten this into result, using bitmapHeap and facePlayback for bitmaps and fonts if given
     template <typename Traits, typename T>
     void unflatten(T* result,
-                   SkBitmapHeap* bitmapHeap = NULL,
-                   SkTypefacePlayback* facePlayback = NULL) const {
+                   SkBitmapHeap* bitmapHeap = nullptr,
+                   SkTypefacePlayback* facePlayback = nullptr) const {
         SkReadBuffer buffer(this->data(), fFlatSize);
 
         if (bitmapHeap) {
             buffer.setBitmapStorage(bitmapHeap);
         }
         if (facePlayback) {
             facePlayback->setupBuffer(buffer);
         }
 
         Traits::Unflatten(buffer, result);
@@ skipping 93 matching lines @@
      *
      */
     int find(const T& element) {
         return this->findAndReturnFlat(element)->index();
     }
 
     /**
      * Similar to find. Allows the caller to specify an SkFlatData to replace in
      * the case of an add. Also tells the caller whether a new SkFlatData was
      * added and whether the old one was replaced. The parameters added and
-     * replaced are required to be non-NULL. Rather than returning the index of
+     * replaced are required to be non-nullptr. Rather than returning the index of
      * the entry in the dictionary, it returns the actual SkFlatData.
      */
     const SkFlatData* findAndReplace(const T& element,
                                      const SkFlatData* toReplace,
                                      bool* added,
                                      bool* replaced) {
-        SkASSERT(added != NULL && replaced != NULL);
+        SkASSERT(added != nullptr && replaced != nullptr);
 
         const int oldCount = this->count();
         SkFlatData* flat = this->findAndReturnMutableFlat(element);
         *added = this->count() > oldCount;
 
         // If we don't want to replace anything, we're done.
-        if (!*added || toReplace == NULL) {
+        if (!*added || toReplace == nullptr) {
             *replaced = false;
             return flat;
         }
 
         // If we don't have the thing to replace, we're done.
         const SkFlatData* found = fHash.find(*toReplace);
-        if (found == NULL) {
+        if (found == nullptr) {
             *replaced = false;
             return flat;
         }
 
         // findAndReturnMutableFlat put flat at the back.  Swap it into found->index() instead.
         // indices in SkFlatData are 1-based, while fIndexedData is 0-based.  Watch out!
         SkASSERT(flat->index() == this->count());
         flat->setIndex(found->index());
         fIndexedData.removeShuffle(found->index()-1);
         SkASSERT(flat == fIndexedData[found->index()-1]);
@@ skipping 16 matching lines @@
         const SkFlatData* element = fIndexedData[index-1];
         SkASSERT(index == element->index());
 
         T* dst = new T;
         this->unflatten(dst, element);
         return dst;
     }
 
     /**
      * Find or insert a flattened version of element into the dictionary.
-     * Caller does not take ownership of the result.  This will not return NULL.
+     * Caller does not take ownership of the result.  This will not return nullptr.
      */
     const SkFlatData* findAndReturnFlat(const T& element) {
         return this->findAndReturnMutableFlat(element);
     }
 
 private:
     // We have to delay fScratch's initialization until its first use; fController might not
     // be fully set up by the time we get it in the constructor.
     void lazyInit() {
         if (fReady) {
             return;
         }
 
         // Without a bitmap heap, we'll flatten bitmaps into paints.  That's never what you want.
-        SkASSERT(fController->getBitmapHeap() != NULL);
+        SkASSERT(fController->getBitmapHeap() != nullptr);
         fScratch.setBitmapHeap(fController->getBitmapHeap());
         fScratch.setTypefaceRecorder(fController->getTypefaceSet());
         fScratch.setNamedFactoryRecorder(fController->getNamedFactorySet());
         fReady = true;
     }
 
     // As findAndReturnFlat, but returns a mutable pointer for internal use.
     SkFlatData* findAndReturnMutableFlat(const T& element) {
         // Only valid until the next call to resetScratch().
         const SkFlatData& scratch = this->resetScratch(element, this->count()+1);
 
         SkFlatData* candidate = fHash.find(scratch);
-        if (candidate != NULL) {
+        if (candidate != nullptr) {
             return candidate;
         }
 
         SkFlatData* detached = this->detachScratch();
         fHash.add(detached);
         *fIndexedData.append() = detached;
         SkASSERT(fIndexedData.top()->index() == this->count());
         return detached;
     }
 
     // This reference is valid only until the next call to resetScratch() or detachScratch().
     const SkFlatData& resetScratch(const T& element, int index) {
         this->lazyInit();
 
         // Layout of fScratch: [ SkFlatData header, 20 bytes ] [ data ..., 4-byte aligned ]
         fScratch.reset();
         fScratch.reserve(sizeof(SkFlatData));
         Traits::Flatten(fScratch, element);
         const size_t dataSize = fScratch.bytesWritten() - sizeof(SkFlatData);
 
         // Reinterpret data in fScratch as an SkFlatData.
         SkFlatData* scratch = (SkFlatData*)fScratch.getWriter32()->contiguousArray();
-        SkASSERT(scratch != NULL);
+        SkASSERT(scratch != nullptr);
         scratch->stampHeader(index, SkToS32(dataSize));
         return *scratch;
     }
 
     // This result is owned by fController and lives as long as it does (unless unalloc'd).
     SkFlatData* detachScratch() {
         // Allocate a new SkFlatData exactly big enough to hold our current scratch.
         // We use the controller for this allocation to extend the allocation's lifetime and allow
         // the controller to do whatever memory management it wants.
         SkFlatData* detached = (SkFlatData*)fController->allocThrow(fScratch.bytesWritten());
 
         // Copy scratch into the new SkFlatData.
         SkFlatData* scratch = (SkFlatData*)fScratch.getWriter32()->contiguousArray();
-        SkASSERT(scratch != NULL);
+        SkASSERT(scratch != nullptr);
         memcpy(detached, scratch, fScratch.bytesWritten());
 
         // We can now reuse fScratch, and detached will live until fController dies.
         return detached;
     }
 
     void unflatten(T* dst, const SkFlatData* element) const {
         element->unflatten<Traits>(dst,
                                    fController->getBitmapHeap(),
                                    fController->getTypefacePlayback());
     }
 
     // All SkFlatData* stored in fIndexedData and fHash are owned by the controller.
     SkAutoTUnref<SkFlatController> fController;
     SkWriteBuffer fScratch;
     bool fReady;
 
     // For index -> SkFlatData.  0-based, while all indices in the API are 1-based.  Careful!
     SkTDArray<const SkFlatData*> fIndexedData;
 
     // For SkFlatData -> cached SkFlatData, which has index().
     SkTDynamicHash<SkFlatData, SkFlatData, SkFlatData::HashTraits> fHash;
 };
 
 #endif