Replace NULL with nullptr in all C++ files.

webrtc/base/diskcache.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 93 matching lines @@
     LOG_F(LS_WARNING) << "Cache overfull";
     return false;
   }
   entry->lock_state = LS_LOCKED;
   return true;
 }
 
 StreamInterface* DiskCache::WriteResource(const std::string& id, size_t index) {
   Entry* entry = GetOrCreateEntry(id, false);
   if (LS_LOCKED != entry->lock_state)
-    return NULL;
+    return nullptr;
 
   size_t previous_size = 0;
   std::string filename(IdToFilename(id, index));
   FileStream::GetSize(filename, &previous_size);
   RTC_DCHECK(previous_size <= entry->size);
   if (previous_size > entry->size) {
     previous_size = entry->size;
   }
 
   std::unique_ptr<FileStream> file(new FileStream);
-  if (!file->Open(filename, "wb", NULL)) {
+  if (!file->Open(filename, "wb", nullptr)) {
     LOG_F(LS_ERROR) << "Couldn't create cache file";
-    return NULL;
+    return nullptr;
   }
 
   entry->streams = std::max(entry->streams, index + 1);
   entry->size -= previous_size;
   total_size_ -= previous_size;
 
   entry->accessors += 1;
   total_accessors_ += 1;
   return new DiskCacheAdapter(this, id, index, file.release());
 }
@@ skipping 10 matching lines @@
     entry->last_modified = time(0);
     CheckLimit();
   }
   return true;
 }
 
 StreamInterface* DiskCache::ReadResource(const std::string& id,
                                          size_t index) const {
   const Entry* entry = GetEntry(id);
   if (LS_UNLOCKED != entry->lock_state)
-    return NULL;
+    return nullptr;
   if (index >= entry->streams)
-    return NULL;
+    return nullptr;
 
   std::unique_ptr<FileStream> file(new FileStream);
-  if (!file->Open(IdToFilename(id, index), "rb", NULL))
-    return NULL;
+  if (!file->Open(IdToFilename(id, index), "rb", nullptr))
+    return nullptr;
 
   entry->accessors += 1;
   total_accessors_ += 1;
   return new DiskCacheAdapter(this, id, index, file.release());
 }
 
 bool DiskCache::HasResource(const std::string& id) const {
   const Entry* entry = GetEntry(id);
-  return (NULL != entry) && (entry->streams > 0);
+  return (nullptr != entry) && (entry->streams > 0);
 }
 
 bool DiskCache::HasResourceStream(const std::string& id, size_t index) const {
   const Entry* entry = GetEntry(id);
-  if ((NULL == entry) || (index >= entry->streams))
+  if ((nullptr == entry) || (index >= entry->streams))
     return false;
 
   std::string filename = IdToFilename(id, index);
 
   return FileExists(filename);
 }
 
 bool DiskCache::DeleteResource(const std::string& id) {
   Entry* entry = GetOrCreateEntry(id, false);
   if (!entry)
@@ skipping 104 matching lines @@
   delete [] buffer;
   return true;
 }
 
 DiskCache::Entry* DiskCache::GetOrCreateEntry(const std::string& id,
                                               bool create) {
   EntryMap::iterator it = map_.find(id);
   if (it != map_.end())
     return &it->second;
   if (!create)
-    return NULL;
+    return nullptr;
   Entry e;
   e.lock_state = LS_UNLOCKED;
   e.accessors = 0;
   e.size = 0;
   e.streams = 0;
   e.last_modified = time(0);
   it = map_.insert(EntryMap::value_type(id, e)).first;
   return &it->second;
 }
 
@@ skipping 24 matching lines @@
       entry2->last_modified = time(0);
       entry2->lock_state = LS_UNLOCKED;
       this2->CheckLimit();
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 } // namespace rtc