Http Cache: Deactivate entries without having the key of the...

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 "base/compiler_specific.h"
 
@@ skipping 1715 matching lines @@
   active_entries_[key] = entry;
   return entry;
 }
 
 #if defined(OS_WIN)
 #pragma optimize("", off)
 #pragma warning(disable:4748)
 #endif
 // Avoid optimizing local_entry out of the code.
 void HttpCache::DeactivateEntry(ActiveEntry* entry) {
+  std::string key = entry->disk_entry->GetKey();
+  if (key.empty())
+    return SlowDeactivateEntry(entry);
+
   // TODO(rvargas): remove this code and go back to DCHECKS once we find out
   // why are we crashing. I'm just trying to gather more info for bug 3931.
   ActiveEntry local_entry = *entry;
   size_t readers_size = local_entry.readers.size();
   size_t pending_size = local_entry.pending_queue.size();
 
-  std::string key = entry->disk_entry->GetKey();
   ActiveEntriesMap::iterator it = active_entries_.find(key);
   if (it == active_entries_.end() || it->second != entry ||
       local_entry.will_process_pending_queue || local_entry.doomed ||
       local_entry.writer || readers_size || pending_size || deleted_) {
     bool local_mem_flag = in_memory_cache_;
     ActiveEntriesSet::iterator it2 = doomed_entries_.find(entry);
     char local_key[64];
     int key_length = key.size();
     base::strlcpy(local_key, key.c_str(), sizeof(local_key));
     CHECK(it2 == doomed_entries_.end());
     CHECK(!deleted_);
     CHECK(local_mem_flag);
     CHECK(key_length);
     CHECK(false);
   }
 
   active_entries_.erase(it);
   delete entry;
 
   // Avoid closing the disk_entry again on the destructor.
   local_entry.disk_entry = NULL;
 }
 #if defined(OS_WIN)
 #pragma warning(default:4748)
 #pragma optimize("", on)
 #endif
 
+// We don't know this entry's key so we have to find it without it.
+void HttpCache::SlowDeactivateEntry(ActiveEntry* entry) {
+  for (ActiveEntriesMap::iterator it = active_entries_.begin();
+       it != active_entries_.end(); ++it) {
+    if (it->second == entry) {
+      active_entries_.erase(it);
+      delete entry;
+      break;
+    }
+  }
+}
+
 int HttpCache::AddTransactionToEntry(ActiveEntry* entry, Transaction* trans) {
   DCHECK(entry);
 
   // We implement a basic reader/writer lock for the disk cache entry.  If
   // there is already a writer, then everyone has to wait for the writer to
   // finish before they can access the cache entry.  There can be multiple
   // readers.
   //
   // NOTE: If the transaction can only write, then the entry should not be in
   // use (since any existing entry should have already been doomed).
@@ skipping 166 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->connection_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net