CachedResource should efficiently construct its ResourceRequest
https://bugs.webkit.org/show_bug.cgi?id=161609
Patch by Youenn Fablet <youenn@apple.com> on 2016-09-16
Reviewed by Sam Weinig.
Covered by existing tests.
Making CachedResourceLoader take a CachedResourceRequest&& when being asked to load resources.
Making CachedResource et al take a CachedResourceRequest&& as constructor parameter.
CachedResource now sets its options at construction time instead of load time.
This may change some specific behaviors, for instance when loading manually images.
Made some refactoring when both the resource and request are needed, for ResourceTimingInformation.
Made local copies of some CachedResourceRequest fields so that we do not need it after being WTFMoved.
Some of these properties may be put outside CachedResourceRequest in a later refactoring step.
* css/CSSFontFaceSrcValue.cpp:
(WebCore::CSSFontFaceSrcValue::cachedFont):
* css/CSSImageSetValue.cpp:
(WebCore::CSSImageSetValue::loadBestFitImage):
* css/CSSImageValue.cpp:
(WebCore::CSSImageValue::loadImage):
* css/StyleRuleImport.cpp:
(WebCore::StyleRuleImport::requestStyleSheet):
* dom/ProcessingInstruction.cpp:
(WebCore::ProcessingInstruction::checkStyleSheet):
* dom/ScriptElement.cpp:
(WebCore::ScriptElement::requestScriptWithCache):
* html/HTMLLinkElement.cpp:
(WebCore::HTMLLinkElement::process):
* html/parser/HTMLResourcePreloader.cpp:
(WebCore::HTMLResourcePreloader::preload):
* loader/CrossOriginPreflightChecker.cpp:
(WebCore::CrossOriginPreflightChecker::startPreflight):
* loader/DocumentLoader.cpp:
(WebCore::DocumentLoader::startLoadingMainResource):
* loader/DocumentThreadableLoader.cpp:
(WebCore::DocumentThreadableLoader::loadRequest):
* loader/ImageLoader.cpp:
(WebCore::ImageLoader::updateFromElement):
* loader/LinkLoader.cpp:
(WebCore::LinkLoader::preloadIfNeeded):
(WebCore::LinkLoader::loadLink):
* loader/MediaResourceLoader.cpp:
(WebCore::MediaResourceLoader::requestResource):
* loader/ResourceTimingInformation.cpp:
(WebCore::ResourceTimingInformation::storeResourceTimingInitiatorInformation):
* loader/ResourceTimingInformation.h:
* loader/TextTrackLoader.cpp:
(WebCore::TextTrackLoader::load):
* loader/cache/CachedCSSStyleSheet.cpp:
(WebCore::CachedCSSStyleSheet::CachedCSSStyleSheet):
* loader/cache/CachedCSSStyleSheet.h:
* loader/cache/CachedFont.cpp:
(WebCore::CachedFont::CachedFont):
(WebCore::CachedFont::load):
(WebCore::CachedFont::beginLoadIfNeeded):
* loader/cache/CachedFont.h:
* loader/cache/CachedImage.cpp:
(WebCore::CachedImage::CachedImage):
(WebCore::CachedImage::load):
* loader/cache/CachedImage.h:
* loader/cache/CachedRawResource.cpp:
(WebCore::CachedRawResource::CachedRawResource):
* loader/cache/CachedRawResource.h:
* loader/cache/CachedResource.cpp:
(WebCore::CachedResource::CachedResource):
(WebCore::CachedResource::load):
(WebCore::CachedResource::loadFrom):
* loader/cache/CachedResource.h:
(WebCore::CachedResource::resourceRequest):
* loader/cache/CachedResourceLoader.cpp:
(WebCore::createResource):
(WebCore::CachedResourceLoader::requestImage):
(WebCore::CachedResourceLoader::requestFont):
(WebCore::CachedResourceLoader::requestTextTrack):
(WebCore::CachedResourceLoader::requestCSSStyleSheet):
(WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
(WebCore::CachedResourceLoader::requestScript):
(WebCore::CachedResourceLoader::requestXSLStyleSheet):
(WebCore::CachedResourceLoader::requestSVGDocument):
(WebCore::CachedResourceLoader::requestLinkResource):
(WebCore::CachedResourceLoader::requestMedia):
(WebCore::CachedResourceLoader::requestRawResource):
(WebCore::CachedResourceLoader::requestMainResource):
(WebCore::CachedResourceLoader::shouldUpdateCachedResourceWithCurrentRequest):
(WebCore::CachedResourceLoader::updateCachedResourceWithCurrentRequest):
(WebCore::CachedResourceLoader::requestResource):
(WebCore::CachedResourceLoader::revalidateResource):
(WebCore::CachedResourceLoader::loadResource):
(WebCore::CachedResourceLoader::reloadImagesIfNotDeferred):
(WebCore::CachedResourceLoader::preload):
(WebCore::CachedResourceLoader::checkForPendingPreloads):
(WebCore::CachedResourceLoader::requestPreload):
* loader/cache/CachedResourceLoader.h:
* loader/cache/CachedSVGDocument.cpp:
(WebCore::CachedSVGDocument::CachedSVGDocument):
* loader/cache/CachedSVGDocument.h:
* loader/cache/CachedSVGDocumentReference.cpp:
(WebCore::CachedSVGDocumentReference::load):
* loader/cache/CachedSVGFont.cpp:
(WebCore::CachedSVGFont::CachedSVGFont):
* loader/cache/CachedSVGFont.h:
* loader/cache/CachedScript.cpp:
(WebCore::CachedScript::CachedScript):
* loader/cache/CachedScript.h:
* loader/cache/CachedTextTrack.cpp:
(WebCore::CachedTextTrack::CachedTextTrack):
* loader/cache/CachedTextTrack.h:
* loader/cache/CachedXSLStyleSheet.cpp:
(WebCore::CachedXSLStyleSheet::CachedXSLStyleSheet):
(WebCore::CachedXSLStyleSheet::didAddClient):
* loader/cache/CachedXSLStyleSheet.h:
* loader/icon/IconLoader.cpp:
(WebCore::IconLoader::startLoading):
* platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp:
(WebCore::WebCoreAVCFResourceLoader::startLoading):
* platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
(WebCore::WebCoreAVFResourceLoader::startLoading):
* svg/SVGFEImageElement.cpp:
(WebCore::SVGFEImageElement::requestImageResource):
* svg/SVGFontFaceUriElement.cpp:
(WebCore::SVGFontFaceUriElement::loadFont):
* svg/SVGUseElement.cpp:
(WebCore::SVGUseElement::updateExternalDocument):
* xml/XSLImportRule.cpp:
(WebCore::XSLImportRule::loadSheet):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@206016 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
index 7de51a3..bd49894 100644
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,5 +1,136 @@
2016-09-16 Youenn Fablet <youenn@apple.com>
+ CachedResource should efficiently construct its ResourceRequest
+ https://bugs.webkit.org/show_bug.cgi?id=161609
+
+ Reviewed by Sam Weinig.
+
+ Covered by existing tests.
+
+ Making CachedResourceLoader take a CachedResourceRequest&& when being asked to load resources.
+ Making CachedResource et al take a CachedResourceRequest&& as constructor parameter.
+
+ CachedResource now sets its options at construction time instead of load time.
+ This may change some specific behaviors, for instance when loading manually images.
+
+ Made some refactoring when both the resource and request are needed, for ResourceTimingInformation.
+ Made local copies of some CachedResourceRequest fields so that we do not need it after being WTFMoved.
+ Some of these properties may be put outside CachedResourceRequest in a later refactoring step.
+
+ * css/CSSFontFaceSrcValue.cpp:
+ (WebCore::CSSFontFaceSrcValue::cachedFont):
+ * css/CSSImageSetValue.cpp:
+ (WebCore::CSSImageSetValue::loadBestFitImage):
+ * css/CSSImageValue.cpp:
+ (WebCore::CSSImageValue::loadImage):
+ * css/StyleRuleImport.cpp:
+ (WebCore::StyleRuleImport::requestStyleSheet):
+ * dom/ProcessingInstruction.cpp:
+ (WebCore::ProcessingInstruction::checkStyleSheet):
+ * dom/ScriptElement.cpp:
+ (WebCore::ScriptElement::requestScriptWithCache):
+ * html/HTMLLinkElement.cpp:
+ (WebCore::HTMLLinkElement::process):
+ * html/parser/HTMLResourcePreloader.cpp:
+ (WebCore::HTMLResourcePreloader::preload):
+ * loader/CrossOriginPreflightChecker.cpp:
+ (WebCore::CrossOriginPreflightChecker::startPreflight):
+ * loader/DocumentLoader.cpp:
+ (WebCore::DocumentLoader::startLoadingMainResource):
+ * loader/DocumentThreadableLoader.cpp:
+ (WebCore::DocumentThreadableLoader::loadRequest):
+ * loader/ImageLoader.cpp:
+ (WebCore::ImageLoader::updateFromElement):
+ * loader/LinkLoader.cpp:
+ (WebCore::LinkLoader::preloadIfNeeded):
+ (WebCore::LinkLoader::loadLink):
+ * loader/MediaResourceLoader.cpp:
+ (WebCore::MediaResourceLoader::requestResource):
+ * loader/ResourceTimingInformation.cpp:
+ (WebCore::ResourceTimingInformation::storeResourceTimingInitiatorInformation):
+ * loader/ResourceTimingInformation.h:
+ * loader/TextTrackLoader.cpp:
+ (WebCore::TextTrackLoader::load):
+ * loader/cache/CachedCSSStyleSheet.cpp:
+ (WebCore::CachedCSSStyleSheet::CachedCSSStyleSheet):
+ * loader/cache/CachedCSSStyleSheet.h:
+ * loader/cache/CachedFont.cpp:
+ (WebCore::CachedFont::CachedFont):
+ (WebCore::CachedFont::load):
+ (WebCore::CachedFont::beginLoadIfNeeded):
+ * loader/cache/CachedFont.h:
+ * loader/cache/CachedImage.cpp:
+ (WebCore::CachedImage::CachedImage):
+ (WebCore::CachedImage::load):
+ * loader/cache/CachedImage.h:
+ * loader/cache/CachedRawResource.cpp:
+ (WebCore::CachedRawResource::CachedRawResource):
+ * loader/cache/CachedRawResource.h:
+ * loader/cache/CachedResource.cpp:
+ (WebCore::CachedResource::CachedResource):
+ (WebCore::CachedResource::load):
+ (WebCore::CachedResource::loadFrom):
+ * loader/cache/CachedResource.h:
+ (WebCore::CachedResource::resourceRequest):
+ * loader/cache/CachedResourceLoader.cpp:
+ (WebCore::createResource):
+ (WebCore::CachedResourceLoader::requestImage):
+ (WebCore::CachedResourceLoader::requestFont):
+ (WebCore::CachedResourceLoader::requestTextTrack):
+ (WebCore::CachedResourceLoader::requestCSSStyleSheet):
+ (WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
+ (WebCore::CachedResourceLoader::requestScript):
+ (WebCore::CachedResourceLoader::requestXSLStyleSheet):
+ (WebCore::CachedResourceLoader::requestSVGDocument):
+ (WebCore::CachedResourceLoader::requestLinkResource):
+ (WebCore::CachedResourceLoader::requestMedia):
+ (WebCore::CachedResourceLoader::requestRawResource):
+ (WebCore::CachedResourceLoader::requestMainResource):
+ (WebCore::CachedResourceLoader::shouldUpdateCachedResourceWithCurrentRequest):
+ (WebCore::CachedResourceLoader::updateCachedResourceWithCurrentRequest):
+ (WebCore::CachedResourceLoader::requestResource):
+ (WebCore::CachedResourceLoader::revalidateResource):
+ (WebCore::CachedResourceLoader::loadResource):
+ (WebCore::CachedResourceLoader::reloadImagesIfNotDeferred):
+ (WebCore::CachedResourceLoader::preload):
+ (WebCore::CachedResourceLoader::checkForPendingPreloads):
+ (WebCore::CachedResourceLoader::requestPreload):
+ * loader/cache/CachedResourceLoader.h:
+ * loader/cache/CachedSVGDocument.cpp:
+ (WebCore::CachedSVGDocument::CachedSVGDocument):
+ * loader/cache/CachedSVGDocument.h:
+ * loader/cache/CachedSVGDocumentReference.cpp:
+ (WebCore::CachedSVGDocumentReference::load):
+ * loader/cache/CachedSVGFont.cpp:
+ (WebCore::CachedSVGFont::CachedSVGFont):
+ * loader/cache/CachedSVGFont.h:
+ * loader/cache/CachedScript.cpp:
+ (WebCore::CachedScript::CachedScript):
+ * loader/cache/CachedScript.h:
+ * loader/cache/CachedTextTrack.cpp:
+ (WebCore::CachedTextTrack::CachedTextTrack):
+ * loader/cache/CachedTextTrack.h:
+ * loader/cache/CachedXSLStyleSheet.cpp:
+ (WebCore::CachedXSLStyleSheet::CachedXSLStyleSheet):
+ (WebCore::CachedXSLStyleSheet::didAddClient):
+ * loader/cache/CachedXSLStyleSheet.h:
+ * loader/icon/IconLoader.cpp:
+ (WebCore::IconLoader::startLoading):
+ * platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp:
+ (WebCore::WebCoreAVCFResourceLoader::startLoading):
+ * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
+ (WebCore::WebCoreAVFResourceLoader::startLoading):
+ * svg/SVGFEImageElement.cpp:
+ (WebCore::SVGFEImageElement::requestImageResource):
+ * svg/SVGFontFaceUriElement.cpp:
+ (WebCore::SVGFontFaceUriElement::loadFont):
+ * svg/SVGUseElement.cpp:
+ (WebCore::SVGUseElement::updateExternalDocument):
+ * xml/XSLImportRule.cpp:
+ (WebCore::XSLImportRule::loadSheet):
+
+2016-09-16 Youenn Fablet <youenn@apple.com>
+
[Fetch API] Headers should be combine with ',' and not ', '
https://bugs.webkit.org/show_bug.cgi?id=161736
diff --git a/Source/WebCore/css/CSSFontFaceSrcValue.cpp b/Source/WebCore/css/CSSFontFaceSrcValue.cpp
index 7e56355..2057f4b 100644
--- a/Source/WebCore/css/CSSFontFaceSrcValue.cpp
+++ b/Source/WebCore/css/CSSFontFaceSrcValue.cpp
@@ -108,7 +108,7 @@
CachedResourceRequest request(ResourceRequest(document->completeURL(m_resource)), options);
request.setInitiator(cachedResourceRequestInitiators().css);
- m_cachedFont = document->cachedResourceLoader().requestFont(request, isSVG);
+ m_cachedFont = document->cachedResourceLoader().requestFont(WTFMove(request), isSVG);
return m_cachedFont.get();
}
diff --git a/Source/WebCore/css/CSSImageSetValue.cpp b/Source/WebCore/css/CSSImageSetValue.cpp
index 9190407..dd14e71 100644
--- a/Source/WebCore/css/CSSImageSetValue.cpp
+++ b/Source/WebCore/css/CSSImageSetValue.cpp
@@ -91,7 +91,7 @@
{
Document* document = loader.document();
updateDeviceScaleFactor(*document);
-
+
if (!m_accessedBestFitImage) {
m_accessedBestFitImage = true;
@@ -105,7 +105,7 @@
ASSERT(document->securityOrigin());
updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
}
- m_cachedImage = loader.requestImage(request);
+ m_cachedImage = loader.requestImage(WTFMove(request));
m_bestFitImageScaleFactor = image.scaleFactor;
}
return { m_cachedImage.get(), m_bestFitImageScaleFactor };
diff --git a/Source/WebCore/css/CSSImageValue.cpp b/Source/WebCore/css/CSSImageValue.cpp
index 6f68ab8..254bb1a 100644
--- a/Source/WebCore/css/CSSImageValue.cpp
+++ b/Source/WebCore/css/CSSImageValue.cpp
@@ -75,7 +75,7 @@
ASSERT(loader.document()->securityOrigin());
updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
}
- m_cachedImage = loader.requestImage(request);
+ m_cachedImage = loader.requestImage(WTFMove(request));
}
return m_cachedImage.get();
}
diff --git a/Source/WebCore/css/StyleRuleImport.cpp b/Source/WebCore/css/StyleRuleImport.cpp
index b03f6e4..0cbaa9f 100644
--- a/Source/WebCore/css/StyleRuleImport.cpp
+++ b/Source/WebCore/css/StyleRuleImport.cpp
@@ -119,10 +119,11 @@
request.setInitiator(cachedResourceRequestInitiators().css);
if (m_cachedSheet)
m_cachedSheet->removeClient(&m_styleSheetClient);
- if (m_parentStyleSheet->isUserStyleSheet())
- m_cachedSheet = document->cachedResourceLoader().requestUserCSSStyleSheet(request);
- else
- m_cachedSheet = document->cachedResourceLoader().requestCSSStyleSheet(request);
+ if (m_parentStyleSheet->isUserStyleSheet()) {
+ request.setOptions(ResourceLoaderOptions(DoNotSendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, SkipSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::SkipPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::AllowCaching));
+ m_cachedSheet = document->cachedResourceLoader().requestUserCSSStyleSheet(WTFMove(request));
+ } else
+ m_cachedSheet = document->cachedResourceLoader().requestCSSStyleSheet(WTFMove(request));
if (m_cachedSheet) {
// if the import rule is issued dynamically, the sheet may be
// removed from the pending sheet count, so let the doc know
diff --git a/Source/WebCore/dom/ProcessingInstruction.cpp b/Source/WebCore/dom/ProcessingInstruction.cpp
index 58b9011..b8d4bc2 100644
--- a/Source/WebCore/dom/ProcessingInstruction.cpp
+++ b/Source/WebCore/dom/ProcessingInstruction.cpp
@@ -129,18 +129,18 @@
m_cachedSheet->removeClient(this);
m_cachedSheet = nullptr;
}
-
+
String url = document().completeURL(href).string();
if (!dispatchBeforeLoadEvent(url))
return;
-
+
m_loading = true;
document().authorStyleSheets().addPendingSheet();
-
+
CachedResourceRequest request(ResourceRequest(document().completeURL(href)));
#if ENABLE(XSLT)
if (m_isXSL)
- m_cachedSheet = document().cachedResourceLoader().requestXSLStyleSheet(request);
+ m_cachedSheet = document().cachedResourceLoader().requestXSLStyleSheet(WTFMove(request));
else
#endif
{
@@ -149,7 +149,7 @@
charset = document().charset();
request.setCharset(charset);
- m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(request);
+ m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(WTFMove(request));
}
if (m_cachedSheet)
m_cachedSheet->addClient(this);
diff --git a/Source/WebCore/dom/ScriptElement.cpp b/Source/WebCore/dom/ScriptElement.cpp
index 31f2f9c..c033e95 100644
--- a/Source/WebCore/dom/ScriptElement.cpp
+++ b/Source/WebCore/dom/ScriptElement.cpp
@@ -293,7 +293,7 @@
request.setCharset(scriptCharset());
request.setInitiator(&element());
- return m_element.document().cachedResourceLoader().requestScript(request);
+ return m_element.document().cachedResourceLoader().requestScript(WTFMove(request));
}
void ScriptElement::executeScript(const ScriptSourceCode& sourceCode)
diff --git a/Source/WebCore/html/HTMLLinkElement.cpp b/Source/WebCore/html/HTMLLinkElement.cpp
index 04f3499..dd5810b 100644
--- a/Source/WebCore/html/HTMLLinkElement.cpp
+++ b/Source/WebCore/html/HTMLLinkElement.cpp
@@ -271,7 +271,7 @@
}
request.setAsPotentiallyCrossOrigin(crossOrigin(), document());
- m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(request);
+ m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(WTFMove(request));
if (m_cachedSheet)
m_cachedSheet->addClient(this);
diff --git a/Source/WebCore/html/parser/HTMLResourcePreloader.cpp b/Source/WebCore/html/parser/HTMLResourcePreloader.cpp
index 4d4ba84..5bbd37b 100644
--- a/Source/WebCore/html/parser/HTMLResourcePreloader.cpp
+++ b/Source/WebCore/html/parser/HTMLResourcePreloader.cpp
@@ -68,8 +68,7 @@
if (!preload->media().isEmpty() && !mediaAttributeMatches(m_document, &m_document.renderView()->style(), preload->media()))
return;
- CachedResourceRequest request = preload->resourceRequest(m_document);
- m_document.cachedResourceLoader().preload(preload->resourceType(), request, preload->charset(), CachedResourceLoader::ImplicitPreload);
+ m_document.cachedResourceLoader().preload(preload->resourceType(), preload->resourceRequest(m_document), CachedResourceLoader::ImplicitPreload);
}
diff --git a/Source/WebCore/loader/CrossOriginPreflightChecker.cpp b/Source/WebCore/loader/CrossOriginPreflightChecker.cpp
index c2945a2..9e8cf61 100644
--- a/Source/WebCore/loader/CrossOriginPreflightChecker.cpp
+++ b/Source/WebCore/loader/CrossOriginPreflightChecker.cpp
@@ -112,7 +112,7 @@
preflightRequest.mutableResourceRequest().setHTTPReferrer(m_loader.referrer());
ASSERT(!m_resource);
- m_resource = m_loader.document().cachedResourceLoader().requestRawResource(preflightRequest);
+ m_resource = m_loader.document().cachedResourceLoader().requestRawResource(WTFMove(preflightRequest));
if (m_resource)
m_resource->addClient(this);
}
diff --git a/Source/WebCore/loader/DocumentLoader.cpp b/Source/WebCore/loader/DocumentLoader.cpp
index de8ce31..5c80a6a 100644
--- a/Source/WebCore/loader/DocumentLoader.cpp
+++ b/Source/WebCore/loader/DocumentLoader.cpp
@@ -1510,8 +1510,7 @@
request.makeUnconditional();
static NeverDestroyed<ResourceLoaderOptions> mainResourceLoadOptions(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, SkipSecurityCheck, FetchOptions::Mode::NoCors, IncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::AllowCaching);
- CachedResourceRequest cachedResourceRequest(ResourceRequest(request), mainResourceLoadOptions);
- m_mainResource = m_cachedResourceLoader->requestMainResource(cachedResourceRequest);
+ m_mainResource = m_cachedResourceLoader->requestMainResource(CachedResourceRequest(ResourceRequest(request), mainResourceLoadOptions));
#if ENABLE(CONTENT_EXTENSIONS)
if (m_mainResource && m_mainResource->errorOccurred() && m_frame->page() && m_mainResource->resourceError().domain() == ContentExtensions::WebKitContentBlockerDomain) {
diff --git a/Source/WebCore/loader/DocumentThreadableLoader.cpp b/Source/WebCore/loader/DocumentThreadableLoader.cpp
index ae55239..a48bc78 100644
--- a/Source/WebCore/loader/DocumentThreadableLoader.cpp
+++ b/Source/WebCore/loader/DocumentThreadableLoader.cpp
@@ -372,12 +372,14 @@
newRequest.mutableResourceRequest().setAllowCookies(m_options.allowCredentials == AllowStoredCredentials);
ASSERT(!m_resource);
- m_resource = m_document.cachedResourceLoader().requestRawResource(newRequest);
+ // We create an URL here as the request will be moved in requestRawResource
+ URL requestUrl = newRequest.resourceRequest().url();
+ m_resource = m_document.cachedResourceLoader().requestRawResource(WTFMove(newRequest));
if (m_resource)
m_resource->addClient(this);
else {
// FIXME: Since we receive a synchronous error, this is probably due to some AccessControl checks. We should try to retrieve the actual error.
- m_client->didFail(ResourceError(String(), 0, newRequest.resourceRequest().url(), String(), ResourceError::Type::AccessControl));
+ m_client->didFail(ResourceError(String(), 0, requestUrl, String(), ResourceError::Type::AccessControl));
}
return;
}
diff --git a/Source/WebCore/loader/ImageLoader.cpp b/Source/WebCore/loader/ImageLoader.cpp
index d853b95..c1ac3be 100644
--- a/Source/WebCore/loader/ImageLoader.cpp
+++ b/Source/WebCore/loader/ImageLoader.cpp
@@ -185,14 +185,14 @@
if (m_loadManually) {
bool autoLoadOtherImages = document.cachedResourceLoader().autoLoadImages();
document.cachedResourceLoader().setAutoLoadImages(false);
- newImage = new CachedImage(request.resourceRequest(), m_element.document().page()->sessionID());
+ newImage = new CachedImage(WTFMove(request), m_element.document().page()->sessionID());
newImage->setStatus(CachedResource::Pending);
newImage->setLoading(true);
newImage->setOwningCachedResourceLoader(&document.cachedResourceLoader());
document.cachedResourceLoader().m_documentResources.set(newImage->url(), newImage.get());
document.cachedResourceLoader().setAutoLoadImages(autoLoadOtherImages);
} else
- newImage = document.cachedResourceLoader().requestImage(request);
+ newImage = document.cachedResourceLoader().requestImage(WTFMove(request));
// If we do not have an image here, it means that a cross-site
// violation occurred, or that the image was blocked via Content
diff --git a/Source/WebCore/loader/LinkLoader.cpp b/Source/WebCore/loader/LinkLoader.cpp
index 3c5cc8b..2dac92a 100644
--- a/Source/WebCore/loader/LinkLoader.cpp
+++ b/Source/WebCore/loader/LinkLoader.cpp
@@ -163,7 +163,7 @@
linkRequest.setAsPotentiallyCrossOrigin(crossOriginMode, document);
linkRequest.setForPreload(true);
- CachedResourceHandle<CachedResource> cachedLinkResource = document.cachedResourceLoader().preload(type.value(), linkRequest, emptyString(), CachedResourceLoader::ExplicitPreload);
+ CachedResourceHandle<CachedResource> cachedLinkResource = document.cachedResourceLoader().preload(type.value(), WTFMove(linkRequest), CachedResourceLoader::ExplicitPreload);
if (cachedLinkResource)
m_preloadResourceClient = createLinkPreloadResourceClient(*cachedLinkResource, *this, type.value());
@@ -195,13 +195,12 @@
priority = ResourceLoadPriority::Low;
type = CachedResource::LinkSubresource;
}
- CachedResourceRequest linkRequest(ResourceRequest(document.completeURL(href)), priority);
if (m_cachedLinkResource) {
m_cachedLinkResource->removeClient(this);
m_cachedLinkResource = nullptr;
}
- m_cachedLinkResource = document.cachedResourceLoader().requestLinkResource(type, linkRequest);
+ m_cachedLinkResource = document.cachedResourceLoader().requestLinkResource(type, CachedResourceRequest(ResourceRequest(document.completeURL(href)), priority));
if (m_cachedLinkResource)
m_cachedLinkResource->addClient(this);
}
diff --git a/Source/WebCore/loader/MediaResourceLoader.cpp b/Source/WebCore/loader/MediaResourceLoader.cpp
index f1979b5..9c72658 100644
--- a/Source/WebCore/loader/MediaResourceLoader.cpp
+++ b/Source/WebCore/loader/MediaResourceLoader.cpp
@@ -79,7 +79,7 @@
cacheRequest.mutableResourceRequest().makeUnconditional();
#endif
- CachedResourceHandle<CachedRawResource> resource = m_document->cachedResourceLoader().requestMedia(cacheRequest);
+ CachedResourceHandle<CachedRawResource> resource = m_document->cachedResourceLoader().requestMedia(WTFMove(cacheRequest));
if (!resource)
return nullptr;
diff --git a/Source/WebCore/loader/ResourceTimingInformation.cpp b/Source/WebCore/loader/ResourceTimingInformation.cpp
index 0926faf..5de66ed 100644
--- a/Source/WebCore/loader/ResourceTimingInformation.cpp
+++ b/Source/WebCore/loader/ResourceTimingInformation.cpp
@@ -59,7 +59,7 @@
}
}
-void ResourceTimingInformation::storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>& resource, const CachedResourceRequest& request, Frame* frame)
+void ResourceTimingInformation::storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>& resource, const AtomicString& initiatorName, Frame* frame)
{
ASSERT(RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled());
ASSERT(resource.get());
@@ -71,7 +71,7 @@
m_initiatorMap.add(resource.get(), info);
}
} else {
- InitiatorInfo info = { request.initiatorName(), monotonicallyIncreasingTime(), NotYetAdded };
+ InitiatorInfo info = { initiatorName, monotonicallyIncreasingTime(), NotYetAdded };
m_initiatorMap.add(resource.get(), info);
}
}
diff --git a/Source/WebCore/loader/ResourceTimingInformation.h b/Source/WebCore/loader/ResourceTimingInformation.h
index fbb2efa0..8363d60 100644
--- a/Source/WebCore/loader/ResourceTimingInformation.h
+++ b/Source/WebCore/loader/ResourceTimingInformation.h
@@ -43,7 +43,7 @@
public:
void addResourceTiming(CachedResource*, Document&, const LoadTiming&);
- void storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>&, const CachedResourceRequest&, Frame*);
+ void storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>&, const AtomicString&, Frame*);
private:
enum AlreadyAdded { NotYetAdded, Added };
diff --git a/Source/WebCore/loader/TextTrackLoader.cpp b/Source/WebCore/loader/TextTrackLoader.cpp
index 0675adc..eeb209d 100644
--- a/Source/WebCore/loader/TextTrackLoader.cpp
+++ b/Source/WebCore/loader/TextTrackLoader.cpp
@@ -157,7 +157,7 @@
CachedResourceRequest cueRequest(ResourceRequest(document->completeURL(url)), options);
cueRequest.setAsPotentiallyCrossOrigin(crossOriginMode, *document);
- m_resource = document->cachedResourceLoader().requestTextTrack(cueRequest);
+ m_resource = document->cachedResourceLoader().requestTextTrack(WTFMove(cueRequest));
if (!m_resource)
return false;
diff --git a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp b/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp
index f884bdb..8f3a0bd 100644
--- a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp
+++ b/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp
@@ -29,6 +29,7 @@
#include "CSSStyleSheet.h"
#include "CachedResourceClientWalker.h"
+#include "CachedResourceRequest.h"
#include "CachedStyleSheetClient.h"
#include "HTTPHeaderNames.h"
#include "HTTPParsers.h"
@@ -40,9 +41,9 @@
namespace WebCore {
-CachedCSSStyleSheet::CachedCSSStyleSheet(const ResourceRequest& resourceRequest, const String& charset, SessionID sessionID)
- : CachedResource(resourceRequest, CSSStyleSheet, sessionID)
- , m_decoder(TextResourceDecoder::create("text/css", charset))
+CachedCSSStyleSheet::CachedCSSStyleSheet(CachedResourceRequest&& request, SessionID sessionID)
+ : CachedResource(WTFMove(request), CSSStyleSheet, sessionID)
+ , m_decoder(TextResourceDecoder::create("text/css", request.charset()))
{
// Prefer text/css but accept any type (dell.com serves a stylesheet
// as text/html; see <http://bugs.webkit.org/show_bug.cgi?id=11451>).
diff --git a/Source/WebCore/loader/cache/CachedCSSStyleSheet.h b/Source/WebCore/loader/cache/CachedCSSStyleSheet.h
index 5444e9c..0843376 100644
--- a/Source/WebCore/loader/cache/CachedCSSStyleSheet.h
+++ b/Source/WebCore/loader/cache/CachedCSSStyleSheet.h
@@ -37,7 +37,7 @@
class CachedCSSStyleSheet final : public CachedResource {
public:
- CachedCSSStyleSheet(const ResourceRequest&, const String& charset, SessionID);
+ CachedCSSStyleSheet(CachedResourceRequest&&, SessionID);
virtual ~CachedCSSStyleSheet();
enum class MIMETypeCheck { Strict, Lax };
diff --git a/Source/WebCore/loader/cache/CachedFont.cpp b/Source/WebCore/loader/cache/CachedFont.cpp
index 16cb41c..e7a5d29 100644
--- a/Source/WebCore/loader/cache/CachedFont.cpp
+++ b/Source/WebCore/loader/cache/CachedFont.cpp
@@ -42,8 +42,8 @@
namespace WebCore {
-CachedFont::CachedFont(const ResourceRequest& resourceRequest, SessionID sessionID, Type type)
- : CachedResource(resourceRequest, type, sessionID)
+CachedFont::CachedFont(CachedResourceRequest&& request, SessionID sessionID, Type type)
+ : CachedResource(WTFMove(request), type, sessionID)
, m_loadInitiated(false)
, m_hasCreatedFontDataWrappingResource(false)
{
@@ -53,11 +53,10 @@
{
}
-void CachedFont::load(CachedResourceLoader&, const ResourceLoaderOptions& options)
+void CachedFont::load(CachedResourceLoader&)
{
// Don't load the file yet. Wait for an access before triggering the load.
setLoading(true);
- m_options = options;
}
void CachedFont::didAddClient(CachedResourceClient* client)
@@ -79,7 +78,7 @@
{
if (!m_loadInitiated) {
m_loadInitiated = true;
- CachedResource::load(loader, m_options);
+ CachedResource::load(loader);
}
}
diff --git a/Source/WebCore/loader/cache/CachedFont.h b/Source/WebCore/loader/cache/CachedFont.h
index e58c9e0..42878ab 100644
--- a/Source/WebCore/loader/cache/CachedFont.h
+++ b/Source/WebCore/loader/cache/CachedFont.h
@@ -43,14 +43,13 @@
class CachedFont : public CachedResource {
public:
- CachedFont(const ResourceRequest&, SessionID, Type = FontResource);
+ CachedFont(CachedResourceRequest&&, SessionID, Type = FontResource);
virtual ~CachedFont();
void beginLoadIfNeeded(CachedResourceLoader&);
bool stillNeedsLoad() const override { return !m_loadInitiated; }
virtual bool ensureCustomFontData(const AtomicString& remoteURI);
-
static std::unique_ptr<FontCustomPlatformData> createCustomFontData(SharedBuffer&, bool& wrapping);
static FontPlatformData platformDataFromCustomData(FontCustomPlatformData&, const FontDescription&, bool bold, bool italic, const FontFeatureSettings&, const FontVariantSettings&);
@@ -65,7 +64,7 @@
void checkNotify() override;
bool mayTryReplaceEncodedData() const override;
- void load(CachedResourceLoader&, const ResourceLoaderOptions&) override;
+ void load(CachedResourceLoader&) override;
void didAddClient(CachedResourceClient*) override;
void finishLoading(SharedBuffer*) override;
diff --git a/Source/WebCore/loader/cache/CachedImage.cpp b/Source/WebCore/loader/cache/CachedImage.cpp
index 1914392..938a113 100644
--- a/Source/WebCore/loader/cache/CachedImage.cpp
+++ b/Source/WebCore/loader/cache/CachedImage.cpp
@@ -56,8 +56,8 @@
namespace WebCore {
-CachedImage::CachedImage(const ResourceRequest& resourceRequest, SessionID sessionID)
- : CachedResource(resourceRequest, ImageResource, sessionID)
+CachedImage::CachedImage(CachedResourceRequest&& request, SessionID sessionID)
+ : CachedResource(WTFMove(request), ImageResource, sessionID)
, m_image(nullptr)
, m_isManuallyCached(false)
, m_shouldPaintBrokenImage(true)
@@ -66,7 +66,7 @@
}
CachedImage::CachedImage(Image* image, SessionID sessionID)
- : CachedResource(ResourceRequest(), ImageResource, sessionID)
+ : CachedResource(CachedResourceRequest(ResourceRequest()), ImageResource, sessionID)
, m_image(image)
, m_isManuallyCached(false)
, m_shouldPaintBrokenImage(true)
@@ -76,7 +76,7 @@
}
CachedImage::CachedImage(const URL& url, Image* image, SessionID sessionID)
- : CachedResource(ResourceRequest(url), ImageResource, sessionID)
+ : CachedResource(CachedResourceRequest(ResourceRequest(url)), ImageResource, sessionID)
, m_image(image)
, m_isManuallyCached(false)
, m_shouldPaintBrokenImage(true)
@@ -86,7 +86,7 @@
}
CachedImage::CachedImage(const URL& url, Image* image, CachedImage::CacheBehaviorType type, SessionID sessionID)
- : CachedResource(ResourceRequest(url), ImageResource, sessionID)
+ : CachedResource(CachedResourceRequest(ResourceRequest(url)), ImageResource, sessionID)
, m_image(image)
, m_isManuallyCached(type == CachedImage::ManuallyCached)
, m_shouldPaintBrokenImage(true)
@@ -106,10 +106,10 @@
clearImage();
}
-void CachedImage::load(CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
+void CachedImage::load(CachedResourceLoader& loader)
{
- if (cachedResourceLoader.shouldPerformImageLoad(url()))
- CachedResource::load(cachedResourceLoader, options);
+ if (loader.shouldPerformImageLoad(url()))
+ CachedResource::load(loader);
else
setLoading(false);
}
diff --git a/Source/WebCore/loader/cache/CachedImage.h b/Source/WebCore/loader/cache/CachedImage.h
index 12f0694..08debba 100644
--- a/Source/WebCore/loader/cache/CachedImage.h
+++ b/Source/WebCore/loader/cache/CachedImage.h
@@ -50,7 +50,7 @@
public:
enum CacheBehaviorType { AutomaticallyCached, ManuallyCached };
- CachedImage(const ResourceRequest&, SessionID);
+ CachedImage(CachedResourceRequest&&, SessionID);
CachedImage(Image*, SessionID);
CachedImage(const URL&, Image*, SessionID);
CachedImage(const URL&, Image*, CacheBehaviorType, SessionID);
@@ -62,7 +62,7 @@
bool currentFrameKnownToBeOpaque(const RenderElement*);
std::pair<Image*, float> brokenImage(float deviceScaleFactor) const; // Returns an image and the image's resolution scale factor.
- bool willPaintBrokenImage() const;
+ bool willPaintBrokenImage() const;
bool canRender(const RenderElement* renderer, float multiplier) { return !errorOccurred() && !imageSizeForRenderer(renderer, multiplier).isEmpty(); }
@@ -84,7 +84,7 @@
bool isManuallyCached() const { return m_isManuallyCached; }
RevalidationDecision makeRevalidationDecision(CachePolicy) const override;
- void load(CachedResourceLoader&, const ResourceLoaderOptions&) override;
+ void load(CachedResourceLoader&) override;
bool isOriginClean(SecurityOrigin*);
diff --git a/Source/WebCore/loader/cache/CachedRawResource.cpp b/Source/WebCore/loader/cache/CachedRawResource.cpp
index fa0df8b..3332e0c 100644
--- a/Source/WebCore/loader/cache/CachedRawResource.cpp
+++ b/Source/WebCore/loader/cache/CachedRawResource.cpp
@@ -36,8 +36,8 @@
namespace WebCore {
-CachedRawResource::CachedRawResource(ResourceRequest& resourceRequest, Type type, SessionID sessionID)
- : CachedResource(resourceRequest, type, sessionID)
+CachedRawResource::CachedRawResource(CachedResourceRequest&& request, Type type, SessionID sessionID)
+ : CachedResource(WTFMove(request), type, sessionID)
, m_identifier(0)
, m_allowEncodedDataReplacement(true)
{
diff --git a/Source/WebCore/loader/cache/CachedRawResource.h b/Source/WebCore/loader/cache/CachedRawResource.h
index 5fb54d8..05a1a5d 100644
--- a/Source/WebCore/loader/cache/CachedRawResource.h
+++ b/Source/WebCore/loader/cache/CachedRawResource.h
@@ -32,7 +32,7 @@
class CachedRawResource final : public CachedResource {
public:
- CachedRawResource(ResourceRequest&, Type, SessionID);
+ CachedRawResource(CachedResourceRequest&&, Type, SessionID);
// FIXME: AssociatedURLLoader shouldn't be a DocumentThreadableLoader and therefore shouldn't
// use CachedRawResource. However, it is, and it needs to be able to defer loading.
@@ -40,7 +40,7 @@
virtual void setDefersLoading(bool);
virtual void setDataBufferingPolicy(DataBufferingPolicy);
-
+
// FIXME: This is exposed for the InpsectorInstrumentation for preflights in DocumentThreadableLoader. It's also really lame.
unsigned long identifier() const { return m_identifier; }
diff --git a/Source/WebCore/loader/cache/CachedResource.cpp b/Source/WebCore/loader/cache/CachedResource.cpp
index 55d2e61..373fde5 100644
--- a/Source/WebCore/loader/cache/CachedResource.cpp
+++ b/Source/WebCore/loader/cache/CachedResource.cpp
@@ -112,8 +112,9 @@
DEFINE_DEBUG_ONLY_GLOBAL(RefCountedLeakCounter, cachedResourceLeakCounter, ("CachedResource"));
-CachedResource::CachedResource(const ResourceRequest& request, Type type, SessionID sessionID)
- : m_resourceRequest(request)
+CachedResource::CachedResource(CachedResourceRequest&& request, Type type, SessionID sessionID)
+ : m_resourceRequest(WTFMove(request.mutableResourceRequest()))
+ , m_options(request.options())
, m_decodedDataDeletionTimer(*this, &CachedResource::destroyDecodedData, deadDecodedDataDeletionIntervalForResourceType(type))
, m_sessionID(sessionID)
, m_loadPriority(defaultPriorityForResourceType(type))
@@ -259,7 +260,7 @@
addAdditionalRequestHeaders(loader);
}
-void CachedResource::load(CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
+void CachedResource::load(CachedResourceLoader& cachedResourceLoader)
{
if (!cachedResourceLoader.frame()) {
failBeforeStarting();
@@ -279,12 +280,11 @@
}
FrameLoader& frameLoader = frame.loader();
- if (options.securityCheck == DoSecurityCheck && (frameLoader.state() == FrameStateProvisional || !frameLoader.activeDocumentLoader() || frameLoader.activeDocumentLoader()->isStopping())) {
+ if (m_options.securityCheck == DoSecurityCheck && (frameLoader.state() == FrameStateProvisional || !frameLoader.activeDocumentLoader() || frameLoader.activeDocumentLoader()->isStopping())) {
failBeforeStarting();
return;
}
- m_options = options;
m_loading = true;
#if USE(QUICK_LOOK)
@@ -335,7 +335,7 @@
m_fragmentIdentifierForRequest = String();
}
- m_loader = platformStrategies()->loaderStrategy()->loadResource(frame, *this, request, options);
+ m_loader = platformStrategies()->loaderStrategy()->loadResource(frame, *this, request, m_options);
if (!m_loader) {
failBeforeStarting();
return;
@@ -344,16 +344,15 @@
m_status = Pending;
}
-void CachedResource::loadFrom(const CachedResource& resource, const ResourceLoaderOptions& options, CachedResourceLoader& cachedResourceLoader)
+void CachedResource::loadFrom(const CachedResource& resource, CachedResourceLoader& cachedResourceLoader)
{
ASSERT(url() == resource.url());
ASSERT(type() == resource.type());
ASSERT(resource.status() == Status::Cached);
- m_options = options;
computeOrigin(cachedResourceLoader);
- if (isCrossOrigin() && options.mode == FetchOptions::Mode::Cors) {
+ if (isCrossOrigin() && m_options.mode == FetchOptions::Mode::Cors) {
ASSERT(m_origin);
String errorMessage;
if (!WebCore::passesAccessControlCheck(resource.response(), m_options.allowCredentials, *m_origin, errorMessage)) {
diff --git a/Source/WebCore/loader/cache/CachedResource.h b/Source/WebCore/loader/cache/CachedResource.h
index 4e531b3..dc5f9a2 100644
--- a/Source/WebCore/loader/cache/CachedResource.h
+++ b/Source/WebCore/loader/cache/CachedResource.h
@@ -46,6 +46,7 @@
class CachedResourceClient;
class CachedResourceHandleBase;
class CachedResourceLoader;
+class CachedResourceRequest;
class InspectorResource;
class SecurityOrigin;
class SharedBuffer;
@@ -93,10 +94,10 @@
DecodeError
};
- CachedResource(const ResourceRequest&, Type, SessionID);
+ CachedResource(CachedResourceRequest&&, Type, SessionID);
virtual ~CachedResource();
- virtual void load(CachedResourceLoader&, const ResourceLoaderOptions&);
+ virtual void load(CachedResourceLoader&);
virtual void setEncoding(const String&) { }
virtual String encoding() const { return String(); }
@@ -111,6 +112,7 @@
virtual bool shouldIgnoreHTTPStatusCodeErrors() const { return false; }
+ const ResourceRequest& resourceRequest() const { return m_resourceRequest; }
ResourceRequest& resourceRequest() { return m_resourceRequest; }
const URL& url() const { return m_resourceRequest.url();}
#if ENABLE(CACHE_PARTITIONING)
@@ -209,7 +211,7 @@
bool isClean() const;
ResourceResponse::Tainting responseTainting() const { return m_responseTainting; }
- void loadFrom(const CachedResource&, const ResourceLoaderOptions&, CachedResourceLoader&);
+ void loadFrom(const CachedResource&, CachedResourceLoader&);
SecurityOrigin* origin() const { return m_origin.get(); }
diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
index 23961bf..8ac89f1 100644
--- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
@@ -82,40 +82,40 @@
namespace WebCore {
-static CachedResource* createResource(CachedResource::Type type, ResourceRequest& request, const String& charset, SessionID sessionID)
+static CachedResource* createResource(CachedResource::Type type, CachedResourceRequest&& request, SessionID sessionID)
{
switch (type) {
case CachedResource::ImageResource:
- return new CachedImage(request, sessionID);
+ return new CachedImage(WTFMove(request), sessionID);
case CachedResource::CSSStyleSheet:
- return new CachedCSSStyleSheet(request, charset, sessionID);
+ return new CachedCSSStyleSheet(WTFMove(request), sessionID);
case CachedResource::Script:
- return new CachedScript(request, charset, sessionID);
+ return new CachedScript(WTFMove(request), sessionID);
case CachedResource::SVGDocumentResource:
- return new CachedSVGDocument(request, sessionID);
+ return new CachedSVGDocument(WTFMove(request), sessionID);
#if ENABLE(SVG_FONTS)
case CachedResource::SVGFontResource:
- return new CachedSVGFont(request, sessionID);
+ return new CachedSVGFont(WTFMove(request), sessionID);
#endif
case CachedResource::FontResource:
- return new CachedFont(request, sessionID);
+ return new CachedFont(WTFMove(request), sessionID);
case CachedResource::MediaResource:
case CachedResource::RawResource:
case CachedResource::MainResource:
- return new CachedRawResource(request, type, sessionID);
+ return new CachedRawResource(WTFMove(request), type, sessionID);
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
- return new CachedXSLStyleSheet(request, sessionID);
+ return new CachedXSLStyleSheet(WTFMove(request), sessionID);
#endif
#if ENABLE(LINK_PREFETCH)
case CachedResource::LinkPrefetch:
- return new CachedResource(request, CachedResource::LinkPrefetch, sessionID);
+ return new CachedResource(WTFMove(request), CachedResource::LinkPrefetch, sessionID);
case CachedResource::LinkSubresource:
- return new CachedResource(request, CachedResource::LinkSubresource, sessionID);
+ return new CachedResource(WTFMove(request), CachedResource::LinkSubresource, sessionID);
#endif
#if ENABLE(VIDEO_TRACK)
case CachedResource::TextTrackResource:
- return new CachedTextTrack(request, sessionID);
+ return new CachedTextTrack(WTFMove(request), sessionID);
#endif
}
ASSERT_NOT_REACHED();
@@ -174,7 +174,7 @@
return sessionID;
}
-CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request)
+CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest&& request)
{
if (Frame* frame = this->frame()) {
if (frame->loader().pageDismissalEventBeingDispatched() != FrameLoader::PageDismissalType::None) {
@@ -186,35 +186,35 @@
return nullptr;
}
}
-
+
request.setDefer(clientDefersImage(request.resourceRequest().url()) ? CachedResourceRequest::DeferredByClient : CachedResourceRequest::NoDefer);
- return downcast<CachedImage>(requestResource(CachedResource::ImageResource, request).get());
+ return downcast<CachedImage>(requestResource(CachedResource::ImageResource, WTFMove(request)).get());
}
-CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest& request, bool isSVG)
+CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest&& request, bool isSVG)
{
#if ENABLE(SVG_FONTS)
if (isSVG)
- return downcast<CachedSVGFont>(requestResource(CachedResource::SVGFontResource, request).get());
+ return downcast<CachedSVGFont>(requestResource(CachedResource::SVGFontResource, WTFMove(request)).get());
#else
UNUSED_PARAM(isSVG);
#endif
- return downcast<CachedFont>(requestResource(CachedResource::FontResource, request).get());
+ return downcast<CachedFont>(requestResource(CachedResource::FontResource, WTFMove(request)).get());
}
#if ENABLE(VIDEO_TRACK)
-CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest& request)
+CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest&& request)
{
- return downcast<CachedTextTrack>(requestResource(CachedResource::TextTrackResource, request).get());
+ return downcast<CachedTextTrack>(requestResource(CachedResource::TextTrackResource, WTFMove(request)).get());
}
#endif
-CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest& request)
+CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest&& request)
{
- return downcast<CachedCSSStyleSheet>(requestResource(CachedResource::CSSStyleSheet, request).get());
+ return downcast<CachedCSSStyleSheet>(requestResource(CachedResource::CSSStyleSheet, WTFMove(request)).get());
}
-CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest& request)
+CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest&& request)
{
URL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.resourceRequest().url());
@@ -234,56 +234,55 @@
if (url.string() != request.resourceRequest().url())
request.mutableResourceRequest().setURL(url);
- CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request.resourceRequest(), request.charset(), sessionID());
+ CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(WTFMove(request), sessionID());
- if (request.allowsCaching())
+ if (userSheet->allowsCaching())
memoryCache.add(*userSheet);
// FIXME: loadResource calls setOwningCachedResourceLoader() if the resource couldn't be added to cache. Does this function need to call it, too?
- userSheet->load(*this, ResourceLoaderOptions(DoNotSendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, SkipSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::SkipPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::AllowCaching));
-
+ userSheet->load(*this);
return userSheet;
}
-CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(CachedResourceRequest& request)
+CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(CachedResourceRequest&& request)
{
- return downcast<CachedScript>(requestResource(CachedResource::Script, request).get());
+ return downcast<CachedScript>(requestResource(CachedResource::Script, WTFMove(request)).get());
}
#if ENABLE(XSLT)
-CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest& request)
+CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest&& request)
{
- return downcast<CachedXSLStyleSheet>(requestResource(CachedResource::XSLStyleSheet, request).get());
+ return downcast<CachedXSLStyleSheet>(requestResource(CachedResource::XSLStyleSheet, WTFMove(request)).get());
}
#endif
-CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest& request)
+CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest&& request)
{
- return downcast<CachedSVGDocument>(requestResource(CachedResource::SVGDocumentResource, request).get());
+ return downcast<CachedSVGDocument>(requestResource(CachedResource::SVGDocumentResource, WTFMove(request)).get());
}
#if ENABLE(LINK_PREFETCH)
-CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, CachedResourceRequest& request)
+CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, CachedResourceRequest&& request)
{
ASSERT(frame());
ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkSubresource);
- return requestResource(type, request);
+ return requestResource(type, WTFMove(request));
}
#endif
-CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMedia(CachedResourceRequest& request)
+CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMedia(CachedResourceRequest&& request)
{
- return downcast<CachedRawResource>(requestResource(CachedResource::MediaResource, request).get());
+ return downcast<CachedRawResource>(requestResource(CachedResource::MediaResource, WTFMove(request)).get());
}
-CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest& request)
+CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest&& request)
{
- return downcast<CachedRawResource>(requestResource(CachedResource::RawResource, request).get());
+ return downcast<CachedRawResource>(requestResource(CachedResource::RawResource, WTFMove(request)).get());
}
-CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMainResource(CachedResourceRequest& request)
+CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMainResource(CachedResourceRequest&& request)
{
- return downcast<CachedRawResource>(requestResource(CachedResource::MainResource, request).get());
+ return downcast<CachedRawResource>(requestResource(CachedResource::MainResource, WTFMove(request)).get());
}
static MixedContentChecker::ContentType contentTypeFromResourceType(CachedResource::Type type)
@@ -539,32 +538,27 @@
return !newRequest.isNull();
}
-bool CachedResourceLoader::updateCachedResourceWithCurrentRequest(CachedResourceRequest& request, CachedResourceHandle<CachedResource>& resourceHandle)
+bool CachedResourceLoader::shouldUpdateCachedResourceWithCurrentRequest(const CachedResource& resource, const CachedResourceRequest& request)
{
- ASSERT(resourceHandle);
-
- CachedResource& resource = *resourceHandle;
-
// FIXME: We should progressively extend this to other reusable resources
if (resource.type() != CachedResource::Type::ImageResource && resource.type() != CachedResource::Type::Script && resource.type() != CachedResource::Type::TextTrackResource && resource.type() != CachedResource::Type::CSSStyleSheet)
return false;
- bool shouldUpdate = resource.options().mode != request.options().mode || request.resourceRequest().httpOrigin() != resource.resourceRequest().httpOrigin();
+ return resource.options().mode != request.options().mode || request.resourceRequest().httpOrigin() != resource.resourceRequest().httpOrigin();
+}
- if (!shouldUpdate)
- return false;
-
+CachedResourceHandle<CachedResource> CachedResourceLoader::updateCachedResourceWithCurrentRequest(const CachedResource& resource, CachedResourceRequest&& request)
+{
// FIXME: For being loaded requests, we currently do not use the same resource, as this may induce errors in the resource response tainting.
// We should find a way to improve this.
if (resource.status() != CachedResource::Cached) {
request.setCachingPolicy(CachingPolicy::DisallowCaching);
- resourceHandle = loadResource(resource.type(), request);
- return true;
+ return loadResource(resource.type(), WTFMove(request));
}
- resourceHandle = createResource(resource.type(), request.mutableResourceRequest(), request.charset(), sessionID());
- resourceHandle->loadFrom(resource, request.options(), *this);
- return true;
+ auto resourceHandle = createResource(resource.type(), WTFMove(request), sessionID());
+ resourceHandle->loadFrom(resource, *this);
+ return resourceHandle;
}
static inline void logMemoryCacheResourceRequest(Frame* frame, const String& description, const String& value = String())
@@ -577,15 +571,15 @@
frame->page()->diagnosticLoggingClient().logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceRequestKey(), description, value, ShouldSample::Yes);
}
-CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request)
+CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest&& request)
{
if (Document* document = this->document())
document->contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(request.mutableResourceRequest(), ContentSecurityPolicy::InsecureRequestType::Load);
-
+
URL url = request.resourceRequest().url();
-
+
LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.stringCenterEllipsizedToLength().latin1().data(), request.charset().latin1().data(), request.priority() ? static_cast<int>(request.priority().value()) : -1, request.forPreload());
-
+
// If only the fragment identifiers differ, it is the same resource.
url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
@@ -602,7 +596,7 @@
applyBlockedStatusToRequest(blockedStatus, resourceRequest);
if (blockedStatus.blockedLoad) {
if (type == CachedResource::Type::MainResource) {
- auto resource = createResource(type, request.mutableResourceRequest(), request.charset(), sessionID());
+ auto resource = createResource(type, WTFMove(request), sessionID());
ASSERT(resource);
resource->error(CachedResource::Status::LoadError);
resource->setResourceError(ResourceError(ContentExtensions::WebKitContentBlockerDomain, 0, request.resourceRequest().url(), WEB_UI_STRING("The URL was blocked by a content blocker", "WebKitErrorBlockedByContentBlocker description")));
@@ -647,6 +641,12 @@
logMemoryCacheResourceRequest(frame(), resource ? DiagnosticLoggingKeys::inMemoryCacheKey() : DiagnosticLoggingKeys::notInMemoryCacheKey());
+ // These 3 fields will be used below after request is moved.
+ // FIXME: We can rearrange the code to not require storing all 3 fields.
+ auto forPreload = request.forPreload();
+ auto defer = request.defer();
+ auto priority = request.priority();
+
RevalidationPolicy policy = determineRevalidationPolicy(type, request, resource.get());
switch (policy) {
case Reload:
@@ -655,19 +655,20 @@
case Load:
if (resource)
logMemoryCacheResourceRequest(frame(), DiagnosticLoggingKeys::inMemoryCacheKey(), DiagnosticLoggingKeys::unusedKey());
- resource = loadResource(type, request);
+ resource = loadResource(type, WTFMove(request));
break;
case Revalidate:
if (resource)
logMemoryCacheResourceRequest(frame(), DiagnosticLoggingKeys::inMemoryCacheKey(), DiagnosticLoggingKeys::revalidatingKey());
- resource = revalidateResource(request, resource.get());
+ resource = revalidateResource(WTFMove(request), *resource);
break;
case Use:
- if (updateCachedResourceWithCurrentRequest(request, resource)) {
+ ASSERT(resource);
+ if (shouldUpdateCachedResourceWithCurrentRequest(*resource, request)) {
+ resource = updateCachedResourceWithCurrentRequest(*resource, WTFMove(request));
if (resource->status() != CachedResource::Status::Cached)
policy = Load;
} else {
- ASSERT(policy == Use);
if (!shouldContinueAfterNotifyingLoadedFromMemoryCache(request, resource.get()))
return nullptr;
logMemoryCacheResourceRequest(frame(), DiagnosticLoggingKeys::inMemoryCacheKey(), DiagnosticLoggingKeys::usedKey());
@@ -677,7 +678,7 @@
// FIXME (161170): The networkLoadTiming shouldn't be stored on the ResourceResponse.
resource->response().networkLoadTiming().reset();
loadTiming.setResponseEnd(monotonicallyIncreasingTime());
- m_resourceTimingInfo.storeResourceTimingInitiatorInformation(resource, request, frame());
+ m_resourceTimingInfo.storeResourceTimingInitiatorInformation(resource, request.initiatorName(), frame());
m_resourceTimingInfo.addResourceTiming(resource.get(), *document(), loadTiming);
}
#endif
@@ -688,16 +689,16 @@
if (!resource)
return nullptr;
- if (!request.forPreload() || policy != Use)
- resource->setLoadPriority(request.priority());
+ if (!forPreload || policy != Use)
+ resource->setLoadPriority(priority);
- if (!request.forPreload() && resource->loader() && resource->resourceRequest().ignoreForRequestCount()) {
+ if (!forPreload && resource->loader() && resource->resourceRequest().ignoreForRequestCount()) {
resource->resourceRequest().setIgnoreForRequestCount(false);
incrementRequestCount(*resource);
}
- if ((policy != Use || resource->stillNeedsLoad()) && CachedResourceRequest::NoDefer == request.defer()) {
- resource->load(*this, request.options());
+ if ((policy != Use || resource->stillNeedsLoad()) && CachedResourceRequest::NoDefer == defer) {
+ resource->load(*this);
// We don't support immediate loads, but we do support immediate failure.
if (resource->errorOccurred()) {
@@ -707,8 +708,8 @@
}
}
- if (document() && !document()->loadEventFinished() && !request.resourceRequest().url().protocolIsData())
- m_validatedURLs.add(request.resourceRequest().url());
+ if (document() && !document()->loadEventFinished() && !resource->resourceRequest().url().protocolIsData())
+ m_validatedURLs.add(resource->resourceRequest().url());
ASSERT(resource->url() == url.string());
m_documentResources.set(resource->url(), resource);
@@ -720,47 +721,50 @@
m_validatedURLs.clear();
}
-CachedResourceHandle<CachedResource> CachedResourceLoader::revalidateResource(const CachedResourceRequest& request, CachedResource* resource)
+CachedResourceHandle<CachedResource> CachedResourceLoader::revalidateResource(CachedResourceRequest&& request, CachedResource& resource)
{
- ASSERT(resource);
- ASSERT(resource->inCache());
+ ASSERT(resource.inCache());
auto& memoryCache = MemoryCache::singleton();
ASSERT(!memoryCache.disabled());
- ASSERT(resource->canUseCacheValidator());
- ASSERT(!resource->resourceToRevalidate());
- ASSERT(resource->sessionID() == sessionID());
- ASSERT(resource->allowsCaching());
+ ASSERT(resource.canUseCacheValidator());
+ ASSERT(!resource.resourceToRevalidate());
+ ASSERT(resource.sessionID() == sessionID());
+ ASSERT(resource.allowsCaching());
- CachedResourceHandle<CachedResource> newResource = createResource(resource->type(), resource->resourceRequest(), resource->encoding(), resource->sessionID());
+#if ENABLE(WEB_TIMING)
+ AtomicString initiatorName = request.initiatorName();
+#endif
+ CachedResourceHandle<CachedResource> newResource = createResource(resource.type(), WTFMove(request), resource.sessionID());
- LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource.get(), resource);
- newResource->setResourceToRevalidate(resource);
-
- memoryCache.remove(*resource);
+ LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource.get(), &resource);
+ newResource->setResourceToRevalidate(&resource);
+
+ memoryCache.remove(resource);
memoryCache.add(*newResource);
#if ENABLE(WEB_TIMING)
if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())
- m_resourceTimingInfo.storeResourceTimingInitiatorInformation(newResource, request, frame());
-#else
- UNUSED_PARAM(request);
+ m_resourceTimingInfo.storeResourceTimingInitiatorInformation(newResource, initiatorName, frame());
#endif
return newResource;
}
-CachedResourceHandle<CachedResource> CachedResourceLoader::loadResource(CachedResource::Type type, CachedResourceRequest& request)
+CachedResourceHandle<CachedResource> CachedResourceLoader::loadResource(CachedResource::Type type, CachedResourceRequest&& request)
{
auto& memoryCache = MemoryCache::singleton();
ASSERT(!request.allowsCaching() || !memoryCache.resourceForRequest(request.resourceRequest(), sessionID()));
LOG(ResourceLoading, "Loading CachedResource for '%s'.", request.resourceRequest().url().stringCenterEllipsizedToLength().latin1().data());
- CachedResourceHandle<CachedResource> resource = createResource(type, request.mutableResourceRequest(), request.charset(), sessionID());
+#if ENABLE(WEB_TIMING)
+ AtomicString initiatorName = request.initiatorName();
+#endif
+ CachedResourceHandle<CachedResource> resource = createResource(type, WTFMove(request), sessionID());
- if (request.allowsCaching() && !memoryCache.add(*resource))
+ if (resource->allowsCaching() && !memoryCache.add(*resource))
resource->setOwningCachedResourceLoader(this);
#if ENABLE(WEB_TIMING)
if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())
- m_resourceTimingInfo.storeResourceTimingInitiatorInformation(resource, request, frame());
+ m_resourceTimingInfo.storeResourceTimingInitiatorInformation(resource, initiatorName, frame());
#endif
return resource;
}
@@ -985,7 +989,7 @@
{
for (auto& resource : m_documentResources.values()) {
if (is<CachedImage>(*resource) && resource->stillNeedsLoad() && !clientDefersImage(resource->url()))
- downcast<CachedImage>(*resource).load(*this, defaultCachedResourceOptions());
+ downcast<CachedImage>(*resource).load(*this);
}
}
@@ -1095,7 +1099,7 @@
ASSERT(m_requestCount > -1);
}
-CachedResourceHandle<CachedResource> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest& request, const String& charset, PreloadType preloadType)
+CachedResourceHandle<CachedResource> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request, PreloadType preloadType)
{
// We always preload resources on iOS. See <https://bugs.webkit.org/show_bug.cgi?id=91276>.
// FIXME: We should consider adding a setting to toggle aggressive preloading behavior as opposed
@@ -1106,17 +1110,17 @@
if (!hasRendering && !canBlockParser && preloadType == ImplicitPreload) {
// 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, request, charset };
+ PendingPreload pendingPreload = { type, WTFMove(request) };
m_pendingPreloads.append(pendingPreload);
return nullptr;
}
#else
UNUSED_PARAM(preloadType);
#endif
- return requestPreload(type, request, charset);
+ return requestPreload(type, WTFMove(request));
}
-void CachedResourceLoader::checkForPendingPreloads()
+void CachedResourceLoader::checkForPendingPreloads()
{
if (m_pendingPreloads.isEmpty())
return;
@@ -1133,21 +1137,18 @@
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(preload.m_request.resourceRequest().url()))
- requestPreload(preload.m_type, preload.m_request, preload.m_charset);
+ requestPreload(preload.m_type, WTFMove(preload.m_request));
}
m_pendingPreloads.clear();
}
-CachedResourceHandle<CachedResource> CachedResourceLoader::requestPreload(CachedResource::Type type, CachedResourceRequest& request, const String& charset)
+CachedResourceHandle<CachedResource> CachedResourceLoader::requestPreload(CachedResource::Type type, CachedResourceRequest&& request)
{
- String encoding;
- if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet)
- encoding = charset.isEmpty() ? m_document->charset() : charset;
-
- request.setCharset(encoding);
+ if (request.charset().isEmpty() && (type == CachedResource::Script || type == CachedResource::CSSStyleSheet))
+ request.setCharset(m_document->charset());
request.setForPreload(true);
- CachedResourceHandle<CachedResource> resource = requestResource(type, request);
+ CachedResourceHandle<CachedResource> resource = requestResource(type, WTFMove(request));
if (!resource || (m_preloads && m_preloads->contains(resource.get())))
return nullptr;
// Fonts need special treatment since just creating the resource doesn't trigger a load.
diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.h b/Source/WebCore/loader/cache/CachedResourceLoader.h
index 4cc8b38..5af71d2a 100644
--- a/Source/WebCore/loader/cache/CachedResourceLoader.h
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.h
@@ -72,23 +72,23 @@
static Ref<CachedResourceLoader> create(DocumentLoader* documentLoader) { return adoptRef(*new CachedResourceLoader(documentLoader)); }
~CachedResourceLoader();
- CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&);
- CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(CachedResourceRequest&);
- CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(CachedResourceRequest&);
- CachedResourceHandle<CachedScript> requestScript(CachedResourceRequest&);
- CachedResourceHandle<CachedFont> requestFont(CachedResourceRequest&, bool isSVG);
- CachedResourceHandle<CachedRawResource> requestMedia(CachedResourceRequest&);
- CachedResourceHandle<CachedRawResource> requestRawResource(CachedResourceRequest&);
- CachedResourceHandle<CachedRawResource> requestMainResource(CachedResourceRequest&);
- CachedResourceHandle<CachedSVGDocument> requestSVGDocument(CachedResourceRequest&);
+ CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&&);
+ CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(CachedResourceRequest&&);
+ CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(CachedResourceRequest&&);
+ CachedResourceHandle<CachedScript> requestScript(CachedResourceRequest&&);
+ CachedResourceHandle<CachedFont> requestFont(CachedResourceRequest&&, bool isSVG);
+ CachedResourceHandle<CachedRawResource> requestMedia(CachedResourceRequest&&);
+ CachedResourceHandle<CachedRawResource> requestRawResource(CachedResourceRequest&&);
+ CachedResourceHandle<CachedRawResource> requestMainResource(CachedResourceRequest&&);
+ CachedResourceHandle<CachedSVGDocument> requestSVGDocument(CachedResourceRequest&&);
#if ENABLE(XSLT)
- CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(CachedResourceRequest&);
+ CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(CachedResourceRequest&&);
#endif
#if ENABLE(LINK_PREFETCH)
- CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, CachedResourceRequest&);
+ CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, CachedResourceRequest&&);
#endif
#if ENABLE(VIDEO_TRACK)
- CachedResourceHandle<CachedTextTrack> requestTextTrack(CachedResourceRequest&);
+ CachedResourceHandle<CachedTextTrack> requestTextTrack(CachedResourceRequest&&);
#endif
// Logs an access denied message to the console for the specified URL.
@@ -96,7 +96,7 @@
CachedResource* cachedResource(const String& url) const;
CachedResource* cachedResource(const URL& url) const;
-
+
typedef HashMap<String, CachedResourceHandle<CachedResource>> DocumentResourceMap;
const DocumentResourceMap& allCachedResources() const { return m_documentResources; }
@@ -131,7 +131,7 @@
void clearPreloads();
void clearPendingPreloads();
enum PreloadType { ImplicitPreload, ExplicitPreload };
- CachedResourceHandle<CachedResource> preload(CachedResource::Type, CachedResourceRequest&, const String& charset, PreloadType);
+ CachedResourceHandle<CachedResource> preload(CachedResource::Type, CachedResourceRequest&&, PreloadType);
void checkForPendingPreloads();
void printPreloadStats();
@@ -148,15 +148,17 @@
private:
explicit CachedResourceLoader(DocumentLoader*);
- CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&);
- CachedResourceHandle<CachedResource> revalidateResource(const CachedResourceRequest&, CachedResource*);
- CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, CachedResourceRequest&);
- CachedResourceHandle<CachedResource> requestPreload(CachedResource::Type, CachedResourceRequest&, const String& charset);
+ CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&&);
+ CachedResourceHandle<CachedResource> revalidateResource(CachedResourceRequest&&, CachedResource&);
+ CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, CachedResourceRequest&&);
+ CachedResourceHandle<CachedResource> requestPreload(CachedResource::Type, CachedResourceRequest&&);
enum RevalidationPolicy { Use, Revalidate, Reload, Load };
RevalidationPolicy determineRevalidationPolicy(CachedResource::Type, CachedResourceRequest&, CachedResource* existingResource) const;
- bool updateCachedResourceWithCurrentRequest(CachedResourceRequest&, CachedResourceHandle<CachedResource>&);
+ bool shouldUpdateCachedResourceWithCurrentRequest(const CachedResource&, const CachedResourceRequest&);
+ CachedResourceHandle<CachedResource> updateCachedResourceWithCurrentRequest(const CachedResource&, CachedResourceRequest&&);
+
bool shouldContinueAfterNotifyingLoadedFromMemoryCache(const CachedResourceRequest&, CachedResource*);
bool checkInsecureContent(CachedResource::Type, const URL&) const;
@@ -178,7 +180,6 @@
struct PendingPreload {
CachedResource::Type m_type;
CachedResourceRequest m_request;
- String m_charset;
};
Deque<PendingPreload> m_pendingPreloads;
diff --git a/Source/WebCore/loader/cache/CachedSVGDocument.cpp b/Source/WebCore/loader/cache/CachedSVGDocument.cpp
index a523020..e3949a3 100644
--- a/Source/WebCore/loader/cache/CachedSVGDocument.cpp
+++ b/Source/WebCore/loader/cache/CachedSVGDocument.cpp
@@ -27,8 +27,8 @@
namespace WebCore {
-CachedSVGDocument::CachedSVGDocument(const ResourceRequest& request, SessionID sessionID)
- : CachedResource(request, SVGDocumentResource, sessionID)
+CachedSVGDocument::CachedSVGDocument(CachedResourceRequest&& request, SessionID sessionID)
+ : CachedResource(WTFMove(request), SVGDocumentResource, sessionID)
, m_decoder(TextResourceDecoder::create("application/xml"))
{
setAccept("image/svg+xml");
diff --git a/Source/WebCore/loader/cache/CachedSVGDocument.h b/Source/WebCore/loader/cache/CachedSVGDocument.h
index 62642fe..06963f8 100644
--- a/Source/WebCore/loader/cache/CachedSVGDocument.h
+++ b/Source/WebCore/loader/cache/CachedSVGDocument.h
@@ -32,7 +32,7 @@
class CachedSVGDocument final : public CachedResource {
public:
- explicit CachedSVGDocument(const ResourceRequest&, SessionID);
+ explicit CachedSVGDocument(CachedResourceRequest&&, SessionID);
virtual ~CachedSVGDocument();
SVGDocument* document() const { return m_document.get(); }
diff --git a/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp b/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp
index 4790f73..5e48a13 100644
--- a/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp
+++ b/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp
@@ -54,7 +54,7 @@
CachedResourceRequest request(ResourceRequest(loader.document()->completeURL(m_url)), options);
request.setInitiator(cachedResourceRequestInitiators().css);
- m_document = loader.requestSVGDocument(request);
+ m_document = loader.requestSVGDocument(WTFMove(request));
if (m_document)
m_document->addClient(this);
diff --git a/Source/WebCore/loader/cache/CachedSVGFont.cpp b/Source/WebCore/loader/cache/CachedSVGFont.cpp
index 73b1b6b..cc72785 100644
--- a/Source/WebCore/loader/cache/CachedSVGFont.cpp
+++ b/Source/WebCore/loader/cache/CachedSVGFont.cpp
@@ -42,8 +42,8 @@
namespace WebCore {
-CachedSVGFont::CachedSVGFont(const ResourceRequest& resourceRequest, SessionID sessionID)
- : CachedFont(resourceRequest, sessionID, SVGFontResource)
+CachedSVGFont::CachedSVGFont(CachedResourceRequest&& request, SessionID sessionID)
+ : CachedFont(WTFMove(request), sessionID, SVGFontResource)
, m_externalSVGFontElement(nullptr)
{
}
diff --git a/Source/WebCore/loader/cache/CachedSVGFont.h b/Source/WebCore/loader/cache/CachedSVGFont.h
index 661ba5c..4424a0f 100644
--- a/Source/WebCore/loader/cache/CachedSVGFont.h
+++ b/Source/WebCore/loader/cache/CachedSVGFont.h
@@ -36,10 +36,10 @@
class CachedSVGFont final : public CachedFont {
public:
- CachedSVGFont(const ResourceRequest&, SessionID);
+ CachedSVGFont(CachedResourceRequest&&, SessionID);
bool ensureCustomFontData(const AtomicString& remoteURI) override;
-
+
RefPtr<Font> createFont(const FontDescription&, const AtomicString& remoteURI, bool syntheticBold, bool syntheticItalic, const FontFeatureSettings&, const FontVariantSettings&) override;
private:
diff --git a/Source/WebCore/loader/cache/CachedScript.cpp b/Source/WebCore/loader/cache/CachedScript.cpp
index 990af1d..f0ba3d0 100644
--- a/Source/WebCore/loader/cache/CachedScript.cpp
+++ b/Source/WebCore/loader/cache/CachedScript.cpp
@@ -29,6 +29,7 @@
#include "CachedResourceClient.h"
#include "CachedResourceClientWalker.h"
+#include "CachedResourceRequest.h"
#include "HTTPHeaderNames.h"
#include "HTTPParsers.h"
#include "MIMETypeRegistry.h"
@@ -39,9 +40,9 @@
namespace WebCore {
-CachedScript::CachedScript(const ResourceRequest& resourceRequest, const String& charset, SessionID sessionID)
- : CachedResource(resourceRequest, Script, sessionID)
- , m_decoder(TextResourceDecoder::create(ASCIILiteral("application/javascript"), charset))
+CachedScript::CachedScript(CachedResourceRequest&& request, SessionID sessionID)
+ : CachedResource(WTFMove(request), Script, sessionID)
+ , m_decoder(TextResourceDecoder::create(ASCIILiteral("application/javascript"), request.charset()))
{
// It's javascript we want.
// But some websites think their scripts are <some wrong mimetype here>
diff --git a/Source/WebCore/loader/cache/CachedScript.h b/Source/WebCore/loader/cache/CachedScript.h
index 4013346..babf486 100644
--- a/Source/WebCore/loader/cache/CachedScript.h
+++ b/Source/WebCore/loader/cache/CachedScript.h
@@ -34,7 +34,7 @@
class CachedScript final : public CachedResource {
public:
- CachedScript(const ResourceRequest&, const String& charset, SessionID);
+ CachedScript(CachedResourceRequest&&, SessionID);
virtual ~CachedScript();
StringView script();
diff --git a/Source/WebCore/loader/cache/CachedTextTrack.cpp b/Source/WebCore/loader/cache/CachedTextTrack.cpp
index 95cb4ae..9a0e4ae 100644
--- a/Source/WebCore/loader/cache/CachedTextTrack.cpp
+++ b/Source/WebCore/loader/cache/CachedTextTrack.cpp
@@ -37,8 +37,8 @@
namespace WebCore {
-CachedTextTrack::CachedTextTrack(const ResourceRequest& resourceRequest, SessionID sessionID)
- : CachedResource(resourceRequest, TextTrackResource, sessionID)
+CachedTextTrack::CachedTextTrack(CachedResourceRequest&& request, SessionID sessionID)
+ : CachedResource(WTFMove(request), TextTrackResource, sessionID)
{
}
diff --git a/Source/WebCore/loader/cache/CachedTextTrack.h b/Source/WebCore/loader/cache/CachedTextTrack.h
index f4e534d..ff51a0c 100644
--- a/Source/WebCore/loader/cache/CachedTextTrack.h
+++ b/Source/WebCore/loader/cache/CachedTextTrack.h
@@ -35,7 +35,7 @@
class CachedTextTrack final : public CachedResource {
public:
- CachedTextTrack(const ResourceRequest&, SessionID);
+ CachedTextTrack(CachedResourceRequest&&, SessionID);
private:
bool mayTryReplaceEncodedData() const override { return true; }
diff --git a/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp b/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp
index fbc14ff..714528c 100644
--- a/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp
+++ b/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp
@@ -36,8 +36,8 @@
#if ENABLE(XSLT)
-CachedXSLStyleSheet::CachedXSLStyleSheet(const ResourceRequest& resourceRequest, SessionID sessionID)
- : CachedResource(resourceRequest, XSLStyleSheet, sessionID)
+CachedXSLStyleSheet::CachedXSLStyleSheet(CachedResourceRequest&& request, SessionID sessionID)
+ : CachedResource(WTFMove(request), XSLStyleSheet, sessionID)
, m_decoder(TextResourceDecoder::create("text/xsl"))
{
// It's XML we want.
@@ -50,7 +50,7 @@
}
void CachedXSLStyleSheet::didAddClient(CachedResourceClient* c)
-{
+{
ASSERT(c->resourceClientType() == CachedStyleSheetClient::expectedType());
if (!isLoading())
static_cast<CachedStyleSheetClient*>(c)->setXSLStyleSheet(m_resourceRequest.url(), m_response.url(), m_sheet);
diff --git a/Source/WebCore/loader/cache/CachedXSLStyleSheet.h b/Source/WebCore/loader/cache/CachedXSLStyleSheet.h
index 8ecff45..5b4793e 100644
--- a/Source/WebCore/loader/cache/CachedXSLStyleSheet.h
+++ b/Source/WebCore/loader/cache/CachedXSLStyleSheet.h
@@ -36,7 +36,7 @@
class CachedXSLStyleSheet final : public CachedResource {
public:
- CachedXSLStyleSheet(const ResourceRequest&, SessionID);
+ CachedXSLStyleSheet(CachedResourceRequest&&, SessionID);
virtual ~CachedXSLStyleSheet();
const String& sheet() const { return m_sheet; }
diff --git a/Source/WebCore/loader/icon/IconLoader.cpp b/Source/WebCore/loader/icon/IconLoader.cpp
index 0be6347..c243f42 100644
--- a/Source/WebCore/loader/icon/IconLoader.cpp
+++ b/Source/WebCore/loader/icon/IconLoader.cpp
@@ -64,7 +64,7 @@
request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
request.setInitiator(cachedResourceRequestInitiators().icon);
- m_resource = m_frame.document()->cachedResourceLoader().requestRawResource(request);
+ m_resource = m_frame.document()->cachedResourceLoader().requestRawResource(WTFMove(request));
if (m_resource)
m_resource->addClient(this);
else
diff --git a/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp b/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp
index 7653202..912c2bfe 100644
--- a/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp
+++ b/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp
@@ -75,7 +75,7 @@
request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
CachedResourceLoader* loader = m_parent->player()->cachedResourceLoader();
- m_resource = loader ? loader->requestRawResource(request) : 0;
+ m_resource = loader ? loader->requestRawResource(WTFMove(request)) : 0;
if (m_resource)
m_resource->addClient(this);
else {
diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm b/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm
index 3a2f55f..5d9c138 100644
--- a/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm
+++ b/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm
@@ -72,7 +72,7 @@
CachedResourceRequest request(nsRequest, ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, FetchOptions::Credentials::Omit, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::DisallowCaching));
request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
if (auto* loader = m_parent->player()->cachedResourceLoader())
- m_resource = loader->requestMedia(request);
+ m_resource = loader->requestMedia(WTFMove(request));
if (m_resource)
m_resource->addClient(this);
diff --git a/Source/WebCore/svg/SVGFEImageElement.cpp b/Source/WebCore/svg/SVGFEImageElement.cpp
index ef2aed8..4d59291 100644
--- a/Source/WebCore/svg/SVGFEImageElement.cpp
+++ b/Source/WebCore/svg/SVGFEImageElement.cpp
@@ -90,7 +90,7 @@
CachedResourceRequest request(ResourceRequest(document().completeURL(href())), options);
request.setInitiator(this);
- m_cachedImage = document().cachedResourceLoader().requestImage(request);
+ m_cachedImage = document().cachedResourceLoader().requestImage(WTFMove(request));
if (m_cachedImage)
m_cachedImage->addClient(this);
diff --git a/Source/WebCore/svg/SVGFontFaceUriElement.cpp b/Source/WebCore/svg/SVGFontFaceUriElement.cpp
index e747961..a3898e0 100644
--- a/Source/WebCore/svg/SVGFontFaceUriElement.cpp
+++ b/Source/WebCore/svg/SVGFontFaceUriElement.cpp
@@ -106,7 +106,7 @@
CachedResourceLoader& cachedResourceLoader = document().cachedResourceLoader();
CachedResourceRequest request(ResourceRequest(document().completeURL(href)), options);
request.setInitiator(this);
- m_cachedFont = cachedResourceLoader.requestFont(request, isSVGFontTarget(*this));
+ m_cachedFont = cachedResourceLoader.requestFont(WTFMove(request), isSVGFontTarget(*this));
if (m_cachedFont) {
m_cachedFont->addClient(this);
m_cachedFont->beginLoadIfNeeded(cachedResourceLoader);
diff --git a/Source/WebCore/svg/SVGUseElement.cpp b/Source/WebCore/svg/SVGUseElement.cpp
index 26d9293..21e271f 100644
--- a/Source/WebCore/svg/SVGUseElement.cpp
+++ b/Source/WebCore/svg/SVGUseElement.cpp
@@ -573,7 +573,7 @@
CachedResourceRequest request { ResourceRequest { externalDocumentURL }, options };
request.setInitiator(this);
- m_externalDocument = document().cachedResourceLoader().requestSVGDocument(request);
+ m_externalDocument = document().cachedResourceLoader().requestSVGDocument(WTFMove(request));
if (m_externalDocument)
m_externalDocument->addClient(this);
}
diff --git a/Source/WebCore/xml/XSLImportRule.cpp b/Source/WebCore/xml/XSLImportRule.cpp
index e99c424..eb96b4b 100644
--- a/Source/WebCore/xml/XSLImportRule.cpp
+++ b/Source/WebCore/xml/XSLImportRule.cpp
@@ -90,22 +90,21 @@
if (!parentSheet->baseURL().isNull())
// use parent styleheet's URL as the base URL
absHref = URL(parentSheet->baseURL(), m_strHref).string();
-
+
// Check for a cycle in our import chain. If we encounter a stylesheet
// in our parent chain with the same URL, then just bail.
for (XSLStyleSheet* parentSheet = parentStyleSheet(); parentSheet; parentSheet = parentSheet->parentStyleSheet()) {
if (absHref == parentSheet->baseURL().string())
return;
}
-
- CachedResourceRequest request(ResourceRequest(cachedResourceLoader->document()->completeURL(absHref)));
+
if (m_cachedSheet)
m_cachedSheet->removeClient(this);
- m_cachedSheet = cachedResourceLoader->requestXSLStyleSheet(request);
-
+ m_cachedSheet = cachedResourceLoader->requestXSLStyleSheet(CachedResourceRequest(ResourceRequest(cachedResourceLoader->document()->completeURL(absHref))));
+
if (m_cachedSheet) {
m_cachedSheet->addClient(this);
-
+
// If the imported sheet is in the cache, then setXSLStyleSheet gets called,
// and the sheet even gets parsed (via parseString). In this case we have
// loaded (even if our subresources haven't), so if we have a stylesheet after
