| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2004 The WebRTC Project Authors. All rights reserved. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license | |
| 5 * that can be found in the LICENSE file in the root of the source | |
| 6 * tree. An additional intellectual property rights grant can be found | |
| 7 * in the file PATENTS. All contributing project authors may | |
| 8 * be found in the AUTHORS file in the root of the source tree. | |
| 9 */ | |
| 10 | |
| 11 #include <time.h> | |
| 12 | |
| 13 #if defined(WEBRTC_WIN) | |
| 14 #include "webrtc/base/win32.h" | |
| 15 #endif | |
| 16 | |
| 17 #include <algorithm> | |
| 18 #include <memory> | |
| 19 | |
| 20 #include "webrtc/base/arraysize.h" | |
| 21 #include "webrtc/base/checks.h" | |
| 22 #include "webrtc/base/diskcache.h" | |
| 23 #include "webrtc/base/fileutils.h" | |
| 24 #include "webrtc/base/pathutils.h" | |
| 25 #include "webrtc/base/stream.h" | |
| 26 #include "webrtc/base/stringencode.h" | |
| 27 #include "webrtc/base/stringutils.h" | |
| 28 | |
| 29 #define TRANSPARENT_CACHE_NAMES RTC_DCHECK_IS_ON | |
| 30 | |
| 31 namespace rtc { | |
| 32 | |
| 33 class DiskCache; | |
| 34 | |
| 35 /////////////////////////////////////////////////////////////////////////////// | |
| 36 // DiskCacheAdapter | |
| 37 /////////////////////////////////////////////////////////////////////////////// | |
| 38 | |
| 39 class DiskCacheAdapter : public StreamAdapterInterface { | |
| 40 public: | |
| 41 DiskCacheAdapter(const DiskCache* cache, const std::string& id, size_t index, | |
| 42 StreamInterface* stream) | |
| 43 : StreamAdapterInterface(stream), cache_(cache), id_(id), index_(index) | |
| 44 { } | |
| 45 ~DiskCacheAdapter() override { | |
| 46 Close(); | |
| 47 cache_->ReleaseResource(id_, index_); | |
| 48 } | |
| 49 | |
| 50 private: | |
| 51 const DiskCache* cache_; | |
| 52 std::string id_; | |
| 53 size_t index_; | |
| 54 }; | |
| 55 | |
| 56 /////////////////////////////////////////////////////////////////////////////// | |
| 57 // DiskCache | |
| 58 /////////////////////////////////////////////////////////////////////////////// | |
| 59 | |
| 60 DiskCache::DiskCache() : max_cache_(0), total_size_(0), total_accessors_(0) { | |
| 61 } | |
| 62 | |
| 63 DiskCache::~DiskCache() { | |
| 64 RTC_DCHECK(0 == total_accessors_); | |
| 65 } | |
| 66 | |
| 67 bool DiskCache::Initialize(const std::string& folder, size_t size) { | |
| 68 if (!folder_.empty() || !Filesystem::CreateFolder(folder)) | |
| 69 return false; | |
| 70 | |
| 71 folder_ = folder; | |
| 72 max_cache_ = size; | |
| 73 RTC_DCHECK(0 == total_size_); | |
| 74 | |
| 75 if (!InitializeEntries()) | |
| 76 return false; | |
| 77 | |
| 78 return CheckLimit(); | |
| 79 } | |
| 80 | |
| 81 bool DiskCache::Purge() { | |
| 82 if (folder_.empty()) | |
| 83 return false; | |
| 84 | |
| 85 if (total_accessors_ > 0) { | |
| 86 LOG_F(LS_WARNING) << "Cache files open"; | |
| 87 return false; | |
| 88 } | |
| 89 | |
| 90 if (!PurgeFiles()) | |
| 91 return false; | |
| 92 | |
| 93 map_.clear(); | |
| 94 return true; | |
| 95 } | |
| 96 | |
| 97 bool DiskCache::LockResource(const std::string& id) { | |
| 98 Entry* entry = GetOrCreateEntry(id, true); | |
| 99 if (LS_LOCKED == entry->lock_state) | |
| 100 return false; | |
| 101 if ((LS_UNLOCKED == entry->lock_state) && (entry->accessors > 0)) | |
| 102 return false; | |
| 103 if ((total_size_ > max_cache_) && !CheckLimit()) { | |
| 104 LOG_F(LS_WARNING) << "Cache overfull"; | |
| 105 return false; | |
| 106 } | |
| 107 entry->lock_state = LS_LOCKED; | |
| 108 return true; | |
| 109 } | |
| 110 | |
| 111 StreamInterface* DiskCache::WriteResource(const std::string& id, size_t index) { | |
| 112 Entry* entry = GetOrCreateEntry(id, false); | |
| 113 if (LS_LOCKED != entry->lock_state) | |
| 114 return NULL; | |
| 115 | |
| 116 size_t previous_size = 0; | |
| 117 std::string filename(IdToFilename(id, index)); | |
| 118 FileStream::GetSize(filename, &previous_size); | |
| 119 RTC_DCHECK(previous_size <= entry->size); | |
| 120 if (previous_size > entry->size) { | |
| 121 previous_size = entry->size; | |
| 122 } | |
| 123 | |
| 124 std::unique_ptr<FileStream> file(new FileStream); | |
| 125 if (!file->Open(filename, "wb", NULL)) { | |
| 126 LOG_F(LS_ERROR) << "Couldn't create cache file"; | |
| 127 return NULL; | |
| 128 } | |
| 129 | |
| 130 entry->streams = std::max(entry->streams, index + 1); | |
| 131 entry->size -= previous_size; | |
| 132 total_size_ -= previous_size; | |
| 133 | |
| 134 entry->accessors += 1; | |
| 135 total_accessors_ += 1; | |
| 136 return new DiskCacheAdapter(this, id, index, file.release()); | |
| 137 } | |
| 138 | |
| 139 bool DiskCache::UnlockResource(const std::string& id) { | |
| 140 Entry* entry = GetOrCreateEntry(id, false); | |
| 141 if (LS_LOCKED != entry->lock_state) | |
| 142 return false; | |
| 143 | |
| 144 if (entry->accessors > 0) { | |
| 145 entry->lock_state = LS_UNLOCKING; | |
| 146 } else { | |
| 147 entry->lock_state = LS_UNLOCKED; | |
| 148 entry->last_modified = time(0); | |
| 149 CheckLimit(); | |
| 150 } | |
| 151 return true; | |
| 152 } | |
| 153 | |
| 154 StreamInterface* DiskCache::ReadResource(const std::string& id, | |
| 155 size_t index) const { | |
| 156 const Entry* entry = GetEntry(id); | |
| 157 if (LS_UNLOCKED != entry->lock_state) | |
| 158 return NULL; | |
| 159 if (index >= entry->streams) | |
| 160 return NULL; | |
| 161 | |
| 162 std::unique_ptr<FileStream> file(new FileStream); | |
| 163 if (!file->Open(IdToFilename(id, index), "rb", NULL)) | |
| 164 return NULL; | |
| 165 | |
| 166 entry->accessors += 1; | |
| 167 total_accessors_ += 1; | |
| 168 return new DiskCacheAdapter(this, id, index, file.release()); | |
| 169 } | |
| 170 | |
| 171 bool DiskCache::HasResource(const std::string& id) const { | |
| 172 const Entry* entry = GetEntry(id); | |
| 173 return (NULL != entry) && (entry->streams > 0); | |
| 174 } | |
| 175 | |
| 176 bool DiskCache::HasResourceStream(const std::string& id, size_t index) const { | |
| 177 const Entry* entry = GetEntry(id); | |
| 178 if ((NULL == entry) || (index >= entry->streams)) | |
| 179 return false; | |
| 180 | |
| 181 std::string filename = IdToFilename(id, index); | |
| 182 | |
| 183 return FileExists(filename); | |
| 184 } | |
| 185 | |
| 186 bool DiskCache::DeleteResource(const std::string& id) { | |
| 187 Entry* entry = GetOrCreateEntry(id, false); | |
| 188 if (!entry) | |
| 189 return true; | |
| 190 | |
| 191 if ((LS_UNLOCKED != entry->lock_state) || (entry->accessors > 0)) | |
| 192 return false; | |
| 193 | |
| 194 bool success = true; | |
| 195 for (size_t index = 0; index < entry->streams; ++index) { | |
| 196 std::string filename = IdToFilename(id, index); | |
| 197 | |
| 198 if (!FileExists(filename)) | |
| 199 continue; | |
| 200 | |
| 201 if (!DeleteFile(filename)) { | |
| 202 LOG_F(LS_ERROR) << "Couldn't remove cache file: " << filename; | |
| 203 success = false; | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 total_size_ -= entry->size; | |
| 208 map_.erase(id); | |
| 209 return success; | |
| 210 } | |
| 211 | |
| 212 bool DiskCache::CheckLimit() { | |
| 213 #if RTC_DCHECK_IS_ON | |
| 214 // Temporary check to make sure everything is working correctly. | |
| 215 size_t cache_size = 0; | |
| 216 for (EntryMap::iterator it = map_.begin(); it != map_.end(); ++it) { | |
| 217 cache_size += it->second.size; | |
| 218 } | |
| 219 RTC_DCHECK(cache_size == total_size_); | |
| 220 #endif | |
| 221 | |
| 222 // TODO: Replace this with a non-brain-dead algorithm for clearing out the | |
| 223 // oldest resources... something that isn't O(n^2) | |
| 224 while (total_size_ > max_cache_) { | |
| 225 EntryMap::iterator oldest = map_.end(); | |
| 226 for (EntryMap::iterator it = map_.begin(); it != map_.end(); ++it) { | |
| 227 if ((LS_UNLOCKED != it->second.lock_state) || (it->second.accessors > 0)) | |
| 228 continue; | |
| 229 oldest = it; | |
| 230 break; | |
| 231 } | |
| 232 if (oldest == map_.end()) { | |
| 233 LOG_F(LS_WARNING) << "All resources are locked!"; | |
| 234 return false; | |
| 235 } | |
| 236 for (EntryMap::iterator it = oldest++; it != map_.end(); ++it) { | |
| 237 if (it->second.last_modified < oldest->second.last_modified) { | |
| 238 oldest = it; | |
| 239 } | |
| 240 } | |
| 241 if (!DeleteResource(oldest->first)) { | |
| 242 LOG_F(LS_ERROR) << "Couldn't delete from cache!"; | |
| 243 return false; | |
| 244 } | |
| 245 } | |
| 246 return true; | |
| 247 } | |
| 248 | |
| 249 std::string DiskCache::IdToFilename(const std::string& id, size_t index) const { | |
| 250 #ifdef TRANSPARENT_CACHE_NAMES | |
| 251 // This escapes colons and other filesystem characters, so the user can't open | |
| 252 // special devices (like "COM1:"), or access other directories. | |
| 253 size_t buffer_size = id.length()*3 + 1; | |
| 254 char* buffer = new char[buffer_size]; | |
| 255 encode(buffer, buffer_size, id.data(), id.length(), | |
| 256 unsafe_filename_characters(), '%'); | |
| 257 // TODO(nisse): RTC_DCHECK(strlen(buffer) < FileSystem::MaxBasenameLength()); | |
| 258 #else // !TRANSPARENT_CACHE_NAMES | |
| 259 // We might want to just use a hash of the filename at some point, both for | |
| 260 // obfuscation, and to avoid both filename length and escaping issues. | |
| 261 RTC_NOTREACHED(); | |
| 262 #endif // !TRANSPARENT_CACHE_NAMES | |
| 263 | |
| 264 char extension[32]; | |
| 265 sprintfn(extension, arraysize(extension), ".%u", index); | |
| 266 | |
| 267 Pathname pathname; | |
| 268 pathname.SetFolder(folder_); | |
| 269 pathname.SetBasename(buffer); | |
| 270 pathname.SetExtension(extension); | |
| 271 | |
| 272 #ifdef TRANSPARENT_CACHE_NAMES | |
| 273 delete [] buffer; | |
| 274 #endif // TRANSPARENT_CACHE_NAMES | |
| 275 | |
| 276 return pathname.pathname(); | |
| 277 } | |
| 278 | |
| 279 bool DiskCache::FilenameToId(const std::string& filename, std::string* id, | |
| 280 size_t* index) const { | |
| 281 Pathname pathname(filename); | |
| 282 unsigned tempdex; | |
| 283 if (1 != sscanf(pathname.extension().c_str(), ".%u", &tempdex)) | |
| 284 return false; | |
| 285 | |
| 286 *index = static_cast<size_t>(tempdex); | |
| 287 | |
| 288 size_t buffer_size = pathname.basename().length() + 1; | |
| 289 char* buffer = new char[buffer_size]; | |
| 290 decode(buffer, buffer_size, pathname.basename().data(), | |
| 291 pathname.basename().length(), '%'); | |
| 292 id->assign(buffer); | |
| 293 delete [] buffer; | |
| 294 return true; | |
| 295 } | |
| 296 | |
| 297 DiskCache::Entry* DiskCache::GetOrCreateEntry(const std::string& id, | |
| 298 bool create) { | |
| 299 EntryMap::iterator it = map_.find(id); | |
| 300 if (it != map_.end()) | |
| 301 return &it->second; | |
| 302 if (!create) | |
| 303 return NULL; | |
| 304 Entry e; | |
| 305 e.lock_state = LS_UNLOCKED; | |
| 306 e.accessors = 0; | |
| 307 e.size = 0; | |
| 308 e.streams = 0; | |
| 309 e.last_modified = time(0); | |
| 310 it = map_.insert(EntryMap::value_type(id, e)).first; | |
| 311 return &it->second; | |
| 312 } | |
| 313 | |
| 314 void DiskCache::ReleaseResource(const std::string& id, size_t index) const { | |
| 315 const Entry* entry = GetEntry(id); | |
| 316 if (!entry) { | |
| 317 LOG_F(LS_WARNING) << "Missing cache entry"; | |
| 318 RTC_NOTREACHED(); | |
| 319 return; | |
| 320 } | |
| 321 | |
| 322 entry->accessors -= 1; | |
| 323 total_accessors_ -= 1; | |
| 324 | |
| 325 if (LS_UNLOCKED != entry->lock_state) { | |
| 326 // This is safe, because locked resources only issue WriteResource, which | |
| 327 // is non-const. Think about a better way to handle it. | |
| 328 DiskCache* this2 = const_cast<DiskCache*>(this); | |
| 329 Entry* entry2 = this2->GetOrCreateEntry(id, false); | |
| 330 | |
| 331 size_t new_size = 0; | |
| 332 std::string filename(IdToFilename(id, index)); | |
| 333 FileStream::GetSize(filename, &new_size); | |
| 334 entry2->size += new_size; | |
| 335 this2->total_size_ += new_size; | |
| 336 | |
| 337 if ((LS_UNLOCKING == entry->lock_state) && (0 == entry->accessors)) { | |
| 338 entry2->last_modified = time(0); | |
| 339 entry2->lock_state = LS_UNLOCKED; | |
| 340 this2->CheckLimit(); | |
| 341 } | |
| 342 } | |
| 343 } | |
| 344 | |
| 345 /////////////////////////////////////////////////////////////////////////////// | |
| 346 | |
| 347 } // namespace rtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2694753002:
Delete httpclient.c and related files. (Closed)
