Style Change: NULL->nullptr

src/gpu/gl/GrGLNameAllocator.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLNameAllocator.h"
 
@@ skipping 46 matching lines @@
 
     /**
      * Remove the leftmost leaf node from this range (or the entire thing if it
      * *is* a leaf node). This is an internal helper method that is used after
      * an allocation if one contiguous range became adjacent to another. (The
      * range gets removed so the one immediately before can be extended,
      * collapsing the two into one.)
      *
      * @param removedCount A pointer that receives the size of the contiguous
                            range that was removed.
-     * @return The resulting SparseNameRange after the removal (or NULL if it
+     * @return The resulting SparseNameRange after the removal (or nullptr if it
      *         became empty). Note that this call is destructive, so the
      *         original SparseNameRange will no longer be valid afterward. The
      *         caller must always update its pointer with the new
      *         SparseNameRange.
      */
     virtual SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) = 0;
 
     /**
      * Append adjacent allocated names to the end of this range. This operation
      * does not affect the structure of the tree. The caller is responsible for
@@ skipping 15 matching lines @@
      */
     virtual GrGLuint prependNames(GrGLuint count) = 0;
 
     /**
      * Free a name so it is no longer tracked as allocated. If the name is at
      * the very beginning or very end of the range, the boundaries [fFirst, fEnd)
      * will be tightened.
      *
      * @param name The name to free. Not-allocated names are silently ignored
      *             the same way they are in the OpenGL spec.
-     * @return The resulting SparseNameRange after the free (or NULL if it
+     * @return The resulting SparseNameRange after the free (or nullptr if it
      *         became empty). Note that this call is destructive, so the
      *         original SparseNameRange will no longer be valid afterward. The
      *         caller must always update its pointer with the new
      *         SparseNameRange.
      */
     virtual SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) = 0;
 
 protected:
     SparseNameRange* takeRef() {
       this->ref();
@@ skipping 25 matching lines @@
         if (0 != *outName) {
             this->updateStats();
             return this->rebalance();
         }
 
         if (fLeft->end() + 1 == fRight->first()) {
             // It closed the gap between fLeft and fRight; merge.
             GrGLuint removedCount;
             fRight.reset(fRight->removeLeftmostContiguousRange(&removedCount));
             *outName = fLeft->appendNames(1 + removedCount);
-            if (NULL == fRight.get()) {
+            if (nullptr == fRight.get()) {
                 return fLeft.detach();
             }
             this->updateStats();
             return this->rebalance();
         }
 
         // There is guaranteed to be a gap between fLeft and fRight, and the
         // "size 1" case has already been covered.
         SkASSERT(fLeft->end() + 1 < fRight->first());
         *outName = fLeft->appendNames(1);
         return this->takeRef();
     }
 
     SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) override {
         fLeft.reset(fLeft->removeLeftmostContiguousRange(removedCount));
-        if (NULL == fLeft) {
+        if (nullptr == fLeft) {
             return fRight.detach();
         }
         this->updateStats();
         return this->rebalance();
     }
 
     GrGLuint appendNames(GrGLuint count) override {
         SkASSERT(fEnd + count > fEnd); // Check for integer wrap.
         GrGLuint name = fRight->appendNames(count);
         SkASSERT(fRight->end() == fEnd + count);
         this->updateStats();
         return name;
     }
 
     GrGLuint prependNames(GrGLuint count) override {
         SkASSERT(fFirst > count); // We can't allocate at or below 0.
         GrGLuint name = fLeft->prependNames(count);
         SkASSERT(fLeft->first() == fFirst - count);
         this->updateStats();
         return name;
     }
 
     SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) override {
         if (name < fLeft->end()) {
             fLeft.reset(fLeft->free(name));
-            if (NULL == fLeft) {
+            if (nullptr == fLeft) {
                 // fLeft became empty after the free.
                 return fRight.detach();
             }
             this->updateStats();
             return this->rebalance();
         } else {
             fRight.reset(fRight->free(name));
-            if (NULL == fRight) {
+            if (nullptr == fRight) {
                 // fRight became empty after the free.
                 return fLeft.detach();
             }
             this->updateStats();
             return this->rebalance();
         }
     }
 
 private:
     typedef SkAutoTUnref<SparseNameRange> SparseNameTree::* ChildRange;
@@ skipping 70 matching lines @@
         fHeight = 0;
     }
 
     SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) override {
         *outName = 0; // No internal gaps, we are contiguous.
         return this->takeRef();
     }
 
     SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) override {
         *removedCount = fEnd - fFirst;
-        return NULL;
+        return nullptr;
     }
 
     GrGLuint appendNames(GrGLuint count) override {
         SkASSERT(fEnd + count > fEnd); // Check for integer wrap.
         GrGLuint name = fEnd;
         fEnd += count;
         return name;
     }
 
     GrGLuint prependNames(GrGLuint count) override {
         SkASSERT(fFirst > count); // We can't allocate at or below 0.
         fFirst -= count;
         return fFirst;
     }
 
     SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) override {
         if (name < fFirst || name >= fEnd) {
           // Not-allocated names are silently ignored.
           return this->takeRef();
         }
 
         if (fFirst == name) {
             ++fFirst;
-            return (fEnd == fFirst) ? NULL : this->takeRef();
+            return (fEnd == fFirst) ? nullptr : this->takeRef();
         }
 
         if (fEnd == name + 1) {
             --fEnd;
             return this->takeRef();
         }
 
         SparseNameRange* left = new ContiguousNameRange(fFirst, name);
         SparseNameRange* right = this->takeRef();
         fFirst = name + 1;
         return new SparseNameTree(left, right);
     }
 };
 
 GrGLNameAllocator::GrGLNameAllocator(GrGLuint firstName, GrGLuint endName)
     : fFirstName(firstName),
       fEndName(endName) {
     SkASSERT(firstName > 0);
     SkASSERT(endName > firstName);
 }
 
 GrGLNameAllocator::~GrGLNameAllocator() {
 }
 
 GrGLuint GrGLNameAllocator::allocateName() {
-    if (NULL == fAllocatedNames.get()) {
+    if (nullptr == fAllocatedNames.get()) {
         fAllocatedNames.reset(new ContiguousNameRange(fFirstName, fFirstName + 1));
         return fFirstName;
     }
 
     if (fAllocatedNames->first() > fFirstName) {
         return fAllocatedNames->prependNames(1);
     }
 
     GrGLuint name;
     fAllocatedNames.reset(fAllocatedNames->internalAllocate(&name));
@@ skipping 10 matching lines @@
 }
 
 void GrGLNameAllocator::free(GrGLuint name) {
     if (!fAllocatedNames.get()) {
       // Not-allocated names are silently ignored.
       return;
     }
 
     fAllocatedNames.reset(fAllocatedNames->free(name));
 }