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 #include "net/disk_cache/blockfile/in_flight_backend_io.h"
6
7 #include "base/bind.h"
8 #include "base/bind_helpers.h"
9 #include "base/compiler_specific.h"
10 #include "base/logging.h"
11 #include "base/single_thread_task_runner.h"
12 #include "net/base/net_errors.h"
13 #include "net/disk_cache/blockfile/backend_impl.h"
14 #include "net/disk_cache/blockfile/entry_impl.h"
15 #include "net/disk_cache/blockfile/histogram_macros.h"
16
17 // Provide a BackendImpl object to macros from histogram_macros.h.
18 #define CACHE_UMA_BACKEND_IMPL_OBJ backend_
19
20 namespace disk_cache {
21
BackendIO(InFlightIO * controller,BackendImpl * backend,const net::CompletionCallback & callback)22 BackendIO::BackendIO(InFlightIO* controller, BackendImpl* backend,
23 const net::CompletionCallback& callback)
24 : BackgroundIO(controller),
25 backend_(backend),
26 callback_(callback),
27 operation_(OP_NONE),
28 entry_ptr_(NULL),
29 iterator_(NULL),
30 entry_(NULL),
31 index_(0),
32 offset_(0),
33 buf_len_(0),
34 truncate_(false),
35 offset64_(0),
36 start_(NULL) {
37 start_time_ = base::TimeTicks::Now();
38 }
39
40 // Runs on the background thread.
ExecuteOperation()41 void BackendIO::ExecuteOperation() {
42 if (IsEntryOperation())
43 return ExecuteEntryOperation();
44
45 ExecuteBackendOperation();
46 }
47
48 // Runs on the background thread.
OnIOComplete(int result)49 void BackendIO::OnIOComplete(int result) {
50 DCHECK(IsEntryOperation());
51 DCHECK_NE(result, net::ERR_IO_PENDING);
52 result_ = result;
53 NotifyController();
54 }
55
56 // Runs on the primary thread.
OnDone(bool cancel)57 void BackendIO::OnDone(bool cancel) {
58 if (IsEntryOperation()) {
59 CACHE_UMA(TIMES, "TotalIOTime", 0, ElapsedTime());
60 }
61
62 if (!ReturnsEntry())
63 return;
64
65 if (result() == net::OK) {
66 static_cast<EntryImpl*>(*entry_ptr_)->OnEntryCreated(backend_);
67 if (cancel)
68 (*entry_ptr_)->Close();
69 }
70 }
71
IsEntryOperation()72 bool BackendIO::IsEntryOperation() {
73 return operation_ > OP_MAX_BACKEND;
74 }
75
76 // Runs on the background thread.
ReferenceEntry()77 void BackendIO::ReferenceEntry() {
78 entry_->AddRef();
79 }
80
Init()81 void BackendIO::Init() {
82 operation_ = OP_INIT;
83 }
84
OpenEntry(const std::string & key,Entry ** entry)85 void BackendIO::OpenEntry(const std::string& key, Entry** entry) {
86 operation_ = OP_OPEN;
87 key_ = key;
88 entry_ptr_ = entry;
89 }
90
CreateEntry(const std::string & key,Entry ** entry)91 void BackendIO::CreateEntry(const std::string& key, Entry** entry) {
92 operation_ = OP_CREATE;
93 key_ = key;
94 entry_ptr_ = entry;
95 }
96
DoomEntry(const std::string & key)97 void BackendIO::DoomEntry(const std::string& key) {
98 operation_ = OP_DOOM;
99 key_ = key;
100 }
101
DoomAllEntries()102 void BackendIO::DoomAllEntries() {
103 operation_ = OP_DOOM_ALL;
104 }
105
DoomEntriesBetween(const base::Time initial_time,const base::Time end_time)106 void BackendIO::DoomEntriesBetween(const base::Time initial_time,
107 const base::Time end_time) {
108 operation_ = OP_DOOM_BETWEEN;
109 initial_time_ = initial_time;
110 end_time_ = end_time;
111 }
112
DoomEntriesSince(const base::Time initial_time)113 void BackendIO::DoomEntriesSince(const base::Time initial_time) {
114 operation_ = OP_DOOM_SINCE;
115 initial_time_ = initial_time;
116 }
117
OpenNextEntry(Rankings::Iterator * iterator,Entry ** next_entry)118 void BackendIO::OpenNextEntry(Rankings::Iterator* iterator,
119 Entry** next_entry) {
120 operation_ = OP_OPEN_NEXT;
121 iterator_ = iterator;
122 entry_ptr_ = next_entry;
123 }
124
EndEnumeration(scoped_ptr<Rankings::Iterator> iterator)125 void BackendIO::EndEnumeration(scoped_ptr<Rankings::Iterator> iterator) {
126 operation_ = OP_END_ENUMERATION;
127 scoped_iterator_ = iterator.Pass();
128 }
129
OnExternalCacheHit(const std::string & key)130 void BackendIO::OnExternalCacheHit(const std::string& key) {
131 operation_ = OP_ON_EXTERNAL_CACHE_HIT;
132 key_ = key;
133 }
134
CloseEntryImpl(EntryImpl * entry)135 void BackendIO::CloseEntryImpl(EntryImpl* entry) {
136 operation_ = OP_CLOSE_ENTRY;
137 entry_ = entry;
138 }
139
DoomEntryImpl(EntryImpl * entry)140 void BackendIO::DoomEntryImpl(EntryImpl* entry) {
141 operation_ = OP_DOOM_ENTRY;
142 entry_ = entry;
143 }
144
FlushQueue()145 void BackendIO::FlushQueue() {
146 operation_ = OP_FLUSH_QUEUE;
147 }
148
RunTask(const base::Closure & task)149 void BackendIO::RunTask(const base::Closure& task) {
150 operation_ = OP_RUN_TASK;
151 task_ = task;
152 }
153
ReadData(EntryImpl * entry,int index,int offset,net::IOBuffer * buf,int buf_len)154 void BackendIO::ReadData(EntryImpl* entry, int index, int offset,
155 net::IOBuffer* buf, int buf_len) {
156 operation_ = OP_READ;
157 entry_ = entry;
158 index_ = index;
159 offset_ = offset;
160 buf_ = buf;
161 buf_len_ = buf_len;
162 }
163
WriteData(EntryImpl * entry,int index,int offset,net::IOBuffer * buf,int buf_len,bool truncate)164 void BackendIO::WriteData(EntryImpl* entry, int index, int offset,
165 net::IOBuffer* buf, int buf_len, bool truncate) {
166 operation_ = OP_WRITE;
167 entry_ = entry;
168 index_ = index;
169 offset_ = offset;
170 buf_ = buf;
171 buf_len_ = buf_len;
172 truncate_ = truncate;
173 }
174
ReadSparseData(EntryImpl * entry,int64 offset,net::IOBuffer * buf,int buf_len)175 void BackendIO::ReadSparseData(EntryImpl* entry, int64 offset,
176 net::IOBuffer* buf, int buf_len) {
177 operation_ = OP_READ_SPARSE;
178 entry_ = entry;
179 offset64_ = offset;
180 buf_ = buf;
181 buf_len_ = buf_len;
182 }
183
WriteSparseData(EntryImpl * entry,int64 offset,net::IOBuffer * buf,int buf_len)184 void BackendIO::WriteSparseData(EntryImpl* entry, int64 offset,
185 net::IOBuffer* buf, int buf_len) {
186 operation_ = OP_WRITE_SPARSE;
187 entry_ = entry;
188 offset64_ = offset;
189 buf_ = buf;
190 buf_len_ = buf_len;
191 }
192
GetAvailableRange(EntryImpl * entry,int64 offset,int len,int64 * start)193 void BackendIO::GetAvailableRange(EntryImpl* entry, int64 offset, int len,
194 int64* start) {
195 operation_ = OP_GET_RANGE;
196 entry_ = entry;
197 offset64_ = offset;
198 buf_len_ = len;
199 start_ = start;
200 }
201
CancelSparseIO(EntryImpl * entry)202 void BackendIO::CancelSparseIO(EntryImpl* entry) {
203 operation_ = OP_CANCEL_IO;
204 entry_ = entry;
205 }
206
ReadyForSparseIO(EntryImpl * entry)207 void BackendIO::ReadyForSparseIO(EntryImpl* entry) {
208 operation_ = OP_IS_READY;
209 entry_ = entry;
210 }
211
~BackendIO()212 BackendIO::~BackendIO() {}
213
ReturnsEntry()214 bool BackendIO::ReturnsEntry() {
215 return operation_ == OP_OPEN || operation_ == OP_CREATE ||
216 operation_ == OP_OPEN_NEXT;
217 }
218
ElapsedTime() const219 base::TimeDelta BackendIO::ElapsedTime() const {
220 return base::TimeTicks::Now() - start_time_;
221 }
222
223 // Runs on the background thread.
ExecuteBackendOperation()224 void BackendIO::ExecuteBackendOperation() {
225 switch (operation_) {
226 case OP_INIT:
227 result_ = backend_->SyncInit();
228 break;
229 case OP_OPEN:
230 result_ = backend_->SyncOpenEntry(key_, entry_ptr_);
231 break;
232 case OP_CREATE:
233 result_ = backend_->SyncCreateEntry(key_, entry_ptr_);
234 break;
235 case OP_DOOM:
236 result_ = backend_->SyncDoomEntry(key_);
237 break;
238 case OP_DOOM_ALL:
239 result_ = backend_->SyncDoomAllEntries();
240 break;
241 case OP_DOOM_BETWEEN:
242 result_ = backend_->SyncDoomEntriesBetween(initial_time_, end_time_);
243 break;
244 case OP_DOOM_SINCE:
245 result_ = backend_->SyncDoomEntriesSince(initial_time_);
246 break;
247 case OP_OPEN_NEXT:
248 result_ = backend_->SyncOpenNextEntry(iterator_, entry_ptr_);
249 break;
250 case OP_END_ENUMERATION:
251 backend_->SyncEndEnumeration(scoped_iterator_.Pass());
252 result_ = net::OK;
253 break;
254 case OP_ON_EXTERNAL_CACHE_HIT:
255 backend_->SyncOnExternalCacheHit(key_);
256 result_ = net::OK;
257 break;
258 case OP_CLOSE_ENTRY:
259 entry_->Release();
260 result_ = net::OK;
261 break;
262 case OP_DOOM_ENTRY:
263 entry_->DoomImpl();
264 result_ = net::OK;
265 break;
266 case OP_FLUSH_QUEUE:
267 result_ = net::OK;
268 break;
269 case OP_RUN_TASK:
270 task_.Run();
271 result_ = net::OK;
272 break;
273 default:
274 NOTREACHED() << "Invalid Operation";
275 result_ = net::ERR_UNEXPECTED;
276 }
277 DCHECK_NE(net::ERR_IO_PENDING, result_);
278 NotifyController();
279 }
280
281 // Runs on the background thread.
ExecuteEntryOperation()282 void BackendIO::ExecuteEntryOperation() {
283 switch (operation_) {
284 case OP_READ:
285 result_ =
286 entry_->ReadDataImpl(index_, offset_, buf_.get(), buf_len_,
287 base::Bind(&BackendIO::OnIOComplete, this));
288 break;
289 case OP_WRITE:
290 result_ =
291 entry_->WriteDataImpl(index_, offset_, buf_.get(), buf_len_,
292 base::Bind(&BackendIO::OnIOComplete, this),
293 truncate_);
294 break;
295 case OP_READ_SPARSE:
296 result_ = entry_->ReadSparseDataImpl(
297 offset64_, buf_.get(), buf_len_,
298 base::Bind(&BackendIO::OnIOComplete, this));
299 break;
300 case OP_WRITE_SPARSE:
301 result_ = entry_->WriteSparseDataImpl(
302 offset64_, buf_.get(), buf_len_,
303 base::Bind(&BackendIO::OnIOComplete, this));
304 break;
305 case OP_GET_RANGE:
306 result_ = entry_->GetAvailableRangeImpl(offset64_, buf_len_, start_);
307 break;
308 case OP_CANCEL_IO:
309 entry_->CancelSparseIOImpl();
310 result_ = net::OK;
311 break;
312 case OP_IS_READY:
313 result_ = entry_->ReadyForSparseIOImpl(
314 base::Bind(&BackendIO::OnIOComplete, this));
315 break;
316 default:
317 NOTREACHED() << "Invalid Operation";
318 result_ = net::ERR_UNEXPECTED;
319 }
320 buf_ = NULL;
321 if (result_ != net::ERR_IO_PENDING)
322 NotifyController();
323 }
324
InFlightBackendIO(BackendImpl * backend,const scoped_refptr<base::SingleThreadTaskRunner> & background_thread)325 InFlightBackendIO::InFlightBackendIO(
326 BackendImpl* backend,
327 const scoped_refptr<base::SingleThreadTaskRunner>& background_thread)
328 : backend_(backend),
329 background_thread_(background_thread),
330 ptr_factory_(this) {
331 }
332
~InFlightBackendIO()333 InFlightBackendIO::~InFlightBackendIO() {
334 }
335
Init(const net::CompletionCallback & callback)336 void InFlightBackendIO::Init(const net::CompletionCallback& callback) {
337 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
338 operation->Init();
339 PostOperation(operation.get());
340 }
341
OpenEntry(const std::string & key,Entry ** entry,const net::CompletionCallback & callback)342 void InFlightBackendIO::OpenEntry(const std::string& key, Entry** entry,
343 const net::CompletionCallback& callback) {
344 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
345 operation->OpenEntry(key, entry);
346 PostOperation(operation.get());
347 }
348
CreateEntry(const std::string & key,Entry ** entry,const net::CompletionCallback & callback)349 void InFlightBackendIO::CreateEntry(const std::string& key, Entry** entry,
350 const net::CompletionCallback& callback) {
351 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
352 operation->CreateEntry(key, entry);
353 PostOperation(operation.get());
354 }
355
DoomEntry(const std::string & key,const net::CompletionCallback & callback)356 void InFlightBackendIO::DoomEntry(const std::string& key,
357 const net::CompletionCallback& callback) {
358 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
359 operation->DoomEntry(key);
360 PostOperation(operation.get());
361 }
362
DoomAllEntries(const net::CompletionCallback & callback)363 void InFlightBackendIO::DoomAllEntries(
364 const net::CompletionCallback& callback) {
365 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
366 operation->DoomAllEntries();
367 PostOperation(operation.get());
368 }
369
DoomEntriesBetween(const base::Time initial_time,const base::Time end_time,const net::CompletionCallback & callback)370 void InFlightBackendIO::DoomEntriesBetween(const base::Time initial_time,
371 const base::Time end_time,
372 const net::CompletionCallback& callback) {
373 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
374 operation->DoomEntriesBetween(initial_time, end_time);
375 PostOperation(operation.get());
376 }
377
DoomEntriesSince(const base::Time initial_time,const net::CompletionCallback & callback)378 void InFlightBackendIO::DoomEntriesSince(
379 const base::Time initial_time, const net::CompletionCallback& callback) {
380 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
381 operation->DoomEntriesSince(initial_time);
382 PostOperation(operation.get());
383 }
384
OpenNextEntry(Rankings::Iterator * iterator,Entry ** next_entry,const net::CompletionCallback & callback)385 void InFlightBackendIO::OpenNextEntry(Rankings::Iterator* iterator,
386 Entry** next_entry,
387 const net::CompletionCallback& callback) {
388 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
389 operation->OpenNextEntry(iterator, next_entry);
390 PostOperation(operation.get());
391 }
392
EndEnumeration(scoped_ptr<Rankings::Iterator> iterator)393 void InFlightBackendIO::EndEnumeration(
394 scoped_ptr<Rankings::Iterator> iterator) {
395 scoped_refptr<BackendIO> operation(
396 new BackendIO(this, backend_, net::CompletionCallback()));
397 operation->EndEnumeration(iterator.Pass());
398 PostOperation(operation.get());
399 }
400
OnExternalCacheHit(const std::string & key)401 void InFlightBackendIO::OnExternalCacheHit(const std::string& key) {
402 scoped_refptr<BackendIO> operation(
403 new BackendIO(this, backend_, net::CompletionCallback()));
404 operation->OnExternalCacheHit(key);
405 PostOperation(operation.get());
406 }
407
CloseEntryImpl(EntryImpl * entry)408 void InFlightBackendIO::CloseEntryImpl(EntryImpl* entry) {
409 scoped_refptr<BackendIO> operation(
410 new BackendIO(this, backend_, net::CompletionCallback()));
411 operation->CloseEntryImpl(entry);
412 PostOperation(operation.get());
413 }
414
DoomEntryImpl(EntryImpl * entry)415 void InFlightBackendIO::DoomEntryImpl(EntryImpl* entry) {
416 scoped_refptr<BackendIO> operation(
417 new BackendIO(this, backend_, net::CompletionCallback()));
418 operation->DoomEntryImpl(entry);
419 PostOperation(operation.get());
420 }
421
FlushQueue(const net::CompletionCallback & callback)422 void InFlightBackendIO::FlushQueue(const net::CompletionCallback& callback) {
423 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
424 operation->FlushQueue();
425 PostOperation(operation.get());
426 }
427
RunTask(const base::Closure & task,const net::CompletionCallback & callback)428 void InFlightBackendIO::RunTask(
429 const base::Closure& task, const net::CompletionCallback& callback) {
430 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
431 operation->RunTask(task);
432 PostOperation(operation.get());
433 }
434
ReadData(EntryImpl * entry,int index,int offset,net::IOBuffer * buf,int buf_len,const net::CompletionCallback & callback)435 void InFlightBackendIO::ReadData(EntryImpl* entry, int index, int offset,
436 net::IOBuffer* buf, int buf_len,
437 const net::CompletionCallback& callback) {
438 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
439 operation->ReadData(entry, index, offset, buf, buf_len);
440 PostOperation(operation.get());
441 }
442
WriteData(EntryImpl * entry,int index,int offset,net::IOBuffer * buf,int buf_len,bool truncate,const net::CompletionCallback & callback)443 void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset,
444 net::IOBuffer* buf, int buf_len,
445 bool truncate,
446 const net::CompletionCallback& callback) {
447 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
448 operation->WriteData(entry, index, offset, buf, buf_len, truncate);
449 PostOperation(operation.get());
450 }
451
ReadSparseData(EntryImpl * entry,int64 offset,net::IOBuffer * buf,int buf_len,const net::CompletionCallback & callback)452 void InFlightBackendIO::ReadSparseData(
453 EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len,
454 const net::CompletionCallback& callback) {
455 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
456 operation->ReadSparseData(entry, offset, buf, buf_len);
457 PostOperation(operation.get());
458 }
459
WriteSparseData(EntryImpl * entry,int64 offset,net::IOBuffer * buf,int buf_len,const net::CompletionCallback & callback)460 void InFlightBackendIO::WriteSparseData(
461 EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len,
462 const net::CompletionCallback& callback) {
463 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
464 operation->WriteSparseData(entry, offset, buf, buf_len);
465 PostOperation(operation.get());
466 }
467
GetAvailableRange(EntryImpl * entry,int64 offset,int len,int64 * start,const net::CompletionCallback & callback)468 void InFlightBackendIO::GetAvailableRange(
469 EntryImpl* entry, int64 offset, int len, int64* start,
470 const net::CompletionCallback& callback) {
471 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
472 operation->GetAvailableRange(entry, offset, len, start);
473 PostOperation(operation.get());
474 }
475
CancelSparseIO(EntryImpl * entry)476 void InFlightBackendIO::CancelSparseIO(EntryImpl* entry) {
477 scoped_refptr<BackendIO> operation(
478 new BackendIO(this, backend_, net::CompletionCallback()));
479 operation->CancelSparseIO(entry);
480 PostOperation(operation.get());
481 }
482
ReadyForSparseIO(EntryImpl * entry,const net::CompletionCallback & callback)483 void InFlightBackendIO::ReadyForSparseIO(
484 EntryImpl* entry, const net::CompletionCallback& callback) {
485 scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
486 operation->ReadyForSparseIO(entry);
487 PostOperation(operation.get());
488 }
489
WaitForPendingIO()490 void InFlightBackendIO::WaitForPendingIO() {
491 InFlightIO::WaitForPendingIO();
492 }
493
OnOperationComplete(BackgroundIO * operation,bool cancel)494 void InFlightBackendIO::OnOperationComplete(BackgroundIO* operation,
495 bool cancel) {
496 BackendIO* op = static_cast<BackendIO*>(operation);
497 op->OnDone(cancel);
498
499 if (!op->callback().is_null() && (!cancel || op->IsEntryOperation()))
500 op->callback().Run(op->result());
501 }
502
PostOperation(BackendIO * operation)503 void InFlightBackendIO::PostOperation(BackendIO* operation) {
504 background_thread_->PostTask(
505 FROM_HERE, base::Bind(&BackendIO::ExecuteOperation, operation));
506 OnOperationPosted(operation);
507 }
508
GetWeakPtr()509 base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() {
510 return ptr_factory_.GetWeakPtr();
511 }
512
513 } // namespace
514