Use |nullptr| instead of |NULL| under //courgette.

Bug: 1080832
Change-Id: I7c01babed13186995b83d4c3a49ce6fdaf2c648e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2219582
Auto-Submit: Łukasz Anforowicz <lukasza@chromium.org>
Reviewed-by: Will Harris <wfh@chromium.org>
Commit-Queue: Will Harris <wfh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#773019}

courgette/assembly_program.h

@@ -74,7 +74,7 @@ class AssemblyProgram {
  private:
   static const int kLabelLowerLimit;
 
-  // Looks up a label or creates a new one.  Might return NULL.
+  // Looks up a label or creates a new one.  Might return nullptr.
   Label* FindLabel(RVA rva, RVAToLabel* labels);
 
   const ExecutableType kind_;

courgette/memory_allocator.h

@@ -102,7 +102,7 @@ class FileMapping {
   bool valid() const;
 
   // Returns a writable pointer to the beginning of the memory mapped file.
-  // If Create has not been called successfully, return value is NULL.
+  // If Create has not been called successfully, return value is nullptr.
   void* view() const;
 
  protected:
@@ -143,7 +143,7 @@ class TempMapping {
 
 // A memory allocator class that allocates memory either from the heap or via a
 // temporary file.  The interface is STL inspired but the class does not throw
-// STL exceptions on allocation failure.  Instead it returns NULL.
+// STL exceptions on allocation failure.  Instead it returns nullptr.
 // A file allocation will be made if either the requested memory size exceeds
 // |kMaxHeapAllocationSize| or if a heap allocation fails.
 // Allocating the memory as a mapping of a temporary file solves the problem
@@ -215,10 +215,10 @@ class MemoryAllocator {
     count++;
 
     if (count > max_size())
-      return NULL;
+      return nullptr;
 
     size_type bytes = count * sizeof(T);
-    uint8_t* mem = NULL;
+    uint8_t* mem = nullptr;
 
     // First see if we can do this allocation on the heap.
     if (count < kMaxHeapAllocationSize &&
@@ -241,7 +241,7 @@ class MemoryAllocator {
     if (!mem && base::UncheckedMalloc(bytes, reinterpret_cast<void**>(&mem))) {
       mem[0] = static_cast<uint8_t>(HEAP_ALLOCATION);
     }
-    return mem ? reinterpret_cast<pointer>(mem + sizeof(T)) : NULL;
+    return mem ? reinterpret_cast<pointer>(mem + sizeof(T)) : nullptr;
   }
 
   pointer allocate(size_type count, const void* hint) {
@@ -300,7 +300,7 @@ class MemoryAllocator {
 
   pointer allocate(size_type count) {
     if (count > max_size())
-      return NULL;
+      return nullptr;
     pointer result = nullptr;
     return base::UncheckedMalloc(count * sizeof(T),
                                  reinterpret_cast<void**>(&result))
@@ -340,8 +340,7 @@ class NoThrowBuffer {
   static const size_t kAllocationFailure = 0xffffffff;
   static const size_t kStartSize = sizeof(T) > 0x100 ? 1 : 0x100 / sizeof(T);
 
-  NoThrowBuffer() : buffer_(NULL), size_(0), alloc_size_(0) {
-  }
+  NoThrowBuffer() : buffer_(nullptr), size_(0), alloc_size_(0) {}
 
   ~NoThrowBuffer() {
     clear();
@@ -350,7 +349,7 @@ class NoThrowBuffer {
   void clear() {
     if (buffer_) {
       alloc_.deallocate(buffer_, alloc_size_);
-      buffer_ = NULL;
+      buffer_ = nullptr;
       size_ = 0;
       alloc_size_ = 0;
     }
@@ -450,25 +449,25 @@ class NoThrowBuffer {
 
   const T* begin() const {
     if (!size_)
-      return NULL;
+      return nullptr;
     return buffer_;
   }
 
   T* begin() {
     if (!size_)
-      return NULL;
+      return nullptr;
     return buffer_;
   }
 
   const T* end() const {
     if (!size_)
-      return NULL;
+      return nullptr;
     return buffer_ + size_;
   }
 
   T* end() {
     if (!size_)
-      return NULL;
+      return nullptr;
     return buffer_ + size_;
   }
 

courgette/region.h

@@ -19,7 +19,7 @@ namespace courgette {
 class Region {
  public:
   // Default constructor: and empty region.
-  Region() : start_(NULL), length_(0) {}
+  Region() : start_(nullptr), length_(0) {}
 
   // Usual constructor for regions given a |start| address and |length|.
   Region(const void* start, size_t length)

courgette/streams.cc

@@ -40,7 +40,7 @@ class Varint {
   static const int kMax32 = 5;
 
   // Parses a Varint32 encoded value from |source| and stores it in |output|,
-  // and returns a pointer to the following byte.  Returns NULL if a valid
+  // and returns a pointer to the following byte.  Returns nullptr if a valid
   // varint value was not found before |limit|.
   static const uint8_t* Parse32WithLimit(const uint8_t* source,
                                          const uint8_t* limit,

courgette/streams.h

@@ -46,7 +46,7 @@ class BasicBuffer {
 // operations.  The stream does not own the memory.
 class SourceStream {
  public:
-  SourceStream() : start_(NULL), end_(NULL), current_(NULL) {}
+  SourceStream() : start_(nullptr), end_(nullptr), current_(nullptr) {}
 
   // Initializes the SourceStream to yield the bytes at |pointer|.  The caller
   // still owns the memory at |pointer| and should free the memory only after
@@ -192,7 +192,9 @@ class SourceStreamSet {
   bool Init(SourceStream* source);
 
   // Returns a pointer to one of the sub-streams.
-  SourceStream* stream(size_t id) { return id < count_ ? &streams_[id] : NULL; }
+  SourceStream* stream(size_t id) {
+    return id < count_ ? &streams_[id] : nullptr;
+  }
 
   // Initialize |set| from |this|.
   bool ReadSet(SourceStreamSet* set);
@@ -222,7 +224,9 @@ class SinkStreamSet {
   void Init(size_t stream_index_limit);
 
   // Returns a pointer to a substream.
-  SinkStream* stream(size_t id) { return id < count_ ? &streams_[id] : NULL; }
+  SinkStream* stream(size_t id) {
+    return id < count_ ? &streams_[id] : nullptr;
+  }
 
   // CopyTo serializes the streams in this SinkStreamSet into a single target
   // stream.  The serialized format may be re-read by initializing a