Style Change: NULL->nullptr

src/gpu/GrTRecorder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrTRecorder_DEFINED
 #define GrTRecorder_DEFINED
 
@@ skipping 36 matching lines @@
     class Iter;
     class ReverseIter;
 
     /**
      * Create a recorder.
      *
      * @param initialSizeInBytes  The amount of memory reserved by the recorder initially,
                                   and after calls to reset().
      */
     GrTRecorder(int initialSizeInBytes)
-        : fHeadBlock(MemBlock::Alloc(LengthOf(initialSizeInBytes), NULL)),
+        : fHeadBlock(MemBlock::Alloc(LengthOf(initialSizeInBytes), nullptr)),
           fTailBlock(fHeadBlock),
-          fLastItem(NULL) {}
+          fLastItem(nullptr) {}
 
     ~GrTRecorder() {
         this->reset();
         MemBlock::Free(fHeadBlock);
     }
 
     bool empty() { return !fLastItem; }
 
     TBase& back() {
         SkASSERT(!this->empty());
@@ skipping 35 matching lines @@
     };
     static int LengthOf(int bytes) { return (bytes + sizeof(TAlign) - 1) / sizeof(TAlign); }
 
     struct Header {
         int fTotalLength; // The length of an entry including header, item, and data in TAligns.
         int fPrevLength;  // Same but for the previous entry. Used for iterating backwards.
     };
     template<typename TItem> void* alloc_back(int dataLength);
 
     struct MemBlock : SkNoncopyable {
-        /** Allocates a new block and appends it to prev if not NULL. The length param is in units
+        /** Allocates a new block and appends it to prev if not nullptr. The length param is in units
             of TAlign. */
         static MemBlock* Alloc(int length, MemBlock* prev) {
             MemBlock* block = reinterpret_cast<MemBlock*>(
                 sk_malloc_throw(sizeof(TAlign) * (length_of<MemBlock>::kValue + length)));
             block->fLength = length;
             block->fBack = 0;
-            block->fNext = NULL;
+            block->fNext = nullptr;
             block->fPrev = prev;
             if (prev) {
-                SkASSERT(NULL == prev->fNext);
+                SkASSERT(nullptr == prev->fNext);
                 prev->fNext = block;
             }
             return block;
         }
 
         // Frees from this block forward. Also adjusts prev block's next ptr.
         static void Free(MemBlock* block) {
             if (block && block->fPrev) {
                 SkASSERT(block->fPrev->fNext == block);
-                block->fPrev->fNext = NULL;
+                block->fPrev->fNext = nullptr;
             }
             while (block) {
                 MemBlock* next = block->fNext;
                 sk_free(block);
                 block = next;
             }
         }
 
         TAlign& operator [](int i) {
             return reinterpret_cast<TAlign*>(this)[length_of<MemBlock>::kValue + i];
@@ skipping 27 matching lines @@
     Header* header = reinterpret_cast<Header*>(
         reinterpret_cast<TAlign*>(fLastItem) - length_of<Header>::kValue);
     fTailBlock->fBack -= header->fTotalLength;
     reinterpret_cast<TBase*>(fLastItem)->~TBase();
 
     int lastItemLength = header->fPrevLength;
 
     if (!header->fPrevLength) {
         // We popped the first entry in the recorder.
         SkASSERT(0 == fTailBlock->fBack);
-        fLastItem = NULL;
+        fLastItem = nullptr;
         return;
     }
     while (!fTailBlock->fBack) {
         // We popped the last entry in a block that isn't the head block. Move back a block but
         // don't free it since we'll probably grow into it shortly.
         fTailBlock = fTailBlock->fPrev;
         SkASSERT(fTailBlock);
     }
     fLastItem = &(*fTailBlock)[fTailBlock->fBack - lastItemLength + length_of<Header>::kValue];
 }
@@ skipping 49 matching lines @@
  * to not have the front item loaded yet; next() must be called first. Usage model:
  *
  *    GrTRecorder<TBase, TAlign>::Iter iter(recorder);
  *    while (iter.next()) {
  *        iter->doSomething();
  *    }
  */
 template<typename TBase, typename TAlign>
 class GrTRecorder<TBase, TAlign>::Iter {
 public:
-    Iter(GrTRecorder& recorder) : fBlock(recorder.fHeadBlock), fPosition(0), fItem(NULL) {}
+    Iter(GrTRecorder& recorder) : fBlock(recorder.fHeadBlock), fPosition(0), fItem(nullptr) {}
 
     bool next() {
         while (fPosition >= fBlock->fBack) {
             SkASSERT(fPosition == fBlock->fBack);
             if (!fBlock->fNext) {
                 return false;
             }
             fBlock = fBlock->fNext;
             fPosition = 0;
         }
@@ skipping 73 matching lines @@
         iter->~TBase();
     }
 
     // Assume the next time this recorder fills up it will use approximately the same
     // amount of space as last time. Leave enough space for up to ~50% growth; free
     // everything else.
     if (fTailBlock->fBack <= fTailBlock->fLength / 2) {
         MemBlock::Free(fTailBlock->fNext);
     } else if (fTailBlock->fNext) {
         MemBlock::Free(fTailBlock->fNext->fNext);
-        fTailBlock->fNext->fNext = NULL;
+        fTailBlock->fNext->fNext = nullptr;
     }
 
     for (MemBlock* block = fHeadBlock; block; block = block->fNext) {
         block->fBack = 0;
     }
 
     fTailBlock = fHeadBlock;
-    fLastItem = NULL;
+    fLastItem = nullptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 template<typename TItem> struct GrTRecorderAllocWrapper {
     GrTRecorderAllocWrapper() : fDataLength(0) {}
 
     template <typename TBase, typename TAlign>
     GrTRecorderAllocWrapper(const GrTRecorder<TBase, TAlign>&, int sizeOfData)
         : fDataLength(GrTRecorder<TBase, TAlign>::LengthOf(sizeOfData)) {}
@@ skipping 15 matching lines @@
     SK_CRASH();
 }
 
 #define GrNEW_APPEND_TO_RECORDER(recorder, type_name, args) \
     (new (recorder, GrTRecorderAllocWrapper<type_name>()) type_name args)
 
 #define GrNEW_APPEND_WITH_DATA_TO_RECORDER(recorder, type_name, args, size_of_data) \
     (new (recorder, GrTRecorderAllocWrapper<type_name>(recorder, size_of_data)) type_name args)
 
 #endif