Resource: Add more crash preventing assertions

Source/core/fetch/Resource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 96 matching lines @@
     , m_protectorCount(0)
     , m_preloadResult(PreloadNotReferenced)
     , m_cacheLiveResourcePriority(CacheLiveResourcePriorityLow)
     , m_requestedFromNetworkingLayer(false)
     , m_loading(false)
     , m_switchingClientsToRevalidatedResource(false)
     , m_type(type)
     , m_status(Pending)
     , m_wasPurged(false)
     , m_needsSynchronousCacheHit(false)
-#ifndef NDEBUG
+#ifdef ENABLE_RESOURCE_IS_DELETED_CHECK
     , m_deleted(false)
 #endif
     , m_resourceToRevalidate(0)
     , m_proxyResource(0)
 {
     ASSERT(m_type == unsigned(type)); // m_type is a bitfield, so this tests careless updates of the enum.
 #ifndef NDEBUG
     cachedResourceLeakCounter.increment();
 #endif
 
     if (!m_resourceRequest.url().hasFragmentIdentifier())
         return;
     KURL urlForCache = MemoryCache::removeFragmentIdentifierIfNeeded(m_resourceRequest.url());
     if (urlForCache.hasFragmentIdentifier())
         return;
     m_fragmentIdentifierForRequest = m_resourceRequest.url().fragmentIdentifier();
     m_resourceRequest.setURL(urlForCache);
 }
 
 Resource::~Resource()
 {
     ASSERT(!m_resourceToRevalidate); // Should be true because canDelete() checks this.
     ASSERT(canDelete());
     RELEASE_ASSERT(!memoryCache()->contains(this));
     RELEASE_ASSERT(!ResourceCallback::callbackHandler()->isScheduled(this));
-    ASSERT(!m_deleted);
     ASSERT(url().isNull() || memoryCache()->resourceForURL(KURL(ParsedURLString, url())) != this);
+    assertAlive();
 
+#ifdef ENABLE_RESOURCE_IS_DELETED_CHECK
+    m_deleted = true;
+#endif
 #ifndef NDEBUG
-    m_deleted = true;
     cachedResourceLeakCounter.decrement();
 #endif
 }
 
 void Resource::failBeforeStarting()
 {
     WTF_LOG(ResourceLoading, "Cannot start loading '%s'", url().string().latin1().data());
     error(Resource::LoadError);
 }
 
@@ skipping 568 matching lines @@
 
     // Calling evict() can potentially delete revalidatingResource, which we use
     // below. This mustn't be the case since revalidation means it is loaded
     // and so canDelete() is false.
     ASSERT(!canDelete());
 
     m_resourceToRevalidate->updateResponseAfterRevalidation(response);
     memoryCache()->replace(m_resourceToRevalidate, this);
 
     switchClientsToRevalidatedResource();
-    ASSERT(!m_deleted);
+    assertAlive();
     // clearResourceToRevalidate deletes this.
     clearResourceToRevalidate();
 }
 
 void Resource::revalidationFailed()
 {
     ASSERT(WTF::isMainThread());
     WTF_LOG(ResourceLoading, "Revalidation failed for %p", this);
     ASSERT(resourceToRevalidate());
     clearResourceToRevalidate();
 }
 
 void Resource::registerHandle(ResourcePtrBase* h)
 {
+    assertAlive();
     ++m_handleCount;
     if (m_resourceToRevalidate)
         m_handlesToRevalidate.add(h);
 }
 
 void Resource::unregisterHandle(ResourcePtrBase* h)
 {
+    assertAlive();
     ASSERT(m_handleCount > 0);
     --m_handleCount;
 
     if (m_resourceToRevalidate)
         m_handlesToRevalidate.remove(h);
 
     if (!m_handleCount) {
         if (deleteIfPossible())
             return;
         unlock();
@@ skipping 72 matching lines @@
 
 Resource::ResourceCallback::ResourceCallback()
     : m_callbackTimer(this, &ResourceCallback::timerFired)
 {
 }
 
 void Resource::ResourceCallback::schedule(Resource* resource)
 {
     if (!m_callbackTimer.isActive())
         m_callbackTimer.startOneShot(0, FROM_HERE);
+    resource->assertAlive();
     m_resourcesWithPendingClients.add(resource);
 }
 
 void Resource::ResourceCallback::cancel(Resource* resource)
 {
+    resource->assertAlive();
     m_resourcesWithPendingClients.remove(resource);
     if (m_callbackTimer.isActive() && m_resourcesWithPendingClients.isEmpty())
         m_callbackTimer.stop();
 }
 
 bool Resource::ResourceCallback::isScheduled(Resource* resource) const
 {
     return m_resourcesWithPendingClients.contains(resource);
 }
 
 void Resource::ResourceCallback::timerFired(Timer<ResourceCallback>*)
 {
     HashSet<Resource*>::iterator end = m_resourcesWithPendingClients.end();
     Vector<ResourcePtr<Resource> > resources;
     for (HashSet<Resource*>::iterator it = m_resourcesWithPendingClients.begin(); it != end; ++it)
         resources.append(*it);
     m_resourcesWithPendingClients.clear();
+
+    for (size_t i = 0; i < resources.size(); i++) {
+        resources[i]->assertAlive();
+        resources[i]->finishPendingClients();
+        resources[i]->assertAlive();
+    }
+
     for (size_t i = 0; i < resources.size(); i++)
-        resources[i]->finishPendingClients();
+        resources[i]->assertAlive();
 }
 
 static const char* initatorTypeNameToString(const AtomicString& initiatorTypeName)
 {
     if (initiatorTypeName == FetchInitiatorTypeNames::css)
         return "CSS resource";
     if (initiatorTypeName == FetchInitiatorTypeNames::document)
         return "Document";
     if (initiatorTypeName == FetchInitiatorTypeNames::icon)
         return "Icon";
@@ skipping 77 matching lines @@
         return "Shader";
     case Resource::ImportResource:
         return "ImportResource";
     }
     ASSERT_NOT_REACHED();
     return "Unknown";
 }
 #endif // !LOG_DISABLED
 
 }