Changeset 206016 in webkit

Timestamp:

Sep 16, 2016 1:56:54 AM (8 years ago)

Author:

commit-queue@webkit.org

Message:

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):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSFontFaceSrcValue.cpp (modified) (1 diff)
• css/CSSImageSetValue.cpp (modified) (2 diffs)
• css/CSSImageValue.cpp (modified) (1 diff)
• css/StyleRuleImport.cpp (modified) (1 diff)
• dom/ProcessingInstruction.cpp (modified) (2 diffs)
• dom/ScriptElement.cpp (modified) (1 diff)
• html/HTMLLinkElement.cpp (modified) (1 diff)
• html/parser/HTMLResourcePreloader.cpp (modified) (1 diff)
• loader/CrossOriginPreflightChecker.cpp (modified) (1 diff)
• loader/DocumentLoader.cpp (modified) (1 diff)
• loader/DocumentThreadableLoader.cpp (modified) (1 diff)
• loader/ImageLoader.cpp (modified) (2 diffs)
• loader/LinkLoader.cpp (modified) (3 diffs)
• loader/MediaResourceLoader.cpp (modified) (1 diff)
• loader/ResourceTimingInformation.cpp (modified) (2 diffs)
• loader/ResourceTimingInformation.h (modified) (1 diff)
• loader/TextTrackLoader.cpp (modified) (1 diff)
• loader/cache/CachedCSSStyleSheet.cpp (modified) (2 diffs)
• loader/cache/CachedCSSStyleSheet.h (modified) (1 diff)
• loader/cache/CachedFont.cpp (modified) (3 diffs)
• loader/cache/CachedFont.h (modified) (3 diffs)
• loader/cache/CachedImage.cpp (modified) (5 diffs)
• loader/cache/CachedImage.h (modified) (3 diffs)
• loader/cache/CachedRawResource.cpp (modified) (1 diff)
• loader/cache/CachedRawResource.h (modified) (2 diffs)
• loader/cache/CachedResource.cpp (modified) (6 diffs)
• loader/cache/CachedResource.h (modified) (4 diffs)
• loader/cache/CachedResourceLoader.cpp (modified) (19 diffs)
• loader/cache/CachedResourceLoader.h (modified) (5 diffs)
• loader/cache/CachedSVGDocument.cpp (modified) (1 diff)
• loader/cache/CachedSVGDocument.h (modified) (1 diff)
• loader/cache/CachedSVGDocumentReference.cpp (modified) (1 diff)
• loader/cache/CachedSVGFont.cpp (modified) (1 diff)
• loader/cache/CachedSVGFont.h (modified) (1 diff)
• loader/cache/CachedScript.cpp (modified) (2 diffs)
• loader/cache/CachedScript.h (modified) (1 diff)
• loader/cache/CachedTextTrack.cpp (modified) (1 diff)
• loader/cache/CachedTextTrack.h (modified) (1 diff)
• loader/cache/CachedXSLStyleSheet.cpp (modified) (2 diffs)
• loader/cache/CachedXSLStyleSheet.h (modified) (1 diff)
• loader/icon/IconLoader.cpp (modified) (1 diff)
• platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp (modified) (1 diff)
• platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm (modified) (1 diff)
• svg/SVGFEImageElement.cpp (modified) (1 diff)
• svg/SVGFontFaceUriElement.cpp (modified) (1 diff)
• svg/SVGUseElement.cpp (modified) (1 diff)
• xml/XSLImportRule.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+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>
 

trunk/Source/WebCore/css/CSSFontFaceSrcValue.cpp

@@ -109 +109 @@
     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();
 }

trunk/Source/WebCore/css/CSSImageSetValue.cpp

@@ -92 +92 @@
     Document* document = loader.document();
     updateDeviceScaleFactor(*document);
-    
+
     if (!m_accessedBestFitImage) {
         m_accessedBestFitImage = true;
@@ -106 +106 @@
             updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
         }
-        m_cachedImage = loader.requestImage(request);
+        m_cachedImage = loader.requestImage(WTFMove(request));
         m_bestFitImageScaleFactor = image.scaleFactor;
     }

trunk/Source/WebCore/css/CSSImageValue.cpp

@@ -76 +76 @@
             updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
         }
-        m_cachedImage = loader.requestImage(request);
+        m_cachedImage = loader.requestImage(WTFMove(request));
     }
     return m_cachedImage.get();

trunk/Source/WebCore/css/StyleRuleImport.cpp

@@ -120 +120 @@
     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

trunk/Source/WebCore/dom/ProcessingInstruction.cpp

@@ -130 +130 @@
                 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
@@ -150 +150 @@
                 request.setCharset(charset);
 
-                m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(request);
+                m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(WTFMove(request));
             }
             if (m_cachedSheet)

trunk/Source/WebCore/dom/ScriptElement.cpp

@@ -294 +294 @@
     request.setInitiator(&element());
 
-    return m_element.document().cachedResourceLoader().requestScript(request);
+    return m_element.document().cachedResourceLoader().requestScript(WTFMove(request));
 }
 

trunk/Source/WebCore/html/HTMLLinkElement.cpp

@@ -272 +272 @@
         request.setAsPotentiallyCrossOrigin(crossOrigin(), document());
 
-        m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(request);
+        m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(WTFMove(request));
 
         if (m_cachedSheet)

trunk/Source/WebCore/html/parser/HTMLResourcePreloader.cpp

@@ -69 +69 @@
         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);
 }
 

trunk/Source/WebCore/loader/CrossOriginPreflightChecker.cpp

@@ -113 +113 @@
 
     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);

trunk/Source/WebCore/loader/DocumentLoader.cpp

@@ -1511 +1511 @@
 
     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)

trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp

@@ -373 +373 @@
 
         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;

trunk/Source/WebCore/loader/ImageLoader.cpp

@@ -186 +186 @@
             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);
@@ -193 +193 @@
             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

trunk/Source/WebCore/loader/LinkLoader.cpp

@@ -164 +164 @@
     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)
@@ -196 +196 @@
             type = CachedResource::LinkSubresource;
         }
-        CachedResourceRequest linkRequest(ResourceRequest(document.completeURL(href)), priority);
 
         if (m_cachedLinkResource) {
@@ -202 +201 @@
             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);

trunk/Source/WebCore/loader/MediaResourceLoader.cpp

@@ -80 +80 @@
 #endif
 
-    CachedResourceHandle<CachedRawResource> resource = m_document->cachedResourceLoader().requestMedia(cacheRequest);
+    CachedResourceHandle<CachedRawResource> resource = m_document->cachedResourceLoader().requestMedia(WTFMove(cacheRequest));
     if (!resource)
         return nullptr;

trunk/Source/WebCore/loader/ResourceTimingInformation.cpp

@@ -60 +60 @@
 }
 
-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());
@@ -72 +72 @@
         }
     } else {
-        InitiatorInfo info = { request.initiatorName(), monotonicallyIncreasingTime(), NotYetAdded };
+        InitiatorInfo info = { initiatorName, monotonicallyIncreasingTime(), NotYetAdded };
         m_initiatorMap.add(resource.get(), info);
     }

trunk/Source/WebCore/loader/ResourceTimingInformation.h

@@ -44 +44 @@
 
     void addResourceTiming(CachedResource*, Document&, const LoadTiming&);
-    void storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>&, const CachedResourceRequest&, Frame*);
+    void storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>&, const AtomicString&, Frame*);
 
 private:

trunk/Source/WebCore/loader/TextTrackLoader.cpp

@@ -158 +158 @@
     cueRequest.setAsPotentiallyCrossOrigin(crossOriginMode, *document);
 
-    m_resource = document->cachedResourceLoader().requestTextTrack(cueRequest);
+    m_resource = document->cachedResourceLoader().requestTextTrack(WTFMove(cueRequest));
     if (!m_resource)
         return false;

trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp

@@ -30 +30 @@
 #include "CSSStyleSheet.h"
 #include "CachedResourceClientWalker.h"
+#include "CachedResourceRequest.h"
 #include "CachedStyleSheetClient.h"
 #include "HTTPHeaderNames.h"
@@ -41 +42 @@
 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

trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.h

@@ -38 +38 @@
     class CachedCSSStyleSheet final : public CachedResource {
     public:
-        CachedCSSStyleSheet(const ResourceRequest&, const String& charset, SessionID);
+        CachedCSSStyleSheet(CachedResourceRequest&&, SessionID);
         virtual ~CachedCSSStyleSheet();
 

trunk/Source/WebCore/loader/cache/CachedFont.cpp

@@ -43 +43 @@
 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)
@@ -54 +54 @@
 }
 
-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;
 }
 
@@ -80 +79 @@
     if (!m_loadInitiated) {
         m_loadInitiated = true;
-        CachedResource::load(loader, m_options);
+        CachedResource::load(loader);
     }
 }

trunk/Source/WebCore/loader/cache/CachedFont.h

@@ -44 +44 @@
 class CachedFont : public CachedResource {
 public:
-    CachedFont(const ResourceRequest&, SessionID, Type = FontResource);
+    CachedFont(CachedResourceRequest&&, SessionID, Type = FontResource);
     virtual ~CachedFont();
 
@@ -51 +51 @@
 
     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&);
@@ -66 +65 @@
     bool mayTryReplaceEncodedData() const override;
 
-    void load(CachedResourceLoader&, const ResourceLoaderOptions&) override;
+    void load(CachedResourceLoader&) override;
 
     void didAddClient(CachedResourceClient*) override;

trunk/Source/WebCore/loader/cache/CachedImage.cpp

@@ -57 +57 @@
 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)
@@ -67 +67 @@
 
 CachedImage::CachedImage(Image* image, SessionID sessionID)
-    : CachedResource(ResourceRequest(), ImageResource, sessionID)
+    : CachedResource(CachedResourceRequest(ResourceRequest()), ImageResource, sessionID)
     , m_image(image)
     , m_isManuallyCached(false)
@@ -77 +77 @@
 
 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)
@@ -87 +87 @@
 
 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)
@@ -107 +107 @@
 }
 
-void CachedImage::load(CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
-{
-    if (cachedResourceLoader.shouldPerformImageLoad(url()))
-        CachedResource::load(cachedResourceLoader, options);
+void CachedImage::load(CachedResourceLoader& loader)
+{
+    if (loader.shouldPerformImageLoad(url()))
+        CachedResource::load(loader);
     else
         setLoading(false);

trunk/Source/WebCore/loader/cache/CachedImage.h

@@ -51 +51 @@
     enum CacheBehaviorType { AutomaticallyCached, ManuallyCached };
 
-    CachedImage(const ResourceRequest&, SessionID);
+    CachedImage(CachedResourceRequest&&, SessionID);
     CachedImage(Image*, SessionID);
     CachedImage(const URL&, Image*, SessionID);
@@ -63 +63 @@
 
     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(); }
@@ -85 +85 @@
     bool isManuallyCached() const { return m_isManuallyCached; }
     RevalidationDecision makeRevalidationDecision(CachePolicy) const override;
-    void load(CachedResourceLoader&, const ResourceLoaderOptions&) override;
+    void load(CachedResourceLoader&) override;
 
     bool isOriginClean(SecurityOrigin*);

trunk/Source/WebCore/loader/cache/CachedRawResource.cpp

@@ -37 +37 @@
 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)

trunk/Source/WebCore/loader/cache/CachedRawResource.h

@@ -33 +33 @@
 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
@@ -41 +41 @@
 
     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; }

trunk/Source/WebCore/loader/cache/CachedResource.cpp

@@ -113 +113 @@
 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)
@@ -260 +261 @@
 }
 
-void CachedResource::load(CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
+void CachedResource::load(CachedResourceLoader& cachedResourceLoader)
 {
     if (!cachedResourceLoader.frame()) {
@@ -280 +281 @@
 
     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;
 
@@ -336 +336 @@
     }
 
-    m_loader = platformStrategies()->loaderStrategy()->loadResource(frame, *this, request, options);
+    m_loader = platformStrategies()->loaderStrategy()->loadResource(frame, *this, request, m_options);
     if (!m_loader) {
         failBeforeStarting();
@@ -345 +345 @@
 }
 
-void CachedResource::loadFrom(const CachedResource& resource, const ResourceLoaderOptions& options, CachedResourceLoader& cachedResourceLoader)
+void CachedResource::loadFrom(const CachedResource& resource, CachedResourceLoader& cachedResourceLoader)
 {
     ASSERT(url() == resource.url());
@@ -351 +351 @@
     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;

trunk/Source/WebCore/loader/cache/CachedResource.h

@@ -47 +47 @@
 class CachedResourceHandleBase;
 class CachedResourceLoader;
+class CachedResourceRequest;
 class InspectorResource;
 class SecurityOrigin;
@@ -94 +95 @@
     };
 
-    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&) { }
@@ -112 +113 @@
     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();}
@@ -210 +212 @@
     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(); }

trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

@@ -83 +83 @@
 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
     }
@@ -175 +175 @@
 }
 
-CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request)
+CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest&& request)
 {
     if (Frame* frame = this->frame()) {
@@ -187 +187 @@
         }
     }
-    
+
     request.setDefer(clientDefersImage(request.resourceRequest().url()) ? CachedResourceRequest::DeferredByClient : CachedResourceRequest::NoDefer);
-    return downcast<CachedImage>(requestResource(CachedResource::ImageResource, request).get());
-}
-
-CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest& request, bool isSVG)
+    return downcast<CachedImage>(requestResource(CachedResource::ImageResource, WTFMove(request)).get());
+}
+
+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)
-{
-    return downcast<CachedTextTrack>(requestResource(CachedResource::TextTrackResource, request).get());
-}
-#endif
-
-CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest& request)
-{
-    return downcast<CachedCSSStyleSheet>(requestResource(CachedResource::CSSStyleSheet, request).get());
-}
-
-CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest& request)
+CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest&& request)
+{
+    return downcast<CachedTextTrack>(requestResource(CachedResource::TextTrackResource, WTFMove(request)).get());
+}
+#endif
+
+CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest&& request)
+{
+    return downcast<CachedCSSStyleSheet>(requestResource(CachedResource::CSSStyleSheet, WTFMove(request)).get());
+}
+
+CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest&& request)
 {
     URL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.resourceRequest().url());
@@ -235 +235 @@
         request.mutableResourceRequest().setURL(url);
 
-    CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request.resourceRequest(), request.charset(), sessionID());
-
-    if (request.allowsCaching())
+    CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(WTFMove(request), sessionID());
+
+    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)
-{
-    return downcast<CachedScript>(requestResource(CachedResource::Script, request).get());
+CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(CachedResourceRequest&& request)
+{
+    return downcast<CachedScript>(requestResource(CachedResource::Script, WTFMove(request)).get());
 }
 
 #if ENABLE(XSLT)
-CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest& request)
-{
-    return downcast<CachedXSLStyleSheet>(requestResource(CachedResource::XSLStyleSheet, request).get());
-}
-#endif
-
-CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest& request)
-{
-    return downcast<CachedSVGDocument>(requestResource(CachedResource::SVGDocumentResource, request).get());
+CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest&& request)
+{
+    return downcast<CachedXSLStyleSheet>(requestResource(CachedResource::XSLStyleSheet, WTFMove(request)).get());
+}
+#endif
+
+CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest&& request)
+{
+    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);
-}
-#endif
-
-CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMedia(CachedResourceRequest& request)
-{
-    return downcast<CachedRawResource>(requestResource(CachedResource::MediaResource, request).get());
-}
-
-CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest& request)
-{
-    return downcast<CachedRawResource>(requestResource(CachedResource::RawResource, request).get());
-}
-
-CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMainResource(CachedResourceRequest& request)
-{
-    return downcast<CachedRawResource>(requestResource(CachedResource::MainResource, request).get());
+    return requestResource(type, WTFMove(request));
+}
+#endif
+
+CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMedia(CachedResourceRequest&& request)
+{
+    return downcast<CachedRawResource>(requestResource(CachedResource::MediaResource, WTFMove(request)).get());
+}
+
+CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest&& request)
+{
+    return downcast<CachedRawResource>(requestResource(CachedResource::RawResource, WTFMove(request)).get());
+}
+
+CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMainResource(CachedResourceRequest&& request)
+{
+    return downcast<CachedRawResource>(requestResource(CachedResource::MainResource, WTFMove(request)).get());
 }
 
@@ -540 +539 @@
 }
 
-bool CachedResourceLoader::updateCachedResourceWithCurrentRequest(CachedResourceRequest& request, CachedResourceHandle<CachedResource>& resourceHandle)
-{
-    ASSERT(resourceHandle);
-
-    CachedResource& resource = *resourceHandle;
-
+bool CachedResourceLoader::shouldUpdateCachedResourceWithCurrentRequest(const CachedResource& resource, const CachedResourceRequest& request)
+{
     // 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();
-
-    if (!shouldUpdate)
-        return false;
-
+    return resource.options().mode != request.options().mode || request.resourceRequest().httpOrigin() != resource.resourceRequest().httpOrigin();
+}
+
+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;
-    }
-
-    resourceHandle = createResource(resource.type(), request.mutableResourceRequest(), request.charset(), sessionID());
-    resourceHandle->loadFrom(resource, request.options(), *this);
-    return true;
+        return loadResource(resource.type(), WTFMove(request));
+    }
+
+    auto resourceHandle = createResource(resource.type(), WTFMove(request), sessionID());
+    resourceHandle->loadFrom(resource, *this);
+    return resourceHandle;
 }
 
@@ -578 +572 @@
 }
 
-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);
@@ -603 +597 @@
         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);
@@ -647 +641 @@
 
     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());
@@ -656 +656 @@
         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;
@@ -678 +679 @@
                 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);
             }
@@ -689 +690 @@
         return nullptr;
 
-    if (!request.forPreload() || policy != Use)
-        resource->setLoadPriority(request.priority());
-
-    if (!request.forPreload() && resource->loader() && resource->resourceRequest().ignoreForRequestCount()) {
+    if (!forPreload || policy != Use)
+        resource->setLoadPriority(priority);
+
+    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.
@@ -708 +709 @@
     }
 
-    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());
@@ -721 +722 @@
 }
 
-CachedResourceHandle<CachedResource> CachedResourceLoader::revalidateResource(const CachedResourceRequest& request, CachedResource* resource)
-{
-    ASSERT(resource);
-    ASSERT(resource->inCache());
+CachedResourceHandle<CachedResource> CachedResourceLoader::revalidateResource(CachedResourceRequest&& request, CachedResource& resource)
+{
+    ASSERT(resource.inCache());
     auto& memoryCache = MemoryCache::singleton();
     ASSERT(!memoryCache.disabled());
-    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());
-
-    LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource.get(), resource);
-    newResource->setResourceToRevalidate(resource);
-    
-    memoryCache.remove(*resource);
+    ASSERT(resource.canUseCacheValidator());
+    ASSERT(!resource.resourceToRevalidate());
+    ASSERT(resource.sessionID() == sessionID());
+    ASSERT(resource.allowsCaching());
+
+#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);
     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();
@@ -755 +756 @@
     LOG(ResourceLoading, "Loading CachedResource for '%s'.", request.resourceRequest().url().stringCenterEllipsizedToLength().latin1().data());
 
-    CachedResourceHandle<CachedResource> resource = createResource(type, request.mutableResourceRequest(), request.charset(), sessionID());
-
-    if (request.allowsCaching() && !memoryCache.add(*resource))
+#if ENABLE(WEB_TIMING)
+    AtomicString initiatorName = request.initiatorName();
+#endif
+    CachedResourceHandle<CachedResource> resource = createResource(type, WTFMove(request), sessionID());
+
+    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;
@@ -986 +990 @@
     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);
     }
 }
@@ -1096 +1100 @@
 }
 
-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>.
@@ -1107 +1111 @@
         // 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;
@@ -1114 +1118 @@
     UNUSED_PARAM(preloadType);
 #endif
-    return requestPreload(type, request, charset);
-}
-
-void CachedResourceLoader::checkForPendingPreloads() 
+    return requestPreload(type, WTFMove(request));
+}
+
+void CachedResourceLoader::checkForPendingPreloads()
 {
     if (m_pendingPreloads.isEmpty())
@@ -1134 +1138 @@
         // 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)
-{
-    String encoding;
-    if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet)
-        encoding = charset.isEmpty() ? m_document->charset() : charset;
-
-    request.setCharset(encoding);
+CachedResourceHandle<CachedResource> CachedResourceLoader::requestPreload(CachedResource::Type type, CachedResourceRequest&& request)
+{
+    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;

trunk/Source/WebCore/loader/cache/CachedResourceLoader.h

@@ -73 +73 @@
     ~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
 
@@ -97 +97 @@
     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; }
@@ -132 +132 @@
     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();
@@ -149 +149 @@
     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;
@@ -179 +181 @@
         CachedResource::Type m_type;
         CachedResourceRequest m_request;
-        String m_charset;
     };
     Deque<PendingPreload> m_pendingPreloads;

trunk/Source/WebCore/loader/cache/CachedSVGDocument.cpp

@@ -28 +28 @@
 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"))
 {

trunk/Source/WebCore/loader/cache/CachedSVGDocument.h

@@ -33 +33 @@
 class CachedSVGDocument final : public CachedResource {
 public:
-    explicit CachedSVGDocument(const ResourceRequest&, SessionID);
+    explicit CachedSVGDocument(CachedResourceRequest&&, SessionID);
     virtual ~CachedSVGDocument();
 

trunk/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp

@@ -55 +55 @@
     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);

trunk/Source/WebCore/loader/cache/CachedSVGFont.cpp

@@ -43 +43 @@
 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)
 {

trunk/Source/WebCore/loader/cache/CachedSVGFont.h

@@ -37 +37 @@
 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;
 

trunk/Source/WebCore/loader/cache/CachedScript.cpp

@@ -30 +30 @@
 #include "CachedResourceClient.h"
 #include "CachedResourceClientWalker.h"
+#include "CachedResourceRequest.h"
 #include "HTTPHeaderNames.h"
 #include "HTTPParsers.h"
@@ -40 +41 @@
 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.

trunk/Source/WebCore/loader/cache/CachedScript.h

@@ -35 +35 @@
 class CachedScript final : public CachedResource {
 public:
-    CachedScript(const ResourceRequest&, const String& charset, SessionID);
+    CachedScript(CachedResourceRequest&&, SessionID);
     virtual ~CachedScript();
 

trunk/Source/WebCore/loader/cache/CachedTextTrack.cpp

@@ -38 +38 @@
 namespace WebCore {
 
-CachedTextTrack::CachedTextTrack(const ResourceRequest& resourceRequest, SessionID sessionID)
-    : CachedResource(resourceRequest, TextTrackResource, sessionID)
+CachedTextTrack::CachedTextTrack(CachedResourceRequest&& request, SessionID sessionID)
+    : CachedResource(WTFMove(request), TextTrackResource, sessionID)
 {
 }

trunk/Source/WebCore/loader/cache/CachedTextTrack.h

@@ -36 +36 @@
 class CachedTextTrack final : public CachedResource {
 public:
-    CachedTextTrack(const ResourceRequest&, SessionID);
+    CachedTextTrack(CachedResourceRequest&&, SessionID);
 
 private:

trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp

@@ -37 +37 @@
 #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"))
 {
@@ -51 +51 @@
 
 void CachedXSLStyleSheet::didAddClient(CachedResourceClient* c)
-{  
+{
     ASSERT(c->resourceClientType() == CachedStyleSheetClient::expectedType());
     if (!isLoading())

trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.h

@@ -37 +37 @@
 class CachedXSLStyleSheet final : public CachedResource {
 public:
-    CachedXSLStyleSheet(const ResourceRequest&, SessionID);
+    CachedXSLStyleSheet(CachedResourceRequest&&, SessionID);
     virtual ~CachedXSLStyleSheet();
 

trunk/Source/WebCore/loader/icon/IconLoader.cpp

@@ -65 +65 @@
     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);

trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp

@@ -76 +76 @@
     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);

trunk/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm

@@ -73 +73 @@
     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)

trunk/Source/WebCore/svg/SVGFEImageElement.cpp

@@ -91 +91 @@
     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)

trunk/Source/WebCore/svg/SVGFontFaceUriElement.cpp

@@ -107 +107 @@
         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);

trunk/Source/WebCore/svg/SVGUseElement.cpp

@@ -574 +574 @@
         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);

trunk/Source/WebCore/xml/XSLImportRule.cpp

@@ -91 +91 @@
         // 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.
@@ -98 +98 @@
             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