Oilpan: enable appcache + move DocumentLoader to the heap.

Source/core/loader/appcache/ApplicationCacheHost.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 52 matching lines @@
 ApplicationCacheHost::ApplicationCacheHost(DocumentLoader* documentLoader)
     : m_domApplicationCache(nullptr)
     , m_documentLoader(documentLoader)
     , m_defersEvents(true)
 {
     ASSERT(m_documentLoader);
 }
 
 ApplicationCacheHost::~ApplicationCacheHost()
 {
+    // Verify that detachFromDocumentLoader() has been performed already.
+    ASSERT(!m_host);
 }
 
 void ApplicationCacheHost::willStartLoadingMainResource(ResourceRequest& request)
 {
     // We defer creating the outer host object to avoid spurious creation/destruction
     // around creating empty documents. At this point, we're initiating a main resource
     // load for the document, so its for real.
 
     if (!isApplicationCacheEnabled())
         return;
 
     ASSERT(m_documentLoader->frame());
     LocalFrame& frame = *m_documentLoader->frame();
     m_host = frame.loader().client()->createApplicationCacheHost(this);
-    if (m_host) {
-        WrappedResourceRequest wrapped(request);
+    if (!m_host)
+        return;
 
-        const WebApplicationCacheHost* spawningHost = 0;
-        Frame* spawningFrame = frame.tree().parent();
-        if (!spawningFrame || !spawningFrame->isLocalFrame())
-            spawningFrame = frame.loader().opener();
-        if (!spawningFrame || !spawningFrame->isLocalFrame())
-            spawningFrame = &frame;
-        if (DocumentLoader* spawningDocLoader = toLocalFrame(spawningFrame)->loader().documentLoader())
-            spawningHost = spawningDocLoader->applicationCacheHost() ? spawningDocLoader->applicationCacheHost()->m_host.get() : 0;
+    WrappedResourceRequest wrapped(request);
 
-        m_host->willStartMainResourceRequest(wrapped, spawningHost);
-    }
+    const WebApplicationCacheHost* spawningHost = nullptr;
+    Frame* spawningFrame = frame.tree().parent();
+    if (!spawningFrame || !spawningFrame->isLocalFrame())
+        spawningFrame = frame.loader().opener();
+    if (!spawningFrame || !spawningFrame->isLocalFrame())
+        spawningFrame = &frame;
+    if (DocumentLoader* spawningDocLoader = toLocalFrame(spawningFrame)->loader().documentLoader())
+        spawningHost = spawningDocLoader->applicationCacheHost() ? spawningDocLoader->applicationCacheHost()->m_host.get() : nullptr;
+
+    m_host->willStartMainResourceRequest(wrapped, spawningHost);
 
     // NOTE: The semantics of this method, and others in this interface, are subtly different
     // than the method names would suggest. For example, in this method never returns an appcached
     // response in the SubstituteData out argument, instead we return the appcached response thru
     // the usual resource loading pipeline.
 }
 
 void ApplicationCacheHost::selectCacheWithoutManifest()
 {
     if (m_host)
@@ skipping 46 matching lines @@
         m_host->willStartSubResourceRequest(wrapped);
     }
 }
 
 void ApplicationCacheHost::setApplicationCache(ApplicationCache* domApplicationCache)
 {
     ASSERT(!m_domApplicationCache || !domApplicationCache);
     m_domApplicationCache = domApplicationCache;
 }
 
-void ApplicationCacheHost::dispose()
+void ApplicationCacheHost::detachFromDocumentLoader()
 {
-    // FIXME: Oilpan: remove the dispose step when the owning DocumentLoader
-    // becomes a garbage collected object. Until that time, have the
-    // DocumentLoader dispose and disable this ApplicationCacheHost when
-    // it is finalized. Releasing the WebApplicationCacheHost is needed
-    // to prevent further embedder notifications, which risk accessing an
-    // invalid DocumentLoader.
-    setApplicationCache(0);
+    // Detach from the owning DocumentLoader and let go of WebApplicationCacheHost.
+    setApplicationCache(nullptr);
     m_host.clear();
     m_documentLoader = nullptr;
 }
 
 void ApplicationCacheHost::notifyApplicationCache(EventID id, int progressTotal, int progressDone, WebApplicationCacheHost::ErrorReason errorReason, const String& errorURL, int errorStatus, const String& errorMessage)
 {
     if (id != PROGRESS_EVENT)
         InspectorInstrumentation::updateApplicationCacheStatus(m_documentLoader->frame());
 
     if (m_defersEvents) {
@@ skipping 23 matching lines @@
     m_host->getResourceList(&webResources);
     for (size_t i = 0; i < webResources.size(); ++i) {
         resources->append(ResourceInfo(
             webResources[i].url, webResources[i].isMaster, webResources[i].isManifest, webResources[i].isFallback,
             webResources[i].isForeign, webResources[i].isExplicit, webResources[i].size));
     }
 }
 
 void ApplicationCacheHost::stopDeferringEvents()
 {
-    RefPtr<DocumentLoader> protect(documentLoader());
+    RefPtrWillBeRawPtr<DocumentLoader> protect(documentLoader());
     for (unsigned i = 0; i < m_deferredEvents.size(); ++i) {
         const DeferredEvent& deferred = m_deferredEvents[i];
         dispatchDOMEvent(deferred.eventID, deferred.progressTotal, deferred.progressDone, deferred.errorReason, deferred.errorURL, deferred.errorStatus, deferred.errorMessage);
     }
     m_deferredEvents.clear();
     m_defersEvents = false;
 }
 
 void ApplicationCacheHost::dispatchDOMEvent(EventID id, int progressTotal, int progressDone, WebApplicationCacheHost::ErrorReason errorReason, const String& errorURL, int errorStatus, const String& errorMessage)
 {
-    if (m_domApplicationCache) {
-        const AtomicString& eventType = ApplicationCache::toEventType(id);
-        RefPtrWillBeRawPtr<Event> event = nullptr;
-        if (id == PROGRESS_EVENT)
-            event = ProgressEvent::create(eventType, true, progressDone, progressTotal);
-        else if (id == ERROR_EVENT)
-            event = ApplicationCacheErrorEvent::create(errorReason, errorURL, errorStatus, errorMessage);
-        else
-            event = Event::create(eventType);
-        m_domApplicationCache->dispatchEvent(event, ASSERT_NO_EXCEPTION);
-    }
+    if (!m_domApplicationCache)
+        return;
+
+    const AtomicString& eventType = ApplicationCache::toEventType(id);
+    RefPtrWillBeRawPtr<Event> event = nullptr;
+    if (id == PROGRESS_EVENT)
+        event = ProgressEvent::create(eventType, true, progressDone, progressTotal);
+    else if (id == ERROR_EVENT)
+        event = ApplicationCacheErrorEvent::create(errorReason, errorURL, errorStatus, errorMessage);
+    else
+        event = Event::create(eventType);
+    m_domApplicationCache->dispatchEvent(event, ASSERT_NO_EXCEPTION);
 }
 
 ApplicationCacheHost::Status ApplicationCacheHost::status() const
 {
     return m_host ? static_cast<Status>(m_host->status()) : UNCACHED;
 }
 
 bool ApplicationCacheHost::update()
 {
     return m_host ? m_host->startUpdate() : false;
@@ skipping 35 matching lines @@
 }
 
 void ApplicationCacheHost::notifyErrorEventListener(WebApplicationCacheHost::ErrorReason reason, const WebURL& url, int status, const WebString& message)
 {
     notifyApplicationCache(ERROR_EVENT, 0, 0, reason, url.string(), status, message);
 }
 
 DEFINE_TRACE(ApplicationCacheHost)
 {
     visitor->trace(m_domApplicationCache);
+    visitor->trace(m_documentLoader);
 }
 
 } // namespace blink