Replace ASSERT by RTC_DCHECK in all non-test code.

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 48 matching lines @@
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // DiskCache
 ///////////////////////////////////////////////////////////////////////////////
 
 DiskCache::DiskCache() : max_cache_(0), total_size_(0), total_accessors_(0) {
 }
 
 DiskCache::~DiskCache() {
-  ASSERT(0 == total_accessors_);
+  RTC_DCHECK(0 == total_accessors_);
 }
 
 bool DiskCache::Initialize(const std::string& folder, size_t size) {
   if (!folder_.empty() || !Filesystem::CreateFolder(folder))
     return false;
 
   folder_ = folder;
   max_cache_ = size;
-  ASSERT(0 == total_size_);
+  RTC_DCHECK(0 == total_size_);
 
   if (!InitializeEntries())
     return false;
 
   return CheckLimit();
 }
 
 bool DiskCache::Purge() {
   if (folder_.empty())
     return false;
@@ skipping 25 matching lines @@
 }
 
 StreamInterface* DiskCache::WriteResource(const std::string& id, size_t index) {
   Entry* entry = GetOrCreateEntry(id, false);
   if (LS_LOCKED != entry->lock_state)
     return NULL;
 
   size_t previous_size = 0;
   std::string filename(IdToFilename(id, index));
   FileStream::GetSize(filename, &previous_size);
-  ASSERT(previous_size <= entry->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)) {
     LOG_F(LS_ERROR) << "Couldn't create cache file";
     return NULL;
   }
 
@@ skipping 79 matching lines @@
   return success;
 }
 
 bool DiskCache::CheckLimit() {
 #if !defined(NDEBUG)
   // Temporary check to make sure everything is working correctly.
   size_t cache_size = 0;
   for (EntryMap::iterator it = map_.begin(); it != map_.end(); ++it) {
     cache_size += it->second.size;
   }
-  ASSERT(cache_size == total_size_);
+  RTC_DCHECK(cache_size == total_size_);
 #endif
 
   // TODO: Replace this with a non-brain-dead algorithm for clearing out the
   // oldest resources... something that isn't O(n^2)
   while (total_size_ > max_cache_) {
     EntryMap::iterator oldest = map_.end();
     for (EntryMap::iterator it = map_.begin(); it != map_.end(); ++it) {
       if ((LS_UNLOCKED != it->second.lock_state) || (it->second.accessors > 0))
         continue;
       oldest = it;
@@ skipping 17 matching lines @@
 }
 
 std::string DiskCache::IdToFilename(const std::string& id, size_t index) const {
 #ifdef TRANSPARENT_CACHE_NAMES
   // This escapes colons and other filesystem characters, so the user can't open
   // special devices (like "COM1:"), or access other directories.
   size_t buffer_size = id.length()*3 + 1;
   char* buffer = new char[buffer_size];
   encode(buffer, buffer_size, id.data(), id.length(),
          unsafe_filename_characters(), '%');
-  // TODO: ASSERT(strlen(buffer) < FileSystem::MaxBasenameLength());
+  // TODO(nisse): RTC_DCHECK(strlen(buffer) < FileSystem::MaxBasenameLength());
 #else  // !TRANSPARENT_CACHE_NAMES
   // We might want to just use a hash of the filename at some point, both for
   // obfuscation, and to avoid both filename length and escaping issues.
   RTC_NOTREACHED();
 #endif  // !TRANSPARENT_CACHE_NAMES
 
   char extension[32];
   sprintfn(extension, arraysize(extension), ".%u", index);
 
   Pathname pathname;
@@ skipping 70 matching lines @@
       entry2->last_modified = time(0);
       entry2->lock_state = LS_UNLOCKED;
       this2->CheckLimit();
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 } // namespace rtc