• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_STORAGE_BLOCK_INL_H_
6 #define NET_DISK_CACHE_STORAGE_BLOCK_INL_H_
7 
8 #include "net/disk_cache/storage_block.h"
9 
10 #include "base/hash.h"
11 #include "base/logging.h"
12 #include "net/disk_cache/trace.h"
13 
14 namespace disk_cache {
15 
StorageBlock(MappedFile * file,Addr address)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 
~StorageBlock()25 template<typename T> StorageBlock<T>::~StorageBlock() {
26   if (modified_)
27     Store();
28   DeleteData();
29 }
30 
buffer()31 template<typename T> void* StorageBlock<T>::buffer() const {
32   return data_;
33 }
34 
size()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 
offset()41 template<typename T> int StorageBlock<T>::offset() const {
42   return address_.start_block() * address_.BlockSize();
43 }
44 
LazyInit(MappedFile * file,Addr address)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 
SetData(T * other)60 template<typename T> void StorageBlock<T>::SetData(T* other) {
61   DCHECK(!modified_);
62   DeleteData();
63   data_ = other;
64 }
65 
Discard()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 
StopSharingData()79 template<typename T> void  StorageBlock<T>::StopSharingData() {
80   if (!data_ || own_data_)
81     return;
82   DCHECK(!modified_);
83   data_ = NULL;
84 }
85 
set_modified()86 template<typename T> void StorageBlock<T>::set_modified() {
87   DCHECK(data_);
88   modified_ = true;
89 }
90 
clear_modified()91 template<typename T> void StorageBlock<T>::clear_modified() {
92   modified_ = false;
93 }
94 
Data()95 template<typename T> T* StorageBlock<T>::Data() {
96   if (!data_)
97     AllocateData();
98   return data_;
99 }
100 
HasData()101 template<typename T> bool StorageBlock<T>::HasData() const {
102   return (NULL != data_);
103 }
104 
VerifyHash()105 template<typename T> bool StorageBlock<T>::VerifyHash() const {
106   uint32 hash = CalculateHash();
107   return (!data_->self_hash || data_->self_hash == hash);
108 }
109 
own_data()110 template<typename T> bool StorageBlock<T>::own_data() const {
111   return own_data_;
112 }
113 
address()114 template<typename T> const Addr StorageBlock<T>::address() const {
115   return address_;
116 }
117 
Load()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 
Store()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 
Load(FileIOCallback * callback,bool * completed)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 
Store(FileIOCallback * callback,bool * completed)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 
AllocateData()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 
DeleteData()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 
CalculateHash()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_STORAGE_BLOCK_INL_H_
206