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