Changeset 132157 in webkit


Ignore:
Timestamp:
Oct 22, 2012 4:35:28 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

Refactor CachedResourceLoader: add CachedResourceRequest
​https://bugs.webkit.org/show_bug.cgi?id=99736

Patch by Marja Hölttä <​marja@chromium.org> on 2012-10-22
Reviewed by Adam Barth.

For fixing bugs 84883 and 92761,
CachedResourceLoader::requestResource should take as parameter
information about who initiated the request. But the parameter
list was already long. This gathers all the parameters into a
separate class, CachedResourceRequest. The next step is to add
information about who initiated the request into
CachedResourceRequest.

No new tests because no changes in functionality, just moving code
around.

  • CMakeLists.txt:
  • GNUmakefile.list.am:
  • Target.pri:
  • WebCore.gypi:
  • WebCore.vcproj/WebCore.vcproj:
  • WebCore.xcodeproj/project.pbxproj:
  • css/CSSFontFaceSrcValue.cpp:

(WebCore::CSSFontFaceSrcValue::cachedFont):

  • css/CSSImageSetValue.cpp:

(WebCore::CSSImageSetValue::cachedImageSet):

  • css/CSSImageValue.cpp:

(WebCore::CSSImageValue::cachedImage):

  • css/StyleRuleImport.cpp:

(WebCore::StyleRuleImport::requestStyleSheet):

  • css/WebKitCSSSVGDocumentValue.cpp:

(WebCore::WebKitCSSSVGDocumentValue::load):

  • css/WebKitCSSShaderValue.cpp:

(WebCore::WebKitCSSShaderValue::cachedShader):

  • dom/ProcessingInstruction.cpp:

(WebCore::ProcessingInstruction::checkStyleSheet):

  • dom/ScriptElement.cpp:

(WebCore::ScriptElement::requestScript):

  • html/HTMLLinkElement.cpp:

(WebCore::HTMLLinkElement::process):

  • loader/DocumentThreadableLoader.cpp:

(WebCore::DocumentThreadableLoader::loadRequest):

  • loader/ImageLoader.cpp:

(WebCore::ImageLoader::updateFromElement):

  • loader/LinkLoader.cpp:

(WebCore::LinkLoader::loadLink):

  • loader/TextTrackLoader.cpp:

(WebCore::TextTrackLoader::load):

  • loader/cache/CachedResourceLoader.cpp:

(WebCore::CachedResourceLoader::requestImage):
(WebCore::CachedResourceLoader::requestFont):
(WebCore::CachedResourceLoader::requestTextTrack):
(WebCore::CachedResourceLoader::requestShader):
(WebCore::CachedResourceLoader::requestCSSStyleSheet):
(WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
(WebCore::CachedResourceLoader::requestScript):
(WebCore::CachedResourceLoader::requestXSLStyleSheet):
(WebCore::CachedResourceLoader::requestSVGDocument):
(WebCore::CachedResourceLoader::requestLinkResource):
(WebCore::CachedResourceLoader::requestRawResource):
(WebCore::CachedResourceLoader::requestResource):
(WebCore::CachedResourceLoader::requestPreload):
(WebCore::CachedResourceLoader::defaultCachedResourceOptions):
(WebCore):

  • loader/cache/CachedResourceLoader.h:

(WebCore):
(CachedResourceLoader):

  • loader/cache/CachedResourceRequest.cpp: Added.

(WebCore):
(WebCore::CachedResourceRequest::CachedResourceRequest):

  • loader/cache/CachedResourceRequest.h: Added.

(WebCore):
(CachedResourceRequest):
(WebCore::CachedResourceRequest::mutableResourceRequest):
(WebCore::CachedResourceRequest::resourceRequest):
(WebCore::CachedResourceRequest::charset):
(WebCore::CachedResourceRequest::setCharset):
(WebCore::CachedResourceRequest::options):
(WebCore::CachedResourceRequest::priority):
(WebCore::CachedResourceRequest::forPreload):
(WebCore::CachedResourceRequest::setForPreload):
(WebCore::CachedResourceRequest::defer):
(WebCore::CachedResourceRequest::setDefer):

  • loader/icon/IconLoader.cpp:

(WebCore::IconLoader::startLoading):

  • svg/SVGFEImageElement.cpp:

(WebCore::SVGFEImageElement::requestImageResource):

  • svg/SVGFontFaceUriElement.cpp:

(WebCore::SVGFontFaceUriElement::loadFont):

  • svg/SVGUseElement.cpp:

(WebCore::SVGUseElement::svgAttributeChanged):

  • xml/XSLImportRule.cpp:

(WebCore::XSLImportRule::loadSheet):

Location:
trunk/Source/WebCore
Files:
2 added
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/CMakeLists.txt

    r132009 r132157  
    16831683    loader/cache/CachedResourceHandle.cpp
    16841684    loader/cache/CachedResourceLoader.cpp
     1685    loader/cache/CachedResourceRequest.cpp
    16851686    loader/cache/CachedScript.cpp
    16861687    loader/cache/CachedShader.cpp

  • trunk/Source/WebCore/ChangeLog

    r132156 r132157  
     12012-10-22  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 Adam Barth.
     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        No new tests because no changes in functionality, just moving code
     17        around.
     18
     19        * CMakeLists.txt:
     20        * GNUmakefile.list.am:
     21        * Target.pri:
     22        * WebCore.gypi:
     23        * WebCore.vcproj/WebCore.vcproj:
     24        * WebCore.xcodeproj/project.pbxproj:
     25        * css/CSSFontFaceSrcValue.cpp:
     26        (WebCore::CSSFontFaceSrcValue::cachedFont):
     27        * css/CSSImageSetValue.cpp:
     28        (WebCore::CSSImageSetValue::cachedImageSet):
     29        * css/CSSImageValue.cpp:
     30        (WebCore::CSSImageValue::cachedImage):
     31        * css/StyleRuleImport.cpp:
     32        (WebCore::StyleRuleImport::requestStyleSheet):
     33        * css/WebKitCSSSVGDocumentValue.cpp:
     34        (WebCore::WebKitCSSSVGDocumentValue::load):
     35        * css/WebKitCSSShaderValue.cpp:
     36        (WebCore::WebKitCSSShaderValue::cachedShader):
     37        * dom/ProcessingInstruction.cpp:
     38        (WebCore::ProcessingInstruction::checkStyleSheet):
     39        * dom/ScriptElement.cpp:
     40        (WebCore::ScriptElement::requestScript):
     41        * html/HTMLLinkElement.cpp:
     42        (WebCore::HTMLLinkElement::process):
     43        * loader/DocumentThreadableLoader.cpp:
     44        (WebCore::DocumentThreadableLoader::loadRequest):
     45        * loader/ImageLoader.cpp:
     46        (WebCore::ImageLoader::updateFromElement):
     47        * loader/LinkLoader.cpp:
     48        (WebCore::LinkLoader::loadLink):
     49        * loader/TextTrackLoader.cpp:
     50        (WebCore::TextTrackLoader::load):
     51        * loader/cache/CachedResourceLoader.cpp:
     52        (WebCore::CachedResourceLoader::requestImage):
     53        (WebCore::CachedResourceLoader::requestFont):
     54        (WebCore::CachedResourceLoader::requestTextTrack):
     55        (WebCore::CachedResourceLoader::requestShader):
     56        (WebCore::CachedResourceLoader::requestCSSStyleSheet):
     57        (WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
     58        (WebCore::CachedResourceLoader::requestScript):
     59        (WebCore::CachedResourceLoader::requestXSLStyleSheet):
     60        (WebCore::CachedResourceLoader::requestSVGDocument):
     61        (WebCore::CachedResourceLoader::requestLinkResource):
     62        (WebCore::CachedResourceLoader::requestRawResource):
     63        (WebCore::CachedResourceLoader::requestResource):
     64        (WebCore::CachedResourceLoader::requestPreload):
     65        (WebCore::CachedResourceLoader::defaultCachedResourceOptions):
     66        (WebCore):
     67        * loader/cache/CachedResourceLoader.h:
     68        (WebCore):
     69        (CachedResourceLoader):
     70        * loader/cache/CachedResourceRequest.cpp: Added.
     71        (WebCore):
     72        (WebCore::CachedResourceRequest::CachedResourceRequest):
     73        * loader/cache/CachedResourceRequest.h: Added.
     74        (WebCore):
     75        (CachedResourceRequest):
     76        (WebCore::CachedResourceRequest::mutableResourceRequest):
     77        (WebCore::CachedResourceRequest::resourceRequest):
     78        (WebCore::CachedResourceRequest::charset):
     79        (WebCore::CachedResourceRequest::setCharset):
     80        (WebCore::CachedResourceRequest::options):
     81        (WebCore::CachedResourceRequest::priority):
     82        (WebCore::CachedResourceRequest::forPreload):
     83        (WebCore::CachedResourceRequest::setForPreload):
     84        (WebCore::CachedResourceRequest::defer):
     85        (WebCore::CachedResourceRequest::setDefer):
     86        * loader/icon/IconLoader.cpp:
     87        (WebCore::IconLoader::startLoading):
     88        * svg/SVGFEImageElement.cpp:
     89        (WebCore::SVGFEImageElement::requestImageResource):
     90        * svg/SVGFontFaceUriElement.cpp:
     91        (WebCore::SVGFontFaceUriElement::loadFont):
     92        * svg/SVGUseElement.cpp:
     93        (WebCore::SVGUseElement::svgAttributeChanged):
     94        * xml/XSLImportRule.cpp:
     95        (WebCore::XSLImportRule::loadSheet):
     96
    1972012-10-22  Adam Barth  <abarth@webkit.org>
    298

  • trunk/Source/WebCore/GNUmakefile.list.am

    r132009 r132157  
    38463846        Source/WebCore/loader/cache/CachedResourceLoader.cpp \
    38473847        Source/WebCore/loader/cache/CachedResourceLoader.h \
     3848        Source/WebCore/loader/cache/CachedResourceRequest.cpp \
     3849        Source/WebCore/loader/cache/CachedResourceRequest.h \
    38483850        Source/WebCore/loader/cache/CachedScript.cpp \
    38493851        Source/WebCore/loader/cache/CachedScript.h \

  • trunk/Source/WebCore/Target.pri

    r132074 r132157  
    818818    loader/CrossOriginPreflightResultCache.cpp \
    819819    loader/cache/CachedResourceLoader.cpp \
     820    loader/cache/CachedResourceRequest.cpp \
    820821    loader/DocumentLoadTiming.cpp \
    821822    loader/DocumentLoader.cpp \

  • trunk/Source/WebCore/WebCore.gypi

    r132102 r132157  
    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',
    … …  
    30643065            'loader/cache/CachedResourceHandle.cpp',
    30653066            'loader/cache/CachedResourceLoader.cpp',
     3067            'loader/cache/CachedResourceRequest.cpp',
    30663068            'loader/cache/CachedScript.cpp',
    30673069            'loader/cache/CachedScript.h',

  • trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

    r132087 r132157  
    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                                        >

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r132009 r132157  
    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 */; };
    … …  
    1296412966                BCB16C100979C3BD00467741 /* CachedResourceLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CachedResourceLoader.cpp; sourceTree = "<group>"; };
    1296512967                BCB16C110979C3BD00467741 /* CachedResourceLoader.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CachedResourceLoader.h; sourceTree = "<group>"; };
     12968                5081E3DF3CFC80C16EF8B48B /* CachedResourceRequest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CachedResourceRequest.cpp; sourceTree = "<group>"; };
     12969                5081E3E13D0280C16EF8B48B /* CachedResourceRequest.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CachedResourceRequest.h; sourceTree = "<group>"; };
    1296612970                BCB7735E0C17853D00132BA4 /* JSNodeFilterCondition.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSNodeFilterCondition.cpp; sourceTree = "<group>"; };
    1296712971                BCB7735F0C17853D00132BA4 /* JSNodeFilterCondition.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSNodeFilterCondition.h; sourceTree = "<group>"; };
    … …  
    1920519209                                BCB16C100979C3BD00467741 /* CachedResourceLoader.cpp */,
    1920619210                                BCB16C110979C3BD00467741 /* CachedResourceLoader.h */,
     19211                                5081E3DF3CFC80C16EF8B48B /* CachedResourceRequest.cpp */,
     19212                                5081E3E13D0280C16EF8B48B /* CachedResourceRequest.h */,
    1920719213                                BCB16C0A0979C3BD00467741 /* CachedScript.cpp */,
    1920819214                                BCB16C0B0979C3BD00467741 /* CachedScript.h */,
    … …  
    2250222508                                E47B4BE80E71241600038854 /* CachedResourceHandle.h in Headers */,
    2250322509                                BCB16C2A0979C3BD00467741 /* CachedResourceLoader.h in Headers */,
     22510                                5081E3E03CFF80C16EF8B48B /* CachedResourceRequest.h in Headers */,
    2250422511                                BCB16C240979C3BD00467741 /* CachedScript.h in Headers */,
    2250522512                                BCD533640ED6848900887468 /* CachedScriptSourceProvider.h in Headers */,
    … …  
    2612526132                                E47B4BE90E71241600038854 /* CachedResourceHandle.cpp in Sources */,
    2612626133                                BCB16C290979C3BD00467741 /* CachedResourceLoader.cpp in Sources */,
     26134                                5081E3C33CE580C16EF8B48B /* CachedResourceRequest.cpp in Sources */,
    2612726135                                BCB16C230979C3BD00467741 /* CachedScript.cpp in Sources */,
    2612826136                                5038BE401472AD980095E0D1 /* CachedShader.cpp in Sources */,

  • trunk/Source/WebCore/css/CSSFontFaceSrcValue.cpp

    r128762 r132157  
    2828#include "CachedFont.h"
    2929#include "CachedResourceLoader.h"
     30#include "CachedResourceRequest.h"
    3031#include "Document.h"
    3132#include "FontCustomPlatformData.h"
    … …  
    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    }
    … …  
    114115
    115116}
    116 

  • trunk/Source/WebCore/css/CSSImageSetValue.cpp

    r129466 r132157  
    3333#include "CachedImage.h"
    3434#include "CachedResourceLoader.h"
     35#include "CachedResourceRequest.h"
    3536#include "Document.h"
    3637#include "Page.h"
    … …  
    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);

  • trunk/Source/WebCore/css/CSSImageValue.cpp

    r128762 r132157  
    2727#include "CachedImage.h"
    2828#include "CachedResourceLoader.h"
     29#include "CachedResourceRequest.h"
    2930#include "Document.h"
    3031#include "MemoryCache.h"
    … …  
    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());

  • trunk/Source/WebCore/css/StyleRuleImport.cpp

    r128762 r132157  
    2626#include "CachedCSSStyleSheet.h"
    2727#include "CachedResourceLoader.h"
     28#include "CachedResourceRequest.h"
    2829#include "Document.h"
    2930#include "SecurityOrigin.h"
    … …  
    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

  • trunk/Source/WebCore/css/WebKitCSSSVGDocumentValue.cpp

    r128762 r132157  
    3030#include "CSSParser.h"
    3131#include "CachedResourceLoader.h"
     32#include "CachedResourceRequest.h"
    3233#include "Document.h"
    3334#include "WebCoreMemoryInstrumentation.h"
    … …  
    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    }

  • trunk/Source/WebCore/css/WebKitCSSShaderValue.cpp

    r128762 r132157  
    3333#include "WebKitCSSShaderValue.h"
    3434
     35#include "CSSParser.h"
    3536#include "CachedResourceLoader.h"
    36 #include "CSSParser.h"
     37#include "CachedResourceRequest.h"
    3738#include "Document.h"
    3839#include "StyleCachedShader.h"
    … …  
    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());

  • trunk/Source/WebCore/dom/ProcessingInstruction.cpp

    r130612 r132157  
    2525#include "CachedCSSStyleSheet.h"
    2626#include "CachedResourceLoader.h"
     27#include "CachedResourceRequest.h"
    2728#include "CachedXSLStyleSheet.h"
    2829#include "Document.h"
    … …  
    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)
    … …  
    174175                if (charset.isEmpty())
    175176                    charset = document()->charset();
    176 
    177                 m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request, charset);
     177                request.setCharset(charset);
     178
     179                m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request);
    178180            }
    179181            if (m_cachedSheet)

  • trunk/Source/WebCore/dom/ScriptElement.cpp

    r126968 r132157  
    2727#include "CachedScript.h"
    2828#include "CachedResourceLoader.h"
     29#include "CachedResourceRequest.h"
    2930#include "ContentSecurityPolicy.h"
    3031#include "CrossOriginAccessControl.h"
    … …  
    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);
    … …  
    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        }
    267 
    268         m_cachedScript = m_element->document()->cachedResourceLoader()->requestScript(request, scriptCharset());
     268        request.setCharset(scriptCharset());
     269
     270        m_cachedScript = m_element->document()->cachedResourceLoader()->requestScript(request);
    269271        m_isExternalScript = true;
    270272    }

  • trunk/Source/WebCore/html/HTMLLinkElement.cpp

    r129423 r132157  
    3030#include "CachedResource.h"
    3131#include "CachedResourceLoader.h"
     32#include "CachedResourceRequest.h"
    3233#include "Document.h"
    3334#include "DocumentStyleSheetCollection.h"
    … …  
    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)

  • trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp

    r128586 r132157  
    3434#include "CachedRawResource.h"
    3535#include "CachedResourceLoader.h"
     36#include "CachedResourceRequest.h"
    3637#include "CrossOriginAccessControl.h"
    3738#include "CrossOriginPreflightResultCache.h"
    … …  
    377378        }
    378379
    379         ResourceRequest newRequest(request);
     380        CachedResourceRequest newRequest(request, options);
    380381#if ENABLE(INSPECTOR)
    381382        if (m_actualRequest) {
    … …  
    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)

  • trunk/Source/WebCore/loader/ImageLoader.cpp

    r131670 r132157  
    2525#include "CachedImage.h"
    2626#include "CachedResourceLoader.h"
     27#include "CachedResourceRequest.h"
    2728#include "CrossOriginAccessControl.h"
    2829#include "Document.h"
    … …  
    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
    … …  
    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());

  • trunk/Source/WebCore/loader/LinkLoader.cpp

    r117029 r132157  
    3636#include "CachedCSSStyleSheet.h"
    3737#include "CachedResourceLoader.h"
     38#include "CachedResourceRequest.h"
    3839#include "ContainerNode.h"
    3940#include "DNS.h"
    … …  
    120121            type = CachedResource::LinkSubresource;
    121122        }
    122         ResourceRequest linkRequest(document->completeURL(href));
     123        CachedResourceRequest linkRequest(ResourceRequest(document->completeURL(href)), priority);
    123124       
    124125        if (m_cachedLinkResource) {
    … …  
    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);

  • trunk/Source/WebCore/loader/TextTrackLoader.cpp

    r130947 r132157  
    3131
    3232#include "CachedResourceLoader.h"
     33#include "CachedResourceRequest.h"
    3334#include "CachedTextTrack.h"
    3435#include "CrossOriginAccessControl.h"
    … …  
    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.

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

    r131782 r132157  
    3333#include "CachedImage.h"
    3434#include "CachedRawResource.h"
     35#include "CachedResourceRequest.h"
    3536#include "CachedScript.h"
    3637#include "CachedXSLStyleSheet.h"
    … …  
    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)
    … …  
    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);
    … …  
    166161        }
    167162    }
    168     return static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String(), defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, false, clientDefersImage(request.url()) ? DeferredByClient : NoDefer).get());
    169 }
    170 
    171 CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(ResourceRequest& request)
    172 {
    173     return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String(), defaultCachedResourceOptions()).get());
     163    request.setDefer(clientDefersImage(request.resourceRequest().url()) ? DeferredByClient : NoDefer);
     164    return static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request).get());
     165}
     166
     167CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest& request)
     168{
     169    return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request).get());
    174170}
    175171
    176172#if ENABLE(VIDEO_TRACK)
    177 CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(ResourceRequest& request)
    178 {
    179     return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request, String(), defaultCachedResourceOptions()).get());
     173CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest& request)
     174{
     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)
    185 {
    186     return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request, String(), defaultCachedResourceOptions()).get());
    187 }
    188 #endif
    189 
    190 CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority)
    191 {
    192     return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, defaultCachedResourceOptions(), priority).get());
    193 }
    194 
    195 CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequest& request, const String& charset)
    196 {
    197     KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.url());
     180CachedResourceHandle<CachedShader> CachedResourceLoader::requestShader(CachedResourceRequest& request)
     181{
     182    return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request).get());
     183}
     184#endif
     185
     186CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest& request)
     187{
     188    return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request).get());
     189}
     190
     191CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest& request)
     192{
     193    KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.resourceRequest().url());
    198194
    199195    if (CachedResource* existing = memoryCache()->resourceForURL(url)) {
    … …  
    202198        memoryCache()->remove(existing);
    203199    }
    204     if (url.string() != request.url())
    205         request.setURL(url);
    206 
    207     CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request, charset);
     200    if (url.string() != request.resourceRequest().url())
     201        request.mutableResourceRequest().setURL(url);
     202
     203    CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request.resourceRequest(), request.charset());
    208204
    209205    memoryCache()->add(userSheet.get());
    … …  
    215211}
    216212
    217 CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset)
    218 {
    219     return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset, defaultCachedResourceOptions()).get());
     213CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(CachedResourceRequest& request)
     214{
     215    return static_cast<CachedScript*>(requestResource(CachedResource::Script, request).get());
    220216}
    221217
    222218#if ENABLE(XSLT)
    223 CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request)
    224 {
    225     return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String(), defaultCachedResourceOptions()).get());
     219CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest& request)
     220{
     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)
    231 {
    232     return static_cast<CachedSVGDocument*>(requestResource(CachedResource::SVGDocumentResource, request, String(), defaultCachedResourceOptions()).get());
     226CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest& request)
     227{
     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);
    242 }
    243 #endif
    244 
    245 CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(ResourceRequest& request, const ResourceLoaderOptions& options)
    246 {
    247     return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request, String(), options, ResourceLoadPriorityUnresolved, false).get());
     237    return requestResource(type, request);
     238}
     239#endif
     240
     241CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest& request)
     242{
     243    return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request).get());
    248244}
    249245
    … …  
    403399}
    404400
    405 CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, const ResourceLoaderOptions& options, ResourceLoadPriority priority, bool forPreload, DeferOption defer)
    406 {
    407     KURL url = request.url();
    408    
    409     LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.string().latin1().data(), charset.latin1().data(), priority, forPreload);
     401CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request)
     402{
     403    KURL url = request.resourceRequest().url();
     404   
     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.
    … …  
    415411        return 0;
    416412
    417     if (!canRequest(type, url, forPreload))
     413    if (!canRequest(type, url, request.forPreload()))
    418414        return 0;
    419415
    … …  
    429425    CachedResourceHandle<CachedResource> resource = memoryCache()->resourceForURL(url);
    430426
    431     if (request.url() != url)
    432         request.setURL(url);
    433 
    434     const RevalidationPolicy policy = determineRevalidationPolicy(type, request, forPreload, resource.get(), defer);
     427    if (request.resourceRequest().url() != url)
     428        request.mutableResourceRequest().setURL(url);
     429
     430    const RevalidationPolicy policy = determineRevalidationPolicy(type, request.mutableResourceRequest(), request.forPreload(), resource.get(), request.defer());
    435431    switch (policy) {
    436432    case Reload:
    … …  
    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:
    … …  
    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.
    … …  
    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());
    … …  
    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;
    … …  
    913912}
    914913
    915 }
     914const ResourceLoaderOptions& CachedResourceLoader::defaultCachedResourceOptions()
     915{
     916    static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck);
     917    return options;
     918}
     919
     920}

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

    r130817 r132157  
    4545class CachedImage;
    4646class CachedRawResource;
     47class CachedResourceRequest;
    4748class CachedScript;
    4849class CachedShader;
    … …  
    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
    … …  
    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);

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

    r130947 r132157  
    2929#include "CachedRawResource.h"
    3030#include "CachedResourceLoader.h"
     31#include "CachedResourceRequest.h"
    3132#include "Document.h"
    3233#include "Frame.h"
    … …  
    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);

  • trunk/Source/WebCore/svg/SVGFEImageElement.cpp

    r120951 r132157  
    2828#include "CachedImage.h"
    2929#include "CachedResourceLoader.h"
     30#include "CachedResourceRequest.h"
    3031#include "ColorSpace.h"
    3132#include "Document.h"
    … …  
    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

  • trunk/Source/WebCore/svg/SVGFontFaceUriElement.cpp

    r118192 r132157  
    2828#include "CachedFont.h"
    2929#include "CachedResourceLoader.h"
     30#include "CachedResourceRequest.h"
    3031#include "Document.h"
    3132#include "SVGFontFaceElement.h"
    … …  
    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) {

  • trunk/Source/WebCore/svg/SVGUseElement.cpp

    r131826 r132157  
    3030#include "Attribute.h"
    3131#include "CachedResourceLoader.h"
     32#include "CachedResourceRequest.h"
    3233#include "Document.h"
    3334#include "ElementShadow.h"
    … …  
    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)

  • trunk/Source/WebCore/xml/XSLImportRule.cpp

    r125805 r132157  
    2727#include "CachedXSLStyleSheet.h"
    2828#include "CachedResourceLoader.h"
     29#include "CachedResourceRequest.h"
    2930#include "Document.h"
    3031#include "XSLStyleSheet.h"
    … …  
    99100    }
    100101   
    101     ResourceRequest request(cachedResourceLoader->document()->completeURL(absHref));
     102    CachedResourceRequest request(ResourceRequest(cachedResourceLoader->document()->completeURL(absHref)));
    102103    m_cachedSheet = cachedResourceLoader->requestXSLStyleSheet(request);
    103104   
Note: See TracChangeset for help on using the changeset viewer.