Use RevocableStore to isolate the http cache from its transactions....

net/http/http_cache.cc

 // Copyright (c) 2006-2008 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/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 142 matching lines @@
       doomed(false) {
 }
 
 HttpCache::ActiveEntry::~ActiveEntry() {
   if (disk_entry)
     disk_entry->Close();
 }
 
 //-----------------------------------------------------------------------------
 
-class HttpCache::Transaction : public HttpTransaction {
+class HttpCache::Transaction
+    : public HttpTransaction, public RevocableStore::Revocable {
  public:
   explicit Transaction(HttpCache* cache)
-      : request_(NULL),
+      : RevocableStore::Revocable(&cache->transactions_),
+        request_(NULL),
         cache_(cache),
         entry_(NULL),
         network_trans_(NULL),
         callback_(NULL),
         mode_(NONE),
         read_offset_(0),
         effective_load_flags_(0),
         final_upload_progress_(0),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_info_callback_(this, &Transaction::OnNetworkInfoAvailable)),
@@ skipping 134 matching lines @@
   scoped_refptr<IOBuffer> read_buf_;
   int read_offset_;
   int effective_load_flags_;
   uint64 final_upload_progress_;
   CompletionCallbackImpl<Transaction> network_info_callback_;
   CompletionCallbackImpl<Transaction> network_read_callback_;
   scoped_refptr<CancelableCompletionCallback<Transaction> > cache_read_callback_;
 };
 
 HttpCache::Transaction::~Transaction() {
-  if (entry_) {
-    cache_->DoneWithEntry(entry_, this);
-  } else {
-    cache_->RemovePendingTransaction(this);
+  if (!revoked()) {
+    if (entry_) {
+      cache_->DoneWithEntry(entry_, this);
+    } else {
+      cache_->RemovePendingTransaction(this);
+    }
   }
 
   // If there is an outstanding callback, mark it as cancelled so running it
   // does nothing.
   cache_read_callback_->Cancel();
 
   // We could still have a cache read in progress, so we just null the cache_
   // pointer to signal that we are dead.  See OnCacheReadCompleted.
   cache_ = NULL;
 }
 
 int HttpCache::Transaction::Start(const HttpRequestInfo* request,
                                   CompletionCallback* callback) {
   DCHECK(request);
   DCHECK(callback);
 
   // ensure that we only have one asynchronous call at a time.
   DCHECK(!callback_);
 
+  if (revoked())
+    return ERR_FAILED;
+
   SetRequest(request);
 
   int rv;
 
   if (ShouldPassThrough()) {
     // if must use cache, then we must fail.  this can happen for back/forward
     // navigations to a page generated via a form post.
     if (effective_load_flags_ & LOAD_ONLY_FROM_CACHE)
       return ERR_CACHE_MISS;
 
@@ skipping 124 matching lines @@
 
 uint64 HttpCache::Transaction::GetUploadProgress() const {
   if (network_trans_.get())
     return network_trans_->GetUploadProgress();
   return final_upload_progress_;
 }
 
 int HttpCache::Transaction::AddToEntry() {
   ActiveEntry* entry = NULL;
 
+  if (revoked())
+    return ERR_FAILED;
+
   if (mode_ == WRITE) {
     cache_->DoomEntry(cache_key_);
   } else {
     entry = cache_->FindActiveEntry(cache_key_);
     if (!entry) {
       entry = cache_->OpenEntry(cache_key_);
       if (!entry) {
         if (mode_ & WRITE) {
           mode_ = WRITE;
         } else {
@@ skipping 337 matching lines @@
                << " status: " << response_.headers->response_code();
 
   cache_->DoneWritingToEntry(entry_, success);
   entry_ = NULL;
   mode_ = NONE;  // switch to 'pass through' mode
 }
 
 void HttpCache::Transaction::OnNetworkInfoAvailable(int result) {
   DCHECK(result != ERR_IO_PENDING);
 
+  if (revoked())
+    return;
+
   if (result == OK) {
     const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
     if (new_response->headers->response_code() == 401 ||
         new_response->headers->response_code() == 407) {
       auth_response_ = *new_response;
     } else {
       // Are we expecting a response to a conditional query?
       if (mode_ == READ_WRITE) {
         if (new_response->headers->response_code() == 304) {
           // Update cached response based on headers in new_response
@@ skipping 517 matching lines @@
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net