Move subresource archive loading out of ResourceLoader

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 85 matching lines @@
     , m_substituteData(substituteData)
     , m_originalRequestCopy(req)
     , m_request(req)
     , m_originalSubstituteDataWasValid(substituteData.isValid())
     , m_committed(false)
     , m_isStopping(false)
     , m_gotFirstByte(false)
     , m_isClientRedirect(false)
     , m_isLoadingMultipartContent(false)
     , m_wasOnloadHandled(false)
-    , m_substituteResourceDeliveryTimer(this, &DocumentLoader::substituteResourceDeliveryTimerFired)
     , m_loadingMainResource(false)
     , m_timeOfLastDataReceived(0.0)
     , m_identifierForLoadWithoutResourceLoader(0)
     , m_dataLoadTimer(this, &DocumentLoader::handleSubstituteDataLoadNow)
     , m_applicationCacheHost(adoptPtr(new ApplicationCacheHost(this)))
 {
 }
 
 FrameLoader* DocumentLoader::frameLoader() const
 {
@@ skipping 566 matching lines @@
     info.addMember(m_mainResource, "mainResource");
     info.addMember(m_resourceLoaders, "resourceLoaders");
     info.addMember(m_multipartResourceLoaders, "multipartResourceLoaders");
     info.addMember(m_substituteData, "substituteData");
     info.addMember(m_pageTitle.string(), "pageTitle.string()");
     info.addMember(m_overrideEncoding, "overrideEncoding");
     info.addMember(m_originalRequest, "originalRequest");
     info.addMember(m_originalRequestCopy, "originalRequestCopy");
     info.addMember(m_request, "request");
     info.addMember(m_response, "response");
-    info.addMember(m_pendingSubstituteResources, "pendingSubstituteResources");
-    info.addMember(m_substituteResourceDeliveryTimer, "substituteResourceDeliveryTimer");
     info.addMember(m_archiveResourceCollection, "archiveResourceCollection");
     info.addMember(m_archive, "archive");
     info.addMember(m_resourcesClientKnowsAbout, "resourcesClientKnowsAbout");
     info.addMember(m_resourcesLoadedFromMemoryCacheForClientNotification, "resourcesLoadedFromMemoryCacheForClientNotification");
     info.addMember(m_applicationCacheHost, "applicationCacheHost");
 }
 
 void DocumentLoader::dataReceived(CachedResource* resource, const char* data, int length)
 {
     ASSERT(data);
@@ skipping 127 matching lines @@
         return;
     addAllArchiveResources(m_archive.get());
 
     ArchiveResource* mainResource = m_archive->mainResource();
     m_substituteData = SubstituteData(mainResource->data(), mainResource->mimeType(), mainResource->textEncoding(), KURL());
 }
 
 void DocumentLoader::clearArchiveResources()
 {
     m_archiveResourceCollection.clear();
-    m_substituteResourceDeliveryTimer.stop();
 }
 
-ArchiveResource* DocumentLoader::archiveResourceForURL(const KURL& url) const
+bool DocumentLoader::scheduleArchiveLoad(CachedResource* cachedResource, const ResourceRequest& request)
 {
-    if (!m_archiveResourceCollection)
-        return 0;
-        
-    ArchiveResource* resource = m_archiveResourceCollection->archiveResourceForURL(url);
+    if (!m_archive)
+        return false;
 
-    return resource && !resource->shouldIgnoreWhenUnarchiving() ? resource : 0;
-}
+    ASSERT(m_archiveResourceCollection);
+    ArchiveResource* archiveResource = m_archiveResourceCollection->archiveResourceForURL(request.url());
+    ASSERT(archiveResource);
 
-void DocumentLoader::deliverSubstituteResourcesAfterDelay()
-{
-    if (m_pendingSubstituteResources.isEmpty())
-        return;
-    ASSERT(m_frame && m_frame->page());
-    if (m_frame->page()->defersLoading())
-        return;
-    if (!m_substituteResourceDeliveryTimer.isActive())
-        m_substituteResourceDeliveryTimer.startOneShot(0);
-}
-
-void DocumentLoader::substituteResourceDeliveryTimerFired(Timer<DocumentLoader>*)
-{
-    if (m_pendingSubstituteResources.isEmpty())
-        return;
-    ASSERT(m_frame && m_frame->page());
-    if (m_frame->page()->defersLoading())
-        return;
-
-    SubstituteResourceMap copy;
-    copy.swap(m_pendingSubstituteResources);
-
-    SubstituteResourceMap::const_iterator end = copy.end();
-    for (SubstituteResourceMap::const_iterator it = copy.begin(); it != end; ++it) {
-        RefPtr<ResourceLoader> loader = it->key;
-        SubstituteResource* resource = it->value.get();
-        
-        if (resource) {
-            SharedBuffer* data = resource->data();
-        
-            loader->didReceiveResponse(0, resource->response());
-
-            // Calling ResourceLoader::didReceiveResponse can end up cancelling the load,
-            // so we need to check if the loader has reached its terminal state.
-            if (loader->reachedTerminalState())
-                return;
-
-            loader->didReceiveData(0, data->data(), data->size(), data->size());
-
-            // Calling ResourceLoader::didReceiveData can end up cancelling the load,
-            // so we need to check if the loader has reached its terminal state.
-            if (loader->reachedTerminalState())
-                return;
-
-            loader->didFinishLoading(0, 0);
-        } else {
-            // A null resource means that we should fail the load.
-            // FIXME: Maybe we should use another error here - something like "not in cache".
-            loader->didFail(0, loader->cannotShowURLError());
-        }
-    }
-}
-
-#ifndef NDEBUG
-bool DocumentLoader::isSubstituteLoadPending(ResourceLoader* loader) const
-{
-    return m_pendingSubstituteResources.contains(loader);
-}
-#endif
-
-void DocumentLoader::cancelPendingSubstituteLoad(ResourceLoader* loader)
-{
-    if (m_pendingSubstituteResources.isEmpty())
-        return;
-    m_pendingSubstituteResources.remove(loader);
-    if (m_pendingSubstituteResources.isEmpty())
-        m_substituteResourceDeliveryTimer.stop();
-}
-
-bool DocumentLoader::scheduleArchiveLoad(ResourceLoader* loader, const ResourceRequest& request)
-{
-    if (ArchiveResource* resource = archiveResourceForURL(request.url())) {
-        m_pendingSubstituteResources.set(loader, resource);
-        deliverSubstituteResourcesAfterDelay();
-        return true;
-    }
-    return m_archive;
+    cachedResource->setLoading(true);
+    SharedBuffer* data = archiveResource->data();
+    cachedResource->responseReceived(archiveResource->response());
+    cachedResource->appendData(data->data(), data->size());
+    cachedResource->finish();

[Nate Chapin, 2013/05/22 23:28:46]

This "loads" the ArchiveResource by directly populating the CachedResource. This
means that when the CachedResourceClient calls addClient(this), it will behave
like a cache hit.

This is technically a behavior change, but seems to me like a reasonable
conceptual match for loading an archive. It also drops the ResourceLoadNotifier
callbacks. Do we want to keep those for mhtml subresources?

[abarth-chromium, 2013/05/23 17:10:07]

They're probably not needed.

+    return true;
 }
 
 void DocumentLoader::setTitle(const StringWithDirection& title)
 {
     if (m_pageTitle == title)
         return;
 
     m_pageTitle = title;
     frameLoader()->didChangeTitle(this);
 }
@@ skipping 41 matching lines @@
 
 void DocumentLoader::setDefersLoading(bool defers)
 {
     // Multiple frames may be loading the same main resource simultaneously. If deferral state changes,
     // each frame's DocumentLoader will try to send a setDefersLoading() to the same underlying ResourceLoader. Ensure only
     // the "owning" DocumentLoader does so, as setDefersLoading() is not resilient to setting the same value repeatedly.
     if (mainResourceLoader() && mainResourceLoader()->documentLoader() == this)
         mainResourceLoader()->setDefersLoading(defers);
 
     setAllDefersLoading(m_resourceLoaders, defers);
-    if (!defers)
-        deliverSubstituteResourcesAfterDelay();
 }
 
 void DocumentLoader::setMainResourceDataBufferingPolicy(DataBufferingPolicy dataBufferingPolicy)
 {
     if (m_mainResource)
         m_mainResource->setDataBufferingPolicy(dataBufferingPolicy);
 }
 
 void DocumentLoader::stopLoadingSubresources()
 {
@@ skipping 136 matching lines @@
     commitLoad(resourceData->data(), resourceData->size());
 }
 
 void DocumentLoader::handledOnloadEvents()
 {
     m_wasOnloadHandled = true;
     applicationCacheHost()->stopDeferringEvents();
 }
 
 } // namespace WebCore