Http cache: Make sure that we remove pending transactions...

net/http/http_cache.cc

 // Copyright (c) 2006-2009 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 <string>
 
 #include "base/compiler_specific.h"
@@ skipping 961 matching lines @@
     }
   }
 
   return ValidateEntryHeadersAndContinue(byte_range_requested);
 }
 
 int HttpCache::Transaction::ValidateEntryHeadersAndContinue(
     bool byte_range_requested) {
   DCHECK(mode_ == READ_WRITE);
 
+  if (!cache_)
+    return HandleResult(ERR_UNEXPECTED);
+
   if (!partial_->UpdateFromStoredHeaders(response_.headers, entry_->disk_entry,
                                          truncated_)) {
     // The stored data cannot be used. Get rid of it and restart this request.
     // We need to also reset the |truncated_| flag as a new entry is created.
     DoomPartialEntry(!byte_range_requested);
     mode_ = WRITE;
     truncated_ = false;
     return AddToEntry();
   }
 
@@ skipping 1045 matching lines @@
   Transaction* trans = entry->writer;
 
   entry->writer = NULL;
   entry->readers.push_back(trans);
 
   ProcessPendingQueue(entry);
 }
 
 void HttpCache::RemovePendingTransaction(Transaction* trans) {
   ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key());
-  if (i == active_entries_.end())
+  bool found = false;
+  if (i != active_entries_.end())
+    found = RemovePendingTransactionFromEntry(i->second, trans);
+
+  if (found)
     return;
 
-  TransactionList& pending_queue = i->second->pending_queue;
+  ActiveEntriesSet::iterator it = doomed_entries_.begin();
+  for (; it != doomed_entries_.end() && !found; ++it)
+    found = RemovePendingTransactionFromEntry(*it, trans);
+}
+
+bool HttpCache::RemovePendingTransactionFromEntry(ActiveEntry* entry,
+                                                  Transaction* trans) {
+  TransactionList& pending_queue = entry->pending_queue;
 
   TransactionList::iterator j =
       find(pending_queue.begin(), pending_queue.end(), trans);
   if (j == pending_queue.end())
-    return;
+    return false;
 
   pending_queue.erase(j);
+  return true;
 }
 
 void HttpCache::ProcessPendingQueue(ActiveEntry* entry) {
   // Multiple readers may finish with an entry at once, so we want to batch up
   // calls to OnProcessPendingQueue.  This flag also tells us that we should
   // not delete the entry before OnProcessPendingQueue runs.
   if (entry->will_process_pending_queue)
     return;
   entry->will_process_pending_queue = true;
 
@@ skipping 28 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net