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 873 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_));
+      base::Bind(&SimpleEntryImpl::DoomOperationComplete,
+                 this, backend_, callback, state_));
   state_ = STATE_IO_PENDING;
 }
 
 void SimpleEntryImpl::CreationOperationComplete(
     const CompletionCallback& completion_callback,
     const base::TimeTicks& start_time,
     scoped_ptr<SimpleEntryCreationResults> in_results,
     Entry** out_entry,
     net::NetLog::EventType end_event_type) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
@@ skipping 153 matching lines @@
     RecordWriteResult(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 base::WeakPtr<SimpleBackendImpl>& backend,
+    const CompletionCallback& callback,
+    State state_to_restore,
+    int result) {
   state_ = state_to_restore;
+  if (backend)
+    backend->OnDoomComplete(entry_hash_);
   if (!callback.is_null())
     callback.Run(result);
   RunNextOperationIfNeeded();
 }
 
 void SimpleEntryImpl::ChecksumOperationComplete(
     int orig_result,
     int stream_index,
     const CompletionCallback& completion_callback,
     scoped_ptr<int> result) {
@@ skipping 127 matching lines @@
     } else {
       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_WRITE
                          : WRITE_FOLLOWS_NON_CONFLICTING_WRITE;
     }
   }
   UMA_HISTOGRAM_ENUMERATION(
       "SimpleCache.WriteDependencyType", type, WRITE_DEPENDENCY_TYPE_MAX);
 }
 
 }  // namespace disk_cache