Home | History | Annotate | Download | only in simple 
      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/simple/simple_entry_impl.h"
      6 
      7 #include <algorithm>
      8 #include <cstring>
      9 #include <vector>
     10 
     11 #include "base/bind.h"
     12 #include "base/bind_helpers.h"
     13 #include "base/callback.h"
     14 #include "base/location.h"
     15 #include "base/logging.h"
     16 #include "base/message_loop/message_loop_proxy.h"
     17 #include "base/metrics/histogram.h"
     18 #include "base/task_runner.h"
     19 #include "base/time/time.h"
     20 #include "net/base/io_buffer.h"
     21 #include "net/base/net_errors.h"
     22 #include "net/disk_cache/net_log_parameters.h"
     23 #include "net/disk_cache/simple/simple_backend_impl.h"
     24 #include "net/disk_cache/simple/simple_index.h"
     25 #include "net/disk_cache/simple/simple_net_log_parameters.h"
     26 #include "net/disk_cache/simple/simple_synchronous_entry.h"
     27 #include "net/disk_cache/simple/simple_util.h"
     28 #include "third_party/zlib/zlib.h"
     29 
     30 namespace {
     31 
     32 // Used in histograms, please only add entries at the end.
     33 enum ReadResult {
     34   READ_RESULT_SUCCESS = 0,
     35   READ_RESULT_INVALID_ARGUMENT = 1,
     36   READ_RESULT_NONBLOCK_EMPTY_RETURN = 2,
     37   READ_RESULT_BAD_STATE = 3,
     38   READ_RESULT_FAST_EMPTY_RETURN = 4,
     39   READ_RESULT_SYNC_READ_FAILURE = 5,
     40   READ_RESULT_SYNC_CHECKSUM_FAILURE = 6,
     41   READ_RESULT_MAX = 7,
     42 };
     43 
     44 // Used in histograms, please only add entries at the end.
     45 enum WriteResult {
     46   WRITE_RESULT_SUCCESS = 0,
     47   WRITE_RESULT_INVALID_ARGUMENT = 1,
     48   WRITE_RESULT_OVER_MAX_SIZE = 2,
     49   WRITE_RESULT_BAD_STATE = 3,
     50   WRITE_RESULT_SYNC_WRITE_FAILURE = 4,
     51   WRITE_RESULT_MAX = 5,
     52 };
     53 
     54 // Used in histograms, please only add entries at the end.
     55 enum HeaderSizeChange {
     56   HEADER_SIZE_CHANGE_INITIAL,
     57   HEADER_SIZE_CHANGE_SAME,
     58   HEADER_SIZE_CHANGE_INCREASE,
     59   HEADER_SIZE_CHANGE_DECREASE,
     60   HEADER_SIZE_CHANGE_UNEXPECTED_WRITE,
     61   HEADER_SIZE_CHANGE_MAX
     62 };
     63 
     64 void RecordReadResult(ReadResult result) {
     65   UMA_HISTOGRAM_ENUMERATION("SimpleCache.ReadResult", result, READ_RESULT_MAX);
     66 };
     67 
     68 void RecordWriteResult(WriteResult result) {
     69   UMA_HISTOGRAM_ENUMERATION("SimpleCache.WriteResult",
     70                             result, WRITE_RESULT_MAX);
     71 };
     72 
     73 // TODO(ttuttle): Consider removing this once we have a good handle on header
     74 // size changes.
     75 void RecordHeaderSizeChange(int old_size, int new_size) {
     76   HeaderSizeChange size_change;
     77 
     78   UMA_HISTOGRAM_COUNTS_10000("SimpleCache.HeaderSize", new_size);
     79 
     80   if (old_size == 0) {
     81     size_change = HEADER_SIZE_CHANGE_INITIAL;
     82   } else if (new_size == old_size) {
     83     size_change = HEADER_SIZE_CHANGE_SAME;
     84   } else if (new_size > old_size) {
     85     int delta = new_size - old_size;
     86     UMA_HISTOGRAM_COUNTS_10000("SimpleCache.HeaderSizeIncreaseAbsolute",
     87                                delta);
     88     UMA_HISTOGRAM_PERCENTAGE("SimpleCache.HeaderSizeIncreasePercentage",
     89                              delta * 100 / old_size);
     90     size_change = HEADER_SIZE_CHANGE_INCREASE;
     91   } else {  // new_size < old_size
     92     int delta = old_size - new_size;
     93     UMA_HISTOGRAM_COUNTS_10000("SimpleCache.HeaderSizeDecreaseAbsolute",
     94                                delta);
     95     UMA_HISTOGRAM_PERCENTAGE("SimpleCache.HeaderSizeDecreasePercentage",
     96                              delta * 100 / old_size);
     97     size_change = HEADER_SIZE_CHANGE_DECREASE;
     98   }
     99 
    100   UMA_HISTOGRAM_ENUMERATION("SimpleCache.HeaderSizeChange",
    101                             size_change,
    102                             HEADER_SIZE_CHANGE_MAX);
    103 }
    104 
    105 void RecordUnexpectedStream0Write() {
    106   UMA_HISTOGRAM_ENUMERATION("SimpleCache.HeaderSizeChange",
    107                             HEADER_SIZE_CHANGE_UNEXPECTED_WRITE,
    108                             HEADER_SIZE_CHANGE_MAX);
    109 }
    110 
    111 // Short trampoline to take an owned input parameter and call a net completion
    112 // callback with its value.
    113 void CallCompletionCallback(const net::CompletionCallback& callback,
    114                             scoped_ptr<int> result) {
    115   DCHECK(result);
    116   if (!callback.is_null())
    117     callback.Run(*result);
    118 }
    119 
    120 int g_open_entry_count = 0;
    121 
    122 void AdjustOpenEntryCountBy(int offset) {
    123   g_open_entry_count += offset;
    124   UMA_HISTOGRAM_COUNTS_10000("SimpleCache.GlobalOpenEntryCount",
    125                              g_open_entry_count);
    126 }
    127 
    128 }  // namespace
    129 
    130 namespace disk_cache {
    131 
    132 using base::Closure;
    133 using base::FilePath;
    134 using base::MessageLoopProxy;
    135 using base::Time;
    136 using base::TaskRunner;
    137 
    138 // A helper class to insure that RunNextOperationIfNeeded() is called when
    139 // exiting the current stack frame.
    140 class SimpleEntryImpl::ScopedOperationRunner {
    141  public:
    142   explicit ScopedOperationRunner(SimpleEntryImpl* entry) : entry_(entry) {
    143   }
    144 
    145   ~ScopedOperationRunner() {
    146     entry_->RunNextOperationIfNeeded();
    147   }
    148 
    149  private:
    150   SimpleEntryImpl* const entry_;
    151 };
    152 
    153 SimpleEntryImpl::SimpleEntryImpl(const FilePath& path,
    154                                  const uint64 entry_hash,
    155                                  OperationsMode operations_mode,
    156                                  SimpleBackendImpl* backend,
    157                                  net::NetLog* net_log)
    158     : backend_(backend->AsWeakPtr()),
    159       worker_pool_(backend->worker_pool()),
    160       path_(path),
    161       entry_hash_(entry_hash),
    162       use_optimistic_operations_(operations_mode == OPTIMISTIC_OPERATIONS),
    163       last_used_(Time::Now()),
    164       last_modified_(last_used_),
    165       open_count_(0),
    166       state_(STATE_UNINITIALIZED),
    167       synchronous_entry_(NULL),
    168       net_log_(net::BoundNetLog::Make(
    169           net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY)) {
    170   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc32s_end_offset_),
    171                  arrays_should_be_same_size);
    172   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc32s_),
    173                  arrays_should_be_same_size);
    174   COMPILE_ASSERT(arraysize(data_size_) == arraysize(have_written_),
    175                  arrays_should_be_same_size);
    176   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc_check_state_),
    177                  arrays_should_be_same_size);
    178   MakeUninitialized();
    179   net_log_.BeginEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY,
    180       CreateNetLogSimpleEntryConstructionCallback(this));
    181 }
    182 
    183 int SimpleEntryImpl::OpenEntry(Entry** out_entry,
    184                                const CompletionCallback& callback) {
    185   DCHECK(backend_.get());
    186 
    187   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_CALL);
    188 
    189   bool have_index = backend_->index()->initialized();
    190   // This enumeration is used in histograms, add entries only at end.
    191   enum OpenEntryIndexEnum {
    192     INDEX_NOEXIST = 0,
    193     INDEX_MISS = 1,
    194     INDEX_HIT = 2,
    195     INDEX_MAX = 3,
    196   };
    197   OpenEntryIndexEnum open_entry_index_enum = INDEX_NOEXIST;
    198   if (have_index) {
    199     if (backend_->index()->Has(entry_hash_))
    200       open_entry_index_enum = INDEX_HIT;
    201     else
    202       open_entry_index_enum = INDEX_MISS;
    203   }
    204   UMA_HISTOGRAM_ENUMERATION("SimpleCache.OpenEntryIndexState",
    205                             open_entry_index_enum, INDEX_MAX);
    206 
    207   // If entry is not known to the index, initiate fast failover to the network.
    208   if (open_entry_index_enum == INDEX_MISS) {
    209     net_log_.AddEventWithNetErrorCode(
    210         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END,
    211         net::ERR_FAILED);
    212     return net::ERR_FAILED;
    213   }
    214 
    215   pending_operations_.push(SimpleEntryOperation::OpenOperation(
    216       this, have_index, callback, out_entry));
    217   RunNextOperationIfNeeded();
    218   return net::ERR_IO_PENDING;
    219 }
    220 
    221 int SimpleEntryImpl::CreateEntry(Entry** out_entry,
    222                                  const CompletionCallback& callback) {
    223   DCHECK(backend_.get());
    224   DCHECK_EQ(entry_hash_, simple_util::GetEntryHashKey(key_));
    225 
    226   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_CALL);
    227 
    228   bool have_index = backend_->index()->initialized();
    229   int ret_value = net::ERR_FAILED;
    230   if (use_optimistic_operations_ &&
    231       state_ == STATE_UNINITIALIZED && pending_operations_.size() == 0) {
    232     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_OPTIMISTIC);
    233 
    234     ReturnEntryToCaller(out_entry);
    235     pending_operations_.push(SimpleEntryOperation::CreateOperation(
    236         this, have_index, CompletionCallback(), static_cast<Entry**>(NULL)));
    237     ret_value = net::OK;
    238   } else {
    239     pending_operations_.push(SimpleEntryOperation::CreateOperation(
    240         this, have_index, callback, out_entry));
    241     ret_value = net::ERR_IO_PENDING;
    242   }
    243 
    244   // We insert the entry in the index before creating the entry files in the
    245   // SimpleSynchronousEntry, because this way the worst scenario is when we
    246   // have the entry in the index but we don't have the created files yet, this
    247   // way we never leak files. CreationOperationComplete will remove the entry
    248   // from the index if the creation fails.
    249   backend_->index()->Insert(key_);
    250 
    251   RunNextOperationIfNeeded();
    252   return ret_value;
    253 }
    254 
    255 int SimpleEntryImpl::DoomEntry(const CompletionCallback& callback) {
    256   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_DOOM_CALL);
    257   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_DOOM_BEGIN);
    258 
    259   MarkAsDoomed();
    260   scoped_ptr<int> result(new int());
    261   Closure task = base::Bind(&SimpleSynchronousEntry::DoomEntry, path_, key_,
    262                             entry_hash_, result.get());
    263   Closure reply = base::Bind(&CallCompletionCallback,
    264                              callback, base::Passed(&result));
    265   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
    266   return net::ERR_IO_PENDING;
    267 }
    268 
    269 void SimpleEntryImpl::SetKey(const std::string& key) {
    270   key_ = key;
    271   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_SET_KEY,
    272       net::NetLog::StringCallback("key", &key));
    273 }
    274 
    275 void SimpleEntryImpl::Doom() {
    276   DoomEntry(CompletionCallback());
    277 }
    278 
    279 void SimpleEntryImpl::Close() {
    280   DCHECK(io_thread_checker_.CalledOnValidThread());
    281   DCHECK_LT(0, open_count_);
    282 
    283   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CLOSE_CALL);
    284 
    285   if (--open_count_ > 0) {
    286     DCHECK(!HasOneRef());
    287     Release();  // Balanced in ReturnEntryToCaller().
    288     return;
    289   }
    290 
    291   pending_operations_.push(SimpleEntryOperation::CloseOperation(this));
    292   DCHECK(!HasOneRef());
    293   Release();  // Balanced in ReturnEntryToCaller().
    294   RunNextOperationIfNeeded();
    295 }
    296 
    297 std::string SimpleEntryImpl::GetKey() const {
    298   DCHECK(io_thread_checker_.CalledOnValidThread());
    299   return key_;
    300 }
    301 
    302 Time SimpleEntryImpl::GetLastUsed() const {
    303   DCHECK(io_thread_checker_.CalledOnValidThread());
    304   return last_used_;
    305 }
    306 
    307 Time SimpleEntryImpl::GetLastModified() const {
    308   DCHECK(io_thread_checker_.CalledOnValidThread());
    309   return last_modified_;
    310 }
    311 
    312 int32 SimpleEntryImpl::GetDataSize(int stream_index) const {
    313   DCHECK(io_thread_checker_.CalledOnValidThread());
    314   DCHECK_LE(0, data_size_[stream_index]);
    315   return data_size_[stream_index];
    316 }
    317 
    318 int SimpleEntryImpl::ReadData(int stream_index,
    319                               int offset,
    320                               net::IOBuffer* buf,
    321                               int buf_len,
    322                               const CompletionCallback& callback) {
    323   DCHECK(io_thread_checker_.CalledOnValidThread());
    324 
    325   if (net_log_.IsLoggingAllEvents()) {
    326     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_CALL,
    327         CreateNetLogReadWriteDataCallback(stream_index, offset, buf_len,
    328                                           false));
    329   }
    330 
    331   if (stream_index < 0 || stream_index >= kSimpleEntryFileCount ||
    332       buf_len < 0) {
    333     if (net_log_.IsLoggingAllEvents()) {
    334       net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
    335           CreateNetLogReadWriteCompleteCallback(net::ERR_INVALID_ARGUMENT));
    336     }
    337 
    338     RecordReadResult(READ_RESULT_INVALID_ARGUMENT);
    339     return net::ERR_INVALID_ARGUMENT;
    340   }
    341   if (pending_operations_.empty() && (offset >= GetDataSize(stream_index) ||
    342                                       offset < 0 || !buf_len)) {
    343     if (net_log_.IsLoggingAllEvents()) {
    344       net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
    345           CreateNetLogReadWriteCompleteCallback(0));
    346     }
    347 
    348     RecordReadResult(READ_RESULT_NONBLOCK_EMPTY_RETURN);
    349     return 0;
    350   }
    351 
    352   // TODO(felipeg): Optimization: Add support for truly parallel read
    353   // operations.
    354   bool alone_in_queue =
    355       pending_operations_.size() == 0 && state_ == STATE_READY;
    356   pending_operations_.push(SimpleEntryOperation::ReadOperation(
    357       this, stream_index, offset, buf_len, buf, callback, alone_in_queue));
    358   RunNextOperationIfNeeded();
    359   return net::ERR_IO_PENDING;
    360 }
    361 
    362 int SimpleEntryImpl::WriteData(int stream_index,
    363                                int offset,
    364                                net::IOBuffer* buf,
    365                                int buf_len,
    366                                const CompletionCallback& callback,
    367                                bool truncate) {
    368   DCHECK(io_thread_checker_.CalledOnValidThread());
    369 
    370   if (net_log_.IsLoggingAllEvents()) {
    371     net_log_.AddEvent(
    372         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_CALL,
    373         CreateNetLogReadWriteDataCallback(stream_index, offset, buf_len,
    374                                           truncate));
    375   }
    376 
    377   if (stream_index < 0 || stream_index >= kSimpleEntryFileCount || offset < 0 ||
    378       buf_len < 0) {
    379     if (net_log_.IsLoggingAllEvents()) {
    380       net_log_.AddEvent(
    381           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
    382           CreateNetLogReadWriteCompleteCallback(net::ERR_INVALID_ARGUMENT));
    383     }
    384     RecordWriteResult(WRITE_RESULT_INVALID_ARGUMENT);
    385     return net::ERR_INVALID_ARGUMENT;
    386   }
    387   if (backend_.get() && offset + buf_len > backend_->GetMaxFileSize()) {
    388     if (net_log_.IsLoggingAllEvents()) {
    389       net_log_.AddEvent(
    390           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
    391           CreateNetLogReadWriteCompleteCallback(net::ERR_FAILED));
    392     }
    393     RecordWriteResult(WRITE_RESULT_OVER_MAX_SIZE);
    394     return net::ERR_FAILED;
    395   }
    396   ScopedOperationRunner operation_runner(this);
    397 
    398   // Currently, Simple Cache is only used for HTTP, which stores the headers in
    399   // stream 0 and always writes them with a single, truncating write.  Detect
    400   // these writes and record the size and size changes of the headers.  Also,
    401   // note writes to stream 0 that violate those assumptions.
    402   if (stream_index == 0) {
    403     if (offset == 0 && truncate)
    404       RecordHeaderSizeChange(data_size_[0], buf_len);
    405     else
    406       RecordUnexpectedStream0Write();
    407   }
    408 
    409   // We can only do optimistic Write if there is no pending operations, so
    410   // that we are sure that the next call to RunNextOperationIfNeeded will
    411   // actually run the write operation that sets the stream size. It also
    412   // prevents from previous possibly-conflicting writes that could be stacked
    413   // in the |pending_operations_|. We could optimize this for when we have
    414   // only read operations enqueued.
    415   const bool optimistic =
    416       (use_optimistic_operations_ && state_ == STATE_READY &&
    417        pending_operations_.size() == 0);
    418   CompletionCallback op_callback;
    419   scoped_refptr<net::IOBuffer> op_buf;
    420   int ret_value = net::ERR_FAILED;
    421   if (!optimistic) {
    422     op_buf = buf;
    423     op_callback = callback;
    424     ret_value = net::ERR_IO_PENDING;
    425   } else {
    426     // TODO(gavinp,pasko): For performance, don't use a copy of an IOBuffer
    427     // here to avoid paying the price of the RefCountedThreadSafe atomic
    428     // operations.
    429     if (buf) {
    430       op_buf = new IOBuffer(buf_len);
    431       memcpy(op_buf->data(), buf->data(), buf_len);
    432     }
    433     op_callback = CompletionCallback();
    434     ret_value = buf_len;
    435     if (net_log_.IsLoggingAllEvents()) {
    436       net_log_.AddEvent(
    437           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_OPTIMISTIC,
    438           CreateNetLogReadWriteCompleteCallback(buf_len));
    439     }
    440   }
    441 
    442   pending_operations_.push(SimpleEntryOperation::WriteOperation(this,
    443                                                                 stream_index,
    444                                                                 offset,
    445                                                                 buf_len,
    446                                                                 op_buf.get(),
    447                                                                 truncate,
    448                                                                 optimistic,
    449                                                                 op_callback));
    450   return ret_value;
    451 }
    452 
    453 int SimpleEntryImpl::ReadSparseData(int64 offset,
    454                                     net::IOBuffer* buf,
    455                                     int buf_len,
    456                                     const CompletionCallback& callback) {
    457   DCHECK(io_thread_checker_.CalledOnValidThread());
    458   // TODO(gavinp): Determine if the simple backend should support sparse data.
    459   NOTIMPLEMENTED();
    460   return net::ERR_FAILED;
    461 }
    462 
    463 int SimpleEntryImpl::WriteSparseData(int64 offset,
    464                                      net::IOBuffer* buf,
    465                                      int buf_len,
    466                                      const CompletionCallback& callback) {
    467   DCHECK(io_thread_checker_.CalledOnValidThread());
    468   // TODO(gavinp): Determine if the simple backend should support sparse data.
    469   NOTIMPLEMENTED();
    470   return net::ERR_FAILED;
    471 }
    472 
    473 int SimpleEntryImpl::GetAvailableRange(int64 offset,
    474                                        int len,
    475                                        int64* start,
    476                                        const CompletionCallback& callback) {
    477   DCHECK(io_thread_checker_.CalledOnValidThread());
    478   // TODO(gavinp): Determine if the simple backend should support sparse data.
    479   NOTIMPLEMENTED();
    480   return net::ERR_FAILED;
    481 }
    482 
    483 bool SimpleEntryImpl::CouldBeSparse() const {
    484   DCHECK(io_thread_checker_.CalledOnValidThread());
    485   // TODO(gavinp): Determine if the simple backend should support sparse data.
    486   return false;
    487 }
    488 
    489 void SimpleEntryImpl::CancelSparseIO() {
    490   DCHECK(io_thread_checker_.CalledOnValidThread());
    491   // TODO(gavinp): Determine if the simple backend should support sparse data.
    492   NOTIMPLEMENTED();
    493 }
    494 
    495 int SimpleEntryImpl::ReadyForSparseIO(const CompletionCallback& callback) {
    496   DCHECK(io_thread_checker_.CalledOnValidThread());
    497   // TODO(gavinp): Determine if the simple backend should support sparse data.
    498   NOTIMPLEMENTED();
    499   return net::ERR_NOT_IMPLEMENTED;
    500 }
    501 
    502 SimpleEntryImpl::~SimpleEntryImpl() {
    503   DCHECK(io_thread_checker_.CalledOnValidThread());
    504   DCHECK_EQ(0U, pending_operations_.size());
    505   DCHECK(state_ == STATE_UNINITIALIZED || state_ == STATE_FAILURE);
    506   DCHECK(!synchronous_entry_);
    507   RemoveSelfFromBackend();
    508   net_log_.EndEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY);
    509 }
    510 
    511 void SimpleEntryImpl::MakeUninitialized() {
    512   state_ = STATE_UNINITIALIZED;
    513   std::memset(crc32s_end_offset_, 0, sizeof(crc32s_end_offset_));
    514   std::memset(crc32s_, 0, sizeof(crc32s_));
    515   std::memset(have_written_, 0, sizeof(have_written_));
    516   std::memset(data_size_, 0, sizeof(data_size_));
    517   for (size_t i = 0; i < arraysize(crc_check_state_); ++i) {
    518     crc_check_state_[i] = CRC_CHECK_NEVER_READ_AT_ALL;
    519   }
    520 }
    521 
    522 void SimpleEntryImpl::ReturnEntryToCaller(Entry** out_entry) {
    523   DCHECK(out_entry);
    524   ++open_count_;
    525   AddRef();  // Balanced in Close()
    526   *out_entry = this;
    527 }
    528 
    529 void SimpleEntryImpl::RemoveSelfFromBackend() {
    530   if (!backend_.get())
    531     return;
    532   backend_->OnDeactivated(this);
    533   backend_.reset();
    534 }
    535 
    536 void SimpleEntryImpl::MarkAsDoomed() {
    537   if (!backend_.get())
    538     return;
    539   backend_->index()->Remove(key_);
    540   RemoveSelfFromBackend();
    541 }
    542 
    543 void SimpleEntryImpl::RunNextOperationIfNeeded() {
    544   DCHECK(io_thread_checker_.CalledOnValidThread());
    545   UMA_HISTOGRAM_CUSTOM_COUNTS("SimpleCache.EntryOperationsPending",
    546                               pending_operations_.size(), 0, 100, 20);
    547   if (!pending_operations_.empty() && state_ != STATE_IO_PENDING) {
    548     scoped_ptr<SimpleEntryOperation> operation(
    549         new SimpleEntryOperation(pending_operations_.front()));
    550     pending_operations_.pop();
    551     switch (operation->type()) {
    552       case SimpleEntryOperation::TYPE_OPEN:
    553         OpenEntryInternal(operation->have_index(),
    554                           operation->callback(),
    555                           operation->out_entry());
    556         break;
    557       case SimpleEntryOperation::TYPE_CREATE:
    558         CreateEntryInternal(operation->have_index(),
    559                             operation->callback(),
    560                             operation->out_entry());
    561         break;
    562       case SimpleEntryOperation::TYPE_CLOSE:
    563         CloseInternal();
    564         break;
    565       case SimpleEntryOperation::TYPE_READ:
    566         RecordReadIsParallelizable(*operation);
    567         ReadDataInternal(operation->index(),
    568                          operation->offset(),
    569                          operation->buf(),
    570                          operation->length(),
    571                          operation->callback());
    572         break;
    573       case SimpleEntryOperation::TYPE_WRITE:
    574         RecordWriteDependencyType(*operation);
    575         WriteDataInternal(operation->index(),
    576                           operation->offset(),
    577                           operation->buf(),
    578                           operation->length(),
    579                           operation->callback(),
    580                           operation->truncate());
    581         break;
    582       default:
    583         NOTREACHED();
    584     }
    585     // The operation is kept for histograms. Makes sure it does not leak
    586     // resources.
    587     executing_operation_.swap(operation);
    588     executing_operation_->ReleaseReferences();
    589     // |this| may have been deleted.
    590   }
    591 }
    592 
    593 void SimpleEntryImpl::OpenEntryInternal(bool have_index,
    594                                         const CompletionCallback& callback,
    595                                         Entry** out_entry) {
    596   ScopedOperationRunner operation_runner(this);
    597 
    598   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_BEGIN);
    599 
    600   if (state_ == STATE_READY) {
    601     ReturnEntryToCaller(out_entry);
    602     MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(callback,
    603                                                                 net::OK));
    604     net_log_.AddEvent(
    605         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END,
    606         CreateNetLogSimpleEntryCreationCallback(this, net::OK));
    607     return;
    608   } else if (state_ == STATE_FAILURE) {
    609     if (!callback.is_null()) {
    610       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
    611           callback, net::ERR_FAILED));
    612     }
    613     net_log_.AddEvent(
    614         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END,
    615         CreateNetLogSimpleEntryCreationCallback(this, net::ERR_FAILED));
    616     return;
    617   }
    618 
    619   DCHECK_EQ(STATE_UNINITIALIZED, state_);
    620   DCHECK(!synchronous_entry_);
    621   state_ = STATE_IO_PENDING;
    622   const base::TimeTicks start_time = base::TimeTicks::Now();
    623   scoped_ptr<SimpleEntryCreationResults> results(
    624       new SimpleEntryCreationResults(
    625           SimpleEntryStat(last_used_, last_modified_, data_size_)));
    626   Closure task = base::Bind(&SimpleSynchronousEntry::OpenEntry,
    627                             path_,
    628                             entry_hash_,
    629                             have_index,
    630                             results.get());
    631   Closure reply = base::Bind(&SimpleEntryImpl::CreationOperationComplete,
    632                              this,
    633                              callback,
    634                              start_time,
    635                              base::Passed(&results),
    636                              out_entry,
    637                              net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END);
    638   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
    639 }
    640 
    641 void SimpleEntryImpl::CreateEntryInternal(bool have_index,
    642                                           const CompletionCallback& callback,
    643                                           Entry** out_entry) {
    644   ScopedOperationRunner operation_runner(this);
    645 
    646   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_BEGIN);
    647 
    648   if (state_ != STATE_UNINITIALIZED) {
    649     // There is already an active normal entry.
    650     net_log_.AddEvent(
    651         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_END,
    652         CreateNetLogSimpleEntryCreationCallback(this, net::ERR_FAILED));
    653 
    654     if (!callback.is_null()) {
    655       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
    656           callback, net::ERR_FAILED));
    657     }
    658     return;
    659   }
    660   DCHECK_EQ(STATE_UNINITIALIZED, state_);
    661   DCHECK(!synchronous_entry_);
    662 
    663   state_ = STATE_IO_PENDING;
    664 
    665   // Since we don't know the correct values for |last_used_| and
    666   // |last_modified_| yet, we make this approximation.
    667   last_used_ = last_modified_ = base::Time::Now();
    668 
    669   // If creation succeeds, we should mark all streams to be saved on close.
    670   for (int i = 0; i < kSimpleEntryFileCount; ++i)
    671     have_written_[i] = true;
    672 
    673   const base::TimeTicks start_time = base::TimeTicks::Now();
    674   scoped_ptr<SimpleEntryCreationResults> results(
    675       new SimpleEntryCreationResults(
    676           SimpleEntryStat(last_used_, last_modified_, data_size_)));
    677   Closure task = base::Bind(&SimpleSynchronousEntry::CreateEntry,
    678                             path_,
    679                             key_,
    680                             entry_hash_,
    681                             have_index,
    682                             results.get());
    683   Closure reply = base::Bind(&SimpleEntryImpl::CreationOperationComplete,
    684                              this,
    685                              callback,
    686                              start_time,
    687                              base::Passed(&results),
    688                              out_entry,
    689                              net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_END);
    690   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
    691 }
    692 
    693 void SimpleEntryImpl::CloseInternal() {
    694   DCHECK(io_thread_checker_.CalledOnValidThread());
    695   typedef SimpleSynchronousEntry::CRCRecord CRCRecord;
    696   scoped_ptr<std::vector<CRCRecord> >
    697       crc32s_to_write(new std::vector<CRCRecord>());
    698 
    699   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CLOSE_BEGIN);
    700 
    701   if (state_ == STATE_READY) {
    702     DCHECK(synchronous_entry_);
    703     state_ = STATE_IO_PENDING;
    704     for (int i = 0; i < kSimpleEntryFileCount; ++i) {
    705       if (have_written_[i]) {
    706         if (GetDataSize(i) == crc32s_end_offset_[i]) {
    707           int32 crc = GetDataSize(i) == 0 ? crc32(0, Z_NULL, 0) : crc32s_[i];
    708           crc32s_to_write->push_back(CRCRecord(i, true, crc));
    709         } else {
    710           crc32s_to_write->push_back(CRCRecord(i, false, 0));
    711         }
    712       }
    713     }
    714   } else {
    715     DCHECK(STATE_UNINITIALIZED == state_ || STATE_FAILURE == state_);
    716   }
    717 
    718   if (synchronous_entry_) {
    719     Closure task =
    720         base::Bind(&SimpleSynchronousEntry::Close,
    721                    base::Unretained(synchronous_entry_),
    722                    SimpleEntryStat(last_used_, last_modified_, data_size_),
    723                    base::Passed(&crc32s_to_write));
    724     Closure reply = base::Bind(&SimpleEntryImpl::CloseOperationComplete, this);
    725     synchronous_entry_ = NULL;
    726     worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
    727 
    728     for (int i = 0; i < kSimpleEntryFileCount; ++i) {
    729       if (!have_written_[i]) {
    730         UMA_HISTOGRAM_ENUMERATION("SimpleCache.CheckCRCResult",
    731                                   crc_check_state_[i], CRC_CHECK_MAX);
    732       }
    733     }
    734   } else {
    735     synchronous_entry_ = NULL;
    736     CloseOperationComplete();
    737   }
    738 }
    739 
    740 void SimpleEntryImpl::ReadDataInternal(int stream_index,
    741                                        int offset,
    742                                        net::IOBuffer* buf,
    743                                        int buf_len,
    744                                        const CompletionCallback& callback) {
    745   DCHECK(io_thread_checker_.CalledOnValidThread());
    746   ScopedOperationRunner operation_runner(this);
    747 
    748   if (net_log_.IsLoggingAllEvents()) {
    749     net_log_.AddEvent(
    750         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_BEGIN,
    751         CreateNetLogReadWriteDataCallback(stream_index, offset, buf_len,
    752                                           false));
    753   }
    754 
    755   if (state_ == STATE_FAILURE || state_ == STATE_UNINITIALIZED) {
    756     if (!callback.is_null()) {
    757       RecordReadResult(READ_RESULT_BAD_STATE);
    758       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
    759           callback, net::ERR_FAILED));
    760     }
    761     if (net_log_.IsLoggingAllEvents()) {
    762       net_log_.AddEvent(
    763           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
    764           CreateNetLogReadWriteCompleteCallback(net::ERR_FAILED));
    765     }
    766     return;
    767   }
    768   DCHECK_EQ(STATE_READY, state_);
    769   if (offset >= GetDataSize(stream_index) || offset < 0 || !buf_len) {
    770     RecordReadResult(READ_RESULT_FAST_EMPTY_RETURN);
    771     // If there is nothing to read, we bail out before setting state_ to
    772     // STATE_IO_PENDING.
    773     if (!callback.is_null())
    774       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
    775           callback, 0));
    776     return;
    777   }
    778 
    779   buf_len = std::min(buf_len, GetDataSize(stream_index) - offset);
    780 
    781   state_ = STATE_IO_PENDING;
    782   if (backend_.get())
    783     backend_->index()->UseIfExists(key_);
    784 
    785   scoped_ptr<uint32> read_crc32(new uint32());
    786   scoped_ptr<int> result(new int());
    787   scoped_ptr<base::Time> last_used(new base::Time());
    788   Closure task = base::Bind(
    789       &SimpleSynchronousEntry::ReadData,
    790       base::Unretained(synchronous_entry_),
    791       SimpleSynchronousEntry::EntryOperationData(stream_index, offset, buf_len),
    792       make_scoped_refptr(buf),
    793       read_crc32.get(),
    794       last_used.get(),
    795       result.get());
    796   Closure reply = base::Bind(&SimpleEntryImpl::ReadOperationComplete,
    797                              this,
    798                              stream_index,
    799                              offset,
    800                              callback,
    801                              base::Passed(&read_crc32),
    802                              base::Passed(&last_used),
    803                              base::Passed(&result));
    804   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
    805 }
    806 
    807 void SimpleEntryImpl::WriteDataInternal(int stream_index,
    808                                        int offset,
    809                                        net::IOBuffer* buf,
    810                                        int buf_len,
    811                                        const CompletionCallback& callback,
    812                                        bool truncate) {
    813   DCHECK(io_thread_checker_.CalledOnValidThread());
    814   ScopedOperationRunner operation_runner(this);
    815 
    816   if (net_log_.IsLoggingAllEvents()) {
    817     net_log_.AddEvent(
    818         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_BEGIN,
    819         CreateNetLogReadWriteDataCallback(stream_index, offset, buf_len,
    820                                           truncate));
    821   }
    822 
    823   if (state_ == STATE_FAILURE || state_ == STATE_UNINITIALIZED) {
    824     RecordWriteResult(WRITE_RESULT_BAD_STATE);
    825     if (net_log_.IsLoggingAllEvents()) {
    826       net_log_.AddEvent(
    827           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
    828           CreateNetLogReadWriteCompleteCallback(net::ERR_FAILED));
    829     }
    830     if (!callback.is_null()) {
    831       // We need to posttask so that we don't go in a loop when we call the
    832       // callback directly.
    833       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
    834           callback, net::ERR_FAILED));
    835     }
    836     // |this| may be destroyed after return here.
    837     return;
    838   }
    839 
    840   DCHECK_EQ(STATE_READY, state_);
    841   state_ = STATE_IO_PENDING;
    842   if (backend_.get())
    843     backend_->index()->UseIfExists(key_);
    844   // It is easy to incrementally compute the CRC from [0 .. |offset + buf_len|)
    845   // if |offset == 0| or we have already computed the CRC for [0 .. offset).
    846   // We rely on most write operations being sequential, start to end to compute
    847   // the crc of the data. When we write to an entry and close without having
    848   // done a sequential write, we don't check the CRC on read.
    849   if (offset == 0 || crc32s_end_offset_[stream_index] == offset) {
    850     uint32 initial_crc = (offset != 0) ? crc32s_[stream_index]
    851                                        : crc32(0, Z_NULL, 0);
    852     if (buf_len > 0) {
    853       crc32s_[stream_index] = crc32(initial_crc,
    854                                     reinterpret_cast<const Bytef*>(buf->data()),
    855                                     buf_len);
    856     }
    857     crc32s_end_offset_[stream_index] = offset + buf_len;
    858   }
    859 
    860   // |entry_stat| needs to be initialized before modifying |data_size_|.
    861   scoped_ptr<SimpleEntryStat> entry_stat(
    862       new SimpleEntryStat(last_used_, last_modified_, data_size_));
    863   if (truncate) {
    864     data_size_[stream_index] = offset + buf_len;
    865   } else {
    866     data_size_[stream_index] = std::max(offset + buf_len,
    867                                         GetDataSize(stream_index));
    868   }
    869 
    870   // Since we don't know the correct values for |last_used_| and
    871   // |last_modified_| yet, we make this approximation.
    872   last_used_ = last_modified_ = base::Time::Now();
    873 
    874   have_written_[stream_index] = true;
    875 
    876   scoped_ptr<int> result(new int());
    877   Closure task = base::Bind(&SimpleSynchronousEntry::WriteData,
    878                             base::Unretained(synchronous_entry_),
    879                             SimpleSynchronousEntry::EntryOperationData(
    880                                 stream_index, offset, buf_len, truncate),
    881                             make_scoped_refptr(buf),
    882                             entry_stat.get(),
    883                             result.get());
    884   Closure reply = base::Bind(&SimpleEntryImpl::WriteOperationComplete,
    885                              this,
    886                              stream_index,
    887                              callback,
    888                              base::Passed(&entry_stat),
    889                              base::Passed(&result));
    890   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
    891 }
    892 
    893 void SimpleEntryImpl::CreationOperationComplete(
    894     const CompletionCallback& completion_callback,
    895     const base::TimeTicks& start_time,
    896     scoped_ptr<SimpleEntryCreationResults> in_results,
    897     Entry** out_entry,
    898     net::NetLog::EventType end_event_type) {
    899   DCHECK(io_thread_checker_.CalledOnValidThread());
    900   DCHECK_EQ(state_, STATE_IO_PENDING);
    901   DCHECK(in_results);
    902   ScopedOperationRunner operation_runner(this);
    903   UMA_HISTOGRAM_BOOLEAN(
    904       "SimpleCache.EntryCreationResult", in_results->result == net::OK);
    905   if (in_results->result != net::OK) {
    906     if (in_results->result != net::ERR_FILE_EXISTS)
    907       MarkAsDoomed();
    908 
    909     net_log_.AddEventWithNetErrorCode(end_event_type, net::ERR_FAILED);
    910 
    911     if (!completion_callback.is_null()) {
    912       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
    913           completion_callback, net::ERR_FAILED));
    914     }
    915     MakeUninitialized();
    916     return;
    917   }
    918   // If out_entry is NULL, it means we already called ReturnEntryToCaller from
    919   // the optimistic Create case.
    920   if (out_entry)
    921     ReturnEntryToCaller(out_entry);
    922 
    923   state_ = STATE_READY;
    924   synchronous_entry_ = in_results->sync_entry;
    925   if (key_.empty()) {
    926     SetKey(synchronous_entry_->key());
    927   } else {
    928     // This should only be triggered when creating an entry. The key check in
    929     // the open case is handled in SimpleBackendImpl.
    930     DCHECK_EQ(key_, synchronous_entry_->key());
    931   }
    932   UpdateDataFromEntryStat(in_results->entry_stat);
    933   UMA_HISTOGRAM_TIMES("SimpleCache.EntryCreationTime",
    934                       (base::TimeTicks::Now() - start_time));
    935   AdjustOpenEntryCountBy(1);
    936 
    937   net_log_.AddEvent(end_event_type);
    938   if (!completion_callback.is_null()) {
    939     MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
    940         completion_callback, net::OK));
    941   }
    942 }
    943 
    944 void SimpleEntryImpl::EntryOperationComplete(
    945     int stream_index,
    946     const CompletionCallback& completion_callback,
    947     const SimpleEntryStat& entry_stat,
    948     scoped_ptr<int> result) {
    949   DCHECK(io_thread_checker_.CalledOnValidThread());
    950   DCHECK(synchronous_entry_);
    951   DCHECK_EQ(STATE_IO_PENDING, state_);
    952   DCHECK(result);
    953   state_ = STATE_READY;
    954   if (*result < 0) {
    955     MarkAsDoomed();
    956     state_ = STATE_FAILURE;
    957     crc32s_end_offset_[stream_index] = 0;
    958   } else {
    959     UpdateDataFromEntryStat(entry_stat);
    960   }
    961 
    962   if (!completion_callback.is_null()) {
    963     MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
    964         completion_callback, *result));
    965   }
    966   RunNextOperationIfNeeded();
    967 }
    968 
    969 void SimpleEntryImpl::ReadOperationComplete(
    970     int stream_index,
    971     int offset,
    972     const CompletionCallback& completion_callback,
    973     scoped_ptr<uint32> read_crc32,
    974     scoped_ptr<base::Time> last_used,
    975     scoped_ptr<int> result) {
    976   DCHECK(io_thread_checker_.CalledOnValidThread());
    977   DCHECK(synchronous_entry_);
    978   DCHECK_EQ(STATE_IO_PENDING, state_);
    979   DCHECK(read_crc32);
    980   DCHECK(result);
    981 
    982   if (*result > 0 &&
    983       crc_check_state_[stream_index] == CRC_CHECK_NEVER_READ_AT_ALL) {
    984     crc_check_state_[stream_index] = CRC_CHECK_NEVER_READ_TO_END;
    985   }
    986 
    987   if (*result > 0 && crc32s_end_offset_[stream_index] == offset) {
    988     uint32 current_crc = offset == 0 ? crc32(0, Z_NULL, 0)
    989                                      : crc32s_[stream_index];
    990     crc32s_[stream_index] = crc32_combine(current_crc, *read_crc32, *result);
    991     crc32s_end_offset_[stream_index] += *result;
    992     if (!have_written_[stream_index] &&
    993         GetDataSize(stream_index) == crc32s_end_offset_[stream_index]) {
    994       // We have just read a file from start to finish, and so we have
    995       // computed a crc of the entire file. We can check it now. If a cache
    996       // entry has a single reader, the normal pattern is to read from start
    997       // to finish.
    998 
    999       // Other cases are possible. In the case of two readers on the same
   1000       // entry, one reader can be behind the other. In this case we compute
   1001       // the crc as the most advanced reader progresses, and check it for
   1002       // both readers as they read the last byte.
   1003 
   1004       net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CHECKSUM_BEGIN);
   1005 
   1006       scoped_ptr<int> new_result(new int());
   1007       Closure task = base::Bind(&SimpleSynchronousEntry::CheckEOFRecord,
   1008                                 base::Unretained(synchronous_entry_),
   1009                                 stream_index,
   1010                                 data_size_[stream_index],
   1011                                 crc32s_[stream_index],
   1012                                 new_result.get());
   1013       Closure reply = base::Bind(&SimpleEntryImpl::ChecksumOperationComplete,
   1014                                  this, *result, stream_index,
   1015                                  completion_callback,
   1016                                  base::Passed(&new_result));
   1017       worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
   1018       crc_check_state_[stream_index] = CRC_CHECK_DONE;
   1019       return;
   1020     }
   1021   }
   1022 
   1023   if (*result < 0) {
   1024     RecordReadResult(READ_RESULT_SYNC_READ_FAILURE);
   1025   } else {
   1026     RecordReadResult(READ_RESULT_SUCCESS);
   1027     if (crc_check_state_[stream_index] == CRC_CHECK_NEVER_READ_TO_END &&
   1028         offset + *result == GetDataSize(stream_index)) {
   1029       crc_check_state_[stream_index] = CRC_CHECK_NOT_DONE;
   1030     }
   1031   }
   1032   if (net_log_.IsLoggingAllEvents()) {
   1033     net_log_.AddEvent(
   1034         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
   1035         CreateNetLogReadWriteCompleteCallback(*result));
   1036   }
   1037 
   1038   EntryOperationComplete(
   1039       stream_index,
   1040       completion_callback,
   1041       SimpleEntryStat(*last_used, last_modified_, data_size_),
   1042       result.Pass());
   1043 }
   1044 
   1045 void SimpleEntryImpl::WriteOperationComplete(
   1046     int stream_index,
   1047     const CompletionCallback& completion_callback,
   1048     scoped_ptr<SimpleEntryStat> entry_stat,
   1049     scoped_ptr<int> result) {
   1050   if (*result >= 0)
   1051     RecordWriteResult(WRITE_RESULT_SUCCESS);
   1052   else
   1053     RecordWriteResult(WRITE_RESULT_SYNC_WRITE_FAILURE);
   1054   if (net_log_.IsLoggingAllEvents()) {
   1055     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
   1056         CreateNetLogReadWriteCompleteCallback(*result));
   1057   }
   1058 
   1059   EntryOperationComplete(
   1060       stream_index, completion_callback, *entry_stat, result.Pass());
   1061 }
   1062 
   1063 void SimpleEntryImpl::ChecksumOperationComplete(
   1064     int orig_result,
   1065     int stream_index,
   1066     const CompletionCallback& completion_callback,
   1067     scoped_ptr<int> result) {
   1068   DCHECK(io_thread_checker_.CalledOnValidThread());
   1069   DCHECK(synchronous_entry_);
   1070   DCHECK_EQ(STATE_IO_PENDING, state_);
   1071   DCHECK(result);
   1072 
   1073   if (net_log_.IsLoggingAllEvents()) {
   1074     net_log_.AddEventWithNetErrorCode(
   1075         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CHECKSUM_END,
   1076         *result);
   1077   }
   1078 
   1079   if (*result == net::OK) {
   1080     *result = orig_result;
   1081     if (orig_result >= 0)
   1082       RecordReadResult(READ_RESULT_SUCCESS);
   1083     else
   1084       RecordReadResult(READ_RESULT_SYNC_READ_FAILURE);
   1085   } else {
   1086     RecordReadResult(READ_RESULT_SYNC_CHECKSUM_FAILURE);
   1087   }
   1088   if (net_log_.IsLoggingAllEvents()) {
   1089     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
   1090         CreateNetLogReadWriteCompleteCallback(*result));
   1091   }
   1092 
   1093   EntryOperationComplete(
   1094       stream_index,
   1095       completion_callback,
   1096       SimpleEntryStat(last_used_, last_modified_, data_size_),
   1097       result.Pass());
   1098 }
   1099 
   1100 void SimpleEntryImpl::CloseOperationComplete() {
   1101   DCHECK(!synchronous_entry_);
   1102   DCHECK_EQ(0, open_count_);
   1103   DCHECK(STATE_IO_PENDING == state_ || STATE_FAILURE == state_ ||
   1104          STATE_UNINITIALIZED == state_);
   1105   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CLOSE_END);
   1106   AdjustOpenEntryCountBy(-1);
   1107   MakeUninitialized();
   1108   RunNextOperationIfNeeded();
   1109 }
   1110 
   1111 void SimpleEntryImpl::UpdateDataFromEntryStat(
   1112     const SimpleEntryStat& entry_stat) {
   1113   DCHECK(io_thread_checker_.CalledOnValidThread());
   1114   DCHECK(synchronous_entry_);
   1115   DCHECK_EQ(STATE_READY, state_);
   1116 
   1117   last_used_ = entry_stat.last_used;
   1118   last_modified_ = entry_stat.last_modified;
   1119   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
   1120     data_size_[i] = entry_stat.data_size[i];
   1121   }
   1122   if (backend_.get())
   1123     backend_->index()->UpdateEntrySize(key_, GetDiskUsage());
   1124 }
   1125 
   1126 int64 SimpleEntryImpl::GetDiskUsage() const {
   1127   int64 file_size = 0;
   1128   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
   1129     file_size +=
   1130         simple_util::GetFileSizeFromKeyAndDataSize(key_, data_size_[i]);
   1131   }
   1132   return file_size;
   1133 }
   1134 
   1135 void SimpleEntryImpl::RecordReadIsParallelizable(
   1136     const SimpleEntryOperation& operation) const {
   1137   if (!executing_operation_)
   1138     return;
   1139   // TODO(clamy): The values of this histogram should be changed to something
   1140   // more useful.
   1141   bool parallelizable_read =
   1142       !operation.alone_in_queue() &&
   1143       executing_operation_->type() == SimpleEntryOperation::TYPE_READ;
   1144   UMA_HISTOGRAM_BOOLEAN("SimpleCache.ReadIsParallelizable",
   1145                         parallelizable_read);
   1146 }
   1147 
   1148 void SimpleEntryImpl::RecordWriteDependencyType(
   1149     const SimpleEntryOperation& operation) const {
   1150   if (!executing_operation_)
   1151     return;
   1152   // Used in histograms, please only add entries at the end.
   1153   enum WriteDependencyType {
   1154     WRITE_OPTIMISTIC = 0,
   1155     WRITE_FOLLOWS_CONFLICTING_OPTIMISTIC = 1,
   1156     WRITE_FOLLOWS_NON_CONFLICTING_OPTIMISTIC = 2,
   1157     WRITE_FOLLOWS_CONFLICTING_WRITE = 3,
   1158     WRITE_FOLLOWS_NON_CONFLICTING_WRITE = 4,
   1159     WRITE_FOLLOWS_CONFLICTING_READ = 5,
   1160     WRITE_FOLLOWS_NON_CONFLICTING_READ = 6,
   1161     WRITE_FOLLOWS_OTHER = 7,
   1162     WRITE_DEPENDENCY_TYPE_MAX = 8,
   1163   };
   1164 
   1165   WriteDependencyType type = WRITE_FOLLOWS_OTHER;
   1166   if (operation.optimistic()) {
   1167     type = WRITE_OPTIMISTIC;
   1168   } else if (executing_operation_->type() == SimpleEntryOperation::TYPE_READ ||
   1169              executing_operation_->type() == SimpleEntryOperation::TYPE_WRITE) {
   1170     bool conflicting = executing_operation_->ConflictsWith(operation);
   1171 
   1172     if (executing_operation_->type() == SimpleEntryOperation::TYPE_READ) {
   1173       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_READ
   1174                          : WRITE_FOLLOWS_NON_CONFLICTING_READ;
   1175     } else if (executing_operation_->optimistic()) {
   1176       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_OPTIMISTIC
   1177                          : WRITE_FOLLOWS_NON_CONFLICTING_OPTIMISTIC;
   1178     } else {
   1179       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_WRITE
   1180                          : WRITE_FOLLOWS_NON_CONFLICTING_WRITE;
   1181     }
   1182   }
   1183   UMA_HISTOGRAM_ENUMERATION(
   1184       "SimpleCache.WriteDependencyType", type, WRITE_DEPENDENCY_TYPE_MAX);
   1185 }
   1186 
   1187 }  // namespace disk_cache
   1188