1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef NET_DISK_CACHE_BLOCKFILE_STORAGE_BLOCK_INL_H_ 6 #define NET_DISK_CACHE_BLOCKFILE_STORAGE_BLOCK_INL_H_ 7 8 #include "net/disk_cache/blockfile/storage_block.h" 9 10 #include "base/hash.h" 11 #include "base/logging.h" 12 #include "net/disk_cache/blockfile/trace.h" 13 14 namespace disk_cache { 15 16 template<typename T> StorageBlock<T>::StorageBlock(MappedFile* file, 17 Addr address) 18 : data_(NULL), file_(file), address_(address), modified_(false), 19 own_data_(false), extended_(false) { 20 if (address.num_blocks() > 1) 21 extended_ = true; 22 DCHECK(!address.is_initialized() || sizeof(*data_) == address.BlockSize()); 23 } 24 25 template<typename T> StorageBlock<T>::~StorageBlock() { 26 if (modified_) 27 Store(); 28 DeleteData(); 29 } 30 31 template<typename T> void* StorageBlock<T>::buffer() const { 32 return data_; 33 } 34 35 template<typename T> size_t StorageBlock<T>::size() const { 36 if (!extended_) 37 return sizeof(*data_); 38 return address_.num_blocks() * sizeof(*data_); 39 } 40 41 template<typename T> int StorageBlock<T>::offset() const { 42 return address_.start_block() * address_.BlockSize(); 43 } 44 45 template<typename T> bool StorageBlock<T>::LazyInit(MappedFile* file, 46 Addr address) { 47 if (file_ || address_.is_initialized()) { 48 NOTREACHED(); 49 return false; 50 } 51 file_ = file; 52 address_.set_value(address.value()); 53 if (address.num_blocks() > 1) 54 extended_ = true; 55 56 DCHECK(sizeof(*data_) == address.BlockSize()); 57 return true; 58 } 59 60 template<typename T> void StorageBlock<T>::SetData(T* other) { 61 DCHECK(!modified_); 62 DeleteData(); 63 data_ = other; 64 } 65 66 template<typename T> void StorageBlock<T>::Discard() { 67 if (!data_) 68 return; 69 if (!own_data_) { 70 NOTREACHED(); 71 return; 72 } 73 DeleteData(); 74 data_ = NULL; 75 modified_ = false; 76 extended_ = false; 77 } 78 79 template<typename T> void StorageBlock<T>::StopSharingData() { 80 if (!data_ || own_data_) 81 return; 82 DCHECK(!modified_); 83 data_ = NULL; 84 } 85 86 template<typename T> void StorageBlock<T>::set_modified() { 87 DCHECK(data_); 88 modified_ = true; 89 } 90 91 template<typename T> void StorageBlock<T>::clear_modified() { 92 modified_ = false; 93 } 94 95 template<typename T> T* StorageBlock<T>::Data() { 96 if (!data_) 97 AllocateData(); 98 return data_; 99 } 100 101 template<typename T> bool StorageBlock<T>::HasData() const { 102 return (NULL != data_); 103 } 104 105 template<typename T> bool StorageBlock<T>::VerifyHash() const { 106 uint32 hash = CalculateHash(); 107 return (!data_->self_hash || data_->self_hash == hash); 108 } 109 110 template<typename T> bool StorageBlock<T>::own_data() const { 111 return own_data_; 112 } 113 114 template<typename T> const Addr StorageBlock<T>::address() const { 115 return address_; 116 } 117 118 template<typename T> bool StorageBlock<T>::Load() { 119 if (file_) { 120 if (!data_) 121 AllocateData(); 122 123 if (file_->Load(this)) { 124 modified_ = false; 125 return true; 126 } 127 } 128 LOG(WARNING) << "Failed data load."; 129 Trace("Failed data load."); 130 return false; 131 } 132 133 template<typename T> bool StorageBlock<T>::Store() { 134 if (file_ && data_) { 135 data_->self_hash = CalculateHash(); 136 if (file_->Store(this)) { 137 modified_ = false; 138 return true; 139 } 140 } 141 LOG(ERROR) << "Failed data store."; 142 Trace("Failed data store."); 143 return false; 144 } 145 146 template<typename T> bool StorageBlock<T>::Load(FileIOCallback* callback, 147 bool* completed) { 148 if (file_) { 149 if (!data_) 150 AllocateData(); 151 152 if (file_->Load(this, callback, completed)) { 153 modified_ = false; 154 return true; 155 } 156 } 157 LOG(WARNING) << "Failed data load."; 158 Trace("Failed data load."); 159 return false; 160 } 161 162 template<typename T> bool StorageBlock<T>::Store(FileIOCallback* callback, 163 bool* completed) { 164 if (file_ && data_) { 165 data_->self_hash = CalculateHash(); 166 if (file_->Store(this, callback, completed)) { 167 modified_ = false; 168 return true; 169 } 170 } 171 LOG(ERROR) << "Failed data store."; 172 Trace("Failed data store."); 173 return false; 174 } 175 176 template<typename T> void StorageBlock<T>::AllocateData() { 177 DCHECK(!data_); 178 if (!extended_) { 179 data_ = new T; 180 } else { 181 void* buffer = new char[address_.num_blocks() * sizeof(*data_)]; 182 data_ = new(buffer) T; 183 } 184 own_data_ = true; 185 } 186 187 template<typename T> void StorageBlock<T>::DeleteData() { 188 if (own_data_) { 189 if (!extended_) { 190 delete data_; 191 } else { 192 data_->~T(); 193 delete[] reinterpret_cast<char*>(data_); 194 } 195 own_data_ = false; 196 } 197 } 198 199 template<typename T> uint32 StorageBlock<T>::CalculateHash() const { 200 return base::Hash(reinterpret_cast<char*>(data_), offsetof(T, self_hash)); 201 } 202 203 } // namespace disk_cache 204 205 #endif // NET_DISK_CACHE_BLOCKFILE_STORAGE_BLOCK_INL_H_ 206
