| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 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 #include "net/disk_cache/tracing_cache_backend.h" | |
| 6 | |
| 7 #include "net/base/net_errors.h" | |
| 8 | |
| 9 namespace disk_cache { | |
| 10 | |
| 11 // Proxies entry objects created by the real underlying backend. Backend users | |
| 12 // will only see the proxy entries. It is necessary for recording the backend | |
| 13 // operations since often non-trivial work is invoked directly on entries. | |
| 14 class EntryProxy : public Entry, public base::RefCountedThreadSafe<EntryProxy> { | |
| 15 public: | |
| 16 EntryProxy(Entry *entry, TracingCacheBackend* backend); | |
| 17 virtual void Doom() OVERRIDE; | |
| 18 virtual void Close() OVERRIDE; | |
| 19 virtual std::string GetKey() const OVERRIDE; | |
| 20 virtual base::Time GetLastUsed() const OVERRIDE; | |
| 21 virtual base::Time GetLastModified() const OVERRIDE; | |
| 22 virtual int32 GetDataSize(int index) const OVERRIDE; | |
| 23 virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len, | |
| 24 const CompletionCallback& callback) OVERRIDE; | |
| 25 virtual int WriteData(int index, int offset, IOBuffer* buf, int buf_len, | |
| 26 const CompletionCallback& callback, | |
| 27 bool truncate) OVERRIDE; | |
| 28 virtual int ReadSparseData(int64 offset, IOBuffer* buf, int buf_len, | |
| 29 const CompletionCallback& callback) OVERRIDE; | |
| 30 virtual int WriteSparseData(int64 offset, IOBuffer* buf, int buf_len, | |
| 31 const CompletionCallback& callback) OVERRIDE; | |
| 32 virtual int GetAvailableRange(int64 offset, int len, int64* start, | |
| 33 const CompletionCallback& callback) OVERRIDE; | |
| 34 virtual bool CouldBeSparse() const OVERRIDE; | |
| 35 virtual void CancelSparseIO() OVERRIDE; | |
| 36 virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE; | |
| 37 | |
| 38 private: | |
| 39 friend class base::RefCountedThreadSafe<EntryProxy>; | |
| 40 typedef TracingCacheBackend::Operation Operation; | |
| 41 virtual ~EntryProxy(); | |
| 42 | |
| 43 struct RwOpExtra { | |
| 44 int index; | |
| 45 int offset; | |
| 46 int buf_len; | |
| 47 bool truncate; | |
| 48 }; | |
| 49 | |
| 50 void RecordEvent(base::TimeTicks start_time, Operation op, RwOpExtra extra, | |
| 51 int result_to_record); | |
| 52 void EntryOpComplete(base::TimeTicks start_time, Operation op, | |
| 53 RwOpExtra extra, const CompletionCallback& cb, | |
| 54 int result); | |
| 55 Entry* entry_; | |
| 56 base::WeakPtr<TracingCacheBackend> backend_; | |
| 57 | |
| 58 DISALLOW_COPY_AND_ASSIGN(EntryProxy); | |
| 59 }; | |
| 60 | |
| 61 EntryProxy::EntryProxy(Entry *entry, TracingCacheBackend* backend) | |
| 62 : entry_(entry), | |
| 63 backend_(backend->AsWeakPtr()) { | |
| 64 } | |
| 65 | |
| 66 void EntryProxy::Doom() { | |
| 67 // TODO(pasko): Record the event. | |
| 68 entry_->Doom(); | |
| 69 } | |
| 70 | |
| 71 void EntryProxy::Close() { | |
| 72 // TODO(pasko): Record the event. | |
| 73 entry_->Close(); | |
| 74 Release(); | |
| 75 } | |
| 76 | |
| 77 std::string EntryProxy::GetKey() const { | |
| 78 return entry_->GetKey(); | |
| 79 } | |
| 80 | |
| 81 base::Time EntryProxy::GetLastUsed() const { | |
| 82 return entry_->GetLastUsed(); | |
| 83 } | |
| 84 | |
| 85 base::Time EntryProxy::GetLastModified() const { | |
| 86 return entry_->GetLastModified(); | |
| 87 } | |
| 88 | |
| 89 int32 EntryProxy::GetDataSize(int index) const { | |
| 90 return entry_->GetDataSize(index); | |
| 91 } | |
| 92 | |
| 93 int EntryProxy::ReadData(int index, int offset, IOBuffer* buf, int buf_len, | |
| 94 const CompletionCallback& callback) { | |
| 95 base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 96 RwOpExtra extra; | |
| 97 extra.index = index; | |
| 98 extra.offset = offset; | |
| 99 extra.buf_len = buf_len; | |
| 100 extra.truncate = false; | |
| 101 int rv = entry_->ReadData( | |
| 102 index, offset, buf, buf_len, | |
| 103 base::Bind(&EntryProxy::EntryOpComplete, this, start_time, | |
| 104 TracingCacheBackend::OP_READ, extra, callback)); | |
| 105 if (rv != net::ERR_IO_PENDING) { | |
| 106 RecordEvent(start_time, TracingCacheBackend::OP_READ, extra, rv); | |
| 107 } | |
| 108 return rv; | |
| 109 } | |
| 110 | |
| 111 int EntryProxy::WriteData(int index, int offset, IOBuffer* buf, int buf_len, | |
| 112 const CompletionCallback& callback, | |
| 113 bool truncate) { | |
| 114 base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 115 RwOpExtra extra; | |
| 116 extra.index = index; | |
| 117 extra.offset = offset; | |
| 118 extra.buf_len = buf_len; | |
| 119 extra.truncate = truncate; | |
| 120 int rv = entry_->WriteData(index, offset, buf, buf_len, | |
| 121 base::Bind(&EntryProxy::EntryOpComplete, this, start_time, | |
| 122 TracingCacheBackend::OP_WRITE, extra, callback), | |
| 123 truncate); | |
| 124 if (rv != net::ERR_IO_PENDING) { | |
| 125 RecordEvent(start_time, TracingCacheBackend::OP_WRITE, extra, rv); | |
| 126 } | |
| 127 return rv; | |
| 128 } | |
| 129 | |
| 130 int EntryProxy::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len, | |
| 131 const CompletionCallback& callback) { | |
| 132 // TODO(pasko): Record the event. | |
| 133 return entry_->ReadSparseData(offset, buf, buf_len, callback); | |
| 134 } | |
| 135 | |
| 136 int EntryProxy::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len, | |
| 137 const CompletionCallback& callback) { | |
| 138 // TODO(pasko): Record the event. | |
| 139 return entry_->WriteSparseData(offset, buf, buf_len, callback); | |
| 140 } | |
| 141 | |
| 142 int EntryProxy::GetAvailableRange(int64 offset, int len, int64* start, | |
| 143 const CompletionCallback& callback) { | |
| 144 return entry_->GetAvailableRange(offset, len, start, callback); | |
| 145 } | |
| 146 | |
| 147 bool EntryProxy::CouldBeSparse() const { | |
| 148 return entry_->CouldBeSparse(); | |
| 149 } | |
| 150 | |
| 151 void EntryProxy::CancelSparseIO() { | |
| 152 return entry_->CancelSparseIO(); | |
| 153 } | |
| 154 | |
| 155 int EntryProxy::ReadyForSparseIO(const CompletionCallback& callback) { | |
| 156 return entry_->ReadyForSparseIO(callback); | |
| 157 } | |
| 158 | |
| 159 void EntryProxy::RecordEvent(base::TimeTicks start_time, Operation op, | |
| 160 RwOpExtra extra, int result_to_record) { | |
| 161 // TODO(pasko): Implement. | |
| 162 } | |
| 163 | |
| 164 void EntryProxy::EntryOpComplete(base::TimeTicks start_time, Operation op, | |
| 165 RwOpExtra extra, const CompletionCallback& cb, | |
| 166 int result) { | |
| 167 RecordEvent(start_time, op, extra, result); | |
| 168 if (!cb.is_null()) { | |
| 169 cb.Run(result); | |
| 170 } | |
| 171 } | |
| 172 | |
| 173 EntryProxy::~EntryProxy() { | |
| 174 if (backend_.get()) { | |
| 175 backend_->OnDeleteEntry(entry_); | |
| 176 } | |
| 177 } | |
| 178 | |
| 179 TracingCacheBackend::TracingCacheBackend(scoped_ptr<Backend> backend) | |
| 180 : backend_(backend.Pass()) { | |
| 181 } | |
| 182 | |
| 183 TracingCacheBackend::~TracingCacheBackend() { | |
| 184 } | |
| 185 | |
| 186 net::CacheType TracingCacheBackend::GetCacheType() const { | |
| 187 return backend_->GetCacheType(); | |
| 188 } | |
| 189 | |
| 190 int32 TracingCacheBackend::GetEntryCount() const { | |
| 191 return backend_->GetEntryCount(); | |
| 192 } | |
| 193 | |
| 194 void TracingCacheBackend::RecordEvent(base::TimeTicks start_time, Operation op, | |
| 195 std::string key, Entry* entry, int rv) { | |
| 196 // TODO(pasko): Implement. | |
| 197 } | |
| 198 | |
| 199 EntryProxy* TracingCacheBackend::FindOrCreateEntryProxy(Entry* entry) { | |
| 200 EntryProxy* entry_proxy; | |
| 201 EntryToProxyMap::iterator it = open_entries_.find(entry); | |
| 202 if (it != open_entries_.end()) { | |
| 203 entry_proxy = it->second; | |
| 204 entry_proxy->AddRef(); | |
| 205 return entry_proxy; | |
| 206 } | |
| 207 entry_proxy = new EntryProxy(entry, this); | |
| 208 entry_proxy->AddRef(); | |
| 209 open_entries_[entry] = entry_proxy; | |
| 210 return entry_proxy; | |
| 211 } | |
| 212 | |
| 213 void TracingCacheBackend::OnDeleteEntry(Entry* entry) { | |
| 214 EntryToProxyMap::iterator it = open_entries_.find(entry); | |
| 215 if (it != open_entries_.end()) { | |
| 216 open_entries_.erase(it); | |
| 217 } | |
| 218 } | |
| 219 | |
| 220 void TracingCacheBackend::BackendOpComplete(base::TimeTicks start_time, | |
| 221 Operation op, | |
| 222 std::string key, | |
| 223 Entry** entry, | |
| 224 const CompletionCallback& callback, | |
| 225 int result) { | |
| 226 RecordEvent(start_time, op, key, *entry, result); | |
| 227 if (*entry) { | |
| 228 *entry = FindOrCreateEntryProxy(*entry); | |
| 229 } | |
| 230 if (!callback.is_null()) { | |
| 231 callback.Run(result); | |
| 232 } | |
| 233 } | |
| 234 | |
| 235 net::CompletionCallback TracingCacheBackend::BindCompletion( | |
| 236 Operation op, base::TimeTicks start_time, const std::string& key, | |
| 237 Entry **entry, const net::CompletionCallback& cb) { | |
| 238 return base::Bind(&TracingCacheBackend::BackendOpComplete, | |
| 239 AsWeakPtr(), start_time, op, key, entry, cb); | |
| 240 } | |
| 241 | |
| 242 int TracingCacheBackend::OpenEntry(const std::string& key, Entry** entry, | |
| 243 const CompletionCallback& callback) { | |
| 244 DCHECK(*entry == NULL); | |
| 245 base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 246 int rv = backend_->OpenEntry(key, entry, | |
| 247 BindCompletion(OP_OPEN, start_time, key, entry, | |
| 248 callback)); | |
| 249 if (rv != net::ERR_IO_PENDING) { | |
| 250 RecordEvent(start_time, OP_OPEN, key, *entry, rv); | |
| 251 if (*entry) { | |
| 252 *entry = FindOrCreateEntryProxy(*entry); | |
| 253 } | |
| 254 } | |
| 255 return rv; | |
| 256 } | |
| 257 | |
| 258 int TracingCacheBackend::CreateEntry(const std::string& key, Entry** entry, | |
| 259 const CompletionCallback& callback) { | |
| 260 base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 261 int rv = backend_->CreateEntry(key, entry, | |
| 262 BindCompletion(OP_CREATE, start_time, key, | |
| 263 entry, callback)); | |
| 264 if (rv != net::ERR_IO_PENDING) { | |
| 265 RecordEvent(start_time, OP_CREATE, key, *entry, rv); | |
| 266 if (*entry) { | |
| 267 *entry = FindOrCreateEntryProxy(*entry); | |
| 268 } | |
| 269 } | |
| 270 return rv; | |
| 271 } | |
| 272 | |
| 273 int TracingCacheBackend::DoomEntry(const std::string& key, | |
| 274 const CompletionCallback& callback) { | |
| 275 base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 276 int rv = backend_->DoomEntry(key, BindCompletion(OP_DOOM_ENTRY, | |
| 277 start_time, key, NULL, | |
| 278 callback)); | |
| 279 if (rv != net::ERR_IO_PENDING) { | |
| 280 RecordEvent(start_time, OP_DOOM_ENTRY, key, NULL, rv); | |
| 281 } | |
| 282 return rv; | |
| 283 } | |
| 284 | |
| 285 int TracingCacheBackend::DoomAllEntries(const CompletionCallback& callback) { | |
| 286 return backend_->DoomAllEntries(callback); | |
| 287 } | |
| 288 | |
| 289 int TracingCacheBackend::DoomEntriesBetween(base::Time initial_time, | |
| 290 base::Time end_time, | |
| 291 const CompletionCallback& cb) { | |
| 292 return backend_->DoomEntriesBetween(initial_time, end_time, cb); | |
| 293 } | |
| 294 | |
| 295 int TracingCacheBackend::DoomEntriesSince(base::Time initial_time, | |
| 296 const CompletionCallback& callback) { | |
| 297 return backend_->DoomEntriesSince(initial_time, callback); | |
| 298 } | |
| 299 | |
| 300 int TracingCacheBackend::OpenNextEntry(void** iter, Entry** next_entry, | |
| 301 const CompletionCallback& callback) { | |
| 302 return backend_->OpenNextEntry(iter, next_entry, callback); | |
| 303 } | |
| 304 | |
| 305 void TracingCacheBackend::EndEnumeration(void** iter) { | |
| 306 return backend_->EndEnumeration(iter); | |
| 307 } | |
| 308 | |
| 309 void TracingCacheBackend::GetStats(StatsItems* stats) { | |
| 310 return backend_->GetStats(stats); | |
| 311 } | |
| 312 | |
| 313 void TracingCacheBackend::OnExternalCacheHit(const std::string& key) { | |
| 314 return backend_->OnExternalCacheHit(key); | |
| 315 } | |
| 316 | |
| 317 } // namespace disk_cache | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 121643003:
Reorganize net/disk_cache into backend specific directories. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src