net/disk_cache/simple/simple_entry_impl.cc

   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/task_runner.h"
  18 #include "base/task_runner_util.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_histogram_macros.h"
  25 #include "net/disk_cache/simple/simple_index.h"
  26 #include "net/disk_cache/simple/simple_net_log_parameters.h"
  27 #include "net/disk_cache/simple/simple_synchronous_entry.h"
  28 #include "net/disk_cache/simple/simple_util.h"
  29 #include "third_party/zlib/zlib.h"
  30
  31 namespace disk_cache {
  32 namespace {
  33
  34 // An entry can store sparse data taking up to 1 / kMaxSparseDataSizeDivisor of
  35 // the cache.
  36 const int64 kMaxSparseDataSizeDivisor = 10;
  37
  38 // Used in histograms, please only add entries at the end.
  39 enum ReadResult {
  40   READ_RESULT_SUCCESS = 0,
  41   READ_RESULT_INVALID_ARGUMENT = 1,
  42   READ_RESULT_NONBLOCK_EMPTY_RETURN = 2,
  43   READ_RESULT_BAD_STATE = 3,
  44   READ_RESULT_FAST_EMPTY_RETURN = 4,
  45   READ_RESULT_SYNC_READ_FAILURE = 5,
  46   READ_RESULT_SYNC_CHECKSUM_FAILURE = 6,
  47   READ_RESULT_MAX = 7,
  48 };
  49
  50 // Used in histograms, please only add entries at the end.
  51 enum WriteResult {
  52   WRITE_RESULT_SUCCESS = 0,
  53   WRITE_RESULT_INVALID_ARGUMENT = 1,
  54   WRITE_RESULT_OVER_MAX_SIZE = 2,
  55   WRITE_RESULT_BAD_STATE = 3,
  56   WRITE_RESULT_SYNC_WRITE_FAILURE = 4,
  57   WRITE_RESULT_FAST_EMPTY_RETURN = 5,
  58   WRITE_RESULT_MAX = 6,
  59 };
  60
  61 // Used in histograms, please only add entries at the end.
  62 enum HeaderSizeChange {
  63   HEADER_SIZE_CHANGE_INITIAL,
  64   HEADER_SIZE_CHANGE_SAME,
  65   HEADER_SIZE_CHANGE_INCREASE,
  66   HEADER_SIZE_CHANGE_DECREASE,
  67   HEADER_SIZE_CHANGE_UNEXPECTED_WRITE,
  68   HEADER_SIZE_CHANGE_MAX
  69 };
  70
  71 void RecordReadResult(net::CacheType cache_type, ReadResult result) {
  72   SIMPLE_CACHE_UMA(ENUMERATION,
  73                    "ReadResult", cache_type, result, READ_RESULT_MAX);
  74 }
  75
  76 void RecordWriteResult(net::CacheType cache_type, WriteResult result) {
  77   SIMPLE_CACHE_UMA(ENUMERATION,
  78                    "WriteResult2", cache_type, result, WRITE_RESULT_MAX);
  79 }
  80
  81 // TODO(ttuttle): Consider removing this once we have a good handle on header
  82 // size changes.
  83 void RecordHeaderSizeChange(net::CacheType cache_type,
  84                             int old_size, int new_size) {
  85   HeaderSizeChange size_change;
  86
  87   SIMPLE_CACHE_UMA(COUNTS_10000, "HeaderSize", cache_type, new_size);
  88
  89   if (old_size == 0) {
  90     size_change = HEADER_SIZE_CHANGE_INITIAL;
  91   } else if (new_size == old_size) {
  92     size_change = HEADER_SIZE_CHANGE_SAME;
  93   } else if (new_size > old_size) {
  94     int delta = new_size - old_size;
  95     SIMPLE_CACHE_UMA(COUNTS_10000,
  96                      "HeaderSizeIncreaseAbsolute", cache_type, delta);
  97     SIMPLE_CACHE_UMA(PERCENTAGE,
  98                      "HeaderSizeIncreasePercentage", cache_type,
  99                      delta * 100 / old_size);
 100     size_change = HEADER_SIZE_CHANGE_INCREASE;
 101   } else {  // new_size < old_size
 102     int delta = old_size - new_size;
 103     SIMPLE_CACHE_UMA(COUNTS_10000,
 104                      "HeaderSizeDecreaseAbsolute", cache_type, delta);
 105     SIMPLE_CACHE_UMA(PERCENTAGE,
 106                      "HeaderSizeDecreasePercentage", cache_type,
 107                      delta * 100 / old_size);
 108     size_change = HEADER_SIZE_CHANGE_DECREASE;
 109   }
 110
 111   SIMPLE_CACHE_UMA(ENUMERATION,
 112                    "HeaderSizeChange", cache_type,
 113                    size_change, HEADER_SIZE_CHANGE_MAX);
 114 }
 115
 116 void RecordUnexpectedStream0Write(net::CacheType cache_type) {
 117   SIMPLE_CACHE_UMA(ENUMERATION,
 118                    "HeaderSizeChange", cache_type,
 119                    HEADER_SIZE_CHANGE_UNEXPECTED_WRITE, HEADER_SIZE_CHANGE_MAX);
 120 }
 121
 122 int g_open_entry_count = 0;
 123
 124 void AdjustOpenEntryCountBy(net::CacheType cache_type, int offset) {
 125   g_open_entry_count += offset;
 126   SIMPLE_CACHE_UMA(COUNTS_10000,
 127                    "GlobalOpenEntryCount", cache_type, g_open_entry_count);
 128 }
 129
 130 void InvokeCallbackIfBackendIsAlive(
 131     const base::WeakPtr<SimpleBackendImpl>& backend,
 132     const net::CompletionCallback& completion_callback,
 133     int result) {
 134   DCHECK(!completion_callback.is_null());
 135   if (!backend.get())
 136     return;
 137   completion_callback.Run(result);
 138 }
 139
 140 }  // namespace
 141
 142 using base::Closure;
 143 using base::FilePath;
 144 using base::MessageLoopProxy;
 145 using base::Time;
 146 using base::TaskRunner;
 147
 148 // A helper class to insure that RunNextOperationIfNeeded() is called when
 149 // exiting the current stack frame.
 150 class SimpleEntryImpl::ScopedOperationRunner {
 151  public:
 152   explicit ScopedOperationRunner(SimpleEntryImpl* entry) : entry_(entry) {
 153   }
 154
 155   ~ScopedOperationRunner() {
 156     entry_->RunNextOperationIfNeeded();
 157   }
 158
 159  private:
 160   SimpleEntryImpl* const entry_;
 161 };
 162
 163 SimpleEntryImpl::SimpleEntryImpl(net::CacheType cache_type,
 164                                  const FilePath& path,
 165                                  const uint64 entry_hash,
 166                                  OperationsMode operations_mode,
 167                                  SimpleBackendImpl* backend,
 168                                  net::NetLog* net_log)
 169     : backend_(backend->AsWeakPtr()),
 170       cache_type_(cache_type),
 171       worker_pool_(backend->worker_pool()),
 172       path_(path),
 173       entry_hash_(entry_hash),
 174       use_optimistic_operations_(operations_mode == OPTIMISTIC_OPERATIONS),
 175       last_used_(Time::Now()),
 176       last_modified_(last_used_),
 177       sparse_data_size_(0),
 178       open_count_(0),
 179       doomed_(false),
 180       state_(STATE_UNINITIALIZED),
 181       synchronous_entry_(NULL),
 182       net_log_(net::BoundNetLog::Make(
 183           net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY)),
 184       stream_0_data_(new net::GrowableIOBuffer()) {
 185   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc32s_end_offset_),
 186                  arrays_should_be_same_size);
 187   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc32s_),
 188                  arrays_should_be_same_size);
 189   COMPILE_ASSERT(arraysize(data_size_) == arraysize(have_written_),
 190                  arrays_should_be_same_size);
 191   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc_check_state_),
 192                  arrays_should_be_same_size);
 193   MakeUninitialized();
 194   net_log_.BeginEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY,
 195       CreateNetLogSimpleEntryConstructionCallback(this));
 196 }
 197
 198 int SimpleEntryImpl::OpenEntry(Entry** out_entry,
 199                                const CompletionCallback& callback) {
 200   DCHECK(backend_.get());
 201
 202   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_CALL);
 203
 204   bool have_index = backend_->index()->initialized();
 205   // This enumeration is used in histograms, add entries only at end.
 206   enum OpenEntryIndexEnum {
 207     INDEX_NOEXIST = 0,
 208     INDEX_MISS = 1,
 209     INDEX_HIT = 2,
 210     INDEX_MAX = 3,
 211   };
 212   OpenEntryIndexEnum open_entry_index_enum = INDEX_NOEXIST;
 213   if (have_index) {
 214     if (backend_->index()->Has(entry_hash_))
 215       open_entry_index_enum = INDEX_HIT;
 216     else
 217       open_entry_index_enum = INDEX_MISS;
 218   }
 219   SIMPLE_CACHE_UMA(ENUMERATION,
 220                    "OpenEntryIndexState", cache_type_,
 221                    open_entry_index_enum, INDEX_MAX);
 222
 223   // If entry is not known to the index, initiate fast failover to the network.
 224   if (open_entry_index_enum == INDEX_MISS) {
 225     net_log_.AddEventWithNetErrorCode(
 226         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END,
 227         net::ERR_FAILED);
 228     return net::ERR_FAILED;
 229   }
 230
 231   pending_operations_.push(SimpleEntryOperation::OpenOperation(
 232       this, have_index, callback, out_entry));
 233   RunNextOperationIfNeeded();
 234   return net::ERR_IO_PENDING;
 235 }
 236
 237 int SimpleEntryImpl::CreateEntry(Entry** out_entry,
 238                                  const CompletionCallback& callback) {
 239   DCHECK(backend_.get());
 240   DCHECK_EQ(entry_hash_, simple_util::GetEntryHashKey(key_));
 241
 242   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_CALL);
 243
 244   bool have_index = backend_->index()->initialized();
 245   int ret_value = net::ERR_FAILED;
 246   if (use_optimistic_operations_ &&
 247       state_ == STATE_UNINITIALIZED && pending_operations_.size() == 0) {
 248     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_OPTIMISTIC);
 249
 250     ReturnEntryToCaller(out_entry);
 251     pending_operations_.push(SimpleEntryOperation::CreateOperation(
 252         this, have_index, CompletionCallback(), static_cast<Entry**>(NULL)));
 253     ret_value = net::OK;
 254   } else {
 255     pending_operations_.push(SimpleEntryOperation::CreateOperation(
 256         this, have_index, callback, out_entry));
 257     ret_value = net::ERR_IO_PENDING;
 258   }
 259
 260   // We insert the entry in the index before creating the entry files in the
 261   // SimpleSynchronousEntry, because this way the worst scenario is when we
 262   // have the entry in the index but we don't have the created files yet, this
 263   // way we never leak files. CreationOperationComplete will remove the entry
 264   // from the index if the creation fails.
 265   backend_->index()->Insert(entry_hash_);
 266
 267   RunNextOperationIfNeeded();
 268   return ret_value;
 269 }
 270
 271 int SimpleEntryImpl::DoomEntry(const CompletionCallback& callback) {
 272   if (doomed_)
 273     return net::OK;
 274   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_DOOM_CALL);
 275   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_DOOM_BEGIN);
 276
 277   MarkAsDoomed();
 278   if (backend_.get())
 279     backend_->OnDoomStart(entry_hash_);
 280   pending_operations_.push(SimpleEntryOperation::DoomOperation(this, callback));
 281   RunNextOperationIfNeeded();
 282   return net::ERR_IO_PENDING;
 283 }
 284
 285 void SimpleEntryImpl::SetKey(const std::string& key) {
 286   key_ = key;
 287   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_SET_KEY,
 288       net::NetLog::StringCallback("key", &key));
 289 }
 290
 291 void SimpleEntryImpl::Doom() {
 292   DoomEntry(CompletionCallback());
 293 }
 294
 295 void SimpleEntryImpl::Close() {
 296   DCHECK(io_thread_checker_.CalledOnValidThread());
 297   DCHECK_LT(0, open_count_);
 298
 299   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CLOSE_CALL);
 300
 301   if (--open_count_ > 0) {
 302     DCHECK(!HasOneRef());
 303     Release();  // Balanced in ReturnEntryToCaller().
 304     return;
 305   }
 306
 307   pending_operations_.push(SimpleEntryOperation::CloseOperation(this));
 308   DCHECK(!HasOneRef());
 309   Release();  // Balanced in ReturnEntryToCaller().
 310   RunNextOperationIfNeeded();
 311 }
 312
 313 std::string SimpleEntryImpl::GetKey() const {
 314   DCHECK(io_thread_checker_.CalledOnValidThread());
 315   return key_;
 316 }
 317
 318 Time SimpleEntryImpl::GetLastUsed() const {
 319   DCHECK(io_thread_checker_.CalledOnValidThread());
 320   return last_used_;
 321 }
 322
 323 Time SimpleEntryImpl::GetLastModified() const {
 324   DCHECK(io_thread_checker_.CalledOnValidThread());
 325   return last_modified_;
 326 }
 327
 328 int32 SimpleEntryImpl::GetDataSize(int stream_index) const {
 329   DCHECK(io_thread_checker_.CalledOnValidThread());
 330   DCHECK_LE(0, data_size_[stream_index]);
 331   return data_size_[stream_index];
 332 }
 333
 334 int SimpleEntryImpl::ReadData(int stream_index,
 335                               int offset,
 336                               net::IOBuffer* buf,
 337                               int buf_len,
 338                               const CompletionCallback& callback) {
 339   DCHECK(io_thread_checker_.CalledOnValidThread());
 340
 341   if (net_log_.IsLogging()) {
 342     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_CALL,
 343         CreateNetLogReadWriteDataCallback(stream_index, offset, buf_len,
 344                                           false));
 345   }
 346
 347   if (stream_index < 0 || stream_index >= kSimpleEntryStreamCount ||
 348       buf_len < 0) {
 349     if (net_log_.IsLogging()) {
 350       net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
 351           CreateNetLogReadWriteCompleteCallback(net::ERR_INVALID_ARGUMENT));
 352     }
 353
 354     RecordReadResult(cache_type_, READ_RESULT_INVALID_ARGUMENT);
 355     return net::ERR_INVALID_ARGUMENT;
 356   }
 357   if (pending_operations_.empty() && (offset >= GetDataSize(stream_index) ||
 358                                       offset < 0 || !buf_len)) {
 359     if (net_log_.IsLogging()) {
 360       net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
 361           CreateNetLogReadWriteCompleteCallback(0));
 362     }
 363
 364     RecordReadResult(cache_type_, READ_RESULT_NONBLOCK_EMPTY_RETURN);
 365     return 0;
 366   }
 367
 368   // TODO(clamy): return immediatly when reading from stream 0.
 369
 370   // TODO(felipeg): Optimization: Add support for truly parallel read
 371   // operations.
 372   bool alone_in_queue =
 373       pending_operations_.size() == 0 && state_ == STATE_READY;
 374   pending_operations_.push(SimpleEntryOperation::ReadOperation(
 375       this, stream_index, offset, buf_len, buf, callback, alone_in_queue));
 376   RunNextOperationIfNeeded();
 377   return net::ERR_IO_PENDING;
 378 }
 379
 380 int SimpleEntryImpl::WriteData(int stream_index,
 381                                int offset,
 382                                net::IOBuffer* buf,
 383                                int buf_len,
 384                                const CompletionCallback& callback,
 385                                bool truncate) {
 386   DCHECK(io_thread_checker_.CalledOnValidThread());
 387
 388   if (net_log_.IsLogging()) {
 389     net_log_.AddEvent(
 390         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_CALL,
 391         CreateNetLogReadWriteDataCallback(stream_index, offset, buf_len,
 392                                           truncate));
 393   }
 394
 395   if (stream_index < 0 || stream_index >= kSimpleEntryStreamCount ||
 396       offset < 0 || buf_len < 0) {
 397     if (net_log_.IsLogging()) {
 398       net_log_.AddEvent(
 399           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
 400           CreateNetLogReadWriteCompleteCallback(net::ERR_INVALID_ARGUMENT));
 401     }
 402     RecordWriteResult(cache_type_, WRITE_RESULT_INVALID_ARGUMENT);
 403     return net::ERR_INVALID_ARGUMENT;
 404   }
 405   if (backend_.get() && offset + buf_len > backend_->GetMaxFileSize()) {
 406     if (net_log_.IsLogging()) {
 407       net_log_.AddEvent(
 408           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
 409           CreateNetLogReadWriteCompleteCallback(net::ERR_FAILED));
 410     }
 411     RecordWriteResult(cache_type_, WRITE_RESULT_OVER_MAX_SIZE);
 412     return net::ERR_FAILED;
 413   }
 414   ScopedOperationRunner operation_runner(this);
 415
 416   // Stream 0 data is kept in memory, so can be written immediatly if there are
 417   // no IO operations pending.
 418   if (stream_index == 0 && state_ == STATE_READY &&
 419       pending_operations_.size() == 0)
 420     return SetStream0Data(buf, offset, buf_len, truncate);
 421
 422   // We can only do optimistic Write if there is no pending operations, so
 423   // that we are sure that the next call to RunNextOperationIfNeeded will
 424   // actually run the write operation that sets the stream size. It also
 425   // prevents from previous possibly-conflicting writes that could be stacked
 426   // in the |pending_operations_|. We could optimize this for when we have
 427   // only read operations enqueued.
 428   const bool optimistic =
 429       (use_optimistic_operations_ && state_ == STATE_READY &&
 430        pending_operations_.size() == 0);
 431   CompletionCallback op_callback;
 432   scoped_refptr<net::IOBuffer> op_buf;
 433   int ret_value = net::ERR_FAILED;
 434   if (!optimistic) {
 435     op_buf = buf;
 436     op_callback = callback;
 437     ret_value = net::ERR_IO_PENDING;
 438   } else {
 439     // TODO(gavinp,pasko): For performance, don't use a copy of an IOBuffer
 440     // here to avoid paying the price of the RefCountedThreadSafe atomic
 441     // operations.
 442     if (buf) {
 443       op_buf = new IOBuffer(buf_len);
 444       memcpy(op_buf->data(), buf->data(), buf_len);
 445     }
 446     op_callback = CompletionCallback();
 447     ret_value = buf_len;
 448     if (net_log_.IsLogging()) {
 449       net_log_.AddEvent(
 450           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_OPTIMISTIC,
 451           CreateNetLogReadWriteCompleteCallback(buf_len));
 452     }
 453   }
 454
 455   pending_operations_.push(SimpleEntryOperation::WriteOperation(this,
 456                                                                 stream_index,
 457                                                                 offset,
 458                                                                 buf_len,
 459                                                                 op_buf.get(),
 460                                                                 truncate,
 461                                                                 optimistic,
 462                                                                 op_callback));
 463   return ret_value;
 464 }
 465
 466 int SimpleEntryImpl::ReadSparseData(int64 offset,
 467                                     net::IOBuffer* buf,
 468                                     int buf_len,
 469                                     const CompletionCallback& callback) {
 470   DCHECK(io_thread_checker_.CalledOnValidThread());
 471
 472   ScopedOperationRunner operation_runner(this);
 473   pending_operations_.push(SimpleEntryOperation::ReadSparseOperation(
 474       this, offset, buf_len, buf, callback));
 475   return net::ERR_IO_PENDING;
 476 }
 477
 478 int SimpleEntryImpl::WriteSparseData(int64 offset,
 479                                      net::IOBuffer* buf,
 480                                      int buf_len,
 481                                      const CompletionCallback& callback) {
 482   DCHECK(io_thread_checker_.CalledOnValidThread());
 483
 484   ScopedOperationRunner operation_runner(this);
 485   pending_operations_.push(SimpleEntryOperation::WriteSparseOperation(
 486       this, offset, buf_len, buf, callback));
 487   return net::ERR_IO_PENDING;
 488 }
 489
 490 int SimpleEntryImpl::GetAvailableRange(int64 offset,
 491                                        int len,
 492                                        int64* start,
 493                                        const CompletionCallback& callback) {
 494   DCHECK(io_thread_checker_.CalledOnValidThread());
 495
 496   ScopedOperationRunner operation_runner(this);
 497   pending_operations_.push(SimpleEntryOperation::GetAvailableRangeOperation(
 498       this, offset, len, start, callback));
 499   return net::ERR_IO_PENDING;
 500 }
 501
 502 bool SimpleEntryImpl::CouldBeSparse() const {
 503   DCHECK(io_thread_checker_.CalledOnValidThread());
 504   // TODO(ttuttle): Actually check.
 505   return true;
 506 }
 507
 508 void SimpleEntryImpl::CancelSparseIO() {
 509   DCHECK(io_thread_checker_.CalledOnValidThread());
 510   // The Simple Cache does not return distinct objects for the same non-doomed
 511   // entry, so there's no need to coordinate which object is performing sparse
 512   // I/O.  Therefore, CancelSparseIO and ReadyForSparseIO succeed instantly.
 513 }
 514
 515 int SimpleEntryImpl::ReadyForSparseIO(const CompletionCallback& callback) {
 516   DCHECK(io_thread_checker_.CalledOnValidThread());
 517   // The simple Cache does not return distinct objects for the same non-doomed
 518   // entry, so there's no need to coordinate which object is performing sparse
 519   // I/O.  Therefore, CancelSparseIO and ReadyForSparseIO succeed instantly.
 520   return net::OK;
 521 }
 522
 523 SimpleEntryImpl::~SimpleEntryImpl() {
 524   DCHECK(io_thread_checker_.CalledOnValidThread());
 525   DCHECK_EQ(0U, pending_operations_.size());
 526   DCHECK(state_ == STATE_UNINITIALIZED || state_ == STATE_FAILURE);
 527   DCHECK(!synchronous_entry_);
 528   RemoveSelfFromBackend();
 529   net_log_.EndEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY);
 530 }
 531
 532 void SimpleEntryImpl::PostClientCallback(const CompletionCallback& callback,
 533                                          int result) {
 534   if (callback.is_null())
 535     return;
 536   // Note that the callback is posted rather than directly invoked to avoid
 537   // reentrancy issues.
 538   MessageLoopProxy::current()->PostTask(
 539       FROM_HERE,
 540       base::Bind(&InvokeCallbackIfBackendIsAlive, backend_, callback, result));
 541 }
 542
 543 void SimpleEntryImpl::MakeUninitialized() {
 544   state_ = STATE_UNINITIALIZED;
 545   std::memset(crc32s_end_offset_, 0, sizeof(crc32s_end_offset_));
 546   std::memset(crc32s_, 0, sizeof(crc32s_));
 547   std::memset(have_written_, 0, sizeof(have_written_));
 548   std::memset(data_size_, 0, sizeof(data_size_));
 549   for (size_t i = 0; i < arraysize(crc_check_state_); ++i) {
 550     crc_check_state_[i] = CRC_CHECK_NEVER_READ_AT_ALL;
 551   }
 552 }
 553
 554 void SimpleEntryImpl::ReturnEntryToCaller(Entry** out_entry) {
 555   DCHECK(out_entry);
 556   ++open_count_;
 557   AddRef();  // Balanced in Close()
 558   if (!backend_.get()) {
 559     // This method can be called when an asynchronous operation completed.
 560     // If the backend no longer exists, the callback won't be invoked, and so we
 561     // must close ourselves to avoid leaking. As well, there's no guarantee the
 562     // client-provided pointer (|out_entry|) hasn't been freed, and no point
 563     // dereferencing it, either.
 564     Close();
 565     return;
 566   }
 567   *out_entry = this;
 568 }
 569
 570 void SimpleEntryImpl::RemoveSelfFromBackend() {
 571   if (!backend_.get())
 572     return;
 573   backend_->OnDeactivated(this);
 574 }
 575
 576 void SimpleEntryImpl::MarkAsDoomed() {
 577   doomed_ = true;
 578   if (!backend_.get())
 579     return;
 580   backend_->index()->Remove(entry_hash_);
 581   RemoveSelfFromBackend();
 582 }
 583
 584 void SimpleEntryImpl::RunNextOperationIfNeeded() {
 585   DCHECK(io_thread_checker_.CalledOnValidThread());
 586   SIMPLE_CACHE_UMA(CUSTOM_COUNTS,
 587                    "EntryOperationsPending", cache_type_,
 588                    pending_operations_.size(), 0, 100, 20);
 589   if (!pending_operations_.empty() && state_ != STATE_IO_PENDING) {
 590     scoped_ptr<SimpleEntryOperation> operation(
 591         new SimpleEntryOperation(pending_operations_.front()));
 592     pending_operations_.pop();
 593     switch (operation->type()) {
 594       case SimpleEntryOperation::TYPE_OPEN:
 595         OpenEntryInternal(operation->have_index(),
 596                           operation->callback(),
 597                           operation->out_entry());
 598         break;
 599       case SimpleEntryOperation::TYPE_CREATE:
 600         CreateEntryInternal(operation->have_index(),
 601                             operation->callback(),
 602                             operation->out_entry());
 603         break;
 604       case SimpleEntryOperation::TYPE_CLOSE:
 605         CloseInternal();
 606         break;
 607       case SimpleEntryOperation::TYPE_READ:
 608         RecordReadIsParallelizable(*operation);
 609         ReadDataInternal(operation->index(),
 610                          operation->offset(),
 611                          operation->buf(),
 612                          operation->length(),
 613                          operation->callback());
 614         break;
 615       case SimpleEntryOperation::TYPE_WRITE:
 616         RecordWriteDependencyType(*operation);
 617         WriteDataInternal(operation->index(),
 618                           operation->offset(),
 619                           operation->buf(),
 620                           operation->length(),
 621                           operation->callback(),
 622                           operation->truncate());
 623         break;
 624       case SimpleEntryOperation::TYPE_READ_SPARSE:
 625         ReadSparseDataInternal(operation->sparse_offset(),
 626                                operation->buf(),
 627                                operation->length(),
 628                                operation->callback());
 629         break;
 630       case SimpleEntryOperation::TYPE_WRITE_SPARSE:
 631         WriteSparseDataInternal(operation->sparse_offset(),
 632                                 operation->buf(),
 633                                 operation->length(),
 634                                 operation->callback());
 635         break;
 636       case SimpleEntryOperation::TYPE_GET_AVAILABLE_RANGE:
 637         GetAvailableRangeInternal(operation->sparse_offset(),
 638                                   operation->length(),
 639                                   operation->out_start(),
 640                                   operation->callback());
 641         break;
 642       case SimpleEntryOperation::TYPE_DOOM:
 643         DoomEntryInternal(operation->callback());
 644         break;
 645       default:
 646         NOTREACHED();
 647     }
 648     // The operation is kept for histograms. Makes sure it does not leak
 649     // resources.
 650     executing_operation_.swap(operation);
 651     executing_operation_->ReleaseReferences();
 652     // |this| may have been deleted.
 653   }
 654 }
 655
 656 void SimpleEntryImpl::OpenEntryInternal(bool have_index,
 657                                         const CompletionCallback& callback,
 658                                         Entry** out_entry) {
 659   ScopedOperationRunner operation_runner(this);
 660
 661   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_BEGIN);
 662
 663   if (state_ == STATE_READY) {
 664     ReturnEntryToCaller(out_entry);
 665     PostClientCallback(callback, net::OK);
 666     net_log_.AddEvent(
 667         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END,
 668         CreateNetLogSimpleEntryCreationCallback(this, net::OK));
 669     return;
 670   }
 671   if (state_ == STATE_FAILURE) {
 672     PostClientCallback(callback, net::ERR_FAILED);
 673     net_log_.AddEvent(
 674         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END,
 675         CreateNetLogSimpleEntryCreationCallback(this, net::ERR_FAILED));
 676     return;
 677   }
 678
 679   DCHECK_EQ(STATE_UNINITIALIZED, state_);
 680   DCHECK(!synchronous_entry_);
 681   state_ = STATE_IO_PENDING;
 682   const base::TimeTicks start_time = base::TimeTicks::Now();
 683   scoped_ptr<SimpleEntryCreationResults> results(
 684       new SimpleEntryCreationResults(
 685           SimpleEntryStat(last_used_, last_modified_, data_size_,
 686                           sparse_data_size_)));
 687   Closure task = base::Bind(&SimpleSynchronousEntry::OpenEntry,
 688                             cache_type_,
 689                             path_,
 690                             entry_hash_,
 691                             have_index,
 692                             results.get());
 693   Closure reply = base::Bind(&SimpleEntryImpl::CreationOperationComplete,
 694                              this,
 695                              callback,
 696                              start_time,
 697                              base::Passed(&results),
 698                              out_entry,
 699                              net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END);
 700   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 701 }
 702
 703 void SimpleEntryImpl::CreateEntryInternal(bool have_index,
 704                                           const CompletionCallback& callback,
 705                                           Entry** out_entry) {
 706   ScopedOperationRunner operation_runner(this);
 707
 708   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_BEGIN);
 709
 710   if (state_ != STATE_UNINITIALIZED) {
 711     // There is already an active normal entry.
 712     net_log_.AddEvent(
 713         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_END,
 714         CreateNetLogSimpleEntryCreationCallback(this, net::ERR_FAILED));
 715     PostClientCallback(callback, net::ERR_FAILED);
 716     return;
 717   }
 718   DCHECK_EQ(STATE_UNINITIALIZED, state_);
 719   DCHECK(!synchronous_entry_);
 720
 721   state_ = STATE_IO_PENDING;
 722
 723   // Since we don't know the correct values for |last_used_| and
 724   // |last_modified_| yet, we make this approximation.
 725   last_used_ = last_modified_ = base::Time::Now();
 726
 727   // If creation succeeds, we should mark all streams to be saved on close.
 728   for (int i = 0; i < kSimpleEntryStreamCount; ++i)
 729     have_written_[i] = true;
 730
 731   const base::TimeTicks start_time = base::TimeTicks::Now();
 732   scoped_ptr<SimpleEntryCreationResults> results(
 733       new SimpleEntryCreationResults(
 734           SimpleEntryStat(last_used_, last_modified_, data_size_,
 735                           sparse_data_size_)));
 736   Closure task = base::Bind(&SimpleSynchronousEntry::CreateEntry,
 737                             cache_type_,
 738                             path_,
 739                             key_,
 740                             entry_hash_,
 741                             have_index,
 742                             results.get());
 743   Closure reply = base::Bind(&SimpleEntryImpl::CreationOperationComplete,
 744                              this,
 745                              callback,
 746                              start_time,
 747                              base::Passed(&results),
 748                              out_entry,
 749                              net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_END);
 750   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 751 }
 752
 753 void SimpleEntryImpl::CloseInternal() {
 754   DCHECK(io_thread_checker_.CalledOnValidThread());
 755   typedef SimpleSynchronousEntry::CRCRecord CRCRecord;
 756   scoped_ptr<std::vector<CRCRecord> >
 757       crc32s_to_write(new std::vector<CRCRecord>());
 758
 759   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CLOSE_BEGIN);
 760
 761   if (state_ == STATE_READY) {
 762     DCHECK(synchronous_entry_);
 763     state_ = STATE_IO_PENDING;
 764     for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
 765       if (have_written_[i]) {
 766         if (GetDataSize(i) == crc32s_end_offset_[i]) {
 767           int32 crc = GetDataSize(i) == 0 ? crc32(0, Z_NULL, 0) : crc32s_[i];
 768           crc32s_to_write->push_back(CRCRecord(i, true, crc));
 769         } else {
 770           crc32s_to_write->push_back(CRCRecord(i, false, 0));
 771         }
 772       }
 773     }
 774   } else {
 775     DCHECK(STATE_UNINITIALIZED == state_ || STATE_FAILURE == state_);
 776   }
 777
 778   if (synchronous_entry_) {
 779     Closure task =
 780         base::Bind(&SimpleSynchronousEntry::Close,
 781                    base::Unretained(synchronous_entry_),
 782                    SimpleEntryStat(last_used_, last_modified_, data_size_,
 783                                    sparse_data_size_),
 784                    base::Passed(&crc32s_to_write),
 785                    stream_0_data_);
 786     Closure reply = base::Bind(&SimpleEntryImpl::CloseOperationComplete, this);
 787     synchronous_entry_ = NULL;
 788     worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 789
 790     for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
 791       if (!have_written_[i]) {
 792         SIMPLE_CACHE_UMA(ENUMERATION,
 793                          "CheckCRCResult", cache_type_,
 794                          crc_check_state_[i], CRC_CHECK_MAX);
 795       }
 796     }
 797   } else {
 798     CloseOperationComplete();
 799   }
 800 }
 801
 802 void SimpleEntryImpl::ReadDataInternal(int stream_index,
 803                                        int offset,
 804                                        net::IOBuffer* buf,
 805                                        int buf_len,
 806                                        const CompletionCallback& callback) {
 807   DCHECK(io_thread_checker_.CalledOnValidThread());
 808   ScopedOperationRunner operation_runner(this);
 809
 810   if (net_log_.IsLogging()) {
 811     net_log_.AddEvent(
 812         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_BEGIN,
 813         CreateNetLogReadWriteDataCallback(stream_index, offset, buf_len,
 814                                           false));
 815   }
 816
 817   if (state_ == STATE_FAILURE || state_ == STATE_UNINITIALIZED) {
 818     if (!callback.is_null()) {
 819       RecordReadResult(cache_type_, READ_RESULT_BAD_STATE);
 820       // Note that the API states that client-provided callbacks for entry-level
 821       // (i.e. non-backend) operations (e.g. read, write) are invoked even if
 822       // the backend was already destroyed.
 823       MessageLoopProxy::current()->PostTask(
 824           FROM_HERE, base::Bind(callback, net::ERR_FAILED));
 825     }
 826     if (net_log_.IsLogging()) {
 827       net_log_.AddEvent(
 828           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
 829           CreateNetLogReadWriteCompleteCallback(net::ERR_FAILED));
 830     }
 831     return;
 832   }
 833   DCHECK_EQ(STATE_READY, state_);
 834   if (offset >= GetDataSize(stream_index) || offset < 0 || !buf_len) {
 835     RecordReadResult(cache_type_, READ_RESULT_FAST_EMPTY_RETURN);
 836     // If there is nothing to read, we bail out before setting state_ to
 837     // STATE_IO_PENDING.
 838     if (!callback.is_null())
 839       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(callback, 0));
 840     return;
 841   }
 842
 843   buf_len = std::min(buf_len, GetDataSize(stream_index) - offset);
 844
 845   // Since stream 0 data is kept in memory, it is read immediately.
 846   if (stream_index == 0) {
 847     int ret_value = ReadStream0Data(buf, offset, buf_len);
 848     if (!callback.is_null()) {
 849       MessageLoopProxy::current()->PostTask(FROM_HERE,
 850                                             base::Bind(callback, ret_value));
 851     }
 852     return;
 853   }
 854
 855   state_ = STATE_IO_PENDING;
 856   if (!doomed_ && backend_.get())
 857     backend_->index()->UseIfExists(entry_hash_);
 858
 859   scoped_ptr<uint32> read_crc32(new uint32());
 860   scoped_ptr<int> result(new int());
 861   scoped_ptr<SimpleEntryStat> entry_stat(
 862       new SimpleEntryStat(last_used_, last_modified_, data_size_,
 863                           sparse_data_size_));
 864   Closure task = base::Bind(
 865       &SimpleSynchronousEntry::ReadData,
 866       base::Unretained(synchronous_entry_),
 867       SimpleSynchronousEntry::EntryOperationData(stream_index, offset, buf_len),
 868       make_scoped_refptr(buf),
 869       read_crc32.get(),
 870       entry_stat.get(),
 871       result.get());
 872   Closure reply = base::Bind(&SimpleEntryImpl::ReadOperationComplete,
 873                              this,
 874                              stream_index,
 875                              offset,
 876                              callback,
 877                              base::Passed(&read_crc32),
 878                              base::Passed(&entry_stat),
 879                              base::Passed(&result));
 880   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 881 }
 882
 883 void SimpleEntryImpl::WriteDataInternal(int stream_index,
 884                                        int offset,
 885                                        net::IOBuffer* buf,
 886                                        int buf_len,
 887                                        const CompletionCallback& callback,
 888                                        bool truncate) {
 889   DCHECK(io_thread_checker_.CalledOnValidThread());
 890   ScopedOperationRunner operation_runner(this);
 891
 892   if (net_log_.IsLogging()) {
 893     net_log_.AddEvent(
 894         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_BEGIN,
 895         CreateNetLogReadWriteDataCallback(stream_index, offset, buf_len,
 896                                           truncate));
 897   }
 898
 899   if (state_ == STATE_FAILURE || state_ == STATE_UNINITIALIZED) {
 900     RecordWriteResult(cache_type_, WRITE_RESULT_BAD_STATE);
 901     if (net_log_.IsLogging()) {
 902       net_log_.AddEvent(
 903           net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
 904           CreateNetLogReadWriteCompleteCallback(net::ERR_FAILED));
 905     }
 906     if (!callback.is_null()) {
 907       MessageLoopProxy::current()->PostTask(
 908           FROM_HERE, base::Bind(callback, net::ERR_FAILED));
 909     }
 910     // |this| may be destroyed after return here.
 911     return;
 912   }
 913
 914   DCHECK_EQ(STATE_READY, state_);
 915
 916   // Since stream 0 data is kept in memory, it will be written immediatly.
 917   if (stream_index == 0) {
 918     int ret_value = SetStream0Data(buf, offset, buf_len, truncate);
 919     if (!callback.is_null()) {
 920       MessageLoopProxy::current()->PostTask(FROM_HERE,
 921                                             base::Bind(callback, ret_value));
 922     }
 923     return;
 924   }
 925
 926   // Ignore zero-length writes that do not change the file size.
 927   if (buf_len == 0) {
 928     int32 data_size = data_size_[stream_index];
 929     if (truncate ? (offset == data_size) : (offset <= data_size)) {
 930       RecordWriteResult(cache_type_, WRITE_RESULT_FAST_EMPTY_RETURN);
 931       if (!callback.is_null()) {
 932         MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
 933             callback, 0));
 934       }
 935       return;
 936     }
 937   }
 938   state_ = STATE_IO_PENDING;
 939   if (!doomed_ && backend_.get())
 940     backend_->index()->UseIfExists(entry_hash_);
 941
 942   AdvanceCrc(buf, offset, buf_len, stream_index);
 943
 944   // |entry_stat| needs to be initialized before modifying |data_size_|.
 945   scoped_ptr<SimpleEntryStat> entry_stat(
 946       new SimpleEntryStat(last_used_, last_modified_, data_size_,
 947                           sparse_data_size_));
 948   if (truncate) {
 949     data_size_[stream_index] = offset + buf_len;
 950   } else {
 951     data_size_[stream_index] = std::max(offset + buf_len,
 952                                         GetDataSize(stream_index));
 953   }
 954
 955   // Since we don't know the correct values for |last_used_| and
 956   // |last_modified_| yet, we make this approximation.
 957   last_used_ = last_modified_ = base::Time::Now();
 958
 959   have_written_[stream_index] = true;
 960   // Writing on stream 1 affects the placement of stream 0 in the file, the EOF
 961   // record will have to be rewritten.
 962   if (stream_index == 1)
 963     have_written_[0] = true;
 964
 965   scoped_ptr<int> result(new int());
 966   Closure task = base::Bind(&SimpleSynchronousEntry::WriteData,
 967                             base::Unretained(synchronous_entry_),
 968                             SimpleSynchronousEntry::EntryOperationData(
 969                                 stream_index, offset, buf_len, truncate,
 970                                 doomed_),
 971                             make_scoped_refptr(buf),
 972                             entry_stat.get(),
 973                             result.get());
 974   Closure reply = base::Bind(&SimpleEntryImpl::WriteOperationComplete,
 975                              this,
 976                              stream_index,
 977                              callback,
 978                              base::Passed(&entry_stat),
 979                              base::Passed(&result));
 980   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 981 }
 982
 983 void SimpleEntryImpl::ReadSparseDataInternal(
 984     int64 sparse_offset,
 985     net::IOBuffer* buf,
 986     int buf_len,
 987     const CompletionCallback& callback) {
 988   DCHECK(io_thread_checker_.CalledOnValidThread());
 989   ScopedOperationRunner operation_runner(this);
 990
 991   DCHECK_EQ(STATE_READY, state_);
 992   state_ = STATE_IO_PENDING;
 993
 994   scoped_ptr<int> result(new int());
 995   scoped_ptr<base::Time> last_used(new base::Time());
 996   Closure task = base::Bind(&SimpleSynchronousEntry::ReadSparseData,
 997                             base::Unretained(synchronous_entry_),
 998                             SimpleSynchronousEntry::EntryOperationData(
 999                                 sparse_offset, buf_len),
1000                             make_scoped_refptr(buf),
1001                             last_used.get(),
1002                             result.get());
1003   Closure reply = base::Bind(&SimpleEntryImpl::ReadSparseOperationComplete,
1004                              this,
1005                              callback,
1006                              base::Passed(&last_used),
1007                              base::Passed(&result));
1008   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
1009 }
1010
1011 void SimpleEntryImpl::WriteSparseDataInternal(
1012     int64 sparse_offset,
1013     net::IOBuffer* buf,
1014     int buf_len,
1015     const CompletionCallback& callback) {
1016   DCHECK(io_thread_checker_.CalledOnValidThread());
1017   ScopedOperationRunner operation_runner(this);
1018
1019   DCHECK_EQ(STATE_READY, state_);
1020   state_ = STATE_IO_PENDING;
1021
1022   int64 max_sparse_data_size = kint64max;
1023   if (backend_.get()) {
1024     int64 max_cache_size = backend_->index()->max_size();
1025     max_sparse_data_size = max_cache_size / kMaxSparseDataSizeDivisor;
1026   }
1027
1028   scoped_ptr<SimpleEntryStat> entry_stat(
1029       new SimpleEntryStat(last_used_, last_modified_, data_size_,
1030                           sparse_data_size_));
1031
1032   last_used_ = last_modified_ = base::Time::Now();
1033
1034   scoped_ptr<int> result(new int());
1035   Closure task = base::Bind(&SimpleSynchronousEntry::WriteSparseData,
1036                             base::Unretained(synchronous_entry_),
1037                             SimpleSynchronousEntry::EntryOperationData(
1038                                 sparse_offset, buf_len),
1039                             make_scoped_refptr(buf),
1040                             max_sparse_data_size,
1041                             entry_stat.get(),
1042                             result.get());
1043   Closure reply = base::Bind(&SimpleEntryImpl::WriteSparseOperationComplete,
1044                              this,
1045                              callback,
1046                              base::Passed(&entry_stat),
1047                              base::Passed(&result));
1048   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
1049 }
1050
1051 void SimpleEntryImpl::GetAvailableRangeInternal(
1052     int64 sparse_offset,
1053     int len,
1054     int64* out_start,
1055     const CompletionCallback& callback) {
1056   DCHECK(io_thread_checker_.CalledOnValidThread());
1057   ScopedOperationRunner operation_runner(this);
1058
1059   DCHECK_EQ(STATE_READY, state_);
1060   state_ = STATE_IO_PENDING;
1061
1062   scoped_ptr<int> result(new int());
1063   Closure task = base::Bind(&SimpleSynchronousEntry::GetAvailableRange,
1064                             base::Unretained(synchronous_entry_),
1065                             SimpleSynchronousEntry::EntryOperationData(
1066                                 sparse_offset, len),
1067                             out_start,
1068                             result.get());
1069   Closure reply = base::Bind(
1070       &SimpleEntryImpl::GetAvailableRangeOperationComplete,
1071       this,
1072       callback,
1073       base::Passed(&result));
1074   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
1075 }
1076
1077 void SimpleEntryImpl::DoomEntryInternal(const CompletionCallback& callback) {
1078   PostTaskAndReplyWithResult(
1079       worker_pool_, FROM_HERE,
1080       base::Bind(&SimpleSynchronousEntry::DoomEntry, path_, entry_hash_),
1081       base::Bind(&SimpleEntryImpl::DoomOperationComplete, this, callback,
1082                  state_));
1083   state_ = STATE_IO_PENDING;
1084 }
1085
1086 void SimpleEntryImpl::CreationOperationComplete(
1087     const CompletionCallback& completion_callback,
1088     const base::TimeTicks& start_time,
1089     scoped_ptr<SimpleEntryCreationResults> in_results,
1090     Entry** out_entry,
1091     net::NetLog::EventType end_event_type) {
1092   DCHECK(io_thread_checker_.CalledOnValidThread());
1093   DCHECK_EQ(state_, STATE_IO_PENDING);
1094   DCHECK(in_results);
1095   ScopedOperationRunner operation_runner(this);
1096   SIMPLE_CACHE_UMA(BOOLEAN,
1097                    "EntryCreationResult", cache_type_,
1098                    in_results->result == net::OK);
1099   if (in_results->result != net::OK) {
1100     if (in_results->result != net::ERR_FILE_EXISTS)
1101       MarkAsDoomed();
1102
1103     net_log_.AddEventWithNetErrorCode(end_event_type, net::ERR_FAILED);
1104     PostClientCallback(completion_callback, net::ERR_FAILED);
1105     MakeUninitialized();
1106     return;
1107   }
1108   // If out_entry is NULL, it means we already called ReturnEntryToCaller from
1109   // the optimistic Create case.
1110   if (out_entry)
1111     ReturnEntryToCaller(out_entry);
1112
1113   state_ = STATE_READY;
1114   synchronous_entry_ = in_results->sync_entry;
1115   if (in_results->stream_0_data) {
1116     stream_0_data_ = in_results->stream_0_data;
1117     // The crc was read in SimpleSynchronousEntry.
1118     crc_check_state_[0] = CRC_CHECK_DONE;
1119     crc32s_[0] = in_results->stream_0_crc32;
1120     crc32s_end_offset_[0] = in_results->entry_stat.data_size(0);
1121   }
1122   if (key_.empty()) {
1123     SetKey(synchronous_entry_->key());
1124   } else {
1125     // This should only be triggered when creating an entry. The key check in
1126     // the open case is handled in SimpleBackendImpl.
1127     DCHECK_EQ(key_, synchronous_entry_->key());
1128   }
1129   UpdateDataFromEntryStat(in_results->entry_stat);
1130   SIMPLE_CACHE_UMA(TIMES,
1131                    "EntryCreationTime", cache_type_,
1132                    (base::TimeTicks::Now() - start_time));
1133   AdjustOpenEntryCountBy(cache_type_, 1);
1134
1135   net_log_.AddEvent(end_event_type);
1136   PostClientCallback(completion_callback, net::OK);
1137 }
1138
1139 void SimpleEntryImpl::EntryOperationComplete(
1140     const CompletionCallback& completion_callback,
1141     const SimpleEntryStat& entry_stat,
1142     scoped_ptr<int> result) {
1143   DCHECK(io_thread_checker_.CalledOnValidThread());
1144   DCHECK(synchronous_entry_);
1145   DCHECK_EQ(STATE_IO_PENDING, state_);
1146   DCHECK(result);
1147   if (*result < 0) {
1148     state_ = STATE_FAILURE;
1149     MarkAsDoomed();
1150   } else {
1151     state_ = STATE_READY;
1152     UpdateDataFromEntryStat(entry_stat);
1153   }
1154
1155   if (!completion_callback.is_null()) {
1156     MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
1157         completion_callback, *result));
1158   }
1159   RunNextOperationIfNeeded();
1160 }
1161
1162 void SimpleEntryImpl::ReadOperationComplete(
1163     int stream_index,
1164     int offset,
1165     const CompletionCallback& completion_callback,
1166     scoped_ptr<uint32> read_crc32,
1167     scoped_ptr<SimpleEntryStat> entry_stat,
1168     scoped_ptr<int> result) {
1169   DCHECK(io_thread_checker_.CalledOnValidThread());
1170   DCHECK(synchronous_entry_);
1171   DCHECK_EQ(STATE_IO_PENDING, state_);
1172   DCHECK(read_crc32);
1173   DCHECK(result);
1174
1175   if (*result > 0 &&
1176       crc_check_state_[stream_index] == CRC_CHECK_NEVER_READ_AT_ALL) {
1177     crc_check_state_[stream_index] = CRC_CHECK_NEVER_READ_TO_END;
1178   }
1179
1180   if (*result > 0 && crc32s_end_offset_[stream_index] == offset) {
1181     uint32 current_crc = offset == 0 ? crc32(0, Z_NULL, 0)
1182                                      : crc32s_[stream_index];
1183     crc32s_[stream_index] = crc32_combine(current_crc, *read_crc32, *result);
1184     crc32s_end_offset_[stream_index] += *result;
1185     if (!have_written_[stream_index] &&
1186         GetDataSize(stream_index) == crc32s_end_offset_[stream_index]) {
1187       // We have just read a file from start to finish, and so we have
1188       // computed a crc of the entire file. We can check it now. If a cache
1189       // entry has a single reader, the normal pattern is to read from start
1190       // to finish.
1191
1192       // Other cases are possible. In the case of two readers on the same
1193       // entry, one reader can be behind the other. In this case we compute
1194       // the crc as the most advanced reader progresses, and check it for
1195       // both readers as they read the last byte.
1196
1197       net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CHECKSUM_BEGIN);
1198
1199       scoped_ptr<int> new_result(new int());
1200       Closure task = base::Bind(&SimpleSynchronousEntry::CheckEOFRecord,
1201                                 base::Unretained(synchronous_entry_),
1202                                 stream_index,
1203                                 *entry_stat,
1204                                 crc32s_[stream_index],
1205                                 new_result.get());
1206       Closure reply = base::Bind(&SimpleEntryImpl::ChecksumOperationComplete,
1207                                  this, *result, stream_index,
1208                                  completion_callback,
1209                                  base::Passed(&new_result));
1210       worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
1211       crc_check_state_[stream_index] = CRC_CHECK_DONE;
1212       return;
1213     }
1214   }
1215
1216   if (*result < 0) {
1217     crc32s_end_offset_[stream_index] = 0;
1218   }
1219
1220   if (*result < 0) {
1221     RecordReadResult(cache_type_, READ_RESULT_SYNC_READ_FAILURE);
1222   } else {
1223     RecordReadResult(cache_type_, READ_RESULT_SUCCESS);
1224     if (crc_check_state_[stream_index] == CRC_CHECK_NEVER_READ_TO_END &&
1225         offset + *result == GetDataSize(stream_index)) {
1226       crc_check_state_[stream_index] = CRC_CHECK_NOT_DONE;
1227     }
1228   }
1229   if (net_log_.IsLogging()) {
1230     net_log_.AddEvent(
1231         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
1232         CreateNetLogReadWriteCompleteCallback(*result));
1233   }
1234
1235   EntryOperationComplete(completion_callback, *entry_stat, result.Pass());
1236 }
1237
1238 void SimpleEntryImpl::WriteOperationComplete(
1239     int stream_index,
1240     const CompletionCallback& completion_callback,
1241     scoped_ptr<SimpleEntryStat> entry_stat,
1242     scoped_ptr<int> result) {
1243   if (*result >= 0)
1244     RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
1245   else
1246     RecordWriteResult(cache_type_, WRITE_RESULT_SYNC_WRITE_FAILURE);
1247   if (net_log_.IsLogging()) {
1248     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
1249         CreateNetLogReadWriteCompleteCallback(*result));
1250   }
1251
1252   if (*result < 0) {
1253     crc32s_end_offset_[stream_index] = 0;
1254   }
1255
1256   EntryOperationComplete(completion_callback, *entry_stat, result.Pass());
1257 }
1258
1259 void SimpleEntryImpl::ReadSparseOperationComplete(
1260     const CompletionCallback& completion_callback,
1261     scoped_ptr<base::Time> last_used,
1262     scoped_ptr<int> result) {
1263   DCHECK(io_thread_checker_.CalledOnValidThread());
1264   DCHECK(synchronous_entry_);
1265   DCHECK(result);
1266
1267   SimpleEntryStat entry_stat(*last_used, last_modified_, data_size_,
1268                              sparse_data_size_);
1269   EntryOperationComplete(completion_callback, entry_stat, result.Pass());
1270 }
1271
1272 void SimpleEntryImpl::WriteSparseOperationComplete(
1273     const CompletionCallback& completion_callback,
1274     scoped_ptr<SimpleEntryStat> entry_stat,
1275     scoped_ptr<int> result) {
1276   DCHECK(io_thread_checker_.CalledOnValidThread());
1277   DCHECK(synchronous_entry_);
1278   DCHECK(result);
1279
1280   EntryOperationComplete(completion_callback, *entry_stat, result.Pass());
1281 }
1282
1283 void SimpleEntryImpl::GetAvailableRangeOperationComplete(
1284     const CompletionCallback& completion_callback,
1285     scoped_ptr<int> result) {
1286   DCHECK(io_thread_checker_.CalledOnValidThread());
1287   DCHECK(synchronous_entry_);
1288   DCHECK(result);
1289
1290   SimpleEntryStat entry_stat(last_used_, last_modified_, data_size_,
1291                              sparse_data_size_);
1292   EntryOperationComplete(completion_callback, entry_stat, result.Pass());
1293 }
1294
1295 void SimpleEntryImpl::DoomOperationComplete(
1296     const CompletionCallback& callback,
1297     State state_to_restore,
1298     int result) {
1299   state_ = state_to_restore;
1300   if (!callback.is_null())
1301     callback.Run(result);
1302   RunNextOperationIfNeeded();
1303   if (backend_)
1304     backend_->OnDoomComplete(entry_hash_);
1305 }
1306
1307 void SimpleEntryImpl::ChecksumOperationComplete(
1308     int orig_result,
1309     int stream_index,
1310     const CompletionCallback& completion_callback,
1311     scoped_ptr<int> result) {
1312   DCHECK(io_thread_checker_.CalledOnValidThread());
1313   DCHECK(synchronous_entry_);
1314   DCHECK_EQ(STATE_IO_PENDING, state_);
1315   DCHECK(result);
1316
1317   if (net_log_.IsLogging()) {
1318     net_log_.AddEventWithNetErrorCode(
1319         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CHECKSUM_END,
1320         *result);
1321   }
1322
1323   if (*result == net::OK) {
1324     *result = orig_result;
1325     if (orig_result >= 0)
1326       RecordReadResult(cache_type_, READ_RESULT_SUCCESS);
1327     else
1328       RecordReadResult(cache_type_, READ_RESULT_SYNC_READ_FAILURE);
1329   } else {
1330     RecordReadResult(cache_type_, READ_RESULT_SYNC_CHECKSUM_FAILURE);
1331   }
1332   if (net_log_.IsLogging()) {
1333     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
1334         CreateNetLogReadWriteCompleteCallback(*result));
1335   }
1336
1337   SimpleEntryStat entry_stat(last_used_, last_modified_, data_size_,
1338                              sparse_data_size_);
1339   EntryOperationComplete(completion_callback, entry_stat, result.Pass());
1340 }
1341
1342 void SimpleEntryImpl::CloseOperationComplete() {
1343   DCHECK(!synchronous_entry_);
1344   DCHECK_EQ(0, open_count_);
1345   DCHECK(STATE_IO_PENDING == state_ || STATE_FAILURE == state_ ||
1346          STATE_UNINITIALIZED == state_);
1347   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CLOSE_END);
1348   AdjustOpenEntryCountBy(cache_type_, -1);
1349   MakeUninitialized();
1350   RunNextOperationIfNeeded();
1351 }
1352
1353 void SimpleEntryImpl::UpdateDataFromEntryStat(
1354     const SimpleEntryStat& entry_stat) {
1355   DCHECK(io_thread_checker_.CalledOnValidThread());
1356   DCHECK(synchronous_entry_);
1357   DCHECK_EQ(STATE_READY, state_);
1358
1359   last_used_ = entry_stat.last_used();
1360   last_modified_ = entry_stat.last_modified();
1361   for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
1362     data_size_[i] = entry_stat.data_size(i);
1363   }
1364   sparse_data_size_ = entry_stat.sparse_data_size();
1365   if (!doomed_ && backend_.get())
1366     backend_->index()->UpdateEntrySize(entry_hash_, GetDiskUsage());
1367 }
1368
1369 int64 SimpleEntryImpl::GetDiskUsage() const {
1370   int64 file_size = 0;
1371   for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
1372     file_size +=
1373         simple_util::GetFileSizeFromKeyAndDataSize(key_, data_size_[i]);
1374   }
1375   file_size += sparse_data_size_;
1376   return file_size;
1377 }
1378
1379 void SimpleEntryImpl::RecordReadIsParallelizable(
1380     const SimpleEntryOperation& operation) const {
1381   if (!executing_operation_)
1382     return;
1383   // Used in histograms, please only add entries at the end.
1384   enum ReadDependencyType {
1385     // READ_STANDALONE = 0, Deprecated.
1386     READ_FOLLOWS_READ = 1,
1387     READ_FOLLOWS_CONFLICTING_WRITE = 2,
1388     READ_FOLLOWS_NON_CONFLICTING_WRITE = 3,
1389     READ_FOLLOWS_OTHER = 4,
1390     READ_ALONE_IN_QUEUE = 5,
1391     READ_DEPENDENCY_TYPE_MAX = 6,
1392   };
1393
1394   ReadDependencyType type = READ_FOLLOWS_OTHER;
1395   if (operation.alone_in_queue()) {
1396     type = READ_ALONE_IN_QUEUE;
1397   } else if (executing_operation_->type() == SimpleEntryOperation::TYPE_READ) {
1398     type = READ_FOLLOWS_READ;
1399   } else if (executing_operation_->type() == SimpleEntryOperation::TYPE_WRITE) {
1400     if (executing_operation_->ConflictsWith(operation))
1401       type = READ_FOLLOWS_CONFLICTING_WRITE;
1402     else
1403       type = READ_FOLLOWS_NON_CONFLICTING_WRITE;
1404   }
1405   SIMPLE_CACHE_UMA(ENUMERATION,
1406                    "ReadIsParallelizable", cache_type_,
1407                    type, READ_DEPENDENCY_TYPE_MAX);
1408 }
1409
1410 void SimpleEntryImpl::RecordWriteDependencyType(
1411     const SimpleEntryOperation& operation) const {
1412   if (!executing_operation_)
1413     return;
1414   // Used in histograms, please only add entries at the end.
1415   enum WriteDependencyType {
1416     WRITE_OPTIMISTIC = 0,
1417     WRITE_FOLLOWS_CONFLICTING_OPTIMISTIC = 1,
1418     WRITE_FOLLOWS_NON_CONFLICTING_OPTIMISTIC = 2,
1419     WRITE_FOLLOWS_CONFLICTING_WRITE = 3,
1420     WRITE_FOLLOWS_NON_CONFLICTING_WRITE = 4,
1421     WRITE_FOLLOWS_CONFLICTING_READ = 5,
1422     WRITE_FOLLOWS_NON_CONFLICTING_READ = 6,
1423     WRITE_FOLLOWS_OTHER = 7,
1424     WRITE_DEPENDENCY_TYPE_MAX = 8,
1425   };
1426
1427   WriteDependencyType type = WRITE_FOLLOWS_OTHER;
1428   if (operation.optimistic()) {
1429     type = WRITE_OPTIMISTIC;
1430   } else if (executing_operation_->type() == SimpleEntryOperation::TYPE_READ ||
1431              executing_operation_->type() == SimpleEntryOperation::TYPE_WRITE) {
1432     bool conflicting = executing_operation_->ConflictsWith(operation);
1433
1434     if (executing_operation_->type() == SimpleEntryOperation::TYPE_READ) {
1435       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_READ
1436                          : WRITE_FOLLOWS_NON_CONFLICTING_READ;
1437     } else if (executing_operation_->optimistic()) {
1438       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_OPTIMISTIC
1439                          : WRITE_FOLLOWS_NON_CONFLICTING_OPTIMISTIC;
1440     } else {
1441       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_WRITE
1442                          : WRITE_FOLLOWS_NON_CONFLICTING_WRITE;
1443     }
1444   }
1445   SIMPLE_CACHE_UMA(ENUMERATION,
1446                    "WriteDependencyType", cache_type_,
1447                    type, WRITE_DEPENDENCY_TYPE_MAX);
1448 }
1449
1450 int SimpleEntryImpl::ReadStream0Data(net::IOBuffer* buf,
1451                                      int offset,
1452                                      int buf_len) {
1453   if (buf_len < 0) {
1454     RecordReadResult(cache_type_, READ_RESULT_SYNC_READ_FAILURE);
1455     return 0;
1456   }
1457   memcpy(buf->data(), stream_0_data_->data() + offset, buf_len);
1458   UpdateDataFromEntryStat(
1459       SimpleEntryStat(base::Time::Now(), last_modified_, data_size_,
1460                       sparse_data_size_));
1461   RecordReadResult(cache_type_, READ_RESULT_SUCCESS);
1462   return buf_len;
1463 }
1464
1465 int SimpleEntryImpl::SetStream0Data(net::IOBuffer* buf,
1466                                     int offset,
1467                                     int buf_len,
1468                                     bool truncate) {
1469   // Currently, stream 0 is only used for HTTP headers, and always writes them
1470   // with a single, truncating write. Detect these writes and record the size
1471   // changes of the headers. Also, support writes to stream 0 that have
1472   // different access patterns, as required by the API contract.
1473   // All other clients of the Simple Cache are encouraged to use stream 1.
1474   have_written_[0] = true;
1475   int data_size = GetDataSize(0);
1476   if (offset == 0 && truncate) {
1477     RecordHeaderSizeChange(cache_type_, data_size, buf_len);
1478     stream_0_data_->SetCapacity(buf_len);
1479     memcpy(stream_0_data_->data(), buf->data(), buf_len);
1480     data_size_[0] = buf_len;
1481   } else {
1482     RecordUnexpectedStream0Write(cache_type_);
1483     const int buffer_size =
1484         truncate ? offset + buf_len : std::max(offset + buf_len, data_size);
1485     stream_0_data_->SetCapacity(buffer_size);
1486     // If |stream_0_data_| was extended, the extension until offset needs to be
1487     // zero-filled.
1488     const int fill_size = offset <= data_size ? 0 : offset - data_size;
1489     if (fill_size > 0)
1490       memset(stream_0_data_->data() + data_size, 0, fill_size);
1491     if (buf)
1492       memcpy(stream_0_data_->data() + offset, buf->data(), buf_len);
1493     data_size_[0] = buffer_size;
1494   }
1495   base::Time modification_time = base::Time::Now();
1496   AdvanceCrc(buf, offset, buf_len, 0);
1497   UpdateDataFromEntryStat(
1498       SimpleEntryStat(modification_time, modification_time, data_size_,
1499                       sparse_data_size_));
1500   RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
1501   return buf_len;
1502 }
1503
1504 void SimpleEntryImpl::AdvanceCrc(net::IOBuffer* buffer,
1505                                  int offset,
1506                                  int length,
1507                                  int stream_index) {
1508   // It is easy to incrementally compute the CRC from [0 .. |offset + buf_len|)
1509   // if |offset == 0| or we have already computed the CRC for [0 .. offset).
1510   // We rely on most write operations being sequential, start to end to compute
1511   // the crc of the data. When we write to an entry and close without having
1512   // done a sequential write, we don't check the CRC on read.
1513   if (offset == 0 || crc32s_end_offset_[stream_index] == offset) {
1514     uint32 initial_crc =
1515         (offset != 0) ? crc32s_[stream_index] : crc32(0, Z_NULL, 0);
1516     if (length > 0) {
1517       crc32s_[stream_index] = crc32(
1518           initial_crc, reinterpret_cast<const Bytef*>(buffer->data()), length);
1519     }
1520     crc32s_end_offset_[stream_index] = offset + length;
1521   } else if (offset < crc32s_end_offset_[stream_index]) {
1522     // If a range for which the crc32 was already computed is rewritten, the
1523     // computation of the crc32 need to start from 0 again.
1524     crc32s_end_offset_[stream_index] = 0;
1525   }
1526 }
1527
1528 }  // namespace disk_cache