Refactor CachedResourceLoader: add CachedResourceRequest
https://bugs.webkit.org/show_bug.cgi?id=99736
Patch by Marja Hölttä <marja@chromium.org> on 2012-10-22
Reviewed by Adam Barth.
For fixing bugs 84883 and 92761,
CachedResourceLoader::requestResource should take as parameter
information about who initiated the request. But the parameter
list was already long. This gathers all the parameters into a
separate class, CachedResourceRequest. The next step is to add
information about who initiated the request into
CachedResourceRequest.
No new tests because no changes in functionality, just moving code
around.
* CMakeLists.txt:
* GNUmakefile.list.am:
* Target.pri:
* WebCore.gypi:
* WebCore.vcproj/WebCore.vcproj:
* WebCore.xcodeproj/project.pbxproj:
* css/CSSFontFaceSrcValue.cpp:
(WebCore::CSSFontFaceSrcValue::cachedFont):
* css/CSSImageSetValue.cpp:
(WebCore::CSSImageSetValue::cachedImageSet):
* css/CSSImageValue.cpp:
(WebCore::CSSImageValue::cachedImage):
* css/StyleRuleImport.cpp:
(WebCore::StyleRuleImport::requestStyleSheet):
* css/WebKitCSSSVGDocumentValue.cpp:
(WebCore::WebKitCSSSVGDocumentValue::load):
* css/WebKitCSSShaderValue.cpp:
(WebCore::WebKitCSSShaderValue::cachedShader):
* dom/ProcessingInstruction.cpp:
(WebCore::ProcessingInstruction::checkStyleSheet):
* dom/ScriptElement.cpp:
(WebCore::ScriptElement::requestScript):
* html/HTMLLinkElement.cpp:
(WebCore::HTMLLinkElement::process):
* loader/DocumentThreadableLoader.cpp:
(WebCore::DocumentThreadableLoader::loadRequest):
* loader/ImageLoader.cpp:
(WebCore::ImageLoader::updateFromElement):
* loader/LinkLoader.cpp:
(WebCore::LinkLoader::loadLink):
* loader/TextTrackLoader.cpp:
(WebCore::TextTrackLoader::load):
* loader/cache/CachedResourceLoader.cpp:
(WebCore::CachedResourceLoader::requestImage):
(WebCore::CachedResourceLoader::requestFont):
(WebCore::CachedResourceLoader::requestTextTrack):
(WebCore::CachedResourceLoader::requestShader):
(WebCore::CachedResourceLoader::requestCSSStyleSheet):
(WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
(WebCore::CachedResourceLoader::requestScript):
(WebCore::CachedResourceLoader::requestXSLStyleSheet):
(WebCore::CachedResourceLoader::requestSVGDocument):
(WebCore::CachedResourceLoader::requestLinkResource):
(WebCore::CachedResourceLoader::requestRawResource):
(WebCore::CachedResourceLoader::requestResource):
(WebCore::CachedResourceLoader::requestPreload):
(WebCore::CachedResourceLoader::defaultCachedResourceOptions):
(WebCore):
* loader/cache/CachedResourceLoader.h:
(WebCore):
(CachedResourceLoader):
* loader/cache/CachedResourceRequest.cpp: Added.
(WebCore):
(WebCore::CachedResourceRequest::CachedResourceRequest):
* loader/cache/CachedResourceRequest.h: Added.
(WebCore):
(CachedResourceRequest):
(WebCore::CachedResourceRequest::mutableResourceRequest):
(WebCore::CachedResourceRequest::resourceRequest):
(WebCore::CachedResourceRequest::charset):
(WebCore::CachedResourceRequest::setCharset):
(WebCore::CachedResourceRequest::options):
(WebCore::CachedResourceRequest::priority):
(WebCore::CachedResourceRequest::forPreload):
(WebCore::CachedResourceRequest::setForPreload):
(WebCore::CachedResourceRequest::defer):
(WebCore::CachedResourceRequest::setDefer):
* loader/icon/IconLoader.cpp:
(WebCore::IconLoader::startLoading):
* svg/SVGFEImageElement.cpp:
(WebCore::SVGFEImageElement::requestImageResource):
* svg/SVGFontFaceUriElement.cpp:
(WebCore::SVGFontFaceUriElement::loadFont):
* svg/SVGUseElement.cpp:
(WebCore::SVGUseElement::svgAttributeChanged):
* xml/XSLImportRule.cpp:
(WebCore::XSLImportRule::loadSheet):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@132157 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/WebCore/loader/DocumentThreadableLoader.cpp b/Source/WebCore/loader/DocumentThreadableLoader.cpp
index 71a1ad3..9c889cd 100644
--- a/Source/WebCore/loader/DocumentThreadableLoader.cpp
+++ b/Source/WebCore/loader/DocumentThreadableLoader.cpp
@@ -33,6 +33,7 @@
#include "CachedRawResource.h"
#include "CachedResourceLoader.h"
+#include "CachedResourceRequest.h"
#include "CrossOriginAccessControl.h"
#include "CrossOriginPreflightResultCache.h"
#include "Document.h"
@@ -376,17 +377,17 @@
options.shouldBufferData = BufferData;
}
- ResourceRequest newRequest(request);
+ CachedResourceRequest newRequest(request, options);
#if ENABLE(INSPECTOR)
if (m_actualRequest) {
// Because willSendRequest only gets called during redirects, we initialize the identifier and the first willSendRequest here.
m_preflightRequestIdentifier = m_document->frame()->page()->progress()->createUniqueIdentifier();
ResourceResponse redirectResponse = ResourceResponse();
- InspectorInstrumentation::willSendRequest(m_document->frame(), m_preflightRequestIdentifier, m_document->frame()->loader()->documentLoader(), newRequest, redirectResponse);
+ InspectorInstrumentation::willSendRequest(m_document->frame(), m_preflightRequestIdentifier, m_document->frame()->loader()->documentLoader(), newRequest.mutableResourceRequest(), redirectResponse);
}
#endif
ASSERT(!m_resource);
- m_resource = m_document->cachedResourceLoader()->requestRawResource(newRequest, options);
+ m_resource = m_document->cachedResourceLoader()->requestRawResource(newRequest);
if (m_resource) {
#if ENABLE(INSPECTOR)
if (m_resource->loader()) {
diff --git a/Source/WebCore/loader/ImageLoader.cpp b/Source/WebCore/loader/ImageLoader.cpp
index a6da61e..c12be2f 100644
--- a/Source/WebCore/loader/ImageLoader.cpp
+++ b/Source/WebCore/loader/ImageLoader.cpp
@@ -24,6 +24,7 @@
#include "CachedImage.h"
#include "CachedResourceLoader.h"
+#include "CachedResourceRequest.h"
#include "CrossOriginAccessControl.h"
#include "Document.h"
#include "Element.h"
@@ -177,18 +178,18 @@
// an empty string.
CachedResourceHandle<CachedImage> newImage = 0;
if (!attr.isNull() && !stripLeadingAndTrailingHTMLSpaces(attr).isEmpty()) {
- ResourceRequest request = ResourceRequest(document()->completeURL(sourceURI(attr)));
+ CachedResourceRequest request(ResourceRequest(document()->completeURL(sourceURI(attr))));
String crossOriginMode = client()->sourceElement()->fastGetAttribute(HTMLNames::crossoriginAttr);
if (!crossOriginMode.isNull()) {
StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
- updateRequestForAccessControl(request, document()->securityOrigin(), allowCredentials);
+ updateRequestForAccessControl(request.mutableResourceRequest(), document()->securityOrigin(), allowCredentials);
}
if (m_loadManually) {
bool autoLoadOtherImages = document()->cachedResourceLoader()->autoLoadImages();
document()->cachedResourceLoader()->setAutoLoadImages(false);
- newImage = new CachedImage(request);
+ newImage = new CachedImage(request.resourceRequest());
newImage->setLoading(true);
newImage->setOwningCachedResourceLoader(document()->cachedResourceLoader());
document()->cachedResourceLoader()->m_documentResources.set(newImage->url(), newImage.get());
diff --git a/Source/WebCore/loader/LinkLoader.cpp b/Source/WebCore/loader/LinkLoader.cpp
index af25a86..e50b379 100644
--- a/Source/WebCore/loader/LinkLoader.cpp
+++ b/Source/WebCore/loader/LinkLoader.cpp
@@ -35,6 +35,7 @@
#include "CSSStyleSheet.h"
#include "CachedCSSStyleSheet.h"
#include "CachedResourceLoader.h"
+#include "CachedResourceRequest.h"
#include "ContainerNode.h"
#include "DNS.h"
#include "Document.h"
@@ -119,13 +120,13 @@
priority = ResourceLoadPriorityLow;
type = CachedResource::LinkSubresource;
}
- ResourceRequest linkRequest(document->completeURL(href));
+ CachedResourceRequest linkRequest(ResourceRequest(document->completeURL(href)), priority);
if (m_cachedLinkResource) {
m_cachedLinkResource->removeClient(this);
m_cachedLinkResource = 0;
}
- m_cachedLinkResource = document->cachedResourceLoader()->requestLinkResource(type, linkRequest, priority);
+ m_cachedLinkResource = document->cachedResourceLoader()->requestLinkResource(type, linkRequest);
if (m_cachedLinkResource)
m_cachedLinkResource->addClient(this);
}
diff --git a/Source/WebCore/loader/TextTrackLoader.cpp b/Source/WebCore/loader/TextTrackLoader.cpp
index a9b7f96..7e14b43 100644
--- a/Source/WebCore/loader/TextTrackLoader.cpp
+++ b/Source/WebCore/loader/TextTrackLoader.cpp
@@ -30,6 +30,7 @@
#include "TextTrackLoader.h"
#include "CachedResourceLoader.h"
+#include "CachedResourceRequest.h"
#include "CachedTextTrack.h"
#include "CrossOriginAccessControl.h"
#include "Document.h"
@@ -153,12 +154,12 @@
ASSERT(m_scriptExecutionContext->isDocument());
Document* document = static_cast<Document*>(m_scriptExecutionContext);
- ResourceRequest cueRequest(document->completeURL(url));
+ CachedResourceRequest cueRequest(ResourceRequest(document->completeURL(url)));
if (!crossOriginMode.isNull()) {
m_crossOriginMode = crossOriginMode;
StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
- updateRequestForAccessControl(cueRequest, document->securityOrigin(), allowCredentials);
+ updateRequestForAccessControl(cueRequest.mutableResourceRequest(), document->securityOrigin(), allowCredentials);
} else {
// Cross-origin resources that are not suitably CORS-enabled may not load.
if (!document->securityOrigin()->canRequest(url)) {
diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
index 1ffca4f..1ccaed9 100644
--- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
@@ -32,6 +32,7 @@
#include "CachedFont.h"
#include "CachedImage.h"
#include "CachedRawResource.h"
+#include "CachedResourceRequest.h"
#include "CachedScript.h"
#include "CachedXSLStyleSheet.h"
#include "Console.h"
@@ -107,12 +108,6 @@
return 0;
}
-static const ResourceLoaderOptions& defaultCachedResourceOptions()
-{
- static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck);
- return options;
-}
-
CachedResourceLoader::CachedResourceLoader(DocumentLoader* documentLoader)
: m_document(0)
, m_documentLoader(documentLoader)
@@ -155,56 +150,57 @@
return m_documentLoader ? m_documentLoader->frame() : 0;
}
-CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(ResourceRequest& request)
+CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request)
{
if (Frame* f = frame()) {
if (f->loader()->pageDismissalEventBeingDispatched() != FrameLoader::NoDismissal) {
- KURL requestURL = request.url();
+ KURL requestURL = request.resourceRequest().url();
if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL))
PingLoader::loadImage(f, requestURL);
return 0;
}
}
- return static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String(), defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, false, clientDefersImage(request.url()) ? DeferredByClient : NoDefer).get());
+ request.setDefer(clientDefersImage(request.resourceRequest().url()) ? DeferredByClient : NoDefer);
+ return static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request).get());
}
-CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(ResourceRequest& request)
+CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest& request)
{
- return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String(), defaultCachedResourceOptions()).get());
+ return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request).get());
}
#if ENABLE(VIDEO_TRACK)
-CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(ResourceRequest& request)
+CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest& request)
{
- return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request, String(), defaultCachedResourceOptions()).get());
+ return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request).get());
}
#endif
#if ENABLE(CSS_SHADERS)
-CachedResourceHandle<CachedShader> CachedResourceLoader::requestShader(ResourceRequest& request)
+CachedResourceHandle<CachedShader> CachedResourceLoader::requestShader(CachedResourceRequest& request)
{
- return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request, String(), defaultCachedResourceOptions()).get());
+ return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request).get());
}
#endif
-CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority)
+CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest& request)
{
- return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, defaultCachedResourceOptions(), priority).get());
+ return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request).get());
}
-CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequest& request, const String& charset)
+CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest& request)
{
- KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.url());
+ KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.resourceRequest().url());
if (CachedResource* existing = memoryCache()->resourceForURL(url)) {
if (existing->type() == CachedResource::CSSStyleSheet)
return static_cast<CachedCSSStyleSheet*>(existing);
memoryCache()->remove(existing);
}
- if (url.string() != request.url())
- request.setURL(url);
+ if (url.string() != request.resourceRequest().url())
+ request.mutableResourceRequest().setURL(url);
- CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request, charset);
+ CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request.resourceRequest(), request.charset());
memoryCache()->add(userSheet.get());
// FIXME: loadResource calls setOwningCachedResourceLoader() if the resource couldn't be added to cache. Does this function need to call it, too?
@@ -214,37 +210,37 @@
return userSheet;
}
-CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset)
+CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(CachedResourceRequest& request)
{
- return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset, defaultCachedResourceOptions()).get());
+ return static_cast<CachedScript*>(requestResource(CachedResource::Script, request).get());
}
#if ENABLE(XSLT)
-CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request)
+CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest& request)
{
- return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String(), defaultCachedResourceOptions()).get());
+ return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request).get());
}
#endif
#if ENABLE(SVG)
-CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(ResourceRequest& request)
+CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest& request)
{
- return static_cast<CachedSVGDocument*>(requestResource(CachedResource::SVGDocumentResource, request, String(), defaultCachedResourceOptions()).get());
+ return static_cast<CachedSVGDocument*>(requestResource(CachedResource::SVGDocumentResource, request).get());
}
#endif
#if ENABLE(LINK_PREFETCH)
-CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, ResourceRequest& request, ResourceLoadPriority priority)
+CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, CachedResourceRequest& request)
{
ASSERT(frame());
ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkSubresource);
- return requestResource(type, request, String(), defaultCachedResourceOptions(), priority);
+ return requestResource(type, request);
}
#endif
-CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(ResourceRequest& request, const ResourceLoaderOptions& options)
+CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest& request)
{
- return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request, String(), options, ResourceLoadPriorityUnresolved, false).get());
+ return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request).get());
}
bool CachedResourceLoader::checkInsecureContent(CachedResource::Type type, const KURL& url) const
@@ -402,11 +398,11 @@
return true;
}
-CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, const ResourceLoaderOptions& options, ResourceLoadPriority priority, bool forPreload, DeferOption defer)
+CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request)
{
- KURL url = request.url();
+ KURL url = request.resourceRequest().url();
- LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.string().latin1().data(), charset.latin1().data(), priority, forPreload);
+ LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.string().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload());
// If only the fragment identifiers differ, it is the same resource.
url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
@@ -414,7 +410,7 @@
if (!url.isValid())
return 0;
- if (!canRequest(type, url, forPreload))
+ if (!canRequest(type, url, request.forPreload()))
return 0;
if (memoryCache()->disabled()) {
@@ -428,16 +424,16 @@
// See if we can use an existing resource from the cache.
CachedResourceHandle<CachedResource> resource = memoryCache()->resourceForURL(url);
- if (request.url() != url)
- request.setURL(url);
+ if (request.resourceRequest().url() != url)
+ request.mutableResourceRequest().setURL(url);
- const RevalidationPolicy policy = determineRevalidationPolicy(type, request, forPreload, resource.get(), defer);
+ const RevalidationPolicy policy = determineRevalidationPolicy(type, request.mutableResourceRequest(), request.forPreload(), resource.get(), request.defer());
switch (policy) {
case Reload:
memoryCache()->remove(resource.get());
// Fall through
case Load:
- resource = loadResource(type, request, charset);
+ resource = loadResource(type, request.mutableResourceRequest(), request.charset());
break;
case Revalidate:
resource = revalidateResource(resource.get());
@@ -451,9 +447,9 @@
if (!resource)
return 0;
- resource->setLoadPriority(priority);
- if ((policy != Use || resource->stillNeedsLoad()) && NoDefer == defer) {
- resource->load(this, options);
+ resource->setLoadPriority(request.priority());
+ if ((policy != Use || resource->stillNeedsLoad()) && NoDefer == request.defer()) {
+ resource->load(this, request.options());
// We don't support immediate loads, but we do support immediate failure.
if (resource->errorOccurred()) {
@@ -463,8 +459,8 @@
}
}
- if (!request.url().protocolIsData())
- m_validatedURLs.add(request.url());
+ if (!request.resourceRequest().url().protocolIsData())
+ m_validatedURLs.add(request.resourceRequest().url());
ASSERT(resource->url() == url.string());
m_documentResources.set(resource->url(), resource);
@@ -793,7 +789,10 @@
if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet)
encoding = charset.isEmpty() ? m_document->charset() : charset;
- CachedResourceHandle<CachedResource> resource = requestResource(type, request, encoding, defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, true);
+ CachedResourceRequest cachedResourceRequest(request, encoding);
+ cachedResourceRequest.setForPreload(true);
+
+ CachedResourceHandle<CachedResource> resource = requestResource(type, cachedResourceRequest);
if (!resource || (m_preloads && m_preloads->contains(resource.get())))
return;
resource->increasePreloadCount();
@@ -912,4 +911,10 @@
info.addMember(m_pendingPreloads);
}
+const ResourceLoaderOptions& CachedResourceLoader::defaultCachedResourceOptions()
+{
+ static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck);
+ return options;
+}
+
}
diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.h b/Source/WebCore/loader/cache/CachedResourceLoader.h
index 2a7985e..0fcb1e3 100644
--- a/Source/WebCore/loader/cache/CachedResourceLoader.h
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.h
@@ -44,6 +44,7 @@
class CachedFont;
class CachedImage;
class CachedRawResource;
+class CachedResourceRequest;
class CachedScript;
class CachedShader;
class CachedTextTrack;
@@ -68,30 +69,31 @@
friend class ResourceCacheValidationSuppressor;
public:
+ enum DeferOption { NoDefer, DeferredByClient };
static PassRefPtr<CachedResourceLoader> create(DocumentLoader* documentLoader) { return adoptRef(new CachedResourceLoader(documentLoader)); }
~CachedResourceLoader();
- CachedResourceHandle<CachedImage> requestImage(ResourceRequest&);
- CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
- CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(ResourceRequest&, const String& charset);
- CachedResourceHandle<CachedScript> requestScript(ResourceRequest&, const String& charset);
- CachedResourceHandle<CachedFont> requestFont(ResourceRequest&);
- CachedResourceHandle<CachedRawResource> requestRawResource(ResourceRequest&, const ResourceLoaderOptions&);
+ CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&);
+ CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(CachedResourceRequest&);
+ CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(CachedResourceRequest&);
+ CachedResourceHandle<CachedScript> requestScript(CachedResourceRequest&);
+ CachedResourceHandle<CachedFont> requestFont(CachedResourceRequest&);
+ CachedResourceHandle<CachedRawResource> requestRawResource(CachedResourceRequest&);
#if ENABLE(SVG)
- CachedResourceHandle<CachedSVGDocument> requestSVGDocument(ResourceRequest&);
+ CachedResourceHandle<CachedSVGDocument> requestSVGDocument(CachedResourceRequest&);
#endif
#if ENABLE(XSLT)
- CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(ResourceRequest&);
+ CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(CachedResourceRequest&);
#endif
#if ENABLE(LINK_PREFETCH)
- CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, ResourceRequest&, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
+ CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, CachedResourceRequest&);
#endif
#if ENABLE(VIDEO_TRACK)
- CachedResourceHandle<CachedTextTrack> requestTextTrack(ResourceRequest&);
+ CachedResourceHandle<CachedTextTrack> requestTextTrack(CachedResourceRequest&);
#endif
#if ENABLE(CSS_SHADERS)
- CachedResourceHandle<CachedShader> requestShader(ResourceRequest&);
+ CachedResourceHandle<CachedShader> requestShader(CachedResourceRequest&);
#endif
// Logs an access denied message to the console for the specified URL.
@@ -135,11 +137,12 @@
void reportMemoryUsage(MemoryObjectInfo*) const;
+ static const ResourceLoaderOptions& defaultCachedResourceOptions();
+
private:
explicit CachedResourceLoader(DocumentLoader*);
- enum DeferOption { NoDefer, DeferredByClient };
- CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, ResourceRequest&, const String& charset, const ResourceLoaderOptions&, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false, DeferOption = NoDefer);
+ CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&);
CachedResourceHandle<CachedResource> revalidateResource(CachedResource*);
CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, ResourceRequest&, const String& charset);
void requestPreload(CachedResource::Type, ResourceRequest&, const String& charset);
diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.cpp b/Source/WebCore/loader/cache/CachedResourceRequest.cpp
new file mode 100644
index 0000000..6add39b
--- /dev/null
+++ b/Source/WebCore/loader/cache/CachedResourceRequest.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2012 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "CachedResourceRequest.h"
+
+namespace WebCore {
+
+CachedResourceRequest::CachedResourceRequest(const ResourceRequest& resourceRequest, const String& charset, ResourceLoadPriority priority)
+ : m_resourceRequest(resourceRequest)
+ , m_charset(charset)
+ , m_options(CachedResourceLoader::defaultCachedResourceOptions())
+ , m_priority(priority)
+ , m_forPreload(false)
+ , m_defer(CachedResourceLoader::NoDefer)
+{
+}
+
+CachedResourceRequest::CachedResourceRequest(const ResourceRequest& resourceRequest, const ResourceLoaderOptions& options)
+ : m_resourceRequest(resourceRequest)
+ , m_options(options)
+ , m_priority(ResourceLoadPriorityUnresolved)
+ , m_forPreload(false)
+ , m_defer(CachedResourceLoader::NoDefer)
+{
+}
+
+CachedResourceRequest::CachedResourceRequest(const ResourceRequest& resourceRequest, ResourceLoadPriority priority)
+ : m_resourceRequest(resourceRequest)
+ , m_options(CachedResourceLoader::defaultCachedResourceOptions())
+ , m_priority(priority)
+ , m_forPreload(false)
+ , m_defer(CachedResourceLoader::NoDefer)
+{
+}
+
+}
diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.h b/Source/WebCore/loader/cache/CachedResourceRequest.h
new file mode 100644
index 0000000..cb043df
--- /dev/null
+++ b/Source/WebCore/loader/cache/CachedResourceRequest.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2012 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CachedResourceRequest_h
+#define CachedResourceRequest_h
+
+#include "CachedResourceLoader.h"
+#include "ResourceLoadPriority.h"
+
+namespace WebCore {
+
+class CachedResourceRequest {
+public:
+ explicit CachedResourceRequest(const ResourceRequest&, const String& charset = String(), ResourceLoadPriority = ResourceLoadPriorityUnresolved);
+ CachedResourceRequest(const ResourceRequest&, const ResourceLoaderOptions&);
+ CachedResourceRequest(const ResourceRequest&, ResourceLoadPriority);
+
+ ResourceRequest& mutableResourceRequest() { return m_resourceRequest; }
+ const ResourceRequest& resourceRequest() const { return m_resourceRequest; }
+ const String& charset() const { return m_charset; }
+ void setCharset(const String& charset) { m_charset = charset; }
+ const ResourceLoaderOptions& options() const { return m_options; }
+ ResourceLoadPriority priority() const { return m_priority; }
+ bool forPreload() const { return m_forPreload; }
+ void setForPreload(bool forPreload) { m_forPreload = forPreload; }
+ CachedResourceLoader::DeferOption defer() const { return m_defer; }
+ void setDefer(CachedResourceLoader::DeferOption defer) { m_defer = defer; }
+
+private:
+ ResourceRequest m_resourceRequest;
+ String m_charset;
+ ResourceLoaderOptions m_options;
+ ResourceLoadPriority m_priority;
+ bool m_forPreload;
+ CachedResourceLoader::DeferOption m_defer;
+};
+
+} // namespace WebCore
+
+#endif
diff --git a/Source/WebCore/loader/icon/IconLoader.cpp b/Source/WebCore/loader/icon/IconLoader.cpp
index 63bc0ea..8c9d0ce 100644
--- a/Source/WebCore/loader/icon/IconLoader.cpp
+++ b/Source/WebCore/loader/icon/IconLoader.cpp
@@ -28,6 +28,7 @@
#include "CachedRawResource.h"
#include "CachedResourceLoader.h"
+#include "CachedResourceRequest.h"
#include "Document.h"
#include "Frame.h"
#include "FrameLoader.h"
@@ -59,14 +60,14 @@
if (m_resource || !m_frame->document())
return;
- ResourceRequest resourceRequest(m_frame->loader()->icon()->url());
-#if PLATFORM(BLACKBERRY)
- resourceRequest.setTargetType(ResourceRequest::TargetIsFavicon);
-#endif
- resourceRequest.setPriority(ResourceLoadPriorityLow);
+ CachedResourceRequest request(ResourceRequest(m_frame->loader()->icon()->url()), ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck));
- m_resource = m_frame->document()->cachedResourceLoader()->requestRawResource(resourceRequest,
- ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck));
+#if PLATFORM(BLACKBERRY)
+ request.mutableResourceRequest().setTargetType(ResourceRequest::TargetIsFavicon);
+#endif
+ request.mutableResourceRequest().setPriority(ResourceLoadPriorityLow);
+
+ m_resource = m_frame->document()->cachedResourceLoader()->requestRawResource(request);
if (m_resource)
m_resource->addClient(this);
else
