Connect SimpleCache Backend active_entries_ more closely to Entry lifetime.

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 @@
   }
 
   ~ScopedOperationRunner() {
     entry_->RunNextOperationIfNeeded();
   }
 
  private:
   SimpleEntryImpl* const entry_;
 };
 
+SimpleEntryImpl::ActiveEntryProxy::~ActiveEntryProxy() {}
+
 SimpleEntryImpl::SimpleEntryImpl(net::CacheType cache_type,
                                  const FilePath& path,
                                  const uint64 entry_hash,
                                  OperationsMode operations_mode,
                                  SimpleBackendImpl* backend,
                                  net::NetLog* net_log)
     : backend_(backend->AsWeakPtr()),
       cache_type_(cache_type),
       worker_pool_(backend->worker_pool()),
       path_(path),
@@ skipping 15 matching lines @@
                  arrays_should_be_same_size);
   COMPILE_ASSERT(arraysize(data_size_) == arraysize(have_written_),
                  arrays_should_be_same_size);
   COMPILE_ASSERT(arraysize(data_size_) == arraysize(crc_check_state_),
                  arrays_should_be_same_size);
   MakeUninitialized();
   net_log_.BeginEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY,
       CreateNetLogSimpleEntryConstructionCallback(this));
 }
 
+void SimpleEntryImpl::SetActiveEntryProxy(
+    scoped_ptr<ActiveEntryProxy> active_entry_proxy) {
+  DCHECK(!active_entry_proxy_);
+  active_entry_proxy_.reset(active_entry_proxy.release());
+}
+
 int SimpleEntryImpl::OpenEntry(Entry** out_entry,
                                const CompletionCallback& callback) {
   DCHECK(backend_.get());
 
   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_CALL);
 
   bool have_index = backend_->index()->initialized();
   // This enumeration is used in histograms, add entries only at end.
   enum OpenEntryIndexEnum {
     INDEX_NOEXIST = 0,
@@ skipping 310 matching lines @@
   // entry, so there's no need to coordinate which object is performing sparse
   // I/O.  Therefore, CancelSparseIO and ReadyForSparseIO succeed instantly.
   return net::OK;
 }
 
 SimpleEntryImpl::~SimpleEntryImpl() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0U, pending_operations_.size());
   DCHECK(state_ == STATE_UNINITIALIZED || state_ == STATE_FAILURE);
   DCHECK(!synchronous_entry_);
-  RemoveSelfFromBackend();
   net_log_.EndEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY);
 }
 
 void SimpleEntryImpl::PostClientCallback(const CompletionCallback& callback,
                                          int result) {
   if (callback.is_null())
     return;
   // Note that the callback is posted rather than directly invoked to avoid
   // reentrancy issues.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 21 matching lines @@
     // If the backend no longer exists, the callback won't be invoked, and so we
     // must close ourselves to avoid leaking. As well, there's no guarantee the
     // client-provided pointer (|out_entry|) hasn't been freed, and no point
     // dereferencing it, either.
     Close();
     return;
   }
   *out_entry = this;
 }
 
-void SimpleEntryImpl::RemoveSelfFromBackend() {
-  if (!backend_.get())
-    return;
-  backend_->OnDeactivated(this);
-}
-
 void SimpleEntryImpl::MarkAsDoomed() {
   doomed_ = true;
   if (!backend_.get())
     return;
   backend_->index()->Remove(entry_hash_);
-  RemoveSelfFromBackend();
+  active_entry_proxy_.reset();
 }
 
 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) {
     scoped_ptr<SimpleEntryOperation> operation(
         new SimpleEntryOperation(pending_operations_.front()));
@@ skipping 929 matching lines @@
     }
     crc32s_end_offset_[stream_index] = offset + length;
   } else if (offset < crc32s_end_offset_[stream_index]) {
     // If a range for which the crc32 was already computed is rewritten, the
     // computation of the crc32 need to start from 0 again.
     crc32s_end_offset_[stream_index] = 0;
   }
 }
 
 }  // namespace disk_cache