Replace ASSERT(false) by RTC_NOTREACHED().

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.
  */
 
 #include <time.h>
 
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/win32.h"
 #endif
 
 #include <algorithm>
 #include <memory>
 
 #include "webrtc/base/arraysize.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/diskcache.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/pathutils.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 
 #if !defined(NDEBUG)
 #define TRANSPARENT_CACHE_NAMES 1
@@ skipping 224 matching lines @@
   // 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());
 #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.
-  ASSERT(false);
+  RTC_NOTREACHED();
 #endif  // !TRANSPARENT_CACHE_NAMES
 
   char extension[32];
   sprintfn(extension, arraysize(extension), ".%u", index);
 
   Pathname pathname;
   pathname.SetFolder(folder_);
   pathname.SetBasename(buffer);
   pathname.SetExtension(extension);
 
@@ skipping 36 matching lines @@
   e.streams = 0;
   e.last_modified = time(0);
   it = map_.insert(EntryMap::value_type(id, e)).first;
   return &it->second;
 }
 
 void DiskCache::ReleaseResource(const std::string& id, size_t index) const {
   const Entry* entry = GetEntry(id);
   if (!entry) {
     LOG_F(LS_WARNING) << "Missing cache entry";
-    ASSERT(false);
+    RTC_NOTREACHED();
     return;
   }
 
   entry->accessors -= 1;
   total_accessors_ -= 1;
 
   if (LS_UNLOCKED != entry->lock_state) {
     // This is safe, because locked resources only issue WriteResource, which
     // is non-const.  Think about a better way to handle it.
     DiskCache* this2 = const_cast<DiskCache*>(this);
     Entry* entry2 = this2->GetOrCreateEntry(id, false);
 
     size_t new_size = 0;
     std::string filename(IdToFilename(id, index));
     FileStream::GetSize(filename, &new_size);
     entry2->size += new_size;
     this2->total_size_ += new_size;
 
     if ((LS_UNLOCKING == entry->lock_state) && (0 == entry->accessors)) {
       entry2->last_modified = time(0);
       entry2->lock_state = LS_UNLOCKED;
       this2->CheckLimit();
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 } // namespace rtc