Add more code to debug a crash inside HttpCache::DeactivateEntry...

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 1241 matching lines @@
                      ProxyService* proxy_service,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(
           host_resolver, proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
+      deleted_(false),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HttpNetworkSession* session,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(session)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
+      deleted_(false),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HostResolver* host_resolver,
                      ProxyService* proxy_service,
                      int cache_size)
     : mode_(NORMAL),
       type_(MEMORY_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(
           host_resolver, proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(true),
+      deleted_(false),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HttpTransactionFactory* network_layer,
                      disk_cache::Backend* disk_cache)
     : mode_(NORMAL),
       type_(DISK_CACHE),
       network_layer_(network_layer),
       disk_cache_(disk_cache),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
+      deleted_(false),
       cache_size_(0) {
 }
 
 HttpCache::~HttpCache() {
   // If we have any active entries remaining, then we need to deactivate them.
   // We may have some pending calls to OnProcessPendingQueue, but since those
   // won't run (due to our destruction), we can simply ignore the corresponding
   // will_process_pending_queue flag.
   while (!active_entries_.empty()) {
     ActiveEntry* entry = active_entries_.begin()->second;
     entry->will_process_pending_queue = false;
     entry->pending_queue.clear();
     entry->readers.clear();
     entry->writer = NULL;
     DeactivateEntry(entry);
   }
 
   ActiveEntriesSet::iterator it = doomed_entries_.begin();
   for (; it != doomed_entries_.end(); ++it)
     delete *it;
+
+  // TODO(rvargas): remove this. I'm just tracking a few crashes.
+  deleted_ = true;
 }
 
 HttpTransaction* HttpCache::CreateTransaction() {
   // Do lazy initialization of disk cache if needed.
   if (!disk_cache_.get()) {
     DCHECK(cache_size_ >= 0);
     if (in_memory_cache_) {
       // We may end up with no folder name and no cache if the initialization
       // of the disk cache fails. We want to be sure that what we wanted to have
       // was an in-memory cache.
@@ skipping 237 matching lines @@
   if (entry->doomed) {
     FinalizeDoomedEntry(entry);
   } else {
     DeactivateEntry(entry);
   }
 }
 
 HttpCache::ActiveEntry* HttpCache::ActivateEntry(
     const std::string& key,
     disk_cache::Entry* disk_entry) {
+  // TODO(rvargas): remove this code.
+  ActiveEntriesMap::iterator it = active_entries_.find(key);
+  CHECK(it == active_entries_.end());
+
   ActiveEntry* entry = new ActiveEntry(disk_entry);
   active_entries_[key] = entry;
   return entry;
 }
 
 #if defined(OS_WIN)
 #pragma optimize("", off)
 #endif
 // Avoid optimizing local_entry out of the code.
 void HttpCache::DeactivateEntry(ActiveEntry* 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();
 
   ActiveEntriesMap::iterator it =
       active_entries_.find(entry->disk_entry->GetKey());
-  CHECK(it != active_entries_.end());
-  CHECK(it->second == entry);
-
-  if (local_entry.will_process_pending_queue || local_entry.doomed ||
-      local_entry.writer || readers_size || pending_size) {
+  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);
+    CHECK(it2 == doomed_entries_.end());
+    CHECK(!deleted_);
+    CHECK(local_mem_flag);
     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)
@@ skipping 31 matching lines @@
 
   // We do this before calling EntryAvailable to force any further calls to
   // AddTransactionToEntry to add their transaction to the pending queue, which
   // ensures FIFO ordering.
   if (!entry->writer && !entry->pending_queue.empty())
     ProcessPendingQueue(entry);
 
   return trans->EntryAvailable(entry);
 }
 
+#if defined(OS_WIN)
+#pragma optimize("", off)
+#pragma warning(disable:4748)
+#endif
+// Avoid optimizing local_transaction out of the code.
 void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans) {
   // If we already posted a task to move on to the next transaction and this was
   // the writer, there is nothing to cancel.
   if (entry->will_process_pending_queue && entry->readers.empty())
     return;
 
   if (entry->writer) {
     // TODO(rvargas): convert this to a DCHECK.
     CHECK(trans == entry->writer);
+    // Get a local copy of the transaction, in preparation for a crash inside
+    // DeactivateEntry.
+    char local_transaction[sizeof(*trans)];
+    memcpy(local_transaction, trans, sizeof(*trans));
+
     // Assume that this is not a successful write.
     DoneWritingToEntry(entry, false);
   } else {
     DoneReadingFromEntry(entry, trans);
   }
 }
+#if defined(OS_WIN)
+#pragma warning(default:4748)
+#pragma optimize("", on)
+#endif
 
 void HttpCache::DoneWritingToEntry(ActiveEntry* entry, bool success) {
   DCHECK(entry->readers.empty());
 
   entry->writer = NULL;
 
   if (success) {
     ProcessPendingQueue(entry);
   } else {
     // TODO(rvargas): convert this to a DCHECK.
@@ skipping 96 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->connection_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net