Changeset 204019 in webkit


Ignore:
Timestamp:
Aug 2, 2016 12:20:23 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

[Fetch API] Add support to ReferrerPolicy
​https://bugs.webkit.org/show_bug.cgi?id=160404

Patch by Youenn Fablet <​youenn@apple.com> on 2016-08-02
Reviewed by Alex Christensen.

LayoutTests/imported/w3c:

  • web-platform-tests/fetch/api/basic/referrer-expected.txt: Added.
  • web-platform-tests/fetch/api/basic/referrer-worker-expected.txt: Added.
  • web-platform-tests/fetch/api/basic/referrer-worker.html: Added.
  • web-platform-tests/fetch/api/basic/referrer.html: Added.
  • web-platform-tests/fetch/api/basic/referrer.js: Added.

(runTest):

  • web-platform-tests/fetch/api/cors/cors-preflight-referrer-expected.txt:
  • web-platform-tests/fetch/api/cors/cors-preflight-referrer-worker-expected.txt:
  • web-platform-tests/fetch/api/cors/cors-preflight-referrer.js:

(corsPreflightReferrer): fix infrastructure bug in test and fix expected referrer policy in default case.

  • web-platform-tests/fetch/api/cors/cors-preflight-worker-expected.txt:

Source/WebCore:

Tests: imported/w3c/web-platform-tests/fetch/api/basic/referrer-worker.html

imported/w3c/web-platform-tests/fetch/api/basic/referrer.html

Refactored ThreadableLoader API to take more references.

Updated loading code in CachedResource to take into account referrer policy, that can be set by fetch API.
To enable correct handling of OriginWhenCrossOrigin policy, the computation of the cross-origin status of a request is
moved from ResourceLoader to CachedResource.

Referrer is passed to the loading code through HTTP headers.
This was triggering preflighting for Workers request as WorkerThreadableLoader was setting the referrer.
It is now done in DocumentThreadableLoader::loadRequest so that preflighting is done before setting the referrer.
Note that this referrer setting is only a way to pass a specific referrer value to the loading code.
CachedResource code will compute the actual referer value based on the referrer policy.
It might be good in the future to have a different way of conveying this information to CachedResource, maybe
through CachedResourceRequest.

  • Modules/fetch/FetchLoader.cpp:

(WebCore::FetchLoader::start): Refactoring of ThreadableLoader API.

  • Modules/fetch/FetchRequest.cpp:

(WebCore::FetchRequest::internalRequest): Setting referrer if it has a specific value.

  • fileapi/FileReaderLoader.cpp:

(WebCore::FileReaderLoader::start): Ractoring of ThreadableLoader API.

  • loader/CrossOriginPreflightChecker.cpp:

(WebCore::CrossOriginPreflightChecker::startPreflight): Set referrer in the preflight request if any.
(WebCore::CrossOriginPreflightChecker::doPreflight): Ditto.

  • loader/DocumentThreadableLoader.cpp:

(WebCore::DocumentThreadableLoader::loadResourceSynchronously): Refactoring of ThreadableLoader API.
(WebCore::DocumentThreadableLoader::create): Ditto.
(WebCore::DocumentThreadableLoader::DocumentThreadableLoader): Ditto.
(WebCore::DocumentThreadableLoader::loadRequest): Ditto.

  • loader/DocumentThreadableLoader.h:

(WebCore::DocumentThreadableLoader::referrer): Storing referrer in case one is defined.

  • loader/SubresourceLoader.cpp:

(WebCore::SubresourceLoader::init): Removing of cross origin computation since it is done earlier in CachedResource.

  • loader/ThreadableLoader.cpp:

(WebCore::ThreadableLoader::create): Refactoring of ThreadableLoader API.
(WebCore::ThreadableLoader::loadResourceSynchronously): Ditto.

  • loader/ThreadableLoader.h:
  • loader/ThreadableLoaderClientWrapper.h:

(WebCore::ThreadableLoaderClientWrapper::create): Ditto.
(WebCore::ThreadableLoaderClientWrapper::ThreadableLoaderClientWrapper): Ditto.

  • loader/WorkerThreadableLoader.cpp:

(WebCore::WorkerThreadableLoader::WorkerThreadableLoader): Ditto.
(WebCore::WorkerThreadableLoader::loadResourceSynchronously): Removing setting of referrer in header and passing
it as a parameter.
(WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge): Ditto.

  • loader/WorkerThreadableLoader.h:

(WebCore::WorkerThreadableLoader::create): Refactoring of ThreadableLoader API.

  • loader/cache/CachedResource.cpp:

(WebCore::addAdditionalRequestHeadersToRequest): Computation of referrer based on referrer policy.
(WebCore::CachedResource::addAdditionalRequestHeaders): Ditto.
(WebCore::CachedResource::load): Computation of cross origin status.
(WebCore::CachedResource::varyHeaderValuesMatch):

  • loader/cache/CachedResource.h:

(WebCore::CachedResource::options):

  • page/EventSource.cpp:

(WebCore::EventSource::connect): Refactoring of ThreadableLoader API.

  • workers/WorkerScriptLoader.cpp:

(WebCore::WorkerScriptLoader::loadSynchronously): Ditto.
(WebCore::WorkerScriptLoader::loadAsynchronously): Ditto.

  • xml/XMLHttpRequest.cpp:

(WebCore::XMLHttpRequest::createRequest): Ditto.

Location:
trunk
Files:
5 added
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r203987 r204019  
     12016-08-02  Youenn Fablet  <youenn@apple.com>
     2
     3        [Fetch API] Add support to ReferrerPolicy
     4        https://bugs.webkit.org/show_bug.cgi?id=160404
     5
     6        Reviewed by Alex Christensen.
     7
     8        * web-platform-tests/fetch/api/basic/referrer-expected.txt: Added.
     9        * web-platform-tests/fetch/api/basic/referrer-worker-expected.txt: Added.
     10        * web-platform-tests/fetch/api/basic/referrer-worker.html: Added.
     11        * web-platform-tests/fetch/api/basic/referrer.html: Added.
     12        * web-platform-tests/fetch/api/basic/referrer.js: Added.
     13        (runTest):
     14        * web-platform-tests/fetch/api/cors/cors-preflight-referrer-expected.txt:
     15        * web-platform-tests/fetch/api/cors/cors-preflight-referrer-worker-expected.txt:
     16        * web-platform-tests/fetch/api/cors/cors-preflight-referrer.js:
     17        (corsPreflightReferrer): fix infrastructure bug in test and fix expected referrer policy in default case.
     18        * web-platform-tests/fetch/api/cors/cors-preflight-worker-expected.txt:
     19
    1202016-08-01  Youenn Fablet  <youenn@apple.com>
    221

  • trunk/LayoutTests/imported/w3c/web-platform-tests/fetch/api/cors/cors-preflight-referrer-expected.txt

    r203638 r204019  
    11
    2 FAIL Referrer policy: no-referrer promise_test: Unhandled rejection with value: object "TypeError: Type error"
    3 FAIL Referrer policy: "" promise_test: Unhandled rejection with value: object "TypeError: Type error"
    4 FAIL Referrer policy: origin promise_test: Unhandled rejection with value: object "TypeError: Type error"
    5 FAIL Referrer policy: origin-when-cross-origin promise_test: Unhandled rejection with value: object "TypeError: Type error"
    6 FAIL Referrer policy: unsafe-url promise_test: Unhandled rejection with value: object "TypeError: Type error"
     2PASS Referrer policy: no-referrer
     3PASS Referrer policy: ""
     4PASS Referrer policy: origin
     5PASS Referrer policy: origin-when-cross-origin
     6PASS Referrer policy: unsafe-url
    77

  • trunk/LayoutTests/imported/w3c/web-platform-tests/fetch/api/cors/cors-preflight-referrer-worker-expected.txt

    r203732 r204019  
    11
    2 FAIL Referrer policy: no-referrer promise_test: Unhandled rejection with value: object "TypeError: Type error"
    3 FAIL Referrer policy: "" promise_test: Unhandled rejection with value: object "TypeError: Type error"
    4 FAIL Referrer policy: origin promise_test: Unhandled rejection with value: object "TypeError: Type error"
    5 FAIL Referrer policy: origin-when-cross-origin promise_test: Unhandled rejection with value: object "TypeError: Type error"
    6 FAIL Referrer policy: unsafe-url promise_test: Unhandled rejection with value: object "TypeError: Type error"
     2PASS Referrer policy: no-referrer
     3PASS Referrer policy: ""
     4PASS Referrer policy: origin
     5PASS Referrer policy: origin-when-cross-origin
     6PASS Referrer policy: unsafe-url
    77

  • trunk/LayoutTests/imported/w3c/web-platform-tests/fetch/api/cors/cors-preflight-referrer.js

    r203408 r204019  
    22  importScripts("/resources/testharness.js");
    33  importScripts("/common/utils.js");
     4  importScripts("../resources/get-host-info.sub.js");
    45  importScripts("../resources/utils.js");
    56}
    … …  
    2223        assert_equals(resp.headers.get("x-did-preflight"), "1", "Preflight request has been made");
    2324        assert_equals(resp.headers.get("x-preflight-referrer"), expectedReferrer, "Preflight's referrer is correct");
    24         assert_equals(resp.headers.get("x-referrer"), expectedReferrer, "Request's refferer is correct");
     25        assert_equals(resp.headers.get("x-referrer"), expectedReferrer, "Request's referrer is correct");
    2526      });
    2627    });
    … …  
    2829}
    2930
    30 var corsUrl = "http://{{host}}:{{ports[http][1]}}" + dirname(location.pathname) + RESOURCES_DIR + "preflight.py";
    31 var origin = "http://{{host}}:{{ports[http][0]}}";
     31var corsUrl = get_host_info().HTTP_REMOTE_ORIGIN + dirname(location.pathname) + RESOURCES_DIR + "preflight.py";
     32var origin = get_host_info().HTTP_ORIGIN + "/";
    3233
    3334corsPreflightReferrer("Referrer policy: no-referrer", corsUrl, "no-referrer", "");
    34 corsPreflightReferrer("Referrer policy: \"\"", corsUrl, "", "");
     35corsPreflightReferrer("Referrer policy: \"\"", corsUrl, "", location.toString())
     36
    3537corsPreflightReferrer("Referrer policy: origin", corsUrl, "origin", origin);
    3638corsPreflightReferrer("Referrer policy: origin-when-cross-origin", corsUrl, "origin-when-cross-origin", origin);

  • trunk/LayoutTests/imported/w3c/web-platform-tests/fetch/api/cors/cors-preflight-worker-expected.txt

    r203899 r204019  
    88PASS CORS [NEW], server allows
    99PASS CORS [NEW], server refuses
    10 FAIL CORS [GET] [x-test-header: allowed], server allows assert_equals: Access-Control-Allow-Headers value expected "x-test-header1" but got "referer,x-test-header1"
     10PASS CORS [GET] [x-test-header: allowed], server allows
    1111PASS CORS [GET] [x-test-header: refused], server refuses
    12 FAIL CORS [GET] [several headers], server allows assert_equals: Access-Control-Allow-Headers value expected "content-type,x-test-header-a,x-test-header-b,x-test-header-c,x-test-header-d,x-test-header1,x-test-header2,x-test-header3" but got "content-type,referer,x-test-header-a,x-test-header-b,x-test-header-c,x-test-header-d,x-test-header1,x-test-header2,x-test-header3"
     12PASS CORS [GET] [several headers], server allows
    1313PASS CORS [GET] [several headers], server refuses
    14 FAIL CORS [PUT] [several headers], server allows assert_equals: Access-Control-Allow-Headers value expected "content-type,x-test-header-a,x-test-header-b,x-test-header-c,x-test-header-d,x-test-header1,x-test-header2,x-test-header3" but got "content-type,referer,x-test-header-a,x-test-header-b,x-test-header-c,x-test-header-d,x-test-header1,x-test-header2,x-test-header3"
     14PASS CORS [PUT] [several headers], server allows
    1515PASS CORS [PUT] [several headers], server refuses
    1616

  • trunk/Source/WebCore/ChangeLog

    r204018 r204019  
     12016-08-02  Youenn Fablet  <youenn@apple.com>
     2
     3        [Fetch API] Add support to ReferrerPolicy
     4        https://bugs.webkit.org/show_bug.cgi?id=160404
     5
     6        Reviewed by Alex Christensen.
     7
     8        Tests: imported/w3c/web-platform-tests/fetch/api/basic/referrer-worker.html
     9               imported/w3c/web-platform-tests/fetch/api/basic/referrer.html
     10
     11        Refactored ThreadableLoader API to take more references.
     12
     13        Updated loading code in CachedResource to take into account referrer policy, that can be set by fetch API.
     14        To enable correct handling of OriginWhenCrossOrigin policy, the computation of the cross-origin status of a request is
     15        moved from ResourceLoader to CachedResource.
     16
     17        Referrer is passed to the loading code through HTTP headers.
     18        This was triggering preflighting for Workers request as WorkerThreadableLoader was setting the referrer.
     19        It is now done in DocumentThreadableLoader::loadRequest so that preflighting is done before setting the referrer.
     20        Note that this referrer setting is only a way to pass a specific referrer value to the loading code.
     21        CachedResource code will compute the actual referer value based on the referrer policy.
     22        It might be good in the future to have a different way of conveying this information to CachedResource, maybe
     23        through CachedResourceRequest.
     24
     25        * Modules/fetch/FetchLoader.cpp:
     26        (WebCore::FetchLoader::start): Refactoring of ThreadableLoader API.
     27        * Modules/fetch/FetchRequest.cpp:
     28        (WebCore::FetchRequest::internalRequest): Setting referrer if it has a specific value.
     29        * fileapi/FileReaderLoader.cpp:
     30        (WebCore::FileReaderLoader::start): Ractoring of ThreadableLoader API.
     31        * loader/CrossOriginPreflightChecker.cpp:
     32        (WebCore::CrossOriginPreflightChecker::startPreflight): Set referrer in the preflight request if any.
     33        (WebCore::CrossOriginPreflightChecker::doPreflight): Ditto.
     34        * loader/DocumentThreadableLoader.cpp:
     35        (WebCore::DocumentThreadableLoader::loadResourceSynchronously): Refactoring of ThreadableLoader API.
     36        (WebCore::DocumentThreadableLoader::create): Ditto.
     37        (WebCore::DocumentThreadableLoader::DocumentThreadableLoader): Ditto.
     38        (WebCore::DocumentThreadableLoader::loadRequest): Ditto.
     39        * loader/DocumentThreadableLoader.h:
     40        (WebCore::DocumentThreadableLoader::referrer): Storing referrer in case one is defined.
     41        * loader/SubresourceLoader.cpp:
     42        (WebCore::SubresourceLoader::init): Removing of cross origin computation since it is done earlier in CachedResource.
     43        * loader/ThreadableLoader.cpp:
     44        (WebCore::ThreadableLoader::create): Refactoring of ThreadableLoader API.
     45        (WebCore::ThreadableLoader::loadResourceSynchronously): Ditto.
     46        * loader/ThreadableLoader.h:
     47        * loader/ThreadableLoaderClientWrapper.h:
     48        (WebCore::ThreadableLoaderClientWrapper::create): Ditto.
     49        (WebCore::ThreadableLoaderClientWrapper::ThreadableLoaderClientWrapper): Ditto.
     50        * loader/WorkerThreadableLoader.cpp:
     51        (WebCore::WorkerThreadableLoader::WorkerThreadableLoader): Ditto.
     52        (WebCore::WorkerThreadableLoader::loadResourceSynchronously): Removing setting of referrer in header and passing
     53        it as a parameter.
     54        (WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge): Ditto.
     55        * loader/WorkerThreadableLoader.h:
     56        (WebCore::WorkerThreadableLoader::create): Refactoring of ThreadableLoader API.
     57        * loader/cache/CachedResource.cpp:
     58        (WebCore::addAdditionalRequestHeadersToRequest): Computation of referrer based on referrer policy.
     59        (WebCore::CachedResource::addAdditionalRequestHeaders): Ditto.
     60        (WebCore::CachedResource::load): Computation of cross origin status.
     61        (WebCore::CachedResource::varyHeaderValuesMatch):
     62        * loader/cache/CachedResource.h:
     63        (WebCore::CachedResource::options):
     64        * page/EventSource.cpp:
     65        (WebCore::EventSource::connect): Refactoring of ThreadableLoader API.
     66        * workers/WorkerScriptLoader.cpp:
     67        (WebCore::WorkerScriptLoader::loadSynchronously): Ditto.
     68        (WebCore::WorkerScriptLoader::loadAsynchronously): Ditto.
     69        * xml/XMLHttpRequest.cpp:
     70        (WebCore::XMLHttpRequest::createRequest): Ditto.
     71
    1722016-08-02  Brady Eidson  <beidson@apple.com>
    273

  • trunk/Source/WebCore/Modules/fetch/FetchLoader.cpp

    r204014 r204019  
    6868    options.contentSecurityPolicyEnforcement = ContentSecurityPolicyEnforcement::DoNotEnforce;
    6969
    70     m_loader = ThreadableLoader::create(&context, this, WTFMove(request), options);
     70    m_loader = ThreadableLoader::create(context, *this, WTFMove(request), options);
    7171    m_isStarted = m_loader;
    7272}
    … …  
    7878    options.dataBufferingPolicy = DoNotBufferData;
    7979
    80     m_loader = ThreadableLoader::create(&context, this, request.internalRequest(), options);
     80    m_loader = ThreadableLoader::create(context, *this, request.internalRequest(), options);
    8181    m_isStarted = m_loader;
    8282}

  • trunk/Source/WebCore/Modules/fetch/FetchRequest.cpp

    r203675 r204019  
    295295    request.setHTTPHeaderFields(m_headers->internalHeaders());
    296296    request.setHTTPBody(body().bodyForInternalRequest());
     297
     298    // FIXME: Support no-referrer and client. Ensure this case-sensitive comparison is ok.
     299    if (m_internalRequest.referrer != "no-referrer" && m_internalRequest.referrer != "client")
     300        request.setHTTPReferrer(m_internalRequest.referrer);
     301
    297302    return request;
    298303}

  • trunk/Source/WebCore/fileapi/FileReaderLoader.cpp

    r204014 r204019  
    7474void FileReaderLoader::start(ScriptExecutionContext* scriptExecutionContext, Blob& blob)
    7575{
     76    ASSERT(scriptExecutionContext);
     77
    7678    // The blob is read by routing through the request handling layer given a temporary public url.
    7779    m_urlForReading = BlobURL::createPublicURL(scriptExecutionContext->securityOrigin());
    … …  
    9496
    9597    if (m_client)
    96         m_loader = ThreadableLoader::create(scriptExecutionContext, this, WTFMove(request), options);
     98        m_loader = ThreadableLoader::create(*scriptExecutionContext, *this, WTFMove(request), options);
    9799    else
    98         ThreadableLoader::loadResourceSynchronously(scriptExecutionContext, WTFMove(request), *this, options);
     100        ThreadableLoader::loadResourceSynchronously(*scriptExecutionContext, WTFMove(request), *this, options);
    99101}
    100102

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

    r204014 r204019  
    109109        preflightRequest.setInitiator(m_loader.options().initiator);
    110110
     111    if (!m_loader.referrer().isNull())
     112        preflightRequest.mutableResourceRequest().setHTTPReferrer(m_loader.referrer());
     113
    111114    ASSERT(!m_resource);
    112115    m_resource = m_loader.document().cachedResourceLoader().requestRawResource(preflightRequest);
    … …  
    124127    ResourceResponse response;
    125128    RefPtr<SharedBuffer> data;
     129
     130    if (!loader.referrer().isNull())
     131        preflightRequest.setHTTPReferrer(loader.referrer());
     132
    126133    unsigned identifier = loader.document().frame()->loader().loadResourceSynchronously(preflightRequest, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, error, response, data);
    127134

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

    r204014 r204019  
    6060{
    6161    // The loader will be deleted as soon as this function exits.
    62     RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadSynchronously, WTFMove(request), options, WTFMove(origin), WTFMove(contentSecurityPolicy)));
     62    Ref<DocumentThreadableLoader> loader = adoptRef(*new DocumentThreadableLoader(document, client, LoadSynchronously, WTFMove(request), options, WTFMove(origin), WTFMove(contentSecurityPolicy), String()));
    6363    ASSERT(loader->hasOneRef());
    6464}
    … …  
    6969}
    7070
    71 RefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document& document, ThreadableLoaderClient& client, ResourceRequest&& request, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy)
    72 {
    73     RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadAsynchronously, WTFMove(request), options, WTFMove(origin), WTFMove(contentSecurityPolicy)));
     71RefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document& document, ThreadableLoaderClient& client, ResourceRequest&& request, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy, String&& referrer)
     72{
     73    RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadAsynchronously, WTFMove(request), options, WTFMove(origin), WTFMove(contentSecurityPolicy), WTFMove(referrer)));
    7474    if (!loader->isLoading())
    7575        loader = nullptr;
    … …  
    7979RefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document& document, ThreadableLoaderClient& client, ResourceRequest&& request, const ThreadableLoaderOptions& options)
    8080{
    81     return create(document, client, WTFMove(request), options, nullptr, nullptr);
    82 }
    83 
    84 DocumentThreadableLoader::DocumentThreadableLoader(Document& document, ThreadableLoaderClient& client, BlockingBehavior blockingBehavior, ResourceRequest&& request, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy)
     81    return create(document, client, WTFMove(request), options, nullptr, nullptr, String());
     82}
     83
     84DocumentThreadableLoader::DocumentThreadableLoader(Document& document, ThreadableLoaderClient& client, BlockingBehavior blockingBehavior, ResourceRequest&& request, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy, String&& referrer)
    8585    : m_client(&client)
    8686    , m_document(document)
    8787    , m_options(options)
    8888    , m_origin(WTFMove(origin))
     89    , m_referrer(WTFMove(referrer))
    8990    , m_sameOriginRequest(securityOrigin().canRequest(request.url()))
    9091    , m_simpleRequest(true)
    … …  
    362363    ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty());
    363364
     365    if (!m_referrer.isNull())
     366        request.setHTTPReferrer(m_referrer);
     367
    364368    if (m_async) {
    365369        ThreadableLoaderOptions options = m_options;

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

    r203971 r204019  
    11/*
    22 * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2930 */
    3031
    31 #ifndef DocumentThreadableLoader_h
    32 #define DocumentThreadableLoader_h
     32#pragma once
    3333
    3434#include "CrossOriginPreflightChecker.h"
    … …  
    4949        static void loadResourceSynchronously(Document&, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
    5050
    51         static RefPtr<DocumentThreadableLoader> create(Document&, ThreadableLoaderClient&, ResourceRequest&&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&);
     51        static RefPtr<DocumentThreadableLoader> create(Document&, ThreadableLoaderClient&, ResourceRequest&&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&, String&& referrer);
    5252        static RefPtr<DocumentThreadableLoader> create(Document&, ThreadableLoaderClient&, ResourceRequest&&, const ThreadableLoaderOptions&);
    5353
    … …  
    7272        };
    7373
    74         DocumentThreadableLoader(Document&, ThreadableLoaderClient&, BlockingBehavior, ResourceRequest&&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&);
     74        DocumentThreadableLoader(Document&, ThreadableLoaderClient&, BlockingBehavior, ResourceRequest&&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&, String&&);
    7575
    7676        void clearResource();
    … …  
    104104        Document& document() { return m_document; }
    105105        const ThreadableLoaderOptions& options() const { return m_options; }
     106        const String& referrer() const { return m_referrer; }
    106107        bool isLoading() { return m_resource || m_preflightChecker; }
    107108
    … …  
    111112        ThreadableLoaderOptions m_options;
    112113        RefPtr<SecurityOrigin> m_origin;
     114        String m_referrer;
    113115        bool m_sameOriginRequest;
    114116        bool m_simpleRequest;
    … …  
    119121
    120122} // namespace WebCore
    121 
    122 #endif // DocumentThreadableLoader_h

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

    r204014 r204019  
    153153    // This would simplify resource loader users as they would only need to set fetch mode to Cors.
    154154    m_origin = m_resource->origin();
    155     // https://fetch.spec.whatwg.org/#main-fetch, step 11, data URL here is considered not cross origin.
    156     if (!request.url().protocolIsData() && m_origin && !m_origin->canRequest(request.url()))
    157         m_resource->setCrossOrigin();
    158155
    159156    return true;

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

    r203971 r204019  
    5959}
    6060
    61 RefPtr<ThreadableLoader> ThreadableLoader::create(ScriptExecutionContext* context, ThreadableLoaderClient* client, ResourceRequest&& request, const ThreadableLoaderOptions& options)
     61RefPtr<ThreadableLoader> ThreadableLoader::create(ScriptExecutionContext& context, ThreadableLoaderClient& client, ResourceRequest&& request, const ThreadableLoaderOptions& options)
    6262{
    63     ASSERT(client);
    64     ASSERT(context);
    65 
    66     if (is<WorkerGlobalScope>(*context))
     63    if (is<WorkerGlobalScope>(context))
    6764        return WorkerThreadableLoader::create(downcast<WorkerGlobalScope>(context), client, WorkerRunLoop::defaultMode(), WTFMove(request), options);
    6865
    69     return DocumentThreadableLoader::create(downcast<Document>(*context), *client, WTFMove(request), options);
     66    return DocumentThreadableLoader::create(downcast<Document>(context), client, WTFMove(request), options);
    7067}
    7168
    72 void ThreadableLoader::loadResourceSynchronously(ScriptExecutionContext* context, ResourceRequest&& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
     69void ThreadableLoader::loadResourceSynchronously(ScriptExecutionContext& context, ResourceRequest&& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
    7370{
    74     ASSERT(context);
    75 
    76     if (is<WorkerGlobalScope>(*context))
     71    if (is<WorkerGlobalScope>(context))
    7772        WorkerThreadableLoader::loadResourceSynchronously(downcast<WorkerGlobalScope>(context), WTFMove(request), client, options);
    7873    else
    79         DocumentThreadableLoader::loadResourceSynchronously(downcast<Document>(*context), WTFMove(request), client, options);
    80     context->didLoadResourceSynchronously();
     74        DocumentThreadableLoader::loadResourceSynchronously(downcast<Document>(context), WTFMove(request), client, options);
     75    context.didLoadResourceSynchronously();
    8176}
    8277

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

    r203971 r204019  
    7575        WTF_MAKE_NONCOPYABLE(ThreadableLoader);
    7676    public:
    77         static void loadResourceSynchronously(ScriptExecutionContext*, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
    78         static RefPtr<ThreadableLoader> create(ScriptExecutionContext*, ThreadableLoaderClient*, ResourceRequest&&, const ThreadableLoaderOptions&);
     77        static void loadResourceSynchronously(ScriptExecutionContext&, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
     78        static RefPtr<ThreadableLoader> create(ScriptExecutionContext&, ThreadableLoaderClient&, ResourceRequest&&, const ThreadableLoaderOptions&);
    7979
    8080        virtual void cancel() = 0;

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

    r202542 r204019  
    4141class ThreadableLoaderClientWrapper : public ThreadSafeRefCounted<ThreadableLoaderClientWrapper> {
    4242public:
    43     static Ref<ThreadableLoaderClientWrapper> create(ThreadableLoaderClient* client)
     43    static Ref<ThreadableLoaderClientWrapper> create(ThreadableLoaderClient& client)
    4444    {
    4545        return adoptRef(*new ThreadableLoaderClientWrapper(client));
    … …  
    9696
    9797protected:
    98     explicit ThreadableLoaderClientWrapper(ThreadableLoaderClient* client)
    99         : m_client(client)
    100         , m_done(false)
    101     {
    102     }
     98    explicit ThreadableLoaderClientWrapper(ThreadableLoaderClient& client) : m_client(&client) { }
    10399
    104100    ThreadableLoaderClient* m_client;
    105     bool m_done;
     101    bool m_done { false };
    106102};
    107103

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

    r203971 r204019  
    11/*
    22 * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    5051static const char loadResourceSynchronouslyMode[] = "loadResourceSynchronouslyMode";
    5152
    52 WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope* workerGlobalScope, ThreadableLoaderClient* client, const String& taskMode, ResourceRequest&& request, const ThreadableLoaderOptions& options)
     53WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope& workerGlobalScope, ThreadableLoaderClient& client, const String& taskMode, ResourceRequest&& request, const ThreadableLoaderOptions& options)
    5354    : m_workerGlobalScope(workerGlobalScope)
    5455    , m_workerClientWrapper(ThreadableLoaderClientWrapper::create(client))
    55     , m_bridge(*new MainThreadBridge(*m_workerClientWrapper, workerGlobalScope->thread().workerLoaderProxy(), taskMode, WTFMove(request), options, workerGlobalScope->url().strippedForUseAsReferrer(), workerGlobalScope->securityOrigin(), workerGlobalScope->contentSecurityPolicy()))
     56    , m_bridge(*new MainThreadBridge(m_workerClientWrapper.get(), workerGlobalScope.thread().workerLoaderProxy(), taskMode, WTFMove(request), options, workerGlobalScope.url().strippedForUseAsReferrer(), workerGlobalScope.securityOrigin(), workerGlobalScope.contentSecurityPolicy()))
    5657{
    5758}
    … …  
    6263}
    6364
    64 void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope* workerGlobalScope, ResourceRequest&& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
    65 {
    66     WorkerRunLoop& runLoop = workerGlobalScope->thread().runLoop();
     65void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& workerGlobalScope, ResourceRequest&& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
     66{
     67    WorkerRunLoop& runLoop = workerGlobalScope.thread().runLoop();
    6768
    6869    // Create a unique mode just for this synchronous resource load.
    … …  
    7071    mode.append(String::number(runLoop.createUniqueId()));
    7172
    72     RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, &client, mode, WTFMove(request), options);
     73    RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, client, mode, WTFMove(request), options);
    7374    MessageQueueWaitResult result = MessageQueueMessageReceived;
    7475    while (!loader->done() && result != MessageQueueTerminated)
    75         result = runLoop.runInMode(workerGlobalScope, mode);
     76        result = runLoop.runInMode(&workerGlobalScope, mode);
    7677
    7778    if (!loader->done() && result == MessageQueueTerminated)
    … …  
    118119        Document& document = downcast<Document>(context);
    119120
    120         request.setHTTPReferrer(options->referrer);
    121 
    122121        // FIXME: If the site requests a local resource, then this will return a non-zero value but the sync path will return a 0 value.
    123122        // Either this should return 0 or the other code path should call a failure callback.
    124         m_mainThreadLoader = DocumentThreadableLoader::create(document, *this, WTFMove(request), options->options, WTFMove(options->origin), WTFMove(contentSecurityPolicyCopy));
     123        m_mainThreadLoader = DocumentThreadableLoader::create(document, *this, WTFMove(request), options->options, WTFMove(options->origin), WTFMove(contentSecurityPolicyCopy), WTFMove(options->referrer));
    125124        ASSERT(m_mainThreadLoader || m_loadingFinished);
    126125    });

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

    r203971 r204019  
    5050        WTF_MAKE_FAST_ALLOCATED;
    5151    public:
    52         static void loadResourceSynchronously(WorkerGlobalScope*, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
    53         static Ref<WorkerThreadableLoader> create(WorkerGlobalScope* workerGlobalScope, ThreadableLoaderClient* client, const String& taskMode, ResourceRequest&& request, const ThreadableLoaderOptions& options)
     52        static void loadResourceSynchronously(WorkerGlobalScope&, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
     53        static Ref<WorkerThreadableLoader> create(WorkerGlobalScope& workerGlobalScope, ThreadableLoaderClient& client, const String& taskMode, ResourceRequest&& request, const ThreadableLoaderOptions& options)
    5454        {
    5555            return adoptRef(*new WorkerThreadableLoader(workerGlobalScope, client, taskMode, WTFMove(request), options));
    … …  
    8686        //    The ThreadableLoaderClientWrapper has the underlying client cleared, so no more calls
    8787        //    go through it.  All tasks posted from the worker object's thread to the worker context's
    88         //    thread contain the RefPtr<ThreadableLoaderClientWrapper> object, so the 
     88        //    thread contain the RefPtr<ThreadableLoaderClientWrapper> object, so the
    8989        //    ThreadableLoaderClientWrapper instance is there until all tasks are executed.
    9090        class MainThreadBridge : public ThreadableLoaderClient {
    … …  
    121121        };
    122122
    123         WorkerThreadableLoader(WorkerGlobalScope*, ThreadableLoaderClient*, const String& taskMode, ResourceRequest&&, const ThreadableLoaderOptions&);
     123        WorkerThreadableLoader(WorkerGlobalScope&, ThreadableLoaderClient&, const String& taskMode, ResourceRequest&&, const ThreadableLoaderOptions&);
    124124
    125         RefPtr<WorkerGlobalScope> m_workerGlobalScope;
    126         RefPtr<ThreadableLoaderClientWrapper> m_workerClientWrapper;
     125        Ref<WorkerGlobalScope> m_workerGlobalScope;
     126        Ref<ThreadableLoaderClientWrapper> m_workerClientWrapper;
    127127        MainThreadBridge& m_bridge;
    128128    };

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

    r204014 r204019  
    184184}
    185185
    186 static void addAdditionalRequestHeadersToRequest(ResourceRequest& request, const CachedResourceLoader& cachedResourceLoader, CachedResource::Type type)
    187 {
    188     if (type == CachedResource::MainResource)
     186static void addAdditionalRequestHeadersToRequest(ResourceRequest& request, const CachedResourceLoader& cachedResourceLoader, CachedResource& resource)
     187{
     188    if (resource.type() == CachedResource::MainResource)
    189189        return;
    190190    // In some cases we may try to load resources in frameless documents. Such loads always fail.
    … …  
    207207    }
    208208
    209     auto referrerPolicy = cachedResourceLoader.document() ? cachedResourceLoader.document()->referrerPolicy() : ReferrerPolicy::Default;
    210     outgoingReferrer = SecurityPolicy::generateReferrerHeader(referrerPolicy, request.url(), outgoingReferrer);
     209    // FIXME: Refactor SecurityPolicy::generateReferrerHeader to align with new terminology used in https://w3c.github.io/webappsec-referrer-policy.
     210    switch (resource.options().referrerPolicy) {
     211    case FetchOptions::ReferrerPolicy::EmptyString: {
     212        ReferrerPolicy referrerPolicy = cachedResourceLoader.document() ? cachedResourceLoader.document()->referrerPolicy() : ReferrerPolicy::Default;
     213        outgoingReferrer = SecurityPolicy::generateReferrerHeader(referrerPolicy, request.url(), outgoingReferrer);
     214        break; }
     215    case FetchOptions::ReferrerPolicy::NoReferrerWhenDowngrade:
     216        outgoingReferrer = SecurityPolicy::generateReferrerHeader(ReferrerPolicy::Default, request.url(), outgoingReferrer);
     217        break;
     218    case FetchOptions::ReferrerPolicy::NoReferrer:
     219        outgoingReferrer = String();
     220        break;
     221    case FetchOptions::ReferrerPolicy::Origin:
     222        outgoingReferrer = SecurityPolicy::generateReferrerHeader(ReferrerPolicy::Origin, request.url(), outgoingReferrer);
     223        break;
     224    case FetchOptions::ReferrerPolicy::OriginWhenCrossOrigin:
     225        if (resource.isCrossOrigin())
     226            outgoingReferrer = SecurityPolicy::generateReferrerHeader(ReferrerPolicy::Origin, request.url(), outgoingReferrer);
     227        break;
     228    case FetchOptions::ReferrerPolicy::UnsafeUrl:
     229        break;
     230    };
     231
    211232    if (outgoingReferrer.isEmpty())
    212233        request.clearHTTPReferrer();
    … …  
    220241void CachedResource::addAdditionalRequestHeaders(CachedResourceLoader& cachedResourceLoader)
    221242{
    222     addAdditionalRequestHeadersToRequest(m_resourceRequest, cachedResourceLoader, type());
     243    addAdditionalRequestHeadersToRequest(m_resourceRequest, cachedResourceLoader, *this);
    223244}
    224245
    … …  
    288309            m_origin = cachedResourceLoader.document()->securityOrigin();
    289310        ASSERT(m_origin);
     311
     312        if (!m_resourceRequest.url().protocolIsData() && m_origin && !m_origin->canRequest(m_resourceRequest.url()))
     313            setCrossOrigin();
     314
    290315        addAdditionalRequestHeaders(cachedResourceLoader);
    291316    }
    … …  
    810835
    811836    ResourceRequest requestWithFullHeaders(request);
    812     addAdditionalRequestHeadersToRequest(requestWithFullHeaders, cachedResourceLoader, type());
     837    addAdditionalRequestHeadersToRequest(requestWithFullHeaders, cachedResourceLoader, *this);
    813838
    814839    return verifyVaryingRequestHeaders(m_varyingHeaderValues, requestWithFullHeaders, m_sessionID);

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

    r204014 r204019  
    231231
    232232    bool allowsCaching() const { return m_options.cachingPolicy == CachingPolicy::AllowCaching; }
     233    const FetchOptions& options() const { return m_options; }
    233234
    234235    virtual void destroyDecodedData() { }

  • trunk/Source/WebCore/page/EventSource.cpp

    r204014 r204019  
    112112    options.contentSecurityPolicyEnforcement = scriptExecutionContext()->shouldBypassMainWorldContentSecurityPolicy() ? ContentSecurityPolicyEnforcement::DoNotEnforce : ContentSecurityPolicyEnforcement::EnforceConnectSrcDirective;
    113113
    114     m_loader = ThreadableLoader::create(scriptExecutionContext(), this, WTFMove(request), options);
     114    ASSERT(scriptExecutionContext());
     115    m_loader = ThreadableLoader::create(*scriptExecutionContext(), *this, WTFMove(request), options);
    115116
    116117    // FIXME: Can we just use m_loader for this, null it out when it's no longer in flight, and eliminate the m_requestInFlight member?

  • trunk/Source/WebCore/workers/WorkerScriptLoader.cpp

    r204014 r204019  
    5757void WorkerScriptLoader::loadSynchronously(ScriptExecutionContext* scriptExecutionContext, const URL& url, FetchOptions::Mode mode, ContentSecurityPolicyEnforcement contentSecurityPolicyEnforcement)
    5858{
     59    ASSERT(scriptExecutionContext);
     60
    5961    m_url = url;
    6062
    … …  
    7476    options.contentSecurityPolicyEnforcement = contentSecurityPolicyEnforcement;
    7577
    76     WorkerThreadableLoader::loadResourceSynchronously(downcast<WorkerGlobalScope>(scriptExecutionContext), WTFMove(*request), *this, options);
     78    WorkerThreadableLoader::loadResourceSynchronously(downcast<WorkerGlobalScope>(*scriptExecutionContext), WTFMove(*request), *this, options);
    7779}
    7880
    … …  
    8082{
    8183    ASSERT(client);
     84    ASSERT(scriptExecutionContext);
     85
    8286    m_client = client;
    8387    m_url = url;
    … …  
    99103    // During create, callbacks may happen which remove the last reference to this object.
    100104    Ref<WorkerScriptLoader> protectedThis(*this);
    101     m_threadableLoader = ThreadableLoader::create(scriptExecutionContext, this, WTFMove(*request), options);
     105    m_threadableLoader = ThreadableLoader::create(*scriptExecutionContext, *this, WTFMove(*request), options);
    102106}
    103107

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

    r204014 r204019  
    714714        // This is true while running onunload handlers.
    715715        // FIXME: Maybe we need to be able to send XMLHttpRequests from onunload, <http://bugs.webkit.org/show_bug.cgi?id=10904>.
    716         m_loader = ThreadableLoader::create(scriptExecutionContext(), this, WTFMove(request), options);
     716        m_loader = ThreadableLoader::create(*scriptExecutionContext(), *this, WTFMove(request), options);
    717717
    718718        // Neither this object nor the JavaScript wrapper should be deleted while
    … …  
    727727    } else {
    728728        InspectorInstrumentation::willLoadXHRSynchronously(scriptExecutionContext());
    729         ThreadableLoader::loadResourceSynchronously(scriptExecutionContext(), WTFMove(request), *this, options);
     729        ThreadableLoader::loadResourceSynchronously(*scriptExecutionContext(), WTFMove(request), *this, options);
    730730        InspectorInstrumentation::didLoadXHRSynchronously(scriptExecutionContext());
    731731    }
Note: See TracChangeset for help on using the changeset viewer.