Http Cache: Enable some checks to track a low volume crash....

net/http/http_cache.cc

 // Copyright (c) 2010 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 33 matching lines @@
 //-----------------------------------------------------------------------------
 
 HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* e)
     : disk_entry(e),
       writer(NULL),
       will_process_pending_queue(false),
       doomed(false) {
 }
 
 HttpCache::ActiveEntry::~ActiveEntry() {
-  if (disk_entry)
+  if (disk_entry) {
     disk_entry->Close();
+    disk_entry = NULL;
+  }
 }
 
 //-----------------------------------------------------------------------------
 
 // This structure keeps track of work items that are attempting to create or
 // open cache entries or the backend itself.
 struct HttpCache::PendingOp {
   PendingOp() : disk_entry(NULL), writer(NULL), callback(NULL) {}
   ~PendingOp() {}
 
@@ skipping 21 matching lines @@
       : operation_(operation), trans_(trans), entry_(entry), callback_(NULL),
         backend_(NULL) {}
   WorkItem(WorkItemOperation operation, Transaction* trans,
            CompletionCallback* cb, disk_cache::Backend** backend)
       : operation_(operation), trans_(trans), entry_(NULL), callback_(cb),
         backend_(backend) {}
   ~WorkItem() {}
 
   // Calls back the transaction with the result of the operation.
   void NotifyTransaction(int result, ActiveEntry* entry) {
+    // TODO(rvargas): convert to DCHECK after fixing bug 47895.
+    CHECK(!entry || entry->disk_entry);
     if (entry_)
       *entry_ = entry;
     if (trans_)
       trans_->io_callback()->Run(result);
   }
 
   // Notifies the caller about the operation completion.
   void DoCallback(int result, disk_cache::Backend* backend) {
     if (backend_)
       *backend_ = backend;
@@ skipping 417 matching lines @@
 HttpCache::ActiveEntry* HttpCache::ActivateEntry(
     const std::string& key,
     disk_cache::Entry* disk_entry) {
   DCHECK(!FindActiveEntry(key));
   ActiveEntry* entry = new ActiveEntry(disk_entry);
   active_entries_[key] = entry;
   return entry;
 }
 
 void HttpCache::DeactivateEntry(ActiveEntry* entry) {
-  DCHECK(!entry->will_process_pending_queue);
-  DCHECK(!entry->doomed);
-  DCHECK(!entry->writer);
-  DCHECK(entry->readers.empty());
-  DCHECK(entry->pending_queue.empty());
+  // TODO(rvargas): convert to DCHECKs after fixing bug 47895.
+  CHECK(!entry->will_process_pending_queue);
+  CHECK(!entry->doomed);
+  CHECK(!entry->writer);
+  CHECK(entry->disk_entry);
+  CHECK(entry->readers.empty());
+  CHECK(entry->pending_queue.empty());
 
   std::string key = entry->disk_entry->GetKey();
   if (key.empty())
     return SlowDeactivateEntry(entry);
 
   ActiveEntriesMap::iterator it = active_entries_.find(key);
-  DCHECK(it != active_entries_.end());
-  DCHECK(it->second == entry);
+  CHECK(it != active_entries_.end());
+  CHECK(it->second == entry);
 
   active_entries_.erase(it);
   delete entry;
 }
 
 // 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) {
@@ skipping 98 matching lines @@
 
 void HttpCache::DestroyEntry(ActiveEntry* entry) {
   if (entry->doomed) {
     FinalizeDoomedEntry(entry);
   } else {
     DeactivateEntry(entry);
   }
 }
 
 int HttpCache::AddTransactionToEntry(ActiveEntry* entry, Transaction* trans) {
-  DCHECK(entry);
+  // TODO(rvargas): convert to DCHECKs after fixing bug 47895.
+  CHECK(entry);
+  CHECK(entry->disk_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).
 
   if (entry->writer || entry->will_process_pending_queue) {
@@ skipping 186 matching lines @@
   entry->will_process_pending_queue = true;
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       task_factory_.NewRunnableMethod(&HttpCache::OnProcessPendingQueue,
                                       entry));
 }
 
 void HttpCache::OnProcessPendingQueue(ActiveEntry* entry) {
   entry->will_process_pending_queue = false;
-  DCHECK(!entry->writer);
+  // TODO(rvargas): convert to DCHECK after fixing bug 47895.
+  CHECK(!entry->writer);
 
   // If no one is interested in this entry, then we can de-activate it.
   if (entry->pending_queue.empty()) {
     if (entry->readers.empty())
       DestroyEntry(entry);
     return;
   }
 
   // Promote next transaction from the pending queue.
   Transaction* next = entry->pending_queue.front();
@@ skipping 118 matching lines @@
     // This could be an external caller or a transaction waiting on Start().
     pending_item->DoCallback(result, temp_backend_);
     pending_item->NotifyTransaction(result, NULL);
   }
 
   DeletePendingOp(pending_op);
   building_backend_ = false;
 }
 
 }  // namespace net