Style Change: NULL->nullptr

src/core/SkPtrRecorder.h

 
 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkPtrSet_DEFINED
 #define SkPtrSet_DEFINED
 
 #include "SkRefCnt.h"
 #include "SkFlattenable.h"
 #include "SkTDArray.h"
 
 /**
  *  Maintains a set of ptrs, assigning each a unique ID [1...N]. Duplicate ptrs
  *  return the same ID (since its a set). Subclasses can override inPtr()
  *  and decPtr(). incPtr() is called each time a unique ptr is added ot the
  *  set. decPtr() is called on each ptr when the set is destroyed or reset.
  */
 class SkPtrSet : public SkRefCnt {
 public:
     
 
     /**
      *  Search for the specified ptr in the set. If it is found, return its
-     *  32bit ID [1..N], or if not found, return 0. Always returns 0 for NULL.
+     *  32bit ID [1..N], or if not found, return 0. Always returns 0 for nullptr.
      */
     uint32_t find(void*) const;
 
     /**
      *  Add the specified ptr to the set, returning a unique 32bit ID for it
      *  [1...N]. Duplicate ptrs will return the same ID.
      *
-     *  If the ptr is NULL, it is not added, and 0 is returned.
+     *  If the ptr is nullptr, it is not added, and 0 is returned.
      */
     uint32_t add(void*);
 
     /**
      *  Return the number of (non-null) ptrs in the set.
      */
     int count() const { return fList.count(); }
 
     /**
      *  Copy the ptrs in the set into the specified array (allocated by the
@@ skipping 16 matching lines @@
     class Iter {
     public:
         Iter(const SkPtrSet& set)
             : fSet(set)
             , fIndex(0) {}
 
         /**
          * Return the next ptr in the set or null if the end was reached.
          */
         void* next() {
-            return fIndex < fSet.fList.count() ? fSet.fList[fIndex++].fPtr : NULL;
+            return fIndex < fSet.fList.count() ? fSet.fList[fIndex++].fPtr : nullptr;
         }
 
     private:
         const SkPtrSet& fSet;
         int             fIndex;
     };
 
 protected:
     virtual void incPtr(void*) {}
     virtual void decPtr(void*) {}
 
 private:
     struct Pair {
-        void*       fPtr;   // never NULL
+        void*       fPtr;   // never nullptr
         uint32_t    fIndex; // 1...N
     };
 
     // we store the ptrs in sorted-order (using Cmp) so that we can efficiently
     // detect duplicates when add() is called. Hence we need to store the
     // ptr and its ID/fIndex explicitly, since the ptr's position in the array
     // is not related to its "index".
     SkTDArray<Pair>  fList;
 
     static bool Less(const Pair& a, const Pair& b);
@@ skipping 64 matching lines @@
     const char* getNextAddedFactoryName();
 private:
     int                    fNextAddedFactory;
     SkFactorySet           fFactorySet;
     SkTDArray<const char*> fNames;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif