Home | History | Annotate | Download | only in blockfile 
      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 
     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.
     41 void BackendIO::ExecuteOperation() {
     42   if (IsEntryOperation())
     43     return ExecuteEntryOperation();
     44 
     45   ExecuteBackendOperation();
     46 }
     47 
     48 // Runs on the background thread.
     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.
     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 
     72 bool BackendIO::IsEntryOperation() {
     73   return operation_ > OP_MAX_BACKEND;
     74 }
     75 
     76 // Runs on the background thread.
     77 void BackendIO::ReferenceEntry() {
     78   entry_->AddRef();
     79 }
     80 
     81 void BackendIO::Init() {
     82   operation_ = OP_INIT;
     83 }
     84 
     85 void BackendIO::OpenEntry(const std::string& key, Entry** entry) {
     86   operation_ = OP_OPEN;
     87   key_ = key;
     88   entry_ptr_ = entry;
     89 }
     90 
     91 void BackendIO::CreateEntry(const std::string& key, Entry** entry) {
     92   operation_ = OP_CREATE;
     93   key_ = key;
     94   entry_ptr_ = entry;
     95 }
     96 
     97 void BackendIO::DoomEntry(const std::string& key) {
     98   operation_ = OP_DOOM;
     99   key_ = key;
    100 }
    101 
    102 void BackendIO::DoomAllEntries() {
    103   operation_ = OP_DOOM_ALL;
    104 }
    105 
    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 
    113 void BackendIO::DoomEntriesSince(const base::Time initial_time) {
    114   operation_ = OP_DOOM_SINCE;
    115   initial_time_ = initial_time;
    116 }
    117 
    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 
    125 void BackendIO::EndEnumeration(scoped_ptr<Rankings::Iterator> iterator) {
    126   operation_ = OP_END_ENUMERATION;
    127   scoped_iterator_ = iterator.Pass();
    128 }
    129 
    130 void BackendIO::OnExternalCacheHit(const std::string& key) {
    131   operation_ = OP_ON_EXTERNAL_CACHE_HIT;
    132   key_ = key;
    133 }
    134 
    135 void BackendIO::CloseEntryImpl(EntryImpl* entry) {
    136   operation_ = OP_CLOSE_ENTRY;
    137   entry_ = entry;
    138 }
    139 
    140 void BackendIO::DoomEntryImpl(EntryImpl* entry) {
    141   operation_ = OP_DOOM_ENTRY;
    142   entry_ = entry;
    143 }
    144 
    145 void BackendIO::FlushQueue() {
    146   operation_ = OP_FLUSH_QUEUE;
    147 }
    148 
    149 void BackendIO::RunTask(const base::Closure& task) {
    150   operation_ = OP_RUN_TASK;
    151   task_ = task;
    152 }
    153 
    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 
    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 
    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 
    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 
    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 
    202 void BackendIO::CancelSparseIO(EntryImpl* entry) {
    203   operation_ = OP_CANCEL_IO;
    204   entry_ = entry;
    205 }
    206 
    207 void BackendIO::ReadyForSparseIO(EntryImpl* entry) {
    208   operation_ = OP_IS_READY;
    209   entry_ = entry;
    210 }
    211 
    212 BackendIO::~BackendIO() {}
    213 
    214 bool BackendIO::ReturnsEntry() {
    215   return operation_ == OP_OPEN || operation_ == OP_CREATE ||
    216       operation_ == OP_OPEN_NEXT;
    217 }
    218 
    219 base::TimeDelta BackendIO::ElapsedTime() const {
    220   return base::TimeTicks::Now() - start_time_;
    221 }
    222 
    223 // Runs on the background thread.
    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.
    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 
    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 
    333 InFlightBackendIO::~InFlightBackendIO() {
    334 }
    335 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    490 void InFlightBackendIO::WaitForPendingIO() {
    491   InFlightIO::WaitForPendingIO();
    492 }
    493 
    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 
    503 void InFlightBackendIO::PostOperation(BackendIO* operation) {
    504   background_thread_->PostTask(
    505       FROM_HERE, base::Bind(&BackendIO::ExecuteOperation, operation));
    506   OnOperationPosted(operation);
    507 }
    508 
    509 base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() {
    510   return ptr_factory_.GetWeakPtr();
    511 }
    512 
    513 }  // namespace
    514