Style Change: NULL->nullptr

src/gpu/GrAllocator.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAllocator_DEFINED
 #define GrAllocator_DEFINED
 
@@ skipping 11 matching lines @@
      *
      * @param   itemSize        the size of each item to allocate
      * @param   itemsPerBlock   the number of items to allocate at once
      * @param   initialBlock    optional memory to use for the first block.
      *                          Must be at least itemSize*itemsPerBlock sized.
      *                          Caller is responsible for freeing this memory.
      */
     GrAllocator(size_t itemSize, int itemsPerBlock, void* initialBlock)
         : fItemSize(itemSize)
         , fItemsPerBlock(itemsPerBlock)
-        , fOwnFirstBlock(NULL == initialBlock)
+        , fOwnFirstBlock(nullptr == initialBlock)
         , fCount(0)
         , fInsertionIndexInBlock(0) {
         SkASSERT(itemsPerBlock > 0);
         fBlockSize = fItemSize * fItemsPerBlock;
         if (fOwnFirstBlock) {
             // This force us to allocate a new block on push_back().
             fInsertionIndexInBlock = fItemsPerBlock;
         } else {
             fBlocks.push_back() = initialBlock;
             fInsertionIndexInBlock = 0;
@@ skipping 142 matching lines @@
      */
     const void* operator[] (int i) const {
         SkASSERT(i >= 0 && i < fCount);
         return (const char*)fBlocks[i / fItemsPerBlock] +
                fItemSize * (i % fItemsPerBlock);
     }
 
 protected:
     /**
      * Set first block of memory to write into.  Must be called before any other methods.
-     * This requires that you have passed NULL in the constructor.
+     * This requires that you have passed nullptr in the constructor.
      *
      * @param   initialBlock    optional memory to use for the first block.
      *                          Must be at least itemSize*itemsPerBlock sized.
      *                          Caller is responsible for freeing this memory.
      */
     void setInitialBlock(void* initialBlock) {
         SkASSERT(0 == fCount);
         SkASSERT(0 == fBlocks.count());
         SkASSERT(fItemsPerBlock == fInsertionIndexInBlock);
         fOwnFirstBlock = false;
@@ skipping 24 matching lines @@
 template <typename T> class GrTAllocator : SkNoncopyable {
 public:
     virtual ~GrTAllocator() { this->reset(); };
 
     /**
      * Create an allocator
      *
      * @param   itemsPerBlock   the number of items to allocate at once
      */
     explicit GrTAllocator(int itemsPerBlock)
-        : fAllocator(sizeof(T), itemsPerBlock, NULL) {}
+        : fAllocator(sizeof(T), itemsPerBlock, nullptr) {}
 
     /**
      * Adds an item and returns it.
      *
      * @return the added item.
      */
     T& push_back() {
         void* item = fAllocator.push_back();
         SkASSERT(item);
         new (item) T;
@@ skipping 138 matching lines @@
 // to match the op new silences warnings about missing op delete when a constructor throws an
 // exception.
 template <typename T> void operator delete(void*, GrTAllocator<T>*) {
     SK_CRASH();
 }
 
 #define GrNEW_APPEND_TO_ALLOCATOR(allocator_ptr, type_name, args) \
     new (allocator_ptr) type_name args
 
 #endif