Source/WebCore/ChangeLog

 12012-10-18 Marja Hölttä <marja@chromium.org>
 2
 3 Refactor CachedResourceLoader: add CachedResourceRequest
 4 https://bugs.webkit.org/show_bug.cgi?id=99736
 5
 6 Reviewed by NOBODY (OOPS!).
 7
 8 For fixing bugs 84883 and 92761,
 9 CachedResourceLoader::requestResource should take as parameter
 10 information about who initiated the request. But the parameter
 11 list was already long. This gathers all the parameters into a
 12 separate class, CachedResourceRequest. The next step is to add
 13 information about who initiated the request into
 14 CachedResourceRequest.
 15
 16 * css/CSSFontFaceSrcValue.cpp:
 17 (WebCore::CSSFontFaceSrcValue::cachedFont):
 18 * css/CSSImageSetValue.cpp:
 19 (WebCore::CSSImageSetValue::cachedImageSet):
 20 * css/CSSImageValue.cpp:
 21 (WebCore::CSSImageValue::cachedImage):
 22 * css/StyleRuleImport.cpp:
 23 (WebCore::StyleRuleImport::requestStyleSheet):
 24 * css/WebKitCSSSVGDocumentValue.cpp:
 25 (WebCore::WebKitCSSSVGDocumentValue::load):
 26 * css/WebKitCSSShaderValue.cpp:
 27 (WebCore::WebKitCSSShaderValue::cachedShader):
 28 * dom/ProcessingInstruction.cpp:
 29 (WebCore::ProcessingInstruction::checkStyleSheet):
 30 * dom/ScriptElement.cpp:
 31 (WebCore::ScriptElement::requestScript):
 32 * html/HTMLLinkElement.cpp:
 33 (WebCore::HTMLLinkElement::process):
 34 * loader/DocumentThreadableLoader.cpp:
 35 (WebCore::DocumentThreadableLoader::loadRequest):
 36 * loader/ImageLoader.cpp:
 37 (WebCore::ImageLoader::updateFromElement):
 38 * loader/LinkLoader.cpp:
 39 (WebCore::LinkLoader::loadLink):
 40 * loader/TextTrackLoader.cpp:
 41 (WebCore::TextTrackLoader::load):
 42 * loader/cache/CachedResourceLoader.cpp:
 43 (WebCore::CachedResourceLoader::CachedResourceRequest::CachedResourceRequest):
 44 (WebCore):
 45 (WebCore::CachedResourceLoader::requestImage):
 46 (WebCore::CachedResourceLoader::requestFont):
 47 (WebCore::CachedResourceLoader::requestTextTrack):
 48 (WebCore::CachedResourceLoader::requestShader):
 49 (WebCore::CachedResourceLoader::requestCSSStyleSheet):
 50 (WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
 51 (WebCore::CachedResourceLoader::requestScript):
 52 (WebCore::CachedResourceLoader::requestXSLStyleSheet):
 53 (WebCore::CachedResourceLoader::requestSVGDocument):
 54 (WebCore::CachedResourceLoader::requestLinkResource):
 55 (WebCore::CachedResourceLoader::requestRawResource):
 56 (WebCore::CachedResourceLoader::requestResource):
 57 (WebCore::CachedResourceLoader::requestPreload):
 58 * loader/cache/CachedResourceLoader.h:
 59 (CachedResourceRequest):
 60 (WebCore::CachedResourceLoader::CachedResourceRequest::setCharset):
 61 (WebCore::CachedResourceLoader::CachedResourceRequest::setDefer):
 62 (WebCore::CachedResourceLoader::CachedResourceRequest::setForPreload):
 63 (WebCore::CachedResourceLoader::CachedResourceRequest::resourceRequest):
 64 (WebCore::CachedResourceLoader::CachedResourceRequest::charset):
 65 (WebCore::CachedResourceLoader::CachedResourceRequest::options):
 66 (WebCore::CachedResourceLoader::CachedResourceRequest::priority):
 67 (WebCore::CachedResourceLoader::CachedResourceRequest::forPreload):
 68 (WebCore::CachedResourceLoader::CachedResourceRequest::defer):
 69 (CachedResourceLoader):
 70 * loader/icon/IconLoader.cpp:
 71 (WebCore::IconLoader::startLoading):
 72 * svg/SVGFEImageElement.cpp:
 73 (WebCore::SVGFEImageElement::requestImageResource):
 74 * svg/SVGFontFaceUriElement.cpp:
 75 (WebCore::SVGFontFaceUriElement::loadFont):
 76 * svg/SVGUseElement.cpp:
 77 (WebCore::SVGUseElement::svgAttributeChanged):
 78 * xml/XSLImportRule.cpp:
 79 (WebCore::XSLImportRule::loadSheet):
 80
1812012-10-18 Tommy Widenflycht <tommyw@google.com>
282
383 MediaStream API: Do some cleanup in the chromium WebKit API

Source/WebCore/CMakeLists.txt

@@SET(WebCore_SOURCES
16811681 loader/cache/CachedResource.cpp
16821682 loader/cache/CachedResourceHandle.cpp
16831683 loader/cache/CachedResourceLoader.cpp
 1684 loader/cache/CachedResourceRequest.cpp
16841685 loader/cache/CachedScript.cpp
16851686 loader/cache/CachedShader.cpp
16861687 loader/cache/CachedSVGDocument.cpp

Source/WebCore/GNUmakefile.list.am

@@webcore_sources += \
38433843 Source/WebCore/loader/cache/CachedResourceHandle.h \
38443844 Source/WebCore/loader/cache/CachedResourceLoader.cpp \
38453845 Source/WebCore/loader/cache/CachedResourceLoader.h \
 3846 Source/WebCore/loader/cache/CachedResourceRequest.cpp \
 3847 Source/WebCore/loader/cache/CachedResourceRequest.h \
38463848 Source/WebCore/loader/cache/CachedScript.cpp \
38473849 Source/WebCore/loader/cache/CachedScript.h \
38483850 Source/WebCore/loader/cache/CachedShader.cpp \

Source/WebCore/Target.pri

@@SOURCES += \
816816 loader/CrossOriginAccessControl.cpp \
817817 loader/CrossOriginPreflightResultCache.cpp \
818818 loader/cache/CachedResourceLoader.cpp \
 819 loader/cache/CachedResourceRequest.cpp \
819820 loader/DocumentLoadTiming.cpp \
820821 loader/DocumentLoader.cpp \
821822 loader/DocumentThreadableLoader.cpp \

Source/WebCore/WebCore.gypi

206206 'loader/cache/CachedResourceClient.h',
207207 'loader/cache/CachedResourceHandle.h',
208208 'loader/cache/CachedResourceLoader.h',
 209 'loader/cache/CachedResourceRequest.h',
209210 'loader/cache/CachedShader.h',
210211 'loader/cache/CachedStyleSheetClient.h',
211212 'loader/cache/MemoryCache.h',

30613062 'loader/cache/CachedResourceClientWalker.h',
30623063 'loader/cache/CachedResourceHandle.cpp',
30633064 'loader/cache/CachedResourceLoader.cpp',
 3065 'loader/cache/CachedResourceRequest.cpp',
30643066 'loader/cache/CachedScript.cpp',
30653067 'loader/cache/CachedScript.h',
30663068 'loader/cache/CachedShader.cpp',

Source/WebCore/WebCore.vcproj/WebCore.vcproj

2819428194 >
2819528195 </File>
2819628196 <File
 28197 RelativePath="..\loader\cache\CachedResourceRequest.cpp"
 28198 >
 28199 </File>
 28200 <File
 28201 RelativePath="..\loader\cache\CachedResourceRequest.h"
 28202 >
 28203 </File>
 28204 <File
2819728205 RelativePath="..\loader\cache\CachedScript.cpp"
2819828206 >
2819928207 </File>

Source/WebCore/WebCore.xcodeproj/project.pbxproj

14911491 503D0CAB14B5B08700F32F57 /* CustomFilterProgram.h in Headers */ = {isa = PBXBuildFile; fileRef = 503D0CA814B5B08700F32F57 /* CustomFilterProgram.h */; settings = {ATTRIBUTES = (); }; };
14921492 503D0CAC14B5B08700F32F57 /* CustomFilterProgramClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 503D0CA914B5B08700F32F57 /* CustomFilterProgramClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
14931493 503D0CAE14B5B0BA00F32F57 /* StyleCustomFilterProgram.h in Headers */ = {isa = PBXBuildFile; fileRef = 503D0CAD14B5B0BA00F32F57 /* StyleCustomFilterProgram.h */; settings = {ATTRIBUTES = (); }; };
 1494 5081E3C33CE580C16EF8B48B /* CachedResourceRequest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5081E3DF3CFC80C16EF8B48B /* CachedResourceRequest.cpp */; };
 1495 5081E3E03CFF80C16EF8B48B /* CachedResourceRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 5081E3E13D0280C16EF8B48B /* CachedResourceRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
14941496 508CCA4F13CF106B003151F3 /* RenderFlowThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 508CCA4D13CF106B003151F3 /* RenderFlowThread.h */; };
14951497 508CCA5013CF106B003151F3 /* RenderFlowThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 508CCA4E13CF106B003151F3 /* RenderFlowThread.cpp */; };
14961498 50987C26157D676D00BDA835 /* CustomFilterGlobalContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 50987C24157D676D00BDA835 /* CustomFilterGlobalContext.cpp */; };

1296112963 BCB16C0F0979C3BD00467741 /* CachedXSLStyleSheet.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CachedXSLStyleSheet.h; sourceTree = "<group>"; };
1296212964 BCB16C100979C3BD00467741 /* CachedResourceLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CachedResourceLoader.cpp; sourceTree = "<group>"; };
1296312965 BCB16C110979C3BD00467741 /* CachedResourceLoader.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CachedResourceLoader.h; sourceTree = "<group>"; };
 12966 5081E3DF3CFC80C16EF8B48B /* CachedResourceRequest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CachedResourceRequest.cpp; sourceTree = "<group>"; };
 12967 5081E3E13D0280C16EF8B48B /* CachedResourceRequest.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CachedResourceRequest.h; sourceTree = "<group>"; };
1296412968 BCB7735E0C17853D00132BA4 /* JSNodeFilterCondition.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSNodeFilterCondition.cpp; sourceTree = "<group>"; };
1296512969 BCB7735F0C17853D00132BA4 /* JSNodeFilterCondition.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSNodeFilterCondition.h; sourceTree = "<group>"; };
1296612970 BCB773600C17853D00132BA4 /* JSNodeFilterCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSNodeFilterCustom.cpp; sourceTree = "<group>"; };

1920019204 E47B4BE60E71241600038854 /* CachedResourceHandle.h */,
1920119205 BCB16C100979C3BD00467741 /* CachedResourceLoader.cpp */,
1920219206 BCB16C110979C3BD00467741 /* CachedResourceLoader.h */,
 19207 5081E3DF3CFC80C16EF8B48B /* CachedResourceRequest.cpp */,
 19208 5081E3E13D0280C16EF8B48B /* CachedResourceRequest.h */,
1920319209 BCB16C0A0979C3BD00467741 /* CachedScript.cpp */,
1920419210 BCB16C0B0979C3BD00467741 /* CachedScript.h */,
1920519211 5038BE3E1472AD980095E0D1 /* CachedShader.cpp */,

2249522501 BCB16C220979C3BD00467741 /* CachedResourceClientWalker.h in Headers */,
2249622502 E47B4BE80E71241600038854 /* CachedResourceHandle.h in Headers */,
2249722503 BCB16C2A0979C3BD00467741 /* CachedResourceLoader.h in Headers */,
 22504 5081E3E03CFF80C16EF8B48B /* CachedResourceRequest.h in Headers */,
2249822505 BCB16C240979C3BD00467741 /* CachedScript.h in Headers */,
2249922506 BCD533640ED6848900887468 /* CachedScriptSourceProvider.h in Headers */,
2250022507 5038BE411472AD980095E0D1 /* CachedShader.h in Headers */,

2611726124 BCB16C1F0979C3BD00467741 /* CachedResource.cpp in Sources */,
2611826125 E47B4BE90E71241600038854 /* CachedResourceHandle.cpp in Sources */,
2611926126 BCB16C290979C3BD00467741 /* CachedResourceLoader.cpp in Sources */,
 26127 5081E3C33CE580C16EF8B48B /* CachedResourceRequest.cpp in Sources */,
2612026128 BCB16C230979C3BD00467741 /* CachedScript.cpp in Sources */,
2612126129 5038BE401472AD980095E0D1 /* CachedShader.cpp in Sources */,
2612226130 A104F24314C71F7A009E2C23 /* CachedSVGDocument.cpp in Sources */,

Source/WebCore/css/CSSFontFaceSrcValue.cpp

2727#include "CSSFontFaceSrcValue.h"
2828#include "CachedFont.h"
2929#include "CachedResourceLoader.h"
 30#include "CachedResourceRequest.h"
3031#include "Document.h"
3132#include "FontCustomPlatformData.h"
3233#include "Node.h"

@@bool CSSFontFaceSrcValue::hasFailedOrCanceledSubresources() const
9596CachedFont* CSSFontFaceSrcValue::cachedFont(Document* document)
9697{
9798 if (!m_cachedFont) {
98  ResourceRequest request(document->completeURL(m_resource));
 99 CachedResourceRequest request(ResourceRequest(document->completeURL(m_resource)));
99100 m_cachedFont = document->cachedResourceLoader()->requestFont(request);
100101 }
101102 return m_cachedFont.get();

@@void CSSFontFaceSrcValue::reportDescendantMemoryUsage(MemoryObjectInfo* memoryOb
113114}
114115
115116}
116 

Source/WebCore/css/CSSImageSetValue.cpp

3232#include "CSSPrimitiveValue.h"
3333#include "CachedImage.h"
3434#include "CachedResourceLoader.h"
 35#include "CachedResourceRequest.h"
3536#include "Document.h"
3637#include "Page.h"
3738#include "StyleCachedImageSet.h"

@@StyleCachedImageSet* CSSImageSetValue::cachedImageSet(CachedResourceLoader* load
108109 // All forms of scale should be included: Page::pageScaleFactor(), Frame::pageZoomFactor(),
109110 // and any CSS transforms. https://bugs.webkit.org/show_bug.cgi?id=81698
110111 ImageWithScale image = bestImageForScaleFactor();
111  ResourceRequest request(loader->document()->completeURL(image.imageURL));
 112 CachedResourceRequest request(ResourceRequest(loader->document()->completeURL(image.imageURL)));
112113 if (CachedResourceHandle<CachedImage> cachedImage = loader->requestImage(request)) {
113114 m_imageSet = StyleCachedImageSet::create(cachedImage.get(), image.scaleFactor, this);
114115 m_accessedBestFitImage = true;

Source/WebCore/css/CSSImageValue.cpp

2626#include "CSSValueKeywords.h"
2727#include "CachedImage.h"
2828#include "CachedResourceLoader.h"
 29#include "CachedResourceRequest.h"
2930#include "Document.h"
3031#include "MemoryCache.h"
3132#include "StyleCachedImage.h"

@@StyleCachedImage* CSSImageValue::cachedImage(CachedResourceLoader* loader, const
8283 if (!m_accessedImage) {
8384 m_accessedImage = true;
8485
85  ResourceRequest request(loader->document()->completeURL(url));
 86 CachedResourceRequest request(ResourceRequest(loader->document()->completeURL(url)));
8687 if (CachedResourceHandle<CachedImage> cachedImage = loader->requestImage(request))
8788 m_image = StyleCachedImage::create(cachedImage.get());
8889 }

Source/WebCore/css/StyleRuleImport.cpp

2525#include "CSSStyleSheet.h"
2626#include "CachedCSSStyleSheet.h"
2727#include "CachedResourceLoader.h"
 28#include "CachedResourceRequest.h"
2829#include "Document.h"
2930#include "SecurityOrigin.h"
3031#include "StyleSheetContents.h"

@@void StyleRuleImport::requestStyleSheet()
115116 rootSheet = sheet;
116117 }
117118
118  ResourceRequest request(absURL);
 119 CachedResourceRequest request(ResourceRequest(absURL), m_parentStyleSheet->charset());
119120 if (m_parentStyleSheet->isUserStyleSheet())
120  m_cachedSheet = cachedResourceLoader->requestUserCSSStyleSheet(request, m_parentStyleSheet->charset());
 121 m_cachedSheet = cachedResourceLoader->requestUserCSSStyleSheet(request);
121122 else
122  m_cachedSheet = cachedResourceLoader->requestCSSStyleSheet(request, m_parentStyleSheet->charset());
 123 m_cachedSheet = cachedResourceLoader->requestCSSStyleSheet(request);
123124 if (m_cachedSheet) {
124125 // if the import rule is issued dynamically, the sheet may be
125126 // removed from the pending sheet count, so let the doc know

Source/WebCore/css/WebKitCSSSVGDocumentValue.cpp

2929
3030#include "CSSParser.h"
3131#include "CachedResourceLoader.h"
 32#include "CachedResourceRequest.h"
3233#include "Document.h"
3334#include "WebCoreMemoryInstrumentation.h"
3435

@@CachedSVGDocument* WebKitCSSSVGDocumentValue::load(CachedResourceLoader* loader)
5253 if (!m_loadRequested) {
5354 m_loadRequested = true;
5455
55  ResourceRequest request(loader->document()->completeURL(m_url));
 56 CachedResourceRequest request(ResourceRequest(loader->document()->completeURL(m_url)));
5657 m_document = loader->requestSVGDocument(request);
5758 }
5859

Source/WebCore/css/WebKitCSSShaderValue.cpp

3232#if ENABLE(CSS_SHADERS)
3333#include "WebKitCSSShaderValue.h"
3434
35 #include "CachedResourceLoader.h"
3635#include "CSSParser.h"
 36#include "CachedResourceLoader.h"
 37#include "CachedResourceRequest.h"
3738#include "Document.h"
3839#include "StyleCachedShader.h"
3940#include "StylePendingShader.h"

@@StyleCachedShader* WebKitCSSShaderValue::cachedShader(CachedResourceLoader* load
5960 if (!m_accessedShader) {
6061 m_accessedShader = true;
6162
62  ResourceRequest request(loader->document()->completeURL(m_url));
 63 CachedResourceRequest request(ResourceRequest(loader->document()->completeURL(m_url)));
6364 if (CachedResourceHandle<CachedShader> cachedShader = loader->requestShader(request))
6465 m_shader = StyleCachedShader::create(cachedShader.get());
6566 }

Source/WebCore/dom/ProcessingInstruction.cpp

2424#include "CSSStyleSheet.h"
2525#include "CachedCSSStyleSheet.h"
2626#include "CachedResourceLoader.h"
 27#include "CachedResourceRequest.h"
2728#include "CachedXSLStyleSheet.h"
2829#include "Document.h"
2930#include "DocumentStyleSheetCollection.h"

@@void ProcessingInstruction::checkStyleSheet()
163164 m_loading = true;
164165 document()->styleSheetCollection()->addPendingSheet();
165166
166  ResourceRequest request(document()->completeURL(href));
 167 CachedResourceRequest request(ResourceRequest(document()->completeURL(href)));
167168#if ENABLE(XSLT)
168169 if (m_isXSL)
169170 m_cachedSheet = document()->cachedResourceLoader()->requestXSLStyleSheet(request);

@@void ProcessingInstruction::checkStyleSheet()
173174 String charset = attrs.get("charset");
174175 if (charset.isEmpty())
175176 charset = document()->charset();
 177 request.setCharset(charset);
176178
177  m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request, charset);
 179 m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request);
178180 }
179181 if (m_cachedSheet)
180182 m_cachedSheet->addClient(this);

Source/WebCore/dom/ScriptElement.cpp

2626
2727#include "CachedScript.h"
2828#include "CachedResourceLoader.h"
 29#include "CachedResourceRequest.h"
2930#include "ContentSecurityPolicy.h"
3031#include "CrossOriginAccessControl.h"
3132#include "Document.h"

@@bool ScriptElement::requestScript(const String& sourceUrl)
256257
257258 ASSERT(!m_cachedScript);
258259 if (!stripLeadingAndTrailingHTMLSpaces(sourceUrl).isEmpty()) {
259  ResourceRequest request = ResourceRequest(m_element->document()->completeURL(sourceUrl));
 260 CachedResourceRequest request(ResourceRequest(m_element->document()->completeURL(sourceUrl)));
260261
261262 String crossOriginMode = m_element->fastGetAttribute(HTMLNames::crossoriginAttr);
262263 if (!crossOriginMode.isNull()) {
263264 m_requestUsesAccessControl = true;
264265 StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
265  updateRequestForAccessControl(request, m_element->document()->securityOrigin(), allowCredentials);
 266 updateRequestForAccessControl(request.mutableResourceRequest(), m_element->document()->securityOrigin(), allowCredentials);
266267 }
 268 request.setCharset(scriptCharset());
267269
268  m_cachedScript = m_element->document()->cachedResourceLoader()->requestScript(request, scriptCharset());
 270 m_cachedScript = m_element->document()->cachedResourceLoader()->requestScript(request);
269271 m_isExternalScript = true;
270272 }
271273

Source/WebCore/html/HTMLLinkElement.cpp

2929#include "CachedCSSStyleSheet.h"
3030#include "CachedResource.h"
3131#include "CachedResourceLoader.h"
 32#include "CachedResourceRequest.h"
3233#include "Document.h"
3334#include "DocumentStyleSheetCollection.h"
3435#include "EventSender.h"

@@void HTMLLinkElement::process()
220221
221222 // Load stylesheets that are not needed for the rendering immediately with low priority.
222223 ResourceLoadPriority priority = blocking ? ResourceLoadPriorityUnresolved : ResourceLoadPriorityVeryLow;
223  ResourceRequest request(document()->completeURL(m_url));
224  m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request, charset, priority);
 224 CachedResourceRequest request(ResourceRequest(document()->completeURL(m_url)), charset, priority);
 225 m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request);
225226
226227 if (m_cachedSheet)
227228 m_cachedSheet->addClient(this);

Source/WebCore/loader/DocumentThreadableLoader.cpp

3333
3434#include "CachedRawResource.h"
3535#include "CachedResourceLoader.h"
 36#include "CachedResourceRequest.h"
3637#include "CrossOriginAccessControl.h"
3738#include "CrossOriginPreflightResultCache.h"
3839#include "Document.h"

@@void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, Secur
376377 options.shouldBufferData = BufferData;
377378 }
378379
379  ResourceRequest newRequest(request);
 380 CachedResourceRequest newRequest(request, options);
380381#if ENABLE(INSPECTOR)
381382 if (m_actualRequest) {
382383 // Because willSendRequest only gets called during redirects, we initialize the identifier and the first willSendRequest here.
383384 m_preflightRequestIdentifier = m_document->frame()->page()->progress()->createUniqueIdentifier();
384385 ResourceResponse redirectResponse = ResourceResponse();
385  InspectorInstrumentation::willSendRequest(m_document->frame(), m_preflightRequestIdentifier, m_document->frame()->loader()->documentLoader(), newRequest, redirectResponse);
 386 InspectorInstrumentation::willSendRequest(m_document->frame(), m_preflightRequestIdentifier, m_document->frame()->loader()->documentLoader(), newRequest.mutableResourceRequest(), redirectResponse);
386387 }
387388#endif
388389 ASSERT(!m_resource);
389  m_resource = m_document->cachedResourceLoader()->requestRawResource(newRequest, options);
 390 m_resource = m_document->cachedResourceLoader()->requestRawResource(newRequest);
390391 if (m_resource) {
391392#if ENABLE(INSPECTOR)
392393 if (m_resource->loader()) {

Source/WebCore/loader/ImageLoader.cpp

2424
2525#include "CachedImage.h"
2626#include "CachedResourceLoader.h"
 27#include "CachedResourceRequest.h"
2728#include "CrossOriginAccessControl.h"
2829#include "Document.h"
2930#include "Element.h"

@@void ImageLoader::updateFromElement()
177178 // an empty string.
178179 CachedResourceHandle<CachedImage> newImage = 0;
179180 if (!attr.isNull() && !stripLeadingAndTrailingHTMLSpaces(attr).isEmpty()) {
180  ResourceRequest request = ResourceRequest(document()->completeURL(sourceURI(attr)));
 181 CachedResourceRequest request(ResourceRequest(document()->completeURL(sourceURI(attr))));
181182
182183 String crossOriginMode = client()->sourceElement()->fastGetAttribute(HTMLNames::crossoriginAttr);
183184 if (!crossOriginMode.isNull()) {
184185 StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
185  updateRequestForAccessControl(request, document()->securityOrigin(), allowCredentials);
 186 updateRequestForAccessControl(request.mutableResourceRequest(), document()->securityOrigin(), allowCredentials);
186187 }
187188
188189 if (m_loadManually) {
189190 bool autoLoadOtherImages = document()->cachedResourceLoader()->autoLoadImages();
190191 document()->cachedResourceLoader()->setAutoLoadImages(false);
191  newImage = new CachedImage(request);
 192 newImage = new CachedImage(request.resourceRequest());
192193 newImage->setLoading(true);
193194 newImage->setOwningCachedResourceLoader(document()->cachedResourceLoader());
194195 document()->cachedResourceLoader()->m_documentResources.set(newImage->url(), newImage.get());

Source/WebCore/loader/LinkLoader.cpp

3535#include "CSSStyleSheet.h"
3636#include "CachedCSSStyleSheet.h"
3737#include "CachedResourceLoader.h"
 38#include "CachedResourceRequest.h"
3839#include "ContainerNode.h"
3940#include "DNS.h"
4041#include "Document.h"

@@bool LinkLoader::loadLink(const LinkRelAttribute& relAttribute, const String& ty
119120 priority = ResourceLoadPriorityLow;
120121 type = CachedResource::LinkSubresource;
121122 }
122  ResourceRequest linkRequest(document->completeURL(href));
 123 CachedResourceRequest linkRequest(ResourceRequest(document->completeURL(href)), priority);
123124
124125 if (m_cachedLinkResource) {
125126 m_cachedLinkResource->removeClient(this);
126127 m_cachedLinkResource = 0;
127128 }
128  m_cachedLinkResource = document->cachedResourceLoader()->requestLinkResource(type, linkRequest, priority);
 129 m_cachedLinkResource = document->cachedResourceLoader()->requestLinkResource(type, linkRequest);
129130 if (m_cachedLinkResource)
130131 m_cachedLinkResource->addClient(this);
131132 }

Source/WebCore/loader/TextTrackLoader.cpp

3030#include "TextTrackLoader.h"
3131
3232#include "CachedResourceLoader.h"
 33#include "CachedResourceRequest.h"
3334#include "CachedTextTrack.h"
3435#include "CrossOriginAccessControl.h"
3536#include "Document.h"

@@bool TextTrackLoader::load(const KURL& url, const String& crossOriginMode)
153154
154155 ASSERT(m_scriptExecutionContext->isDocument());
155156 Document* document = static_cast<Document*>(m_scriptExecutionContext);
156  ResourceRequest cueRequest(document->completeURL(url));
 157 CachedResourceRequest cueRequest(ResourceRequest(document->completeURL(url)));
157158
158159 if (!crossOriginMode.isNull()) {
159160 m_crossOriginMode = crossOriginMode;
160161 StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
161  updateRequestForAccessControl(cueRequest, document->securityOrigin(), allowCredentials);
 162 updateRequestForAccessControl(cueRequest.mutableResourceRequest(), document->securityOrigin(), allowCredentials);
162163 } else {
163164 // Cross-origin resources that are not suitably CORS-enabled may not load.
164165 if (!document->securityOrigin()->canRequest(url)) {

Source/WebCore/loader/cache/CachedResourceLoader.cpp

3232#include "CachedFont.h"
3333#include "CachedImage.h"
3434#include "CachedRawResource.h"
 35#include "CachedResourceRequest.h"
3536#include "CachedScript.h"
3637#include "CachedXSLStyleSheet.h"
3738#include "Console.h"

@@static CachedResource* createResource(CachedResource::Type type, ResourceRequest
107108 return 0;
108109}
109110
110 static const ResourceLoaderOptions& defaultCachedResourceOptions()
111 {
112  static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck);
113  return options;
114 }
115 
116111CachedResourceLoader::CachedResourceLoader(DocumentLoader* documentLoader)
117112 : m_document(0)
118113 , m_documentLoader(documentLoader)

@@Frame* CachedResourceLoader::frame() const
155150 return m_documentLoader ? m_documentLoader->frame() : 0;
156151}
157152
158 CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(ResourceRequest& request)
 153CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request)
159154{
160155 if (Frame* f = frame()) {
161156 if (f->loader()->pageDismissalEventBeingDispatched() != FrameLoader::NoDismissal) {
162  KURL requestURL = request.url();
 157 KURL requestURL = request.resourceRequest().url();
163158 if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL))
164159 PingLoader::loadImage(f, requestURL);
165160 return 0;
166161 }
167162 }
168  return static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String(), defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, false, clientDefersImage(request.url()) ? DeferredByClient : NoDefer).get());
 163 request.setDefer(clientDefersImage(request.resourceRequest().url()) ? DeferredByClient : NoDefer);
 164 return static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request).get());
169165}
170166
171 CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(ResourceRequest& request)
 167CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest& request)
172168{
173  return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String(), defaultCachedResourceOptions()).get());
 169 return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request).get());
174170}
175171
176172#if ENABLE(VIDEO_TRACK)
177 CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(ResourceRequest& request)
 173CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest& request)
178174{
179  return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request, String(), defaultCachedResourceOptions()).get());
 175 return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request).get());
180176}
181177#endif
182178
183179#if ENABLE(CSS_SHADERS)
184 CachedResourceHandle<CachedShader> CachedResourceLoader::requestShader(ResourceRequest& request)
 180CachedResourceHandle<CachedShader> CachedResourceLoader::requestShader(CachedResourceRequest& request)
185181{
186  return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request, String(), defaultCachedResourceOptions()).get());
 182 return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request).get());
187183}
188184#endif
189185
190 CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority)
 186CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest& request)
191187{
192  return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, defaultCachedResourceOptions(), priority).get());
 188 return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request).get());
193189}
194190
195 CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequest& request, const String& charset)
 191CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest& request)
196192{
197  KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.url());
 193 KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.resourceRequest().url());
198194
199195 if (CachedResource* existing = memoryCache()->resourceForURL(url)) {
200196 if (existing->type() == CachedResource::CSSStyleSheet)
201197 return static_cast<CachedCSSStyleSheet*>(existing);
202198 memoryCache()->remove(existing);
203199 }
204  if (url.string() != request.url())
205  request.setURL(url);
 200 if (url.string() != request.resourceRequest().url())
 201 request.mutableResourceRequest().setURL(url);
206202
207  CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request, charset);
 203 CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request.resourceRequest(), request.charset());
208204
209205 memoryCache()->add(userSheet.get());
210206 // FIXME: loadResource calls setOwningCachedResourceLoader() if the resource couldn't be added to cache. Does this function need to call it, too?

@@CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSSt
214210 return userSheet;
215211}
216212
217 CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset)
 213CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(CachedResourceRequest& request)
218214{
219  return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset, defaultCachedResourceOptions()).get());
 215 return static_cast<CachedScript*>(requestResource(CachedResource::Script, request).get());
220216}
221217
222218#if ENABLE(XSLT)
223 CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request)
 219CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest& request)
224220{
225  return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String(), defaultCachedResourceOptions()).get());
 221 return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request).get());
226222}
227223#endif
228224
229225#if ENABLE(SVG)
230 CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(ResourceRequest& request)
 226CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest& request)
231227{
232  return static_cast<CachedSVGDocument*>(requestResource(CachedResource::SVGDocumentResource, request, String(), defaultCachedResourceOptions()).get());
 228 return static_cast<CachedSVGDocument*>(requestResource(CachedResource::SVGDocumentResource, request).get());
233229}
234230#endif
235231
236232#if ENABLE(LINK_PREFETCH)
237 CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, ResourceRequest& request, ResourceLoadPriority priority)
 233CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, CachedResourceRequest& request)
238234{
239235 ASSERT(frame());
240236 ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkSubresource);
241  return requestResource(type, request, String(), defaultCachedResourceOptions(), priority);
 237 return requestResource(type, request);
242238}
243239#endif
244240
245 CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(ResourceRequest& request, const ResourceLoaderOptions& options)
 241CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest& request)
246242{
247  return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request, String(), options, ResourceLoadPriorityUnresolved, false).get());
 243 return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request).get());
248244}
249245
250246bool CachedResourceLoader::checkInsecureContent(CachedResource::Type type, const KURL& url) const

@@bool CachedResourceLoader::canRequest(CachedResource::Type type, const KURL& url
402398 return true;
403399}
404400
405 CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, const ResourceLoaderOptions& options, ResourceLoadPriority priority, bool forPreload, DeferOption defer)
 401CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request)
406402{
407  KURL url = request.url();
 403 KURL url = request.resourceRequest().url();
408404
409  LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.string().latin1().data(), charset.latin1().data(), priority, forPreload);
 405 LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.string().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload());
410406
411407 // If only the fragment identifiers differ, it is the same resource.
412408 url = MemoryCache::removeFragmentIdentifierIfNeeded(url);

@@CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(Cache
414410 if (!url.isValid())
415411 return 0;
416412
417  if (!canRequest(type, url, forPreload))
 413 if (!canRequest(type, url, request.forPreload()))
418414 return 0;
419415
420416 if (memoryCache()->disabled()) {

@@CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(Cache
428424 // See if we can use an existing resource from the cache.
429425 CachedResourceHandle<CachedResource> resource = memoryCache()->resourceForURL(url);
430426
431  if (request.url() != url)
432  request.setURL(url);
 427 if (request.resourceRequest().url() != url)
 428 request.mutableResourceRequest().setURL(url);
433429
434  const RevalidationPolicy policy = determineRevalidationPolicy(type, request, forPreload, resource.get(), defer);
 430 const RevalidationPolicy policy = determineRevalidationPolicy(type, request.mutableResourceRequest(), request.forPreload(), resource.get(), request.defer());
435431 switch (policy) {
436432 case Reload:
437433 memoryCache()->remove(resource.get());
438434 // Fall through
439435 case Load:
440  resource = loadResource(type, request, charset);
 436 resource = loadResource(type, request.mutableResourceRequest(), request.charset());
441437 break;
442438 case Revalidate:
443439 resource = revalidateResource(resource.get());

@@CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(Cache
451447 if (!resource)
452448 return 0;
453449
454  resource->setLoadPriority(priority);
455  if ((policy != Use || resource->stillNeedsLoad()) && NoDefer == defer) {
456  resource->load(this, options);
 450 resource->setLoadPriority(request.priority());
 451 if ((policy != Use || resource->stillNeedsLoad()) && NoDefer == request.defer()) {
 452 resource->load(this, request.options());
457453
458454 // We don't support immediate loads, but we do support immediate failure.
459455 if (resource->errorOccurred()) {

@@CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(Cache
463459 }
464460 }
465461
466  if (!request.url().protocolIsData())
467  m_validatedURLs.add(request.url());
 462 if (!request.resourceRequest().url().protocolIsData())
 463 m_validatedURLs.add(request.resourceRequest().url());
468464
469465 ASSERT(resource->url() == url.string());
470466 m_documentResources.set(resource->url(), resource);

@@void CachedResourceLoader::requestPreload(CachedResource::Type type, ResourceReq
793789 if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet)
794790 encoding = charset.isEmpty() ? m_document->charset() : charset;
795791
796  CachedResourceHandle<CachedResource> resource = requestResource(type, request, encoding, defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, true);
 792 CachedResourceRequest cachedResourceRequest(request, encoding);
 793 cachedResourceRequest.setForPreload(true);
 794
 795 CachedResourceHandle<CachedResource> resource = requestResource(type, cachedResourceRequest);
797796 if (!resource || (m_preloads && m_preloads->contains(resource.get())))
798797 return;
799798 resource->increasePreloadCount();

@@void CachedResourceLoader::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo)
912911 info.addMember(m_pendingPreloads);
913912}
914913
 914const ResourceLoaderOptions& CachedResourceLoader::defaultCachedResourceOptions()
 915{
 916 static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck);
 917 return options;
 918}
 919
915920}

Source/WebCore/loader/cache/CachedResourceLoader.h

@@class CachedSVGDocument;
4444class CachedFont;
4545class CachedImage;
4646class CachedRawResource;
 47class CachedResourceRequest;
4748class CachedScript;
4849class CachedShader;
4950class CachedTextTrack;

@@friend class ImageLoader;
6869friend class ResourceCacheValidationSuppressor;
6970
7071public:
 72 enum DeferOption { NoDefer, DeferredByClient };
7173 static PassRefPtr<CachedResourceLoader> create(DocumentLoader* documentLoader) { return adoptRef(new CachedResourceLoader(documentLoader)); }
7274 ~CachedResourceLoader();
7375
74  CachedResourceHandle<CachedImage> requestImage(ResourceRequest&);
75  CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
76  CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(ResourceRequest&, const String& charset);
77  CachedResourceHandle<CachedScript> requestScript(ResourceRequest&, const String& charset);
78  CachedResourceHandle<CachedFont> requestFont(ResourceRequest&);
79  CachedResourceHandle<CachedRawResource> requestRawResource(ResourceRequest&, const ResourceLoaderOptions&);
 76 CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&);
 77 CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(CachedResourceRequest&);
 78 CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(CachedResourceRequest&);
 79 CachedResourceHandle<CachedScript> requestScript(CachedResourceRequest&);
 80 CachedResourceHandle<CachedFont> requestFont(CachedResourceRequest&);
 81 CachedResourceHandle<CachedRawResource> requestRawResource(CachedResourceRequest&);
8082
8183#if ENABLE(SVG)
82  CachedResourceHandle<CachedSVGDocument> requestSVGDocument(ResourceRequest&);
 84 CachedResourceHandle<CachedSVGDocument> requestSVGDocument(CachedResourceRequest&);
8385#endif
8486#if ENABLE(XSLT)
85  CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(ResourceRequest&);
 87 CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(CachedResourceRequest&);
8688#endif
8789#if ENABLE(LINK_PREFETCH)
88  CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, ResourceRequest&, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
 90 CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, CachedResourceRequest&);
8991#endif
9092#if ENABLE(VIDEO_TRACK)
91  CachedResourceHandle<CachedTextTrack> requestTextTrack(ResourceRequest&);
 93 CachedResourceHandle<CachedTextTrack> requestTextTrack(CachedResourceRequest&);
9294#endif
9395#if ENABLE(CSS_SHADERS)
94  CachedResourceHandle<CachedShader> requestShader(ResourceRequest&);
 96 CachedResourceHandle<CachedShader> requestShader(CachedResourceRequest&);
9597#endif
9698
9799 // Logs an access denied message to the console for the specified URL.

@@public:
135137
136138 void reportMemoryUsage(MemoryObjectInfo*) const;
137139
 140 static const ResourceLoaderOptions& defaultCachedResourceOptions();
 141
138142private:
139143 explicit CachedResourceLoader(DocumentLoader*);
140144
141  enum DeferOption { NoDefer, DeferredByClient };
142  CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, ResourceRequest&, const String& charset, const ResourceLoaderOptions&, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false, DeferOption = NoDefer);
 145 CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&);
143146 CachedResourceHandle<CachedResource> revalidateResource(CachedResource*);
144147 CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, ResourceRequest&, const String& charset);
145148 void requestPreload(CachedResource::Type, ResourceRequest&, const String& charset);

Source/WebCore/loader/cache/CachedResourceRequest.cpp

 1/*
 2 * Copyright (C) 2012 Google, Inc. All rights reserved.
 3 *
 4 * Redistribution and use in source and binary forms, with or without
 5 * modification, are permitted provided that the following conditions
 6 * are met:
 7 * 1. Redistributions of source code must retain the above copyright
 8 * notice, this list of conditions and the following disclaimer.
 9 * 2. Redistributions in binary form must reproduce the above copyright
 10 * notice, this list of conditions and the following disclaimer in the
 11 * documentation and/or other materials provided with the distribution.
 12 *
 13 * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY
 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 */
 25
 26#include "config.h"
 27#include "CachedResourceRequest.h"
 28
 29namespace WebCore {
 30
 31CachedResourceRequest::CachedResourceRequest(const ResourceRequest& resourceRequest, const String& charset, ResourceLoadPriority priority)
 32 : m_resourceRequest(resourceRequest)
 33 , m_charset(charset)
 34 , m_options(CachedResourceLoader::defaultCachedResourceOptions())
 35 , m_priority(priority)
 36 , m_forPreload(false)
 37 , m_defer(CachedResourceLoader::NoDefer)
 38{
 39}
 40
 41CachedResourceRequest::CachedResourceRequest(const ResourceRequest& resourceRequest, const ResourceLoaderOptions& options)
 42 : m_resourceRequest(resourceRequest)
 43 , m_options(options)
 44 , m_priority(ResourceLoadPriorityUnresolved)
 45 , m_forPreload(false)
 46 , m_defer(CachedResourceLoader::NoDefer)
 47{
 48}
 49
 50CachedResourceRequest::CachedResourceRequest(const ResourceRequest& resourceRequest, ResourceLoadPriority priority)
 51 : m_resourceRequest(resourceRequest)
 52 , m_options(CachedResourceLoader::defaultCachedResourceOptions())
 53 , m_priority(priority)
 54 , m_forPreload(false)
 55 , m_defer(CachedResourceLoader::NoDefer)
 56{
 57}
 58
 59}

Source/WebCore/loader/cache/CachedResourceRequest.h

 1/*
 2 * Copyright (C) 2012 Google, Inc. All rights reserved.
 3 *
 4 * Redistribution and use in source and binary forms, with or without
 5 * modification, are permitted provided that the following conditions
 6 * are met:
 7 * 1. Redistributions of source code must retain the above copyright
 8 * notice, this list of conditions and the following disclaimer.
 9 * 2. Redistributions in binary form must reproduce the above copyright
 10 * notice, this list of conditions and the following disclaimer in the
 11 * documentation and/or other materials provided with the distribution.
 12 *
 13 * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY
 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 */
 25
 26#ifndef CachedResourceRequest_h
 27#define CachedResourceRequest_h
 28
 29#include "CachedResourceLoader.h"
 30#include "ResourceLoadPriority.h"
 31
 32namespace WebCore {
 33
 34class CachedResourceRequest {
 35public:
 36 explicit CachedResourceRequest(const ResourceRequest&, const String& charset = String(), ResourceLoadPriority = ResourceLoadPriorityUnresolved);
 37 CachedResourceRequest(const ResourceRequest&, const ResourceLoaderOptions&);
 38 CachedResourceRequest(const ResourceRequest&, ResourceLoadPriority);
 39
 40 ResourceRequest& mutableResourceRequest() { return m_resourceRequest; }
 41 const ResourceRequest& resourceRequest() const { return m_resourceRequest; }
 42 const String& charset() const { return m_charset; }
 43 void setCharset(const String& charset) { m_charset = charset; }
 44 const ResourceLoaderOptions& options() const { return m_options; }
 45 ResourceLoadPriority priority() const { return m_priority; }
 46 bool forPreload() const { return m_forPreload; }
 47 void setForPreload(bool forPreload) { m_forPreload = forPreload; }
 48 CachedResourceLoader::DeferOption defer() const { return m_defer; }
 49 void setDefer(CachedResourceLoader::DeferOption defer) { m_defer = defer; }
 50
 51private:
 52 ResourceRequest m_resourceRequest;
 53 String m_charset;
 54 ResourceLoaderOptions m_options;
 55 ResourceLoadPriority m_priority;
 56 bool m_forPreload;
 57 CachedResourceLoader::DeferOption m_defer;
 58};
 59
 60} // namespace WebCore
 61
 62#endif

Source/WebCore/loader/icon/IconLoader.cpp

2828
2929#include "CachedRawResource.h"
3030#include "CachedResourceLoader.h"
 31#include "CachedResourceRequest.h"
3132#include "Document.h"
3233#include "Frame.h"
3334#include "FrameLoader.h"

@@void IconLoader::startLoading()
5960 if (m_resource || !m_frame->document())
6061 return;
6162
62  ResourceRequest resourceRequest(m_frame->loader()->icon()->url());
 63 CachedResourceRequest request(ResourceRequest(m_frame->loader()->icon()->url()), ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck));
 64
6365#if PLATFORM(BLACKBERRY)
64  resourceRequest.setTargetType(ResourceRequest::TargetIsFavicon);
 66 request.mutableResourceRequest().setTargetType(ResourceRequest::TargetIsFavicon);
6567#endif
66  resourceRequest.setPriority(ResourceLoadPriorityLow);
 68 request.mutableResourceRequest().setPriority(ResourceLoadPriorityLow);
6769
68  m_resource = m_frame->document()->cachedResourceLoader()->requestRawResource(resourceRequest,
69  ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck));
 70 m_resource = m_frame->document()->cachedResourceLoader()->requestRawResource(request);
7071 if (m_resource)
7172 m_resource->addClient(this);
7273 else

Source/WebCore/svg/SVGFEImageElement.cpp

2727#include "Attr.h"
2828#include "CachedImage.h"
2929#include "CachedResourceLoader.h"
 30#include "CachedResourceRequest.h"
3031#include "ColorSpace.h"
3132#include "Document.h"
3233#include "Image.h"

@@void SVGFEImageElement::clearResourceReferences()
8081
8182void SVGFEImageElement::requestImageResource()
8283{
83  ResourceRequest request(ownerDocument()->completeURL(href()));
 84 CachedResourceRequest request(ResourceRequest(ownerDocument()->completeURL(href())));
8485 m_cachedImage = document()->cachedResourceLoader()->requestImage(request);
8586
8687 if (m_cachedImage)

Source/WebCore/svg/SVGFontFaceUriElement.cpp

2727#include "CSSFontFaceSrcValue.h"
2828#include "CachedFont.h"
2929#include "CachedResourceLoader.h"
 30#include "CachedResourceRequest.h"
3031#include "Document.h"
3132#include "SVGFontFaceElement.h"
3233#include "SVGNames.h"

@@void SVGFontFaceUriElement::loadFont()
9697 const AtomicString& href = getAttribute(XLinkNames::hrefAttr);
9798 if (!href.isNull()) {
9899 CachedResourceLoader* cachedResourceLoader = document()->cachedResourceLoader();
99  ResourceRequest request(document()->completeURL(href));
 100 CachedResourceRequest request(ResourceRequest(document()->completeURL(href)));
100101 m_cachedFont = cachedResourceLoader->requestFont(request);
101102 if (m_cachedFont) {
102103 m_cachedFont->addClient(this);

Source/WebCore/svg/SVGUseElement.cpp

2929
3030#include "Attribute.h"
3131#include "CachedResourceLoader.h"
 32#include "CachedResourceRequest.h"
3233#include "Document.h"
3334#include "ElementShadow.h"
3435#include "Event.h"

@@void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
254255 if (isExternalReference) {
255256 KURL url = document()->completeURL(href());
256257 if (url.hasFragmentIdentifier()) {
257  ResourceRequest request(url.string());
 258 CachedResourceRequest request(ResourceRequest(url.string()));
258259 m_cachedDocument = document()->cachedResourceLoader()->requestSVGDocument(request);
259260 if (m_cachedDocument)
260261 m_cachedDocument->addClient(this);

Source/WebCore/xml/XSLImportRule.cpp

2626
2727#include "CachedXSLStyleSheet.h"
2828#include "CachedResourceLoader.h"
 29#include "CachedResourceRequest.h"
2930#include "Document.h"
3031#include "XSLStyleSheet.h"
3132

@@void XSLImportRule::loadSheet()
9899 return;
99100 }
100101
101  ResourceRequest request(cachedResourceLoader->document()->completeURL(absHref));
 102 CachedResourceRequest request(ResourceRequest(cachedResourceLoader->document()->completeURL(absHref)));
102103 m_cachedSheet = cachedResourceLoader->requestXSLStyleSheet(request);
103104
104105 if (m_cachedSheet) {