Diff
Modified: trunk/Source/WebCore/ChangeLog (206015 => 206016)
--- trunk/Source/WebCore/ChangeLog 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/ChangeLog 2016-09-16 08:56:54 UTC (rev 206016)
@@ -1,5 +1,136 @@
2016-09-16 Youenn Fablet <you...@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 <you...@apple.com>
+
[Fetch API] Headers should be combine with ',' and not ', '
https://bugs.webkit.org/show_bug.cgi?id=161736
Modified: trunk/Source/WebCore/css/CSSFontFaceSrcValue.cpp (206015 => 206016)
--- trunk/Source/WebCore/css/CSSFontFaceSrcValue.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/css/CSSFontFaceSrcValue.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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();
}
Modified: trunk/Source/WebCore/css/CSSImageSetValue.cpp (206015 => 206016)
--- trunk/Source/WebCore/css/CSSImageSetValue.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/css/CSSImageSetValue.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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 };
Modified: trunk/Source/WebCore/css/CSSImageValue.cpp (206015 => 206016)
--- trunk/Source/WebCore/css/CSSImageValue.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/css/CSSImageValue.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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();
}
Modified: trunk/Source/WebCore/css/StyleRuleImport.cpp (206015 => 206016)
--- trunk/Source/WebCore/css/StyleRuleImport.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/css/StyleRuleImport.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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
Modified: trunk/Source/WebCore/dom/ProcessingInstruction.cpp (206015 => 206016)
--- trunk/Source/WebCore/dom/ProcessingInstruction.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/dom/ProcessingInstruction.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -129,18 +129,18 @@
m_cachedSheet->removeClient(this);
m_cachedSheet = nullptr;
}
-
+
String url = ""
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);
Modified: trunk/Source/WebCore/dom/ScriptElement.cpp (206015 => 206016)
--- trunk/Source/WebCore/dom/ScriptElement.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/dom/ScriptElement.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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)
Modified: trunk/Source/WebCore/html/HTMLLinkElement.cpp (206015 => 206016)
--- trunk/Source/WebCore/html/HTMLLinkElement.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/html/HTMLLinkElement.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
Modified: trunk/Source/WebCore/html/parser/HTMLResourcePreloader.cpp (206015 => 206016)
--- trunk/Source/WebCore/html/parser/HTMLResourcePreloader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/html/parser/HTMLResourcePreloader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
}
Modified: trunk/Source/WebCore/loader/CrossOriginPreflightChecker.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/CrossOriginPreflightChecker.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/CrossOriginPreflightChecker.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
}
Modified: trunk/Source/WebCore/loader/DocumentLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/DocumentLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/DocumentLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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) {
Modified: trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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;
}
Modified: trunk/Source/WebCore/loader/ImageLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/ImageLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/ImageLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -185,7 +185,7 @@
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());
@@ -192,7 +192,7 @@
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
Modified: trunk/Source/WebCore/loader/LinkLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/LinkLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/LinkLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
}
Modified: trunk/Source/WebCore/loader/MediaResourceLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/MediaResourceLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/MediaResourceLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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;
Modified: trunk/Source/WebCore/loader/ResourceTimingInformation.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/ResourceTimingInformation.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/ResourceTimingInformation.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
}
}
Modified: trunk/Source/WebCore/loader/ResourceTimingInformation.h (206015 => 206016)
--- trunk/Source/WebCore/loader/ResourceTimingInformation.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/ResourceTimingInformation.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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 };
Modified: trunk/Source/WebCore/loader/TextTrackLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/TextTrackLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/TextTrackLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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;
Modified: trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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>).
Modified: trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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 };
Modified: trunk/Source/WebCore/loader/cache/CachedFont.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedFont.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedFont.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
}
}
Modified: trunk/Source/WebCore/loader/cache/CachedFont.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedFont.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedFont.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -43,7 +43,7 @@
class CachedFont : public CachedResource {
public:
- CachedFont(const ResourceRequest&, SessionID, Type = FontResource);
+ CachedFont(CachedResourceRequest&&, SessionID, Type = FontResource);
virtual ~CachedFont();
void beginLoadIfNeeded(CachedResourceLoader&);
@@ -50,7 +50,6 @@
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;
Modified: trunk/Source/WebCore/loader/cache/CachedImage.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedImage.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedImage.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
}
Modified: trunk/Source/WebCore/loader/cache/CachedImage.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedImage.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedImage.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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*);
Modified: trunk/Source/WebCore/loader/cache/CachedRawResource.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedRawResource.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedRawResource.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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)
{
Modified: trunk/Source/WebCore/loader/cache/CachedRawResource.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedRawResource.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedRawResource.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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; }
Modified: trunk/Source/WebCore/loader/cache/CachedResource.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedResource.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedResource.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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)) {
Modified: trunk/Source/WebCore/loader/cache/CachedResource.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedResource.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedResource.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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(); }
Modified: trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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 = ""
@@ -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 = ""
-
+
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 = ""
@@ -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,34 +721,34 @@
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()));
@@ -754,13 +755,16 @@
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,7 +1110,7 @@
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;
}
@@ -1113,10 +1117,10 @@
#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.
Modified: trunk/Source/WebCore/loader/cache/CachedResourceLoader.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedResourceLoader.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedResourceLoader.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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;
Modified: trunk/Source/WebCore/loader/cache/CachedSVGDocument.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedSVGDocument.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedSVGDocument.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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");
Modified: trunk/Source/WebCore/loader/cache/CachedSVGDocument.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedSVGDocument.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedSVGDocument.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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(); }
Modified: trunk/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
Modified: trunk/Source/WebCore/loader/cache/CachedSVGFont.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedSVGFont.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedSVGFont.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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)
{
}
Modified: trunk/Source/WebCore/loader/cache/CachedSVGFont.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedSVGFont.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedSVGFont.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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:
Modified: trunk/Source/WebCore/loader/cache/CachedScript.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedScript.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedScript.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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>
Modified: trunk/Source/WebCore/loader/cache/CachedScript.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedScript.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedScript.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -34,7 +34,7 @@
class CachedScript final : public CachedResource {
public:
- CachedScript(const ResourceRequest&, const String& charset, SessionID);
+ CachedScript(CachedResourceRequest&&, SessionID);
virtual ~CachedScript();
StringView script();
Modified: trunk/Source/WebCore/loader/cache/CachedTextTrack.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedTextTrack.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedTextTrack.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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)
{
}
Modified: trunk/Source/WebCore/loader/cache/CachedTextTrack.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedTextTrack.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedTextTrack.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -35,7 +35,7 @@
class CachedTextTrack final : public CachedResource {
public:
- CachedTextTrack(const ResourceRequest&, SessionID);
+ CachedTextTrack(CachedResourceRequest&&, SessionID);
private:
bool mayTryReplaceEncodedData() const override { return true; }
Modified: trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
Modified: trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.h (206015 => 206016)
--- trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.h 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.h 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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; }
Modified: trunk/Source/WebCore/loader/icon/IconLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/loader/icon/IconLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/loader/icon/IconLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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
Modified: trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp (206015 => 206016)
--- trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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 {
Modified: trunk/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm (206015 => 206016)
--- trunk/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
Modified: trunk/Source/WebCore/svg/SVGFEImageElement.cpp (206015 => 206016)
--- trunk/Source/WebCore/svg/SVGFEImageElement.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/svg/SVGFEImageElement.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
Modified: trunk/Source/WebCore/svg/SVGFontFaceUriElement.cpp (206015 => 206016)
--- trunk/Source/WebCore/svg/SVGFontFaceUriElement.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/svg/SVGFontFaceUriElement.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
Modified: trunk/Source/WebCore/svg/SVGUseElement.cpp (206015 => 206016)
--- trunk/Source/WebCore/svg/SVGUseElement.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/svg/SVGUseElement.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -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);
}
Modified: trunk/Source/WebCore/xml/XSLImportRule.cpp (206015 => 206016)
--- trunk/Source/WebCore/xml/XSLImportRule.cpp 2016-09-16 08:47:08 UTC (rev 206015)
+++ trunk/Source/WebCore/xml/XSLImportRule.cpp 2016-09-16 08:56:54 UTC (rev 206016)
@@ -90,7 +90,7 @@
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()) {
@@ -97,15 +97,14 @@
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
