Changeset 207281 in webkit


Ignore:
Timestamp:
Oct 13, 2016 3:34:15 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Remove CachedResourceRequest::mutableResourceRequest
​https://bugs.webkit.org/show_bug.cgi?id=163277

Patch by Youenn Fablet <​youenn@apple.com> on 2016-10-13
Reviewed by Sam Weinig.

No change of behavior.

Removing CachedResourceRequest::mutableResourceRequest requires call sites to either update the ResourceRequest
before creating the CachedResourceRequest or to add methods at CachedResourceRequest.

Adding CachedResourceRequest::releaseResourceRequest for CachedResource constructor.

Most new CachedResourceRequest methods are used by CachedResourceLoader which is passed a CachedResourceRequest.
This allows code in CachedResourceLoader to be easier to read.

  • css/CSSImageSetValue.cpp:

(WebCore::CSSImageSetValue::loadBestFitImage):

  • css/CSSImageValue.cpp:

(WebCore::CSSImageValue::loadImage):

  • dom/ScriptElement.cpp:

(WebCore::ScriptElement::requestScriptWithCache):

  • loader/CrossOriginAccessControl.cpp:

(WebCore::createAccessControlPreflightRequest):

  • loader/CrossOriginAccessControl.h:
  • loader/CrossOriginPreflightChecker.cpp:

(WebCore::CrossOriginPreflightChecker::startPreflight):
(WebCore::CrossOriginPreflightChecker::doPreflight):

  • loader/DocumentThreadableLoader.cpp:

(WebCore::DocumentThreadableLoader::loadRequest):

  • loader/MediaResourceLoader.cpp:

(WebCore::MediaResourceLoader::requestResource):

  • loader/cache/CachedResource.cpp:

(WebCore::CachedResource::CachedResource):

  • loader/cache/CachedResourceLoader.cpp:

(WebCore::CachedResourceLoader::requestImage):
(WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
(WebCore::CachedResourceLoader::prepareFetch):
(WebCore::CachedResourceLoader::updateHTTPRequestHeaders):
(WebCore::CachedResourceLoader::requestResource):
(WebCore::acceptHeaderValueFromType): Deleted.
(WebCore::updateRequestAccordingCacheMode): Deleted.

  • loader/cache/CachedResourceRequest.cpp:

(WebCore::CachedResourceRequest::setAsPotentiallyCrossOrigin):
(WebCore::CachedResourceRequest::updateForAccessControl):
(WebCore::CachedResourceRequest::upgradeInsecureRequestIfNeeded):
(WebCore::CachedResourceRequest::setDomainForCachePartition):
(WebCore::acceptHeaderValueFromType):
(WebCore::CachedResourceRequest::setAcceptHeaderIfNone):
(WebCore::CachedResourceRequest::updateAccordingCacheMode):
(WebCore::CachedResourceRequest::removeFragmentIdentifierIfNeeded):
(WebCore::CachedResourceRequest::applyBlockedStatus):

  • loader/cache/CachedResourceRequest.h:

(WebCore::CachedResourceRequest::releaseResourceRequest):
(WebCore::CachedResourceRequest::setCachingPolicy):
(WebCore::CachedResourceRequest::mutableResourceRequest): Deleted.
(WebCore::CachedResourceRequest::setCacheModeToNoStore): Deleted.

  • loader/icon/IconLoader.cpp:

(WebCore::IconLoader::startLoading):

  • platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp:

(WebCore::WebCoreAVCFResourceLoader::startLoading):

  • platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:

(WebCore::WebCoreAVFResourceLoader::startLoading):

Location:
trunk/Source/WebCore
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r207280 r207281  
     12016-10-13  Youenn Fablet  <youenn@apple.com>
     2
     3        Remove CachedResourceRequest::mutableResourceRequest
     4        https://bugs.webkit.org/show_bug.cgi?id=163277
     5
     6        Reviewed by Sam Weinig.
     7
     8        No change of behavior.
     9
     10        Removing CachedResourceRequest::mutableResourceRequest requires call sites to either update the ResourceRequest
     11        before creating the CachedResourceRequest or to add methods at CachedResourceRequest.
     12
     13        Adding CachedResourceRequest::releaseResourceRequest for CachedResource constructor.
     14
     15        Most new CachedResourceRequest methods are used by CachedResourceLoader which is passed a CachedResourceRequest.
     16        This allows code in CachedResourceLoader to be easier to read.
     17
     18        * css/CSSImageSetValue.cpp:
     19        (WebCore::CSSImageSetValue::loadBestFitImage):
     20        * css/CSSImageValue.cpp:
     21        (WebCore::CSSImageValue::loadImage):
     22        * dom/ScriptElement.cpp:
     23        (WebCore::ScriptElement::requestScriptWithCache):
     24        * loader/CrossOriginAccessControl.cpp:
     25        (WebCore::createAccessControlPreflightRequest):
     26        * loader/CrossOriginAccessControl.h:
     27        * loader/CrossOriginPreflightChecker.cpp:
     28        (WebCore::CrossOriginPreflightChecker::startPreflight):
     29        (WebCore::CrossOriginPreflightChecker::doPreflight):
     30        * loader/DocumentThreadableLoader.cpp:
     31        (WebCore::DocumentThreadableLoader::loadRequest):
     32        * loader/MediaResourceLoader.cpp:
     33        (WebCore::MediaResourceLoader::requestResource):
     34        * loader/cache/CachedResource.cpp:
     35        (WebCore::CachedResource::CachedResource):
     36        * loader/cache/CachedResourceLoader.cpp:
     37        (WebCore::CachedResourceLoader::requestImage):
     38        (WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
     39        (WebCore::CachedResourceLoader::prepareFetch):
     40        (WebCore::CachedResourceLoader::updateHTTPRequestHeaders):
     41        (WebCore::CachedResourceLoader::requestResource):
     42        (WebCore::acceptHeaderValueFromType): Deleted.
     43        (WebCore::updateRequestAccordingCacheMode): Deleted.
     44        * loader/cache/CachedResourceRequest.cpp:
     45        (WebCore::CachedResourceRequest::setAsPotentiallyCrossOrigin):
     46        (WebCore::CachedResourceRequest::updateForAccessControl):
     47        (WebCore::CachedResourceRequest::upgradeInsecureRequestIfNeeded):
     48        (WebCore::CachedResourceRequest::setDomainForCachePartition):
     49        (WebCore::acceptHeaderValueFromType):
     50        (WebCore::CachedResourceRequest::setAcceptHeaderIfNone):
     51        (WebCore::CachedResourceRequest::updateAccordingCacheMode):
     52        (WebCore::CachedResourceRequest::removeFragmentIdentifierIfNeeded):
     53        (WebCore::CachedResourceRequest::applyBlockedStatus):
     54        * loader/cache/CachedResourceRequest.h:
     55        (WebCore::CachedResourceRequest::releaseResourceRequest):
     56        (WebCore::CachedResourceRequest::setCachingPolicy):
     57        (WebCore::CachedResourceRequest::mutableResourceRequest): Deleted.
     58        (WebCore::CachedResourceRequest::setCacheModeToNoStore): Deleted.
     59        * loader/icon/IconLoader.cpp:
     60        (WebCore::IconLoader::startLoading):
     61        * platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp:
     62        (WebCore::WebCoreAVCFResourceLoader::startLoading):
     63        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
     64        (WebCore::WebCoreAVFResourceLoader::startLoading):
     65
    1662016-10-13  Antti Koivisto  <antti@apple.com>
    267

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

    r206016 r207281  
    9191{
    9292    Document* document = loader.document();
     93    ASSERT(document);
     94
    9395    updateDeviceScaleFactor(*document);
    9496
    … …  
    102104        CachedResourceRequest request(ResourceRequest(document->completeURL(image.imageURL)), options);
    103105        request.setInitiator(cachedResourceRequestInitiators().css);
    104         if (options.mode == FetchOptions::Mode::Cors) {
    105             ASSERT(document->securityOrigin());
    106             updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
    107         }
     106        if (options.mode == FetchOptions::Mode::Cors)
     107            request.updateForAccessControl(*document);
     108
    108109        m_cachedImage = loader.requestImage(WTFMove(request));
    109110        m_bestFitImageScaleFactor = image.scaleFactor;

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

    r206744 r207281  
    7373
    7474        if (options.mode == FetchOptions::Mode::Cors) {
    75             ASSERT(loader.document()->securityOrigin());
    76             updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
     75            ASSERT(loader.document());
     76            request.updateForAccessControl(*loader.document());
    7777        }
    7878        m_cachedImage = loader.requestImage(WTFMove(request));

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

    r206203 r207281  
    294294    CachedResourceRequest request(ResourceRequest(sourceURL), options);
    295295    request.setAsPotentiallyCrossOrigin(m_element.attributeWithoutSynchronization(HTMLNames::crossoriginAttr), document);
    296 
    297     document.contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(request.mutableResourceRequest(), ContentSecurityPolicy::InsecureRequestType::Load);
     296    request.upgradeInsecureRequestIfNeeded(document);
    298297
    299298    request.setCharset(scriptCharset());

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

    r206014 r207281  
    104104}
    105105
    106 ResourceRequest createAccessControlPreflightRequest(const ResourceRequest& request, SecurityOrigin& securityOrigin)
     106ResourceRequest createAccessControlPreflightRequest(const ResourceRequest& request, SecurityOrigin& securityOrigin, const String& referrer)
    107107{
    108108    ResourceRequest preflightRequest(request.url());
    … …  
    111111    preflightRequest.setHTTPHeaderField(HTTPHeaderName::AccessControlRequestMethod, request.httpMethod());
    112112    preflightRequest.setPriority(request.priority());
     113    if (!referrer.isNull())
     114        preflightRequest.setHTTPReferrer(referrer);
    113115
    114116    const HTTPHeaderMap& requestHeaderFields = request.httpHeaderFields();

  • trunk/Source/WebCore/loader/CrossOriginAccessControl.h

    r203815 r207281  
    4646
    4747void updateRequestForAccessControl(ResourceRequest&, SecurityOrigin&, StoredCredentials);
    48 ResourceRequest createAccessControlPreflightRequest(const ResourceRequest&, SecurityOrigin&);
     48ResourceRequest createAccessControlPreflightRequest(const ResourceRequest&, SecurityOrigin&, const String&);
    4949
    5050bool isValidCrossOriginRedirectionURL(const URL&);

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

    r206903 r207281  
    110110    options.contentSecurityPolicyImposition = ContentSecurityPolicyImposition::SkipPolicyCheck;
    111111
    112     CachedResourceRequest preflightRequest(createAccessControlPreflightRequest(m_request, m_loader.securityOrigin()), options);
     112    CachedResourceRequest preflightRequest(createAccessControlPreflightRequest(m_request, m_loader.securityOrigin(), m_loader.referrer()), options);
    113113    if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())
    114114        preflightRequest.setInitiator(m_loader.options().initiator);
    115 
    116     if (!m_loader.referrer().isNull())
    117         preflightRequest.mutableResourceRequest().setHTTPReferrer(m_loader.referrer());
    118115
    119116    ASSERT(!m_resource);
    … …  
    128125        return;
    129126
    130     ResourceRequest preflightRequest = createAccessControlPreflightRequest(request, loader.securityOrigin());
     127    ResourceRequest preflightRequest = createAccessControlPreflightRequest(request, loader.securityOrigin(), loader.referrer());
    131128    ResourceError error;
    132129    ResourceResponse response;
    133130    RefPtr<SharedBuffer> data;
    134 
    135     if (!loader.referrer().isNull())
    136         preflightRequest.setHTTPReferrer(loader.referrer());
    137131
    138132    unsigned identifier = loader.document().frame()->loader().loadResourceSynchronously(preflightRequest, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, error, response, data);

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

    r206903 r207281  
    381381        options.contentSecurityPolicyImposition = ContentSecurityPolicyImposition::SkipPolicyCheck;
    382382
     383        request.setAllowCookies(m_options.allowCredentials == AllowStoredCredentials);
    383384        CachedResourceRequest newRequest(WTFMove(request), options);
    384385        if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())
    385386            newRequest.setInitiator(m_options.initiator);
    386         newRequest.mutableResourceRequest().setAllowCookies(m_options.allowCredentials == AllowStoredCredentials);
    387387        newRequest.setOrigin(&securityOrigin());
    388388

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

    r207190 r207281  
    6666    auto cachingPolicy = options & LoadOption::DisallowCaching ? CachingPolicy::DisallowCaching : CachingPolicy::AllowCaching;
    6767
     68    request.setRequester(ResourceRequest::Requester::Media);
     69#if HAVE(AVFOUNDATION_LOADER_DELEGATE) && PLATFORM(MAC)
     70    // FIXME: Workaround for <rdar://problem/26071607>. We are not able to do CORS checking on 304 responses because they are usually missing the headers we need.
     71    if (!m_crossOriginMode.isNull())
     72        request.makeUnconditional();
     73#endif
     74
    6875    // FIXME: Skip Content Security Policy check if the element that initiated this request is in a user-agent shadow tree. See <https://bugs.webkit.org/show_bug.cgi?id=155505>.
    6976    CachedResourceRequest cacheRequest(WTFMove(request), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, bufferingPolicy, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, cachingPolicy));
    70 
    7177    cacheRequest.setAsPotentiallyCrossOrigin(m_crossOriginMode, *m_document);
    72 
    73     cacheRequest.mutableResourceRequest().setRequester(ResourceRequest::Requester::Media);
    74 #if HAVE(AVFOUNDATION_LOADER_DELEGATE) && PLATFORM(MAC)
    75     // FIXME: Workaround for <rdar://problem/26071607>. We are not able to do CORS checking on 304 responses because they
    76     // are usually missing the headers we need.
    77     if (cacheRequest.options().mode == FetchOptions::Mode::Cors)
    78         cacheRequest.mutableResourceRequest().makeUnconditional();
    79 #endif
    8078
    8179    CachedResourceHandle<CachedRawResource> resource = m_document->cachedResourceLoader().requestMedia(WTFMove(cacheRequest));

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

    r206903 r207281  
    116116
    117117CachedResource::CachedResource(CachedResourceRequest&& request, Type type, SessionID sessionID)
    118     : m_resourceRequest(WTFMove(request.mutableResourceRequest()))
     118    : m_resourceRequest(request.releaseResourceRequest())
    119119    , m_options(request.options())
    120120    , m_decodedDataDeletionTimer(*this, &CachedResource::destroyDecodedData, deadDecodedDataDeletionIntervalForResourceType(type))

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

    r207143 r207281  
    5252#include "HTMLElement.h"
    5353#include "HTMLFrameOwnerElement.h"
    54 #include "HTTPHeaderValues.h"
    5554#include "LoaderStrategy.h"
    5655#include "LocalizedStrings.h"
    … …  
    183182        if (frame->loader().pageDismissalEventBeingDispatched() != FrameLoader::PageDismissalType::None) {
    184183            if (Document* document = frame->document())
    185                 document->contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(request.mutableResourceRequest(), ContentSecurityPolicy::InsecureRequestType::Load);
     184                request.upgradeInsecureRequestIfNeeded(*document);
    186185            URL requestURL = request.resourceRequest().url();
    187186            if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL, request, ForPreload::No))
    … …  
    220219CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest&& request)
    221220{
    222     URL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.resourceRequest().url());
    223 
    224221#if ENABLE(CACHE_PARTITIONING)
    225     request.mutableResourceRequest().setDomainForCachePartition(document()->topOrigin()->domainForCachePartition());
     222    ASSERT(document());
     223    request.setDomainForCachePartition(*document());
    226224#endif
    227225
    … …  
    235233    }
    236234
    237     if (url.string() != request.resourceRequest().url())
    238         request.mutableResourceRequest().setURL(url);
     235    request.removeFragmentIdentifierIfNeeded();
    239236
    240237    CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(WTFMove(request), sessionID());
    … …  
    634631}
    635632
    636 static inline String acceptHeaderValueFromType(CachedResource::Type type)
    637 {
    638     switch (type) {
    639     case CachedResource::Type::MainResource:
    640         return ASCIILiteral("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
    641     case CachedResource::Type::ImageResource:
    642         return ASCIILiteral("image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5");
    643     case CachedResource::Type::CSSStyleSheet:
    644         return ASCIILiteral("text/css,*/*;q=0.1");
    645     case CachedResource::Type::SVGDocumentResource:
    646         return ASCIILiteral("image/svg+xml");
    647 #if ENABLE(XSLT)
    648     case CachedResource::Type::XSLStyleSheet:
    649         // FIXME: This should accept more general xml formats */*+xml, image/svg+xml for example.
    650         return ASCIILiteral("text/xml,application/xml,application/xhtml+xml,text/xsl,application/rss+xml,application/atom+xml");
    651 #endif
    652     default:
    653         return ASCIILiteral("*/*");
    654     }
    655 }
    656 
    657633void CachedResourceLoader::prepareFetch(CachedResource::Type type, CachedResourceRequest& request)
    658634{
    … …  
    662638        request.setOrigin(document()->securityOrigin());
    663639
    664     if (!request.resourceRequest().hasHTTPHeader(HTTPHeaderName::Accept))
    665         request.mutableResourceRequest().setHTTPHeaderField(HTTPHeaderName::Accept, acceptHeaderValueFromType(type));
     640    request.setAcceptHeaderIfNone(type);
    666641
    667642    // Accept-Language value is handled in underlying port-specific code.
    … …  
    669644}
    670645
    671 static inline void updateRequestAccordingCacheMode(CachedResourceRequest& request)
    672 {
    673     if (request.options().cache == FetchOptions::Cache::Default
    674             && (request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfModifiedSince)
    675                 || request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfNoneMatch)
    676                 || request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfUnmodifiedSince)
    677                 || request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfMatch)
    678                 || request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfRange)))
    679         request.setCacheModeToNoStore();
    680 
    681     switch (request.options().cache) {
    682     case FetchOptions::Cache::NoCache:
    683         request.mutableResourceRequest().setCachePolicy(ReloadIgnoringCacheData);
    684         request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, HTTPHeaderValues::maxAge0());
    685         break;
    686     case FetchOptions::Cache::NoStore:
    687         request.setCachingPolicy(CachingPolicy::DisallowCaching);
    688         request.mutableResourceRequest().setCachePolicy(ReloadIgnoringCacheData);
    689         request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::Pragma, HTTPHeaderValues::noCache());
    690         request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, HTTPHeaderValues::noCache());
    691         break;
    692     case FetchOptions::Cache::Reload:
    693         request.mutableResourceRequest().setCachePolicy(ReloadIgnoringCacheData);
    694         request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::Pragma, HTTPHeaderValues::noCache());
    695         request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, HTTPHeaderValues::noCache());
    696         break;
    697     case FetchOptions::Cache::Default:
    698         break;
    699     case FetchOptions::Cache::ForceCache:
    700         request.mutableResourceRequest().setCachePolicy(ReturnCacheDataElseLoad);
    701         break;
    702     case FetchOptions::Cache::OnlyIfCached:
    703         request.mutableResourceRequest().setCachePolicy(ReturnCacheDataDontLoad);
    704         break;
    705     }
    706 }
    707 
    708 void CachedResourceLoader::updateHTTPRequestHeaders(CachedResourceRequest& resourceRequest)
     646
     647void CachedResourceLoader::updateHTTPRequestHeaders(CachedResourceRequest& request)
    709648{
    710649    // Implementing steps 10 to 12 of https://fetch.spec.whatwg.org/#http-network-or-cache-fetch
    711     updateRequestAccordingCacheMode(resourceRequest);
     650    request.updateAccordingCacheMode();
    712651}
    713652
    … …  
    715654{
    716655    if (Document* document = this->document())
    717         document->contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(request.mutableResourceRequest(), ContentSecurityPolicy::InsecureRequestType::Load);
     656        request.upgradeInsecureRequestIfNeeded(*document);
    718657
    719658    URL url = request.resourceRequest().url();
    … …  
    739678#if ENABLE(CONTENT_EXTENSIONS)
    740679    if (frame() && frame()->mainFrame().page() && m_documentLoader) {
    741         auto& resourceRequest = request.mutableResourceRequest();
     680        const auto& resourceRequest = request.resourceRequest();
    742681        auto blockedStatus = frame()->mainFrame().page()->userContentProvider().processContentExtensionRulesForLoad(resourceRequest.url(), toResourceType(type), *m_documentLoader);
    743         applyBlockedStatusToRequest(blockedStatus, resourceRequest);
     682        request.applyBlockedStatus(blockedStatus);
    744683        if (blockedStatus.blockedLoad) {
    745684            RELEASE_LOG_IF_ALLOWED("requestResource: Resource blocked by content blocker (frame = %p)", frame());
    … …  
    748687                ASSERT(resource);
    749688                resource->error(CachedResource::Status::LoadError);
    750                 resource->setResourceError(ResourceError(ContentExtensions::WebKitContentBlockerDomain, 0, request.resourceRequest().url(), WEB_UI_STRING("The URL was blocked by a content blocker", "WebKitErrorBlockedByContentBlocker description")));
     689                resource->setResourceError(ResourceError(ContentExtensions::WebKitContentBlockerDomain, 0, resourceRequest.url(), WEB_UI_STRING("The URL was blocked by a content blocker", "WebKitErrorBlockedByContentBlocker description")));
    751690                return resource;
    752691            }
    … …  
    785724#if ENABLE(CACHE_PARTITIONING)
    786725    if (document())
    787         request.mutableResourceRequest().setDomainForCachePartition(document()->topOrigin()->domainForCachePartition());
     726        request.setDomainForCachePartition(*document());
    788727#endif
    789728

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

    r207053 r207281  
    2828
    2929#include "CachedResourceLoader.h"
     30#include "ContentExtensionActions.h"
    3031#include "CrossOriginAccessControl.h"
    3132#include "Document.h"
    3233#include "Element.h"
     34#include "HTTPHeaderValues.h"
     35#include "MemoryCache.h"
    3336#include <wtf/NeverDestroyed.h>
    3437
    … …  
    7982    m_options.allowCredentials = equalLettersIgnoringASCIICase(mode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
    8083
    81     updateRequestForAccessControl(m_resourceRequest, *document.securityOrigin(), m_options.allowCredentials);
     84    WebCore::updateRequestForAccessControl(m_resourceRequest, *document.securityOrigin(), m_options.allowCredentials);
    8285}
    8386
     87void CachedResourceRequest::updateForAccessControl(Document& document)
     88{
     89    ASSERT(m_options.mode == FetchOptions::Mode::Cors);
     90    ASSERT(document.securityOrigin());
     91
     92    m_origin = document.securityOrigin();
     93    WebCore::updateRequestForAccessControl(m_resourceRequest, *document.securityOrigin(), m_options.allowCredentials);
     94}
     95
     96void CachedResourceRequest::upgradeInsecureRequestIfNeeded(Document& document)
     97{
     98    URL url = m_resourceRequest.url();
     99
     100    ASSERT(document.contentSecurityPolicy());
     101    document.contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(url, ContentSecurityPolicy::InsecureRequestType::Load);
     102
     103    if (url == m_resourceRequest.url())
     104        return;
     105
     106    m_resourceRequest.setURL(url);
     107}
     108
     109#if ENABLE(CACHE_PARTITIONING)
     110void CachedResourceRequest::setDomainForCachePartition(Document& document)
     111{
     112    ASSERT(document.topOrigin());
     113    m_resourceRequest.setDomainForCachePartition(document.topOrigin()->domainForCachePartition());
     114}
     115#endif
     116
     117static inline String acceptHeaderValueFromType(CachedResource::Type type)
     118{
     119    switch (type) {
     120    case CachedResource::Type::MainResource:
     121        return ASCIILiteral("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
     122    case CachedResource::Type::ImageResource:
     123        return ASCIILiteral("image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5");
     124    case CachedResource::Type::CSSStyleSheet:
     125        return ASCIILiteral("text/css,*/*;q=0.1");
     126    case CachedResource::Type::SVGDocumentResource:
     127        return ASCIILiteral("image/svg+xml");
     128#if ENABLE(XSLT)
     129    case CachedResource::Type::XSLStyleSheet:
     130        // FIXME: This should accept more general xml formats */*+xml, image/svg+xml for example.
     131        return ASCIILiteral("text/xml,application/xml,application/xhtml+xml,text/xsl,application/rss+xml,application/atom+xml");
     132#endif
     133    default:
     134        return ASCIILiteral("*/*");
     135    }
     136}
     137
     138void CachedResourceRequest::setAcceptHeaderIfNone(CachedResource::Type type)
     139{
     140    if (!m_resourceRequest.hasHTTPHeader(HTTPHeaderName::Accept))
     141        m_resourceRequest.setHTTPHeaderField(HTTPHeaderName::Accept, acceptHeaderValueFromType(type));
     142}
     143
     144void CachedResourceRequest::updateAccordingCacheMode()
     145{
     146    if (m_options.cache == FetchOptions::Cache::Default
     147        && (m_resourceRequest.hasHTTPHeaderField(HTTPHeaderName::IfModifiedSince)
     148            || m_resourceRequest.hasHTTPHeaderField(HTTPHeaderName::IfNoneMatch)
     149            || m_resourceRequest.hasHTTPHeaderField(HTTPHeaderName::IfUnmodifiedSince)
     150            || m_resourceRequest.hasHTTPHeaderField(HTTPHeaderName::IfMatch)
     151            || m_resourceRequest.hasHTTPHeaderField(HTTPHeaderName::IfRange)))
     152        m_options.cache = FetchOptions::Cache::NoStore;
     153
     154    switch (m_options.cache) {
     155    case FetchOptions::Cache::NoCache:
     156        m_resourceRequest.setCachePolicy(ReloadIgnoringCacheData);
     157        m_resourceRequest.addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, HTTPHeaderValues::maxAge0());
     158        break;
     159    case FetchOptions::Cache::NoStore:
     160        m_options.cachingPolicy = CachingPolicy::DisallowCaching;
     161        m_resourceRequest.setCachePolicy(ReloadIgnoringCacheData);
     162        m_resourceRequest.addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::Pragma, HTTPHeaderValues::noCache());
     163        m_resourceRequest.addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, HTTPHeaderValues::noCache());
     164        break;
     165    case FetchOptions::Cache::Reload:
     166        m_resourceRequest.setCachePolicy(ReloadIgnoringCacheData);
     167        m_resourceRequest.addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::Pragma, HTTPHeaderValues::noCache());
     168        m_resourceRequest.addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, HTTPHeaderValues::noCache());
     169        break;
     170    case FetchOptions::Cache::Default:
     171        break;
     172    case FetchOptions::Cache::ForceCache:
     173        m_resourceRequest.setCachePolicy(ReturnCacheDataElseLoad);
     174        break;
     175    case FetchOptions::Cache::OnlyIfCached:
     176        m_resourceRequest.setCachePolicy(ReturnCacheDataDontLoad);
     177        break;
     178    }
     179}
     180
     181void CachedResourceRequest::removeFragmentIdentifierIfNeeded()
     182{
     183    URL url = MemoryCache::removeFragmentIdentifierIfNeeded(m_resourceRequest.url());
     184    if (url.string() != m_resourceRequest.url())
     185        m_resourceRequest.setURL(url);
     186}
     187
     188#if ENABLE(CONTENT_EXTENSIONS)
     189void CachedResourceRequest::applyBlockedStatus(const ContentExtensions::BlockedStatus& blockedStatus)
     190{
     191    ContentExtensions::applyBlockedStatusToRequest(blockedStatus, m_resourceRequest);
     192}
     193#endif
     194
    84195} // namespace WebCore

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

    r207086 r207281  
    2727#define CachedResourceRequest_h
    2828
     29#include "CachedResource.h"
    2930#include "DocumentLoader.h"
    3031#include "Element.h"
    … …  
    3738
    3839namespace WebCore {
     40
     41namespace ContentExtensions {
     42struct BlockedStatus;
     43}
    3944class Document;
    4045
    … …  
    4348    CachedResourceRequest(ResourceRequest&&, const ResourceLoaderOptions&, Optional<ResourceLoadPriority> = Nullopt, String&& charset = String());
    4449
    45     ResourceRequest& mutableResourceRequest() { return m_resourceRequest; }
     50    ResourceRequest&& releaseResourceRequest() { return WTFMove(m_resourceRequest); }
    4651    const ResourceRequest& resourceRequest() const { return m_resourceRequest; }
    4752    const String& charset() const { return m_charset; }
    … …  
    5459    const AtomicString& initiatorName() const;
    5560    bool allowsCaching() const { return m_options.cachingPolicy == CachingPolicy::AllowCaching; }
    56     void setCachingPolicy(CachingPolicy policy) { m_options.cachingPolicy = policy; }
     61    void setCachingPolicy(CachingPolicy policy) { m_options.cachingPolicy = policy;  }
    5762
    5863    void setAsPotentiallyCrossOrigin(const String&, Document&);
     64    void updateForAccessControl(Document&);
     65
     66    void upgradeInsecureRequestIfNeeded(Document&);
     67    void setAcceptHeaderIfNone(CachedResource::Type);
     68    void updateAccordingCacheMode();
     69    void removeFragmentIdentifierIfNeeded();
     70#if ENABLE(CONTENT_EXTENSIONS)
     71    void applyBlockedStatus(const ContentExtensions::BlockedStatus&);
     72#endif
     73#if ENABLE(CACHE_PARTITIONING)
     74    void setDomainForCachePartition(Document&);
     75#endif
     76
    5977    void setOrigin(RefPtr<SecurityOrigin>&& origin) { ASSERT(!m_origin); m_origin = WTFMove(origin); }
    6078    RefPtr<SecurityOrigin> releaseOrigin() { return WTFMove(m_origin); }
    6179    SecurityOrigin* origin() const { return m_origin.get(); }
    62 
    63     void setCacheModeToNoStore() { m_options.cache = FetchOptions::Cache::NoStore; }
    6480
    6581private:

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

    r206903 r207281  
    5959        return;
    6060
     61    ResourceRequest resourceRequest(m_frame.loader().icon().url());
     62    resourceRequest.setPriority(ResourceLoadPriority::Low);
     63
    6164    // ContentSecurityPolicyImposition::DoPolicyCheck is a placeholder value. It does not affect the request since Content Security Policy does not apply to raw resources.
    62     CachedResourceRequest request(ResourceRequest(m_frame.loader().icon().url()), ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, FetchOptions::Credentials::Omit, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::AllowCaching));
     65    CachedResourceRequest request(WTFMove(resourceRequest), ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, FetchOptions::Credentials::Omit, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::AllowCaching));
    6366
    64     request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
    6567    request.setInitiator(cachedResourceRequestInitiators().icon);
    6668

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

    r206903 r207281  
    7171    RetainPtr<CFURLRequestRef> urlRequest = AVCFAssetResourceLoadingRequestGetURLRequest(m_avRequest.get());
    7272
     73    ResourceRequest resourceRequest(urlRequest.get());
     74    resourceRequest.setPriority(ResourceLoadPriority::Low);
     75
    7376    // ContentSecurityPolicyImposition::DoPolicyCheck is a placeholder value. It does not affect the request since Content Security Policy does not apply to raw resources.
    74     CachedResourceRequest request(ResourceRequest(urlRequest.get()), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, FetchOptions::Credentials::Omit, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::DisallowCaching));
     77    CachedResourceRequest request(WTFMove(resourceRequest), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, FetchOptions::Credentials::Omit, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::DisallowCaching));
    7578
    76     request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
    7779    CachedResourceLoader* loader = m_parent->player()->cachedResourceLoader();
    7880    m_resource = loader ? loader->requestRawResource(WTFMove(request)) : 0;

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

    r206903 r207281  
    6868    NSURLRequest *nsRequest = [m_avRequest.get() request];
    6969
     70    ResourceRequest resourceRequest(nsRequest);
     71    resourceRequest.setPriority(ResourceLoadPriority::Low);
     72
    7073    // FIXME: Skip Content Security Policy check if the element that inititated this request
    7174    // is in a user-agent shadow tree. See <https://bugs.webkit.org/show_bug.cgi?id=155505>.
    72     CachedResourceRequest request(nsRequest, ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, FetchOptions::Credentials::Omit, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::DisallowCaching));
    73     request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
     75    CachedResourceRequest request(WTFMove(resourceRequest), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, FetchOptions::Credentials::Omit, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::DisallowCaching));
    7476    if (auto* loader = m_parent->player()->cachedResourceLoader())
    7577        m_resource = loader->requestMedia(WTFMove(request));
Note: See TracChangeset for help on using the changeset viewer.