diff options
Diffstat (limited to 'Source/WebCore/loader/cache')
| -rw-r--r-- | Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp | 8 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedCSSStyleSheet.h | 2 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedFont.cpp | 4 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedFont.h | 2 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedImage.cpp | 10 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedImage.h | 2 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedResource.cpp | 17 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedResource.h | 49 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedResourceLoader.cpp | 195 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedResourceLoader.h | 24 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedResourceRequest.cpp | 25 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedScript.cpp | 4 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedScript.h | 2 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp | 8 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/CachedXSLStyleSheet.h | 2 | ||||
| -rw-r--r-- | Source/WebCore/loader/cache/MemoryCache.cpp | 4 |
16 files changed, 195 insertions, 163 deletions
diff --git a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp b/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp index ae7a03c..53a04fb 100644 --- a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp +++ b/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp @@ -37,8 +37,8 @@ namespace WebCore { -CachedCSSStyleSheet::CachedCSSStyleSheet(const String& url, const String& charset) - : CachedResource(url, CSSStyleSheet) +CachedCSSStyleSheet::CachedCSSStyleSheet(const ResourceRequest& resourceRequest, const String& charset) + : CachedResource(resourceRequest, CSSStyleSheet) , m_decoder(TextResourceDecoder::create("text/css", charset)) { // Prefer text/css but accept any type (dell.com serves a stylesheet @@ -53,7 +53,7 @@ CachedCSSStyleSheet::~CachedCSSStyleSheet() void CachedCSSStyleSheet::didAddClient(CachedResourceClient *c) { if (!isLoading()) - c->setCSSStyleSheet(m_url, m_response.url(), m_decoder->encoding().name(), this); + c->setCSSStyleSheet(m_resourceRequest.url(), m_response.url(), m_decoder->encoding().name(), this); } void CachedCSSStyleSheet::allClientsRemoved() @@ -113,7 +113,7 @@ void CachedCSSStyleSheet::checkNotify() CachedResourceClientWalker w(m_clients); while (CachedResourceClient *c = w.next()) - c->setCSSStyleSheet(m_url, m_response.url(), m_decoder->encoding().name(), this); + c->setCSSStyleSheet(m_resourceRequest.url(), m_response.url(), m_decoder->encoding().name(), this); } void CachedCSSStyleSheet::error(CachedResource::Status status) diff --git a/Source/WebCore/loader/cache/CachedCSSStyleSheet.h b/Source/WebCore/loader/cache/CachedCSSStyleSheet.h index a982e03..6398717 100644 --- a/Source/WebCore/loader/cache/CachedCSSStyleSheet.h +++ b/Source/WebCore/loader/cache/CachedCSSStyleSheet.h @@ -37,7 +37,7 @@ namespace WebCore { class CachedCSSStyleSheet : public CachedResource { public: - CachedCSSStyleSheet(const String& URL, const String& charset); + CachedCSSStyleSheet(const ResourceRequest&, const String& charset); virtual ~CachedCSSStyleSheet(); const String sheetText(bool enforceMIMEType = true, bool* hasValidMIMEType = 0) const; diff --git a/Source/WebCore/loader/cache/CachedFont.cpp b/Source/WebCore/loader/cache/CachedFont.cpp index 60f0d6c..3e8508c 100644 --- a/Source/WebCore/loader/cache/CachedFont.cpp +++ b/Source/WebCore/loader/cache/CachedFont.cpp @@ -55,8 +55,8 @@ namespace WebCore { -CachedFont::CachedFont(const String &url) - : CachedResource(url, FontResource) +CachedFont::CachedFont(const ResourceRequest& resourceRequest) + : CachedResource(resourceRequest, FontResource) , m_fontData(0) , m_loadInitiated(false) { diff --git a/Source/WebCore/loader/cache/CachedFont.h b/Source/WebCore/loader/cache/CachedFont.h index dd9d60e..68dd01d 100644 --- a/Source/WebCore/loader/cache/CachedFont.h +++ b/Source/WebCore/loader/cache/CachedFont.h @@ -49,7 +49,7 @@ struct FontCustomPlatformData; class CachedFont : public CachedResource { public: - CachedFont(const String& url); + CachedFont(const ResourceRequest&); virtual ~CachedFont(); virtual void load(CachedResourceLoader* cachedResourceLoader); diff --git a/Source/WebCore/loader/cache/CachedImage.cpp b/Source/WebCore/loader/cache/CachedImage.cpp index 6867302..e96d784 100644 --- a/Source/WebCore/loader/cache/CachedImage.cpp +++ b/Source/WebCore/loader/cache/CachedImage.cpp @@ -52,8 +52,8 @@ using std::max; namespace WebCore { -CachedImage::CachedImage(const String& url) - : CachedResource(url, ImageResource) +CachedImage::CachedImage(const ResourceRequest& resourceRequest) + : CachedResource(resourceRequest, ImageResource) , m_image(0) , m_decodedDataDeletionTimer(this, &CachedImage::decodedDataDeletionTimerFired) , m_shouldPaintBrokenImage(true) @@ -63,7 +63,7 @@ CachedImage::CachedImage(const String& url) } CachedImage::CachedImage(Image* image) - : CachedResource(String(), ImageResource) + : CachedResource(ResourceRequest(), ImageResource) , m_image(image) , m_decodedDataDeletionTimer(this, &CachedImage::decodedDataDeletionTimerFired) , m_shouldPaintBrokenImage(true) @@ -86,7 +86,7 @@ void CachedImage::decodedDataDeletionTimerFired(Timer<CachedImage>*) void CachedImage::load(CachedResourceLoader* cachedResourceLoader) { #ifdef ANDROID_BLOCK_NETWORK_IMAGE - if (!cachedResourceLoader || (cachedResourceLoader->autoLoadImages() && !cachedResourceLoader->shouldBlockNetworkImage(m_url))) + if (!cachedResourceLoader || (cachedResourceLoader->autoLoadImages() && !cachedResourceLoader->shouldBlockNetworkImage(m_resourceRequest.url()))) #else if (!cachedResourceLoader || cachedResourceLoader->autoLoadImages()) #endif @@ -231,7 +231,7 @@ void CachedImage::checkShouldPaintBrokenImage() if (!frame) return; - m_shouldPaintBrokenImage = frame->loader()->client()->shouldPaintBrokenImage(KURL(ParsedURLString, m_url)); + m_shouldPaintBrokenImage = frame->loader()->client()->shouldPaintBrokenImage(m_resourceRequest.url()); } void CachedImage::clear() diff --git a/Source/WebCore/loader/cache/CachedImage.h b/Source/WebCore/loader/cache/CachedImage.h index 79643d7..dc12ba2 100644 --- a/Source/WebCore/loader/cache/CachedImage.h +++ b/Source/WebCore/loader/cache/CachedImage.h @@ -38,7 +38,7 @@ class CachedImage : public CachedResource, public ImageObserver { friend class MemoryCache; public: - CachedImage(const String& url); + CachedImage(const ResourceRequest&); CachedImage(Image*); virtual ~CachedImage(); diff --git a/Source/WebCore/loader/cache/CachedResource.cpp b/Source/WebCore/loader/cache/CachedResource.cpp index e599769..ab92bec 100644 --- a/Source/WebCore/loader/cache/CachedResource.cpp +++ b/Source/WebCore/loader/cache/CachedResource.cpp @@ -31,6 +31,7 @@ #include "CachedResourceHandle.h" #include "CachedResourceLoader.h" #include "CachedResourceRequest.h" +#include "CrossOriginAccessControl.h" #include "Frame.h" #include "FrameLoaderClient.h" #include "KURL.h" @@ -62,7 +63,11 @@ static ResourceLoadPriority defaultPriorityForResourceType(CachedResource::Type case CachedResource::ImageResource: return ResourceLoadPriorityLow; #if ENABLE(LINK_PREFETCH) - case CachedResource::LinkResource: + case CachedResource::LinkPrefetch: + return ResourceLoadPriorityVeryLow; + case CachedResource::LinkPrerender: + return ResourceLoadPriorityVeryLow; + case CachedResource::LinkSubresource: return ResourceLoadPriorityVeryLow; #endif } @@ -74,8 +79,8 @@ static ResourceLoadPriority defaultPriorityForResourceType(CachedResource::Type static RefCountedLeakCounter cachedResourceLeakCounter("CachedResource"); #endif -CachedResource::CachedResource(const String& url, Type type) - : m_url(url) +CachedResource::CachedResource(const ResourceRequest& request, Type type) + : m_resourceRequest(request) , m_request(0) , m_loadPriority(defaultPriorityForResourceType(type)) , m_responseTimestamp(currentTime()) @@ -168,6 +173,12 @@ void CachedResource::finish() m_status = Cached; } +bool CachedResource::passesAccessControlCheck(SecurityOrigin* securityOrigin) +{ + String errorDescription; + return WebCore::passesAccessControlCheck(m_response, resourceRequest().allowCookies(), securityOrigin, errorDescription); +} + bool CachedResource::isExpired() const { if (m_response.isNull()) diff --git a/Source/WebCore/loader/cache/CachedResource.h b/Source/WebCore/loader/cache/CachedResource.h index 2f33ac7..f216527 100644 --- a/Source/WebCore/loader/cache/CachedResource.h +++ b/Source/WebCore/loader/cache/CachedResource.h @@ -28,6 +28,7 @@ #include "PlatformString.h" #include "PurgePriority.h" #include "ResourceLoadPriority.h" +#include "ResourceRequest.h" #include "ResourceResponse.h" #include <wtf/HashCountedSet.h> #include <wtf/HashSet.h> @@ -46,6 +47,7 @@ class CachedResourceRequest; class Frame; class InspectorResource; class PurgeableBuffer; +class SecurityOrigin; // A resource that is held in the cache. Classes who want to use this object should derive // from CachedResourceClient, to get the function calls in case the requested data has arrived. @@ -54,7 +56,7 @@ class CachedResource { WTF_MAKE_NONCOPYABLE(CachedResource); WTF_MAKE_FAST_ALLOCATED; friend class MemoryCache; friend class InspectorResource; - + public: enum Type { ImageResource, @@ -65,7 +67,9 @@ public: , XSLStyleSheet #endif #if ENABLE(LINK_PREFETCH) - , LinkResource + , LinkPrefetch + , LinkPrerender + , LinkSubresource #endif }; @@ -77,9 +81,9 @@ public: DecodeError }; - CachedResource(const String& url, Type); + CachedResource(const ResourceRequest&, Type); virtual ~CachedResource(); - + virtual void load(CachedResourceLoader* cachedResourceLoader) { load(cachedResourceLoader, false, DoSecurityCheck, true); } void load(CachedResourceLoader*, bool incremental, SecurityCheckPolicy, bool sendResourceLoadCallbacks); @@ -90,9 +94,10 @@ public: virtual bool shouldIgnoreHTTPStatusCodeErrors() const { return false; } - const String &url() const { return m_url; } + ResourceRequest& resourceRequest() { return m_resourceRequest; } + const KURL& url() const { return m_resourceRequest.url();} Type type() const { return static_cast<Type>(m_type); } - + ResourceLoadPriority loadPriority() const { return m_loadPriority; } void setLoadPriority(ResourceLoadPriority); @@ -122,7 +127,7 @@ public: unsigned encodedSize() const { return m_encodedSize; } unsigned decodedSize() const { return m_decodedSize; } unsigned overheadSize() const; - + bool isLoaded() const { return !m_loading; } // FIXME. Method name is inaccurate. Loading might not have started yet. bool isLoading() const { return m_loading; } @@ -133,7 +138,7 @@ public: bool isLinkResource() const { #if ENABLE(LINK_PREFETCH) - return type() == LinkResource; + return type() == LinkPrefetch || type() == LinkPrerender || type() == LinkSubresource; #else return false; #endif @@ -142,20 +147,22 @@ public: unsigned accessCount() const { return m_accessCount; } void increaseAccessCount() { m_accessCount++; } - // Computes the status of an object after loading. + // Computes the status of an object after loading. // Updates the expire date on the cache entry file void finish(); + bool passesAccessControlCheck(SecurityOrigin*); + // Called by the cache if the object has been removed from the cache // while still being referenced. This means the object should delete itself // if the number of clients observing it ever drops to 0. // The resource can be brought back to cache after successful revalidation. void setInCache(bool inCache) { m_inCache = inCache; } bool inCache() const { return m_inCache; } - + void setInLiveDecodedResourcesList(bool b) { m_inLiveDecodedResourcesList = b; } bool inLiveDecodedResourcesList() { return m_inLiveDecodedResourcesList; } - + void setRequest(CachedResourceRequest*); SharedBuffer* data() const { ASSERT(!m_purgeableData); return m_data.get(); } @@ -186,26 +193,26 @@ public: bool errorOccurred() const { return (status() == LoadError || status() == DecodeError); } bool sendResourceLoadCallbacks() const { return m_sendResourceLoadCallbacks; } - + virtual void destroyDecodedData() { } void setOwningCachedResourceLoader(CachedResourceLoader* cachedResourceLoader) { m_owningCachedResourceLoader = cachedResourceLoader; } - + bool isPreloaded() const { return m_preloadCount; } void increasePreloadCount() { ++m_preloadCount; } void decreasePreloadCount() { ASSERT(m_preloadCount); --m_preloadCount; } - + void registerHandle(CachedResourceHandleBase* h); void unregisterHandle(CachedResourceHandleBase* h); - + bool canUseCacheValidator() const; bool mustRevalidateDueToCacheHeaders(CachePolicy) const; bool isCacheValidator() const { return m_resourceToRevalidate; } CachedResource* resourceToRevalidate() const { return m_resourceToRevalidate; } - + bool isPurgeable() const; bool wasPurged() const; - + // This is used by the archive machinery to get at a purged resource without // triggering a load. We should make it protected again if we can find a // better way to handle the archive case. @@ -225,10 +232,10 @@ protected: void didAccessDecodedData(double timeStamp); bool isSafeToMakePurgeable() const; - + HashCountedSet<CachedResourceClient*> m_clients; - String m_url; + ResourceRequest m_resourceRequest; String m_accept; CachedResourceRequest* m_request; ResourceLoadPriority m_loadPriority; @@ -276,12 +283,12 @@ private: CachedResource* m_nextInAllResourcesList; CachedResource* m_prevInAllResourcesList; - + CachedResource* m_nextInLiveResourcesList; CachedResource* m_prevInLiveResourcesList; CachedResourceLoader* m_owningCachedResourceLoader; // only non-0 for resources that are not in the cache - + // If this field is non-null we are using the resource as a proxy for checking whether an existing resource is still up to date // using HTTP If-Modified-Since/If-None-Match headers. If the response is 304 all clients of this resource are moved // to to be clients of m_resourceToRevalidate and the resource is deleted. If not, the field is zeroed and this diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp index fe25a93..6511b5e 100644 --- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp +++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp @@ -55,24 +55,28 @@ namespace WebCore { -static CachedResource* createResource(CachedResource::Type type, const KURL& url, const String& charset) +static CachedResource* createResource(CachedResource::Type type, ResourceRequest& request, const String& charset) { switch (type) { case CachedResource::ImageResource: - return new CachedImage(url.string()); + return new CachedImage(request); case CachedResource::CSSStyleSheet: - return new CachedCSSStyleSheet(url.string(), charset); + return new CachedCSSStyleSheet(request, charset); case CachedResource::Script: - return new CachedScript(url.string(), charset); + return new CachedScript(request, charset); case CachedResource::FontResource: - return new CachedFont(url.string()); + return new CachedFont(request); #if ENABLE(XSLT) case CachedResource::XSLStyleSheet: - return new CachedXSLStyleSheet(url.string()); + return new CachedXSLStyleSheet(request); #endif #if ENABLE(LINK_PREFETCH) - case CachedResource::LinkResource: - return new CachedResource(url.string(), CachedResource::LinkResource); + case CachedResource::LinkPrefetch: + return new CachedResource(request, CachedResource::LinkPrefetch); + case CachedResource::LinkPrerender: + return new CachedResource(request, CachedResource::LinkPrerender); + case CachedResource::LinkSubresource: + return new CachedResource(request, CachedResource::LinkSubresource); #endif } ASSERT_NOT_REACHED(); @@ -106,16 +110,16 @@ CachedResourceLoader::~CachedResourceLoader() ASSERT(m_requestCount == 0); } -CachedResource* CachedResourceLoader::cachedResource(const String& resourceURL) const +CachedResource* CachedResourceLoader::cachedResource(const String& resourceURL) const { KURL url = m_document->completeURL(resourceURL); - return cachedResource(url); + return cachedResource(url); } CachedResource* CachedResourceLoader::cachedResource(const KURL& resourceURL) const { KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL); - return m_documentResources.get(url).get(); + return m_documentResources.get(url).get(); } Frame* CachedResourceLoader::frame() const @@ -123,7 +127,7 @@ Frame* CachedResourceLoader::frame() const return m_document ? m_document->frame() : 0; } -CachedImage* CachedResourceLoader::requestImage(const String& url) +CachedImage* CachedResourceLoader::requestImage(ResourceRequest& request) { if (Frame* f = frame()) { Settings* settings = f->settings(); @@ -131,22 +135,22 @@ CachedImage* CachedResourceLoader::requestImage(const String& url) return 0; if (f->loader()->pageDismissalEventBeingDispatched()) { - KURL completeURL = m_document->completeURL(url); - if (completeURL.isValid() && canRequest(CachedResource::ImageResource, completeURL)) - PingLoader::loadImage(f, completeURL); + KURL requestURL = request.url(); + if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL)) + PingLoader::loadImage(f, requestURL); return 0; } } - CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, url, String())); + CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String())); if (resource) { #ifdef ANDROID_BLOCK_NETWORK_IMAGE - resource->setAutoLoadWasPreventedBySettings(!autoLoadImages() || shouldBlockNetworkImage(url)); + resource->setAutoLoadWasPreventedBySettings(!autoLoadImages() || shouldBlockNetworkImage(request.url())); #else resource->setAutoLoadWasPreventedBySettings(!autoLoadImages()); #endif if (autoLoadImages() && resource->stillNeedsLoad()) { #ifdef ANDROID_BLOCK_NETWORK_IMAGE - if (shouldBlockNetworkImage(url)) { + if (shouldBlockNetworkImage(request.url())) { return resource; } #endif @@ -157,56 +161,60 @@ CachedImage* CachedResourceLoader::requestImage(const String& url) return resource; } -CachedFont* CachedResourceLoader::requestFont(const String& url) +CachedFont* CachedResourceLoader::requestFont(ResourceRequest& request) { - return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, url, String())); + return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String())); } -CachedCSSStyleSheet* CachedResourceLoader::requestCSSStyleSheet(const String& url, const String& charset, ResourceLoadPriority priority) +CachedCSSStyleSheet* CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority) { - return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, url, charset, priority)); + return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, priority)); } -CachedCSSStyleSheet* CachedResourceLoader::requestUserCSSStyleSheet(const String& requestURL, const String& charset) +CachedCSSStyleSheet* CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequest& request, const String& charset) { - KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(KURL(KURL(), requestURL)); + KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.url()); if (CachedResource* existing = memoryCache()->resourceForURL(url)) { if (existing->type() == CachedResource::CSSStyleSheet) return static_cast<CachedCSSStyleSheet*>(existing); memoryCache()->remove(existing); } - CachedCSSStyleSheet* userSheet = new CachedCSSStyleSheet(url, charset); - + if (url.string() != request.url()) + request.setURL(url); + + CachedCSSStyleSheet* userSheet = new CachedCSSStyleSheet(request, charset); + bool inCache = memoryCache()->add(userSheet); if (!inCache) userSheet->setInCache(true); - + userSheet->load(this, /*incremental*/ false, SkipSecurityCheck, /*sendResourceLoadCallbacks*/ false); if (!inCache) userSheet->setInCache(false); - + return userSheet; } -CachedScript* CachedResourceLoader::requestScript(const String& url, const String& charset) +CachedScript* CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset) { - return static_cast<CachedScript*>(requestResource(CachedResource::Script, url, charset)); + return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset)); } #if ENABLE(XSLT) -CachedXSLStyleSheet* CachedResourceLoader::requestXSLStyleSheet(const String& url) +CachedXSLStyleSheet* CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request) { - return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, url, String())); + return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String())); } #endif #if ENABLE(LINK_PREFETCH) -CachedResource* CachedResourceLoader::requestLinkResource(const String& url, ResourceLoadPriority priority) +CachedResource* CachedResourceLoader::requestLinkResource(CachedResource::Type type, ResourceRequest& request, ResourceLoadPriority priority) { ASSERT(frame()); - return requestResource(CachedResource::LinkResource, url, String(), priority); + ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkPrerender || type == CachedResource::LinkSubresource); + return requestResource(type, request, String(), priority); } #endif @@ -221,7 +229,9 @@ bool CachedResourceLoader::canRequest(CachedResource::Type type, const KURL& url case CachedResource::Script: case CachedResource::FontResource: #if ENABLE(LINK_PREFETCH) - case CachedResource::LinkResource: + case CachedResource::LinkPrefetch: + case CachedResource::LinkPrerender: + case CachedResource::LinkSubresource: #endif // These types of resources can be loaded from any origin. // FIXME: Are we sure about CachedResource::FontResource? @@ -242,7 +252,7 @@ bool CachedResourceLoader::canRequest(CachedResource::Type type, const KURL& url // Note: Currently, we always allow mixed content, but we generate a // callback to the FrameLoaderClient in case the embedder wants to // update any security indicators. - // + // switch (type) { case CachedResource::Script: #if ENABLE(XSLT) @@ -263,7 +273,9 @@ bool CachedResourceLoader::canRequest(CachedResource::Type type, const KURL& url break; } #if ENABLE(LINK_PREFETCH) - case CachedResource::LinkResource: + case CachedResource::LinkPrefetch: + case CachedResource::LinkPrerender: + case CachedResource::LinkSubresource: // Prefetch cannot affect the current document. break; #endif @@ -292,9 +304,9 @@ bool CachedResourceLoader::canRequest(CachedResource::Type type, const KURL& url break; } #if ENABLE(LINK_PREFETCH) - case CachedResource::LinkResource: - if (!m_document->settings()->linkPrefetchEnabled()) - return false; + case CachedResource::LinkPrefetch: + case CachedResource::LinkPrerender: + case CachedResource::LinkSubresource: break; #endif } @@ -302,18 +314,18 @@ bool CachedResourceLoader::canRequest(CachedResource::Type type, const KURL& url return true; } -CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, const String& resourceURL, const String& charset, ResourceLoadPriority priority, bool forPreload) +CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, ResourceLoadPriority priority, bool forPreload) { - KURL url = m_document->completeURL(resourceURL); - + KURL url = request.url(); + LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.string().latin1().data(), charset.latin1().data(), priority, forPreload); - + // If only the fragment identifiers differ, it is the same resource. url = MemoryCache::removeFragmentIdentifierIfNeeded(url); if (!url.isValid()) return 0; - + if (!canRequest(type, url)) return 0; @@ -336,13 +348,16 @@ CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, // See if we can use an existing resource from the cache. CachedResource* resource = memoryCache()->resourceForURL(url); + if (request.url() != url) + request.setURL(url); + switch (determineRevalidationPolicy(type, forPreload, resource)) { case Load: - resource = loadResource(type, url, charset, priority); + resource = loadResource(type, request, charset, priority); break; case Reload: memoryCache()->remove(resource); - resource = loadResource(type, url, charset, priority); + resource = loadResource(type, request, charset, priority); break; case Revalidate: resource = revalidateResource(resource, priority); @@ -358,10 +373,10 @@ CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, ASSERT(resource->url() == url.string()); m_documentResources.set(resource->url(), resource); - + return resource; } - + CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resource, ResourceLoadPriority priority) { ASSERT(resource); @@ -369,42 +384,42 @@ CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resourc ASSERT(!memoryCache()->disabled()); ASSERT(resource->canUseCacheValidator()); ASSERT(!resource->resourceToRevalidate()); - + // Copy the URL out of the resource to be revalidated in case it gets deleted by the remove() call below. String url = resource->url(); - CachedResource* newResource = createResource(resource->type(), KURL(ParsedURLString, url), resource->encoding()); - + CachedResource* newResource = createResource(resource->type(), resource->resourceRequest(), resource->encoding()); + LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource, resource); newResource->setResourceToRevalidate(resource); - + memoryCache()->remove(resource); memoryCache()->add(newResource); - + newResource->setLoadPriority(priority); newResource->load(this); - + m_validatedURLs.add(url); return newResource; } -CachedResource* CachedResourceLoader::loadResource(CachedResource::Type type, const KURL& url, const String& charset, ResourceLoadPriority priority) +CachedResource* CachedResourceLoader::loadResource(CachedResource::Type type, ResourceRequest& request, const String& charset, ResourceLoadPriority priority) { - ASSERT(!memoryCache()->resourceForURL(url)); - - LOG(ResourceLoading, "Loading CachedResource for '%s'.", url.string().latin1().data()); - - CachedResource* resource = createResource(type, url, charset); - + ASSERT(!memoryCache()->resourceForURL(request.url())); + + LOG(ResourceLoading, "Loading CachedResource for '%s'.", request.url().string().latin1().data()); + + CachedResource* resource = createResource(type, request, charset); + bool inCache = memoryCache()->add(resource); - + // Pretend the resource is in the cache, to prevent it from being deleted during the load() call. // FIXME: CachedResource should just use normal refcounting instead. if (!inCache) resource->setInCache(true); - + resource->setLoadPriority(priority); resource->load(this); - + if (!inCache) { resource->setOwningCachedResourceLoader(this); resource->setInCache(false); @@ -419,7 +434,7 @@ CachedResource* CachedResourceLoader::loadResource(CachedResource::Type type, co return 0; } - m_validatedURLs.add(url.string()); + m_validatedURLs.add(request.url()); return resource; } @@ -427,25 +442,25 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida { if (!existingResource) return Load; - + // We already have a preload going for this URL. if (forPreload && existingResource->isPreloaded()) return Use; - + // If the same URL has been loaded as a different type, we need to reload. if (existingResource->type() != type) { LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to type mismatch."); return Reload; } - + // Don't reload resources while pasting. if (m_allowStaleResources) return Use; - + // Alwaus use preloads. if (existingResource->isPreloaded()) return Use; - + // CachePolicyHistoryBuffer uses the cache no matter what. if (cachePolicy() == CachePolicyHistoryBuffer) return Use; @@ -459,19 +474,19 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida // Avoid loading the same resource multiple times for a single document, even if the cache policies would tell us to. if (m_validatedURLs.contains(existingResource->url())) return Use; - + // CachePolicyReload always reloads if (cachePolicy() == CachePolicyReload) { LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to CachePolicyReload."); return Reload; } - + // We'll try to reload the resource if it failed last time. if (existingResource->errorOccurred()) { LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicye reloading due to resource being in the error state"); return Reload; } - + // For resources that are not yet loaded we ignore the cache policy. if (existingResource->isLoading()) return Use; @@ -481,9 +496,9 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida // See if the resource has usable ETag or Last-modified headers. if (existingResource->canUseCacheValidator()) return Revalidate; - + // No, must reload. - LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to missing cache validators."); + LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to missing cache validators."); return Reload; } @@ -675,8 +690,8 @@ int CachedResourceLoader::requestCount() return m_requestCount + 1; return m_requestCount; } - -void CachedResourceLoader::preload(CachedResource::Type type, const String& url, const String& charset, bool referencedFromBody) + +void CachedResourceLoader::preload(CachedResource::Type type, ResourceRequest& request, const String& charset, bool referencedFromBody) { // FIXME: Rip this out when we are sure it is no longer necessary (even for mobile). UNUSED_PARAM(referencedFromBody); @@ -686,33 +701,33 @@ void CachedResourceLoader::preload(CachedResource::Type type, const String& url, if (!hasRendering && !canBlockParser) { // Don't preload subresources that can't block the parser before we have something to draw. // This helps prevent preloads from delaying first display when bandwidth is limited. - PendingPreload pendingPreload = { type, url, charset }; + PendingPreload pendingPreload = { type, request, charset }; m_pendingPreloads.append(pendingPreload); return; } - requestPreload(type, url, charset); + requestPreload(type, request, charset); } -void CachedResourceLoader::checkForPendingPreloads() +void CachedResourceLoader::checkForPendingPreloads() { if (m_pendingPreloads.isEmpty() || !m_document->body() || !m_document->body()->renderer()) return; while (!m_pendingPreloads.isEmpty()) { PendingPreload preload = m_pendingPreloads.takeFirst(); // Don't request preload if the resource already loaded normally (this will result in double load if the page is being reloaded with cached results ignored). - if (!cachedResource(m_document->completeURL(preload.m_url))) - requestPreload(preload.m_type, preload.m_url, preload.m_charset); + if (!cachedResource(preload.m_request.url())) + requestPreload(preload.m_type, preload.m_request, preload.m_charset); } m_pendingPreloads.clear(); } -void CachedResourceLoader::requestPreload(CachedResource::Type type, const String& url, const String& charset) +void CachedResourceLoader::requestPreload(CachedResource::Type type, ResourceRequest& request, const String& charset) { String encoding; if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet) encoding = charset.isEmpty() ? m_document->charset() : charset; - CachedResource* resource = requestResource(type, url, encoding, ResourceLoadPriorityUnresolved, true); + CachedResource* resource = requestResource(type, request, encoding, ResourceLoadPriorityUnresolved, true); if (!resource || (m_preloads && m_preloads->contains(resource))) return; resource->increasePreloadCount(); @@ -769,7 +784,7 @@ void CachedResourceLoader::printPreloadStats() printf("HIT COMPLETE PRELOAD %s\n", res->url().latin1().data()); else if (res->preloadResult() == CachedResource::PreloadReferencedWhileLoading) printf("HIT LOADING PRELOAD %s\n", res->url().latin1().data()); - + if (res->type() == CachedResource::Script) { scripts++; if (res->preloadResult() < CachedResource::PreloadReferencedWhileLoading) @@ -783,14 +798,14 @@ void CachedResourceLoader::printPreloadStats() if (res->preloadResult() < CachedResource::PreloadReferencedWhileLoading) imageMisses++; } - + if (res->errorOccurred()) memoryCache()->remove(res); - + res->decreasePreloadCount(); } m_preloads.clear(); - + if (scripts) printf("SCRIPTS: %d (%d hits, hit rate %d%%)\n", scripts, scripts - scriptMisses, (scripts - scriptMisses) * 100 / scripts); if (stylesheets) @@ -799,5 +814,5 @@ void CachedResourceLoader::printPreloadStats() printf("IMAGES: %d (%d hits, hit rate %d%%)\n", images, images - imageMisses, (images - imageMisses) * 100 / images); } #endif - + } diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.h b/Source/WebCore/loader/cache/CachedResourceLoader.h index 79c63b9..a3933f3 100644 --- a/Source/WebCore/loader/cache/CachedResourceLoader.h +++ b/Source/WebCore/loader/cache/CachedResourceLoader.h @@ -59,17 +59,17 @@ public: CachedResourceLoader(Document*); ~CachedResourceLoader(); - CachedImage* requestImage(const String& url); - CachedCSSStyleSheet* requestCSSStyleSheet(const String& url, const String& charset, ResourceLoadPriority priority = ResourceLoadPriorityUnresolved); - CachedCSSStyleSheet* requestUserCSSStyleSheet(const String& url, const String& charset); - CachedScript* requestScript(const String& url, const String& charset); - CachedFont* requestFont(const String& url); + CachedImage* requestImage(ResourceRequest&); + CachedCSSStyleSheet* requestCSSStyleSheet(ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved); + CachedCSSStyleSheet* requestUserCSSStyleSheet(ResourceRequest&, const String& charset); + CachedScript* requestScript(ResourceRequest&, const String& charset); + CachedFont* requestFont(ResourceRequest&); #if ENABLE(XSLT) - CachedXSLStyleSheet* requestXSLStyleSheet(const String& url); + CachedXSLStyleSheet* requestXSLStyleSheet(ResourceRequest&); #endif #if ENABLE(LINK_PREFETCH) - CachedResource* requestLinkResource(const String &url, ResourceLoadPriority priority = ResourceLoadPriorityUnresolved); + CachedResource* requestLinkResource(CachedResource::Type, ResourceRequest&, ResourceLoadPriority = ResourceLoadPriorityUnresolved); #endif // Logs an access denied message to the console for the specified URL. @@ -110,15 +110,15 @@ public: void clearPreloads(); void clearPendingPreloads(); - void preload(CachedResource::Type, const String& url, const String& charset, bool referencedFromBody); + void preload(CachedResource::Type, ResourceRequest&, const String& charset, bool referencedFromBody); void checkForPendingPreloads(); void printPreloadStats(); private: - CachedResource* requestResource(CachedResource::Type, const String& url, const String& charset, ResourceLoadPriority priority = ResourceLoadPriorityUnresolved, bool isPreload = false); + CachedResource* requestResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false); CachedResource* revalidateResource(CachedResource*, ResourceLoadPriority priority); - CachedResource* loadResource(CachedResource::Type, const KURL&, const String& charset, ResourceLoadPriority priority); - void requestPreload(CachedResource::Type, const String& url, const String& charset); + CachedResource* loadResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority); + void requestPreload(CachedResource::Type, ResourceRequest& url, const String& charset); enum RevalidationPolicy { Use, Revalidate, Reload, Load }; RevalidationPolicy determineRevalidationPolicy(CachedResource::Type, bool forPreload, CachedResource* existingResource) const; @@ -142,7 +142,7 @@ private: OwnPtr<ListHashSet<CachedResource*> > m_preloads; struct PendingPreload { CachedResource::Type m_type; - String m_url; + ResourceRequest m_request; String m_charset; }; Deque<PendingPreload> m_pendingPreloads; diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.cpp b/Source/WebCore/loader/cache/CachedResourceRequest.cpp index 9e7fe8f..e4e6b8b 100644 --- a/Source/WebCore/loader/cache/CachedResourceRequest.cpp +++ b/Source/WebCore/loader/cache/CachedResourceRequest.cpp @@ -42,11 +42,8 @@ namespace WebCore { -static ResourceRequest::TargetType cachedResourceTypeToTargetType(CachedResource::Type type, ResourceLoadPriority priority) +static ResourceRequest::TargetType cachedResourceTypeToTargetType(CachedResource::Type type) { -#if !ENABLE(LINK_PREFETCH) - UNUSED_PARAM(priority); -#endif switch (type) { case CachedResource::CSSStyleSheet: #if ENABLE(XSLT) @@ -60,9 +57,11 @@ static ResourceRequest::TargetType cachedResourceTypeToTargetType(CachedResource case CachedResource::ImageResource: return ResourceRequest::TargetIsImage; #if ENABLE(LINK_PREFETCH) - case CachedResource::LinkResource: - if (priority == ResourceLoadPriorityLowest) - return ResourceRequest::TargetIsPrefetch; + case CachedResource::LinkPrefetch: + return ResourceRequest::TargetIsPrefetch; + case CachedResource::LinkPrerender: + return ResourceRequest::TargetIsSubresource; + case CachedResource::LinkSubresource: return ResourceRequest::TargetIsSubresource; #endif } @@ -89,8 +88,8 @@ PassRefPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoad { RefPtr<CachedResourceRequest> request = adoptRef(new CachedResourceRequest(cachedResourceLoader, resource, incremental)); - ResourceRequest resourceRequest(resource->url()); - resourceRequest.setTargetType(cachedResourceTypeToTargetType(resource->type(), resource->loadPriority())); + ResourceRequest resourceRequest = resource->resourceRequest(); + resourceRequest.setTargetType(cachedResourceTypeToTargetType(resource->type())); if (!resource->accept().isEmpty()) resourceRequest.setHTTPAccept(resource->accept()); @@ -113,7 +112,7 @@ PassRefPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoad } #if ENABLE(LINK_PREFETCH) - if (resource->type() == CachedResource::LinkResource) + if (resource->type() == CachedResource::LinkPrefetch || resource->type() == CachedResource::LinkPrerender || resource->type() == CachedResource::LinkSubresource) resourceRequest.setHTTPHeaderField("Purpose", "prefetch"); #endif @@ -124,7 +123,7 @@ PassRefPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoad request.get(), resourceRequest, priority, securityCheck, sendResourceLoadCallbacks); if (!loader || loader->reachedTerminalState()) { // FIXME: What if resources in other frames were waiting for this revalidation? - LOG(ResourceLoading, "Cannot start loading '%s'", resource->url().latin1().data()); + LOG(ResourceLoading, "Cannot start loading '%s'", resource->url().string().latin1().data()); cachedResourceLoader->decrementRequestCount(resource); cachedResourceLoader->loadFinishing(); if (resource->resourceToRevalidate()) @@ -149,7 +148,7 @@ void CachedResourceRequest::didFinishLoading(SubresourceLoader* loader, double) ASSERT(loader == m_loader.get()); ASSERT(!m_resource->resourceToRevalidate()); - LOG(ResourceLoading, "Received '%s'.", m_resource->url().latin1().data()); + LOG(ResourceLoading, "Received '%s'.", m_resource->url().string().latin1().data()); // Prevent the document from being destroyed before we are done with // the cachedResourceLoader that it will delete when the document gets deleted. @@ -181,7 +180,7 @@ void CachedResourceRequest::didFail(bool cancelled) if (m_finishing) return; - LOG(ResourceLoading, "Failed to load '%s' (cancelled=%d).\n", m_resource->url().latin1().data(), cancelled); + LOG(ResourceLoading, "Failed to load '%s' (cancelled=%d).\n", m_resource->url().string().latin1().data(), cancelled); // Prevent the document from being destroyed before we are done with // the cachedResourceLoader that it will delete when the document gets deleted. diff --git a/Source/WebCore/loader/cache/CachedScript.cpp b/Source/WebCore/loader/cache/CachedScript.cpp index e1a8a32..8c83bca 100644 --- a/Source/WebCore/loader/cache/CachedScript.cpp +++ b/Source/WebCore/loader/cache/CachedScript.cpp @@ -40,8 +40,8 @@ namespace WebCore { -CachedScript::CachedScript(const String& url, const String& charset) - : CachedResource(url, Script) +CachedScript::CachedScript(const ResourceRequest& resourceRequest, const String& charset) + : CachedResource(resourceRequest, Script) , m_decoder(TextResourceDecoder::create("application/javascript", charset)) , m_decodedDataDeletionTimer(this, &CachedScript::decodedDataDeletionTimerFired) { diff --git a/Source/WebCore/loader/cache/CachedScript.h b/Source/WebCore/loader/cache/CachedScript.h index a4ea453..1a76c18 100644 --- a/Source/WebCore/loader/cache/CachedScript.h +++ b/Source/WebCore/loader/cache/CachedScript.h @@ -42,7 +42,7 @@ namespace WebCore { class CachedScript : public CachedResource { public: - CachedScript(const String& url, const String& charset); + CachedScript(const ResourceRequest&, const String& charset); virtual ~CachedScript(); const String& script(); diff --git a/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp b/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp index ca7bf13..62e5048 100644 --- a/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp +++ b/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp @@ -37,8 +37,8 @@ namespace WebCore { #if ENABLE(XSLT) -CachedXSLStyleSheet::CachedXSLStyleSheet(const String &url) - : CachedResource(url, XSLStyleSheet) +CachedXSLStyleSheet::CachedXSLStyleSheet(const ResourceRequest& resourceRequest) + : CachedResource(resourceRequest, XSLStyleSheet) , m_decoder(TextResourceDecoder::create("text/xsl")) { // It's XML we want. @@ -49,7 +49,7 @@ CachedXSLStyleSheet::CachedXSLStyleSheet(const String &url) void CachedXSLStyleSheet::didAddClient(CachedResourceClient* c) { if (!isLoading()) - c->setXSLStyleSheet(m_url, m_response.url(), m_sheet); + c->setXSLStyleSheet(m_resourceRequest.url(), m_response.url(), m_sheet); } void CachedXSLStyleSheet::setEncoding(const String& chs) @@ -84,7 +84,7 @@ void CachedXSLStyleSheet::checkNotify() CachedResourceClientWalker w(m_clients); while (CachedResourceClient *c = w.next()) - c->setXSLStyleSheet(m_url, m_response.url(), m_sheet); + c->setXSLStyleSheet(m_resourceRequest.url(), m_response.url(), m_sheet); } void CachedXSLStyleSheet::error(CachedResource::Status status) diff --git a/Source/WebCore/loader/cache/CachedXSLStyleSheet.h b/Source/WebCore/loader/cache/CachedXSLStyleSheet.h index 8b29792..b8f7283 100644 --- a/Source/WebCore/loader/cache/CachedXSLStyleSheet.h +++ b/Source/WebCore/loader/cache/CachedXSLStyleSheet.h @@ -37,7 +37,7 @@ namespace WebCore { #if ENABLE(XSLT) class CachedXSLStyleSheet : public CachedResource { public: - CachedXSLStyleSheet(const String& url); + CachedXSLStyleSheet(const ResourceRequest&); const String& sheet() const { return m_sheet; } diff --git a/Source/WebCore/loader/cache/MemoryCache.cpp b/Source/WebCore/loader/cache/MemoryCache.cpp index cb11e15..363668c 100644 --- a/Source/WebCore/loader/cache/MemoryCache.cpp +++ b/Source/WebCore/loader/cache/MemoryCache.cpp @@ -93,7 +93,7 @@ bool MemoryCache::add(CachedResource* resource) resourceAccessed(resource); - LOG(ResourceLoading, "MemoryCache::add Added '%s', resource %p\n", resource->url().latin1().data(), resource); + LOG(ResourceLoading, "MemoryCache::add Added '%s', resource %p\n", resource->url().string().latin1().data(), resource); return true; } @@ -323,7 +323,7 @@ bool MemoryCache::makeResourcePurgeable(CachedResource* resource) void MemoryCache::evict(CachedResource* resource) { - LOG(ResourceLoading, "Evicting resource %p for '%s' from cache", resource, resource->url().latin1().data()); + LOG(ResourceLoading, "Evicting resource %p for '%s' from cache", resource, resource->url().string().latin1().data()); // The resource may have already been removed by someone other than our caller, // who needed a fresh copy for a reload. See <http://bugs.webkit.org/show_bug.cgi?id=12479#c6>. if (resource->inCache()) { |