Oilpan: enable appcache + move DocumentLoader to the heap.

Source/core/loader/DocumentLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 82 matching lines @@
     , m_navigationType(NavigationTypeOther)
     , m_loadingMainResource(false)
     , m_timeOfLastDataReceived(0.0)
     , m_applicationCacheHost(ApplicationCacheHost::create(this))
 {
 }
 
 FrameLoader* DocumentLoader::frameLoader() const
 {
     if (!m_frame)
-        return 0;
+        return nullptr;
     return &m_frame->loader();
 }
 
 ResourceLoader* DocumentLoader::mainResourceLoader() const
 {
-    return m_mainResource ? m_mainResource->loader() : 0;
+    return m_mainResource ? m_mainResource->loader() : nullptr;
 }
 
 DocumentLoader::~DocumentLoader()
 {
     ASSERT(!m_frame || !isLoading());
-    clearMainResourceHandle();
-    m_applicationCacheHost->dispose();
+    ASSERT(!m_mainResource);
+    ASSERT(!m_applicationCacheHost);
+}
+
+DEFINE_TRACE(DocumentLoader)
+{
+    visitor->trace(m_frame);
+    visitor->trace(m_fetcher);
+    // TODO(sof): start tracing ResourcePtr<>s (and m_mainResource.)
+    visitor->trace(m_writer);
+    visitor->trace(m_archive);
+    visitor->trace(m_applicationCacheHost);
 }
 
 unsigned long DocumentLoader::mainResourceIdentifier() const
 {
     return m_mainResource ? m_mainResource->identifier() : 0;
 }
 
 Document* DocumentLoader::document() const
 {
     if (m_frame && m_frame->loader().documentLoader() == this)
         return m_frame->document();
-    return 0;
+    return nullptr;
 }
 
 const ResourceRequest& DocumentLoader::originalRequest() const
 {
     return m_originalRequest;
 }
 
 const ResourceRequest& DocumentLoader::request() const
 {
     return m_request;
@@ skipping 44 matching lines @@
 
 const KURL& DocumentLoader::urlForHistory() const
 {
     return unreachableURL().isEmpty() ? url() : unreachableURL();
 }
 
 void DocumentLoader::mainReceivedError(const ResourceError& error)
 {
     ASSERT(!error.isNull());
     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading() || InspectorInstrumentation::isDebuggerPaused(m_frame));
-    m_applicationCacheHost->failedLoadingMainResource();
+    if (m_applicationCacheHost)
+        m_applicationCacheHost->failedLoadingMainResource();
     if (!frameLoader())
         return;
     m_mainDocumentError = error;
     clearMainResourceLoader();
     frameLoader()->receivedMainResourceError(this, error);
     clearMainResourceHandle();
 }
 
 // Cancels the data source's pending loads.  Conceptually, a data source only loads
 // one document at a time, but one document may have many related resources.
 // stopLoading will stop all loads initiated by the data source,
 // but not loads initiated by child frames' data sources -- that's the WebFrame's job.
 void DocumentLoader::stopLoading()
 {
-    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame);
-    RefPtr<DocumentLoader> protectLoader(this);
+    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame.get());
+    RefPtrWillBeRawPtr<DocumentLoader> protectLoader(this);
 
     m_fetcher->stopFetching();
     if (isLoading())
         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
 }
 
 void DocumentLoader::commitIfReady()
 {
     if (!m_committed) {
         m_committed = true;
         frameLoader()->commitProvisionalLoad();
     }
 }
 
 bool DocumentLoader::isLoading() const
 {
     if (document() && document()->hasActiveParser())
         return true;
 
     return m_loadingMainResource || m_fetcher->isFetching();
 }
 
 void DocumentLoader::notifyFinished(Resource* resource)
 {
     ASSERT_UNUSED(resource, m_mainResource == resource);
     ASSERT(m_mainResource);
 
-    RefPtr<DocumentLoader> protect(this);
+    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
 
     if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {
         finishedLoading(m_mainResource->loadFinishTime());
         return;
     }
 
     mainReceivedError(m_mainResource->resourceError());
 }
 
 void DocumentLoader::finishedLoading(double finishTime)
 {
     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading() || InspectorInstrumentation::isDebuggerPaused(m_frame));
 
-    RefPtr<DocumentLoader> protect(this);
+    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
 
     double responseEndTime = finishTime;
     if (!responseEndTime)
         responseEndTime = m_timeOfLastDataReceived;
     if (!responseEndTime)
         responseEndTime = monotonicallyIncreasingTime();
     timing().setResponseEnd(responseEndTime);
 
     commitIfReady();
     if (!frameLoader())
@@ skipping 167 matching lines @@
     // The load event might have detached this frame. In that case, the load will already have been cancelled during detach.
     if (frameLoader())
         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
     return;
 }
 
 void DocumentLoader::responseReceived(Resource* resource, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
     ASSERT_UNUSED(resource, m_mainResource == resource);
     ASSERT_UNUSED(handle, !handle);
-    RefPtr<DocumentLoader> protect(this);
+    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
     ASSERT(frame());
 
     m_applicationCacheHost->didReceiveResponseForMainResource(response);
 
     // The memory cache doesn't understand the application cache or its caching rules. So if a main resource is served
     // from the application cache, ensure we don't save the result for future use. All responses loaded
     // from appcache will have a non-zero appCacheID().
     if (response.appCacheID())
         memoryCache()->remove(m_mainResource.get());
 
@@ skipping 84 matching lines @@
 void DocumentLoader::dataReceived(Resource* resource, const char* data, unsigned length)
 {
     ASSERT(data);
     ASSERT(length);
     ASSERT_UNUSED(resource, resource == m_mainResource);
     ASSERT(!m_response.isNull());
     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());
 
     // Both unloading the old page and parsing the new page may execute JavaScript which destroys the datasource
     // by starting a new load, so retain temporarily.
-    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame);
-    RefPtr<DocumentLoader> protectLoader(this);
+    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame.get());
+    RefPtrWillBeRawPtr<DocumentLoader> protectLoader(this);
 
     m_applicationCacheHost->mainResourceDataReceived(data, length);
     m_timeOfLastDataReceived = monotonicallyIncreasingTime();
 
     if (isArchiveMIMEType(response().mimeType()))
         return;
     commitIfReady();
     if (!frameLoader())
         return;
     commitData(data, length);
@@ skipping 15 matching lines @@
 }
 
 bool DocumentLoader::loadingMultipartContent() const
 {
     return mainResourceLoader() ? mainResourceLoader()->loadingMultipartContent() : false;
 }
 
 void DocumentLoader::detachFromFrame()
 {
     ASSERT(m_frame);
-    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame);
-    RefPtr<DocumentLoader> protectLoader(this);
+    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame.get());
+    RefPtrWillBeRawPtr<DocumentLoader> protectLoader(this);
 
     // It never makes sense to have a document loader that is detached from its
     // frame have any loads active, so go ahead and kill all the loads.
     stopLoading();
 
+    // If that load cancellation triggered another detach, leave.
+    // (fast/frames/detach-frame-nested-no-crash.html is an example of this.)
+    if (!m_frame)
+        return;
+
     m_fetcher->clearContext();
-    m_applicationCacheHost->setApplicationCache(0);
+    m_applicationCacheHost->detachFromDocumentLoader();
+    m_applicationCacheHost.clear();
     WeakIdentifierMap<DocumentLoader>::notifyObjectDestroyed(this);
-    m_frame = 0;
+    clearMainResourceHandle();
+    m_frame = nullptr;
 }
 
 void DocumentLoader::clearMainResourceLoader()
 {
     m_loadingMainResource = false;
 }
 
 void DocumentLoader::clearMainResourceHandle()
 {
     if (!m_mainResource)
         return;
     m_mainResource->removeClient(this);
-    m_mainResource = 0;
+    m_mainResource = nullptr;
 }
 
 bool DocumentLoader::maybeCreateArchive()
 {
     // Only the top-frame can load MHTML.
     if (m_frame->tree().parent())
         return false;
 
     // Give the archive machinery a crack at this document. If the MIME type is not an archive type, it will return 0.
     if (!isArchiveMIMEType(m_response.mimeType()))
@@ skipping 69 matching lines @@
 
     if (m_request.url().isEmpty() && !frameLoader()->stateMachine()->creatingInitialEmptyDocument())
         m_request.setURL(blankURL());
     m_response = ResourceResponse(m_request.url(), "text/html", 0, nullAtom, String());
     finishedLoading(monotonicallyIncreasingTime());
     return true;
 }
 
 void DocumentLoader::startLoadingMainResource()
 {
-    RefPtr<DocumentLoader> protect(this);
+    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
     m_mainDocumentError = ResourceError();
     timing().markNavigationStart();
     ASSERT(!m_mainResource);
     ASSERT(!m_loadingMainResource);
     m_loadingMainResource = true;
 
     if (maybeLoadEmpty())
         return;
 
     ASSERT(timing().navigationStart());
@@ skipping 11 matching lines @@
     ResourceRequest request(m_request);
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, mainResourceLoadOptions,
         (DoNotBufferData, AllowStoredCredentials, ClientRequestedCredentials, CheckContentSecurityPolicy, DocumentContext));
     FetchRequest cachedResourceRequest(request, FetchInitiatorTypeNames::document, mainResourceLoadOptions);
     m_mainResource = RawResource::fetchMainResource(cachedResourceRequest, fetcher(), m_substituteData);
     if (!m_mainResource) {
         m_request = ResourceRequest();
         // If the load was aborted by clearing m_request, it's possible the ApplicationCacheHost
         // is now in a state where starting an empty load will be inconsistent. Replace it with
         // a new ApplicationCacheHost.
+        if (m_applicationCacheHost)
+            m_applicationCacheHost->detachFromDocumentLoader();
         m_applicationCacheHost = ApplicationCacheHost::create(this);
         maybeLoadEmpty();
         return;
     }
     m_mainResource->addClient(this);
 
     // A bunch of headers are set when the underlying ResourceLoader is created, and m_request needs to include those.
     if (mainResourceLoader())
         request = mainResourceLoader()->originalRequest();
     // If there was a fragment identifier on m_request, the cache will have stripped it. m_request should include
     // the fragment identifier, so add that back in.
     if (equalIgnoringFragmentIdentifier(m_request.url(), request.url()))
         request.setURL(m_request.url());
     m_request = request;
 }
 
 void DocumentLoader::cancelMainResourceLoad(const ResourceError& resourceError)
 {
-    RefPtr<DocumentLoader> protect(this);
+    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
     ResourceError error = resourceError.isNull() ? ResourceError::cancelledError(m_request.url()) : resourceError;
 
     if (mainResourceLoader())
         mainResourceLoader()->cancel(error);
 
     mainReceivedError(error);
 }
 
 void DocumentLoader::attachThreadedDataReceiver(PassRefPtrWillBeRawPtr<ThreadedDataReceiver> threadedDataReceiver)
 {
@@ skipping 44 matching lines @@
 // This is only called by FrameLoader::replaceDocumentWhileExecutingJavaScriptURL()
 void DocumentLoader::replaceDocumentWhileExecutingJavaScriptURL(const DocumentInit& init, const String& source, Document* ownerDocument)
 {
     m_writer = createWriterFor(ownerDocument, init, mimeType(), m_writer ? m_writer->encoding() : emptyAtom, true, ForceSynchronousParsing);
     if (!source.isNull())
         m_writer->appendReplacingData(source);
     endWriting(m_writer.get());
 }
 
 } // namespace blink