Track entries pending Doom in SimpleCache backend.

net/disk_cache/simple/simple_entry_impl.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/disk_cache/simple/simple_entry_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <vector>
 
@@ skipping 143 matching lines @@
                                  net::NetLog* net_log)
     : backend_(backend->AsWeakPtr()),
       cache_type_(cache_type),
       worker_pool_(backend->worker_pool()),
       path_(path),
       entry_hash_(entry_hash),
       use_optimistic_operations_(operations_mode == OPTIMISTIC_OPERATIONS),
       last_used_(Time::Now()),
       last_modified_(last_used_),
       open_count_(0),
+      doomed_(false),
       state_(STATE_UNINITIALIZED),
       synchronous_entry_(NULL),
       net_log_(net::BoundNetLog::Make(
           net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY)) {
   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc32s_end_offset_),
                  arrays_should_be_same_size);
   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc32s_),
                  arrays_should_be_same_size);
   COMPILE_ASSERT(arraysize(data_size_) == arraysize(have_written_),
                  arrays_should_be_same_size);
@@ skipping 344 matching lines @@
   DCHECK(out_entry);
   ++open_count_;
   AddRef();  // Balanced in Close()
   *out_entry = this;
 }
 
 void SimpleEntryImpl::RemoveSelfFromBackend() {
   if (!backend_.get())
     return;
   backend_->OnDeactivated(this);
-  backend_.reset();
 }
 
 void SimpleEntryImpl::MarkAsDoomed() {
   if (!backend_.get())
     return;
+  doomed_ = true;
   backend_->index()->Remove(entry_hash_);
   RemoveSelfFromBackend();
 }
 
 void SimpleEntryImpl::RunNextOperationIfNeeded() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   SIMPLE_CACHE_UMA(CUSTOM_COUNTS,
                    "EntryOperationsPending", cache_type_,
                    pending_operations_.size(), 0, 100, 20);
   if (!pending_operations_.empty() && state_ != STATE_IO_PENDING) {
@@ skipping 230 matching lines @@
     // STATE_IO_PENDING.
     if (!callback.is_null())
       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
           callback, 0));
     return;
   }
 
   buf_len = std::min(buf_len, GetDataSize(stream_index) - offset);
 
   state_ = STATE_IO_PENDING;
-  if (backend_.get())
+  if (!doomed_ && backend_.get())
     backend_->index()->UseIfExists(entry_hash_);
 
   scoped_ptr<uint32> read_crc32(new uint32());
   scoped_ptr<int> result(new int());
   scoped_ptr<base::Time> last_used(new base::Time());
   Closure task = base::Bind(
       &SimpleSynchronousEntry::ReadData,
       base::Unretained(synchronous_entry_),
       SimpleSynchronousEntry::EntryOperationData(stream_index, offset, buf_len),
       make_scoped_refptr(buf),
@@ skipping 39 matching lines @@
       // callback directly.
       MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
           callback, net::ERR_FAILED));
     }
     // |this| may be destroyed after return here.
     return;
   }
 
   DCHECK_EQ(STATE_READY, state_);
   state_ = STATE_IO_PENDING;
-  if (backend_.get())
+  if (!doomed_ && backend_.get())
     backend_->index()->UseIfExists(entry_hash_);
   // It is easy to incrementally compute the CRC from [0 .. |offset + buf_len|)
   // if |offset == 0| or we have already computed the CRC for [0 .. offset).
   // We rely on most write operations being sequential, start to end to compute
   // the crc of the data. When we write to an entry and close without having
   // done a sequential write, we don't check the CRC on read.
   if (offset == 0 || crc32s_end_offset_[stream_index] == offset) {
     uint32 initial_crc = (offset != 0) ? crc32s_[stream_index]
                                        : crc32(0, Z_NULL, 0);
     if (buf_len > 0) {
@@ skipping 31 matching lines @@
   Closure reply = base::Bind(&SimpleEntryImpl::WriteOperationComplete,
                              this,
                              stream_index,
                              callback,
                              base::Passed(&entry_stat),
                              base::Passed(&result));
   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 }
 
 void SimpleEntryImpl::DoomEntryInternal(const CompletionCallback& callback) {
+  if (backend_)
+    backend_->OnDoomStart(entry_hash_);
   PostTaskAndReplyWithResult(
       worker_pool_, FROM_HERE,
       base::Bind(&SimpleSynchronousEntry::DoomEntry, path_, key_, entry_hash_),
       base::Bind(&SimpleEntryImpl::DoomOperationComplete, this, callback,
                  state_));
   state_ = STATE_IO_PENDING;
 }
 
 void SimpleEntryImpl::CreationOperationComplete(
     const CompletionCallback& completion_callback,
@@ skipping 160 matching lines @@
     RecordWriteResult(cache_type_, WRITE_RESULT_SYNC_WRITE_FAILURE);
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
         CreateNetLogReadWriteCompleteCallback(*result));
   }
 
   EntryOperationComplete(
       stream_index, completion_callback, *entry_stat, result.Pass());
 }
 
-void SimpleEntryImpl::DoomOperationComplete(const CompletionCallback& callback,
-                                            State state_to_restore,
-                                            int result) {
+void SimpleEntryImpl::DoomOperationComplete(
+    const CompletionCallback& callback,
+    State state_to_restore,
+    int result) {
   state_ = state_to_restore;
   if (!callback.is_null())
     callback.Run(result);
   RunNextOperationIfNeeded();
+  if (backend_)
+    backend_->OnDoomComplete(entry_hash_);
 }
 
 void SimpleEntryImpl::ChecksumOperationComplete(
     int orig_result,
     int stream_index,
     const CompletionCallback& completion_callback,
     scoped_ptr<int> result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK_EQ(STATE_IO_PENDING, state_);
@@ skipping 41 matching lines @@
     const SimpleEntryStat& entry_stat) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK_EQ(STATE_READY, state_);
 
   last_used_ = entry_stat.last_used;
   last_modified_ = entry_stat.last_modified;
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     data_size_[i] = entry_stat.data_size[i];
   }
-  if (backend_.get())
+  if (!doomed_ && backend_.get())
     backend_->index()->UpdateEntrySize(entry_hash_, GetDiskUsage());
 }
 
 int64 SimpleEntryImpl::GetDiskUsage() const {
   int64 file_size = 0;
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     file_size +=
         simple_util::GetFileSizeFromKeyAndDataSize(key_, data_size_[i]);
   }
   return file_size;
@@ skipping 64 matching lines @@
       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_WRITE
                          : WRITE_FOLLOWS_NON_CONFLICTING_WRITE;
     }
   }
   SIMPLE_CACHE_UMA(ENUMERATION,
                    "WriteDependencyType", cache_type_,
                    type, WRITE_DEPENDENCY_TYPE_MAX);
 }
 
 }  // namespace disk_cache